Full Code of launchbadge/sqlx for AI

gitextract_7wdu157x/

├── .editorconfig
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.yml
│   │   ├── config.yml
│   │   └── feature_request.yml
│   ├── pull_request_template.md
│   └── workflows/
│       ├── examples.yml
│       ├── sqlx-cli.yml
│       └── sqlx.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── Cargo.toml
├── FAQ.md
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── benches/
│   └── sqlite/
│       └── describe.rs
├── clippy.toml
├── contrib/
│   └── ide/
│       └── vscode/
│           └── settings.json
├── examples/
│   ├── .gitignore
│   ├── mysql/
│   │   └── todos/
│   │       ├── Cargo.toml
│   │       ├── README.md
│   │       ├── migrations/
│   │       │   └── 20200718111257_todos.sql
│   │       └── src/
│   │           └── main.rs
│   ├── postgres/
│   │   ├── axum-social-with-tests/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── migrations/
│   │   │   │   ├── 1_user.sql
│   │   │   │   ├── 2_post.sql
│   │   │   │   └── 3_comment.sql
│   │   │   ├── src/
│   │   │   │   ├── http/
│   │   │   │   │   ├── error.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   ├── post/
│   │   │   │   │   │   ├── comment.rs
│   │   │   │   │   │   └── mod.rs
│   │   │   │   │   └── user.rs
│   │   │   │   ├── lib.rs
│   │   │   │   ├── main.rs
│   │   │   │   └── password.rs
│   │   │   └── tests/
│   │   │       ├── comment.rs
│   │   │       ├── common.rs
│   │   │       ├── fixtures/
│   │   │       │   ├── comments.sql
│   │   │       │   ├── posts.sql
│   │   │       │   └── users.sql
│   │   │       ├── post.rs
│   │   │       └── user.rs
│   │   ├── chat/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   └── src/
│   │   │       └── main.rs
│   │   ├── files/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── migrations/
│   │   │   │   └── 20220712221654_files.sql
│   │   │   ├── queries/
│   │   │   │   ├── insert_seed_data.sql
│   │   │   │   └── list_all_posts.sql
│   │   │   └── src/
│   │   │       └── main.rs
│   │   ├── json/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── migrations/
│   │   │   │   └── 20200824190010_json.sql
│   │   │   └── src/
│   │   │       └── main.rs
│   │   ├── listen/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   └── src/
│   │   │       └── main.rs
│   │   ├── mockable-todos/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── docker-compose.yml
│   │   │   ├── migrations/
│   │   │   │   └── 20200718111257_todos.sql
│   │   │   └── src/
│   │   │       └── main.rs
│   │   ├── multi-database/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── accounts/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── migrations/
│   │   │   │   │   ├── 01_setup.sql
│   │   │   │   │   ├── 02_account.sql
│   │   │   │   │   └── 03_session.sql
│   │   │   │   ├── sqlx.toml
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   ├── payments/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── migrations/
│   │   │   │   │   ├── 01_setup.sql
│   │   │   │   │   └── 02_payment.sql
│   │   │   │   ├── sqlx.toml
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   ├── sqlx.toml
│   │   │   └── src/
│   │   │       ├── main.rs
│   │   │       └── migrations/
│   │   │           ├── 01_setup.sql
│   │   │           └── 02_purchase.sql
│   │   ├── multi-tenant/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── accounts/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── migrations/
│   │   │   │   │   ├── 01_setup.sql
│   │   │   │   │   ├── 02_account.sql
│   │   │   │   │   └── 03_session.sql
│   │   │   │   ├── sqlx.toml
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   ├── payments/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── migrations/
│   │   │   │   │   ├── 01_setup.sql
│   │   │   │   │   └── 02_payment.sql
│   │   │   │   ├── sqlx.toml
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   ├── sqlx.toml
│   │   │   └── src/
│   │   │       ├── main.rs
│   │   │       └── migrations/
│   │   │           ├── 01_setup.sql
│   │   │           └── 02_purchase.sql
│   │   ├── preferred-crates/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── sqlx.toml
│   │   │   ├── src/
│   │   │   │   ├── main.rs
│   │   │   │   └── migrations/
│   │   │   │       ├── 01_setup.sql
│   │   │   │       └── 02_users.sql
│   │   │   ├── uses-rust-decimal/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   └── uses-time/
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           └── lib.rs
│   │   ├── todos/
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   ├── migrations/
│   │   │   │   └── 20200718111257_todos.sql
│   │   │   └── src/
│   │   │       └── main.rs
│   │   └── transaction/
│   │       ├── Cargo.toml
│   │       ├── README.md
│   │       ├── migrations/
│   │       │   └── 20200718111257_todos.sql
│   │       └── src/
│   │           └── main.rs
│   ├── sqlite/
│   │   ├── extension/
│   │   │   ├── Cargo.toml
│   │   │   ├── download-extension.sh
│   │   │   ├── migrations/
│   │   │   │   └── 20250203094951_addresses.sql
│   │   │   ├── sqlx.toml
│   │   │   └── src/
│   │   │       └── main.rs
│   │   └── todos/
│   │       ├── Cargo.toml
│   │       ├── README.md
│   │       ├── migrations/
│   │       │   └── 20200718111257_todos.sql
│   │       └── src/
│   │           └── main.rs
│   └── x.py
├── gen-changelog.sh
├── rust-toolchain.toml
├── sqlx-cli/
│   ├── Cargo.toml
│   ├── README.md
│   ├── src/
│   │   ├── bin/
│   │   │   ├── cargo-sqlx.rs
│   │   │   └── sqlx.rs
│   │   ├── completions.rs
│   │   ├── database.rs
│   │   ├── lib.rs
│   │   ├── metadata.rs
│   │   ├── migrate.rs
│   │   ├── opt.rs
│   │   └── prepare.rs
│   └── tests/
│       ├── add.rs
│       ├── assets/
│       │   ├── config_default_type_reversible.toml
│       │   ├── config_default_versioning_sequential.toml
│       │   ├── config_default_versioning_timestamp.toml
│       │   └── sample_metadata.json
│       ├── common/
│       │   └── mod.rs
│       ├── ignored-chars/
│       │   ├── BOM/
│       │   │   ├── .gitattributes
│       │   │   ├── 1_user.sql
│       │   │   ├── 2_post.sql
│       │   │   └── 3_comment.sql
│       │   ├── CRLF/
│       │   │   ├── .gitattributes
│       │   │   ├── 1_user.sql
│       │   │   ├── 2_post.sql
│       │   │   └── 3_comment.sql
│       │   ├── LF/
│       │   │   ├── .gitattributes
│       │   │   ├── 1_user.sql
│       │   │   ├── 2_post.sql
│       │   │   └── 3_comment.sql
│       │   ├── oops-all-tabs/
│       │   │   ├── .gitattributes
│       │   │   ├── 1_user.sql
│       │   │   ├── 2_post.sql
│       │   │   └── 3_comment.sql
│       │   └── sqlx.toml
│       ├── migrate.rs
│       └── migrations_reversible/
│           ├── 20230101000000_test1.down.sql
│           ├── 20230101000000_test1.up.sql
│           ├── 20230201000000_test2.down.sql
│           ├── 20230201000000_test2.up.sql
│           ├── 20230301000000_test3.down.sql
│           ├── 20230301000000_test3.up.sql
│           ├── 20230401000000_test4.down.sql
│           ├── 20230401000000_test4.up.sql
│           ├── 20230501000000_test5.down.sql
│           └── 20230501000000_test5.up.sql
├── sqlx-core/
│   ├── Cargo.toml
│   └── src/
│       ├── acquire.rs
│       ├── any/
│       │   ├── arguments.rs
│       │   ├── column.rs
│       │   ├── connection/
│       │   │   ├── backend.rs
│       │   │   ├── executor.rs
│       │   │   └── mod.rs
│       │   ├── database.rs
│       │   ├── driver.rs
│       │   ├── error.rs
│       │   ├── kind.rs
│       │   ├── migrate.rs
│       │   ├── mod.rs
│       │   ├── options.rs
│       │   ├── query_result.rs
│       │   ├── row.rs
│       │   ├── statement.rs
│       │   ├── transaction.rs
│       │   ├── type_info.rs
│       │   ├── types/
│       │   │   ├── blob.rs
│       │   │   ├── bool.rs
│       │   │   ├── float.rs
│       │   │   ├── int.rs
│       │   │   ├── mod.rs
│       │   │   └── str.rs
│       │   └── value.rs
│       ├── arguments.rs
│       ├── column.rs
│       ├── common/
│       │   ├── mod.rs
│       │   └── statement_cache.rs
│       ├── config/
│       │   ├── common.rs
│       │   ├── drivers.rs
│       │   ├── macros.rs
│       │   ├── migrate.rs
│       │   ├── mod.rs
│       │   ├── reference.toml
│       │   └── tests.rs
│       ├── connection.rs
│       ├── database.rs
│       ├── decode.rs
│       ├── describe.rs
│       ├── encode.rs
│       ├── error.rs
│       ├── executor.rs
│       ├── ext/
│       │   ├── async_stream.rs
│       │   ├── mod.rs
│       │   └── ustr.rs
│       ├── from_row.rs
│       ├── fs.rs
│       ├── io/
│       │   ├── buf.rs
│       │   ├── buf_mut.rs
│       │   ├── buf_stream.rs
│       │   ├── decode.rs
│       │   ├── encode.rs
│       │   ├── mod.rs
│       │   ├── read_buf.rs
│       │   └── write_and_flush.rs
│       ├── lib.rs
│       ├── logger.rs
│       ├── migrate/
│       │   ├── error.rs
│       │   ├── migrate.rs
│       │   ├── migration.rs
│       │   ├── migration_type.rs
│       │   ├── migrator.rs
│       │   ├── mod.rs
│       │   └── source.rs
│       ├── net/
│       │   ├── mod.rs
│       │   ├── socket/
│       │   │   ├── buffered.rs
│       │   │   └── mod.rs
│       │   └── tls/
│       │       ├── mod.rs
│       │       ├── tls_native_tls.rs
│       │       ├── tls_rustls.rs
│       │       └── util.rs
│       ├── pool/
│       │   ├── connection.rs
│       │   ├── executor.rs
│       │   ├── inner.rs
│       │   ├── maybe.rs
│       │   ├── mod.rs
│       │   └── options.rs
│       ├── query.rs
│       ├── query_as.rs
│       ├── query_builder.rs
│       ├── query_scalar.rs
│       ├── raw_sql.rs
│       ├── row.rs
│       ├── rt/
│       │   ├── mod.rs
│       │   ├── rt_async_io/
│       │   │   ├── mod.rs
│       │   │   ├── socket.rs
│       │   │   └── timeout.rs
│       │   └── rt_tokio/
│       │       ├── mod.rs
│       │       └── socket.rs
│       ├── sql_str.rs
│       ├── statement.rs
│       ├── sync.rs
│       ├── testing/
│       │   ├── fixtures.rs
│       │   └── mod.rs
│       ├── transaction.rs
│       ├── type_checking.rs
│       ├── type_info.rs
│       ├── types/
│       │   ├── bstr.rs
│       │   ├── json.rs
│       │   ├── mod.rs
│       │   ├── non_zero.rs
│       │   └── text.rs
│       └── value.rs
├── sqlx-macros/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── sqlx-macros-core/
│   ├── Cargo.toml
│   ├── clippy.toml
│   └── src/
│       ├── common.rs
│       ├── database/
│       │   ├── impls.rs
│       │   └── mod.rs
│       ├── derives/
│       │   ├── attributes.rs
│       │   ├── decode.rs
│       │   ├── encode.rs
│       │   ├── mod.rs
│       │   ├── row.rs
│       │   └── type.rs
│       ├── lib.rs
│       ├── migrate.rs
│       ├── query/
│       │   ├── args.rs
│       │   ├── cache.rs
│       │   ├── data.rs
│       │   ├── input.rs
│       │   ├── metadata.rs
│       │   ├── mod.rs
│       │   └── output.rs
│       └── test_attr.rs
├── sqlx-mysql/
│   ├── Cargo.toml
│   └── src/
│       ├── any.rs
│       ├── arguments.rs
│       ├── collation.rs
│       ├── column.rs
│       ├── connection/
│       │   ├── auth.rs
│       │   ├── establish.rs
│       │   ├── executor.rs
│       │   ├── mod.rs
│       │   ├── stream.rs
│       │   └── tls.rs
│       ├── database.rs
│       ├── error.rs
│       ├── io/
│       │   ├── buf.rs
│       │   ├── buf_mut.rs
│       │   └── mod.rs
│       ├── lib.rs
│       ├── migrate.rs
│       ├── options/
│       │   ├── connect.rs
│       │   ├── mod.rs
│       │   ├── parse.rs
│       │   └── ssl_mode.rs
│       ├── protocol/
│       │   ├── auth.rs
│       │   ├── capabilities.rs
│       │   ├── connect/
│       │   │   ├── auth_switch.rs
│       │   │   ├── handshake.rs
│       │   │   ├── handshake_response.rs
│       │   │   ├── mod.rs
│       │   │   └── ssl_request.rs
│       │   ├── mod.rs
│       │   ├── packet.rs
│       │   ├── response/
│       │   │   ├── eof.rs
│       │   │   ├── err.rs
│       │   │   ├── mod.rs
│       │   │   ├── ok.rs
│       │   │   └── status.rs
│       │   ├── row.rs
│       │   ├── statement/
│       │   │   ├── execute.rs
│       │   │   ├── mod.rs
│       │   │   ├── prepare.rs
│       │   │   ├── prepare_ok.rs
│       │   │   ├── row.rs
│       │   │   └── stmt_close.rs
│       │   └── text/
│       │       ├── column.rs
│       │       ├── mod.rs
│       │       ├── ping.rs
│       │       ├── query.rs
│       │       ├── quit.rs
│       │       └── row.rs
│       ├── query_result.rs
│       ├── row.rs
│       ├── statement.rs
│       ├── testing/
│       │   └── mod.rs
│       ├── transaction.rs
│       ├── type_checking.rs
│       ├── type_info.rs
│       ├── types/
│       │   ├── bigdecimal.rs
│       │   ├── bool.rs
│       │   ├── bytes.rs
│       │   ├── chrono.rs
│       │   ├── float.rs
│       │   ├── inet.rs
│       │   ├── int.rs
│       │   ├── json.rs
│       │   ├── mod.rs
│       │   ├── mysql_time.rs
│       │   ├── rust_decimal.rs
│       │   ├── str.rs
│       │   ├── text.rs
│       │   ├── time.rs
│       │   ├── uint.rs
│       │   └── uuid.rs
│       └── value.rs
├── sqlx-postgres/
│   ├── Cargo.toml
│   └── src/
│       ├── advisory_lock.rs
│       ├── any.rs
│       ├── arguments.rs
│       ├── bind_iter.rs
│       ├── column.rs
│       ├── connection/
│       │   ├── describe.rs
│       │   ├── establish.rs
│       │   ├── executor.rs
│       │   ├── mod.rs
│       │   ├── resolve.rs
│       │   ├── sasl.rs
│       │   ├── stream.rs
│       │   └── tls.rs
│       ├── copy.rs
│       ├── database.rs
│       ├── error.rs
│       ├── io/
│       │   ├── buf_mut.rs
│       │   └── mod.rs
│       ├── lib.rs
│       ├── listener.rs
│       ├── message/
│       │   ├── authentication.rs
│       │   ├── backend_key_data.rs
│       │   ├── bind.rs
│       │   ├── close.rs
│       │   ├── command_complete.rs
│       │   ├── copy.rs
│       │   ├── data_row.rs
│       │   ├── describe.rs
│       │   ├── execute.rs
│       │   ├── flush.rs
│       │   ├── mod.rs
│       │   ├── notification.rs
│       │   ├── parameter_description.rs
│       │   ├── parameter_status.rs
│       │   ├── parse.rs
│       │   ├── parse_complete.rs
│       │   ├── password.rs
│       │   ├── query.rs
│       │   ├── ready_for_query.rs
│       │   ├── response.rs
│       │   ├── row_description.rs
│       │   ├── sasl.rs
│       │   ├── ssl_request.rs
│       │   ├── startup.rs
│       │   ├── sync.rs
│       │   └── terminate.rs
│       ├── migrate.rs
│       ├── options/
│       │   ├── connect.rs
│       │   ├── doc.md
│       │   ├── mod.rs
│       │   ├── parse.rs
│       │   ├── pgpass.rs
│       │   └── ssl_mode.rs
│       ├── query_result.rs
│       ├── row.rs
│       ├── statement.rs
│       ├── testing/
│       │   └── mod.rs
│       ├── transaction.rs
│       ├── type_checking.rs
│       ├── type_info.rs
│       ├── types/
│       │   ├── array.rs
│       │   ├── bigdecimal-range.md
│       │   ├── bigdecimal.rs
│       │   ├── bit_vec.rs
│       │   ├── bool.rs
│       │   ├── bytes.rs
│       │   ├── chrono/
│       │   │   ├── date.rs
│       │   │   ├── datetime.rs
│       │   │   ├── mod.rs
│       │   │   └── time.rs
│       │   ├── citext.rs
│       │   ├── cube.rs
│       │   ├── float.rs
│       │   ├── geometry/
│       │   │   ├── box.rs
│       │   │   ├── circle.rs
│       │   │   ├── line.rs
│       │   │   ├── line_segment.rs
│       │   │   ├── mod.rs
│       │   │   ├── path.rs
│       │   │   ├── point.rs
│       │   │   └── polygon.rs
│       │   ├── hstore.rs
│       │   ├── int.rs
│       │   ├── interval.rs
│       │   ├── ipnet/
│       │   │   ├── ipaddr.rs
│       │   │   ├── ipnet.rs
│       │   │   └── mod.rs
│       │   ├── ipnetwork/
│       │   │   ├── ipaddr.rs
│       │   │   ├── ipnetwork.rs
│       │   │   └── mod.rs
│       │   ├── json.rs
│       │   ├── lquery.rs
│       │   ├── ltree.rs
│       │   ├── mac_address.rs
│       │   ├── mod.rs
│       │   ├── money.rs
│       │   ├── numeric.rs
│       │   ├── oid.rs
│       │   ├── range.rs
│       │   ├── record.rs
│       │   ├── rust_decimal-range.md
│       │   ├── rust_decimal.rs
│       │   ├── str.rs
│       │   ├── text.rs
│       │   ├── time/
│       │   │   ├── date.rs
│       │   │   ├── datetime.rs
│       │   │   ├── mod.rs
│       │   │   └── time.rs
│       │   ├── time_tz.rs
│       │   ├── tuple.rs
│       │   ├── uuid.rs
│       │   └── void.rs
│       └── value.rs
├── sqlx-sqlite/
│   ├── Cargo.toml
│   └── src/
│       ├── any.rs
│       ├── arguments.rs
│       ├── column.rs
│       ├── connection/
│       │   ├── collation.rs
│       │   ├── describe.rs
│       │   ├── deserialize.rs
│       │   ├── establish.rs
│       │   ├── execute.rs
│       │   ├── executor.rs
│       │   ├── explain.rs
│       │   ├── handle.rs
│       │   ├── intmap.rs
│       │   ├── mod.rs
│       │   ├── preupdate_hook.rs
│       │   └── worker.rs
│       ├── database.rs
│       ├── error.rs
│       ├── lib.rs
│       ├── logger.rs
│       ├── migrate.rs
│       ├── options/
│       │   ├── auto_vacuum.rs
│       │   ├── connect.rs
│       │   ├── journal_mode.rs
│       │   ├── locking_mode.rs
│       │   ├── mod.rs
│       │   ├── parse.rs
│       │   └── synchronous.rs
│       ├── query_result.rs
│       ├── regexp.rs
│       ├── row.rs
│       ├── statement/
│       │   ├── handle.rs
│       │   ├── mod.rs
│       │   ├── unlock_notify.rs
│       │   └── virtual.rs
│       ├── testing/
│       │   └── mod.rs
│       ├── transaction.rs
│       ├── type_checking.rs
│       ├── type_info.rs
│       ├── types/
│       │   ├── bool.rs
│       │   ├── bytes.rs
│       │   ├── chrono.rs
│       │   ├── float.rs
│       │   ├── int.rs
│       │   ├── json.rs
│       │   ├── mod.rs
│       │   ├── str.rs
│       │   ├── text.rs
│       │   ├── time.rs
│       │   ├── uint.rs
│       │   └── uuid.rs
│       └── value.rs
├── sqlx-test/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── src/
│   ├── any/
│   │   ├── install_drivers_note.md
│   │   └── mod.rs
│   ├── lib.md
│   ├── lib.rs
│   ├── macros/
│   │   ├── mod.rs
│   │   └── test.md
│   ├── spec_error.rs
│   └── ty_match.rs
└── tests/
    ├── .dockerignore
    ├── .env
    ├── .gitignore
    ├── README.md
    ├── any/
    │   ├── any.rs
    │   └── pool.rs
    ├── certs/
    │   ├── .gitignore
    │   ├── README.md
    │   ├── ca.crt
    │   ├── client.crt
    │   ├── keys/
    │   │   ├── ca.key
    │   │   ├── client.key
    │   │   └── server.key
    │   └── server.crt
    ├── docker-compose.yml
    ├── docker.py
    ├── fixtures/
    │   ├── mysql/
    │   │   ├── posts.sql
    │   │   └── users.sql
    │   └── postgres/
    │       ├── posts.sql
    │       └── users.sql
    ├── migrate/
    │   ├── macro.rs
    │   ├── migrations_reversible/
    │   │   ├── 20220721124650_add_table.down.sql
    │   │   ├── 20220721124650_add_table.up.sql
    │   │   ├── 20220721125033_modify_column.down.sql
    │   │   └── 20220721125033_modify_column.up.sql
    │   └── migrations_simple/
    │       ├── 20220721115250_add_test_table.sql
    │       └── 20220721115524_convert_type.sql
    ├── mssql/
    │   ├── Dockerfile
    │   ├── configure-db.sh
    │   ├── describe.rs
    │   ├── entrypoint.sh
    │   ├── macros.rs
    │   ├── mssql-2017.dockerfile
    │   ├── mssql.rs
    │   ├── setup.sql
    │   └── types.rs
    ├── mysql/
    │   ├── Dockerfile
    │   ├── derives.rs
    │   ├── describe.rs
    │   ├── error.rs
    │   ├── fixtures/
    │   │   ├── comments.sql
    │   │   ├── posts.sql
    │   │   └── users.sql
    │   ├── macros.rs
    │   ├── migrate.rs
    │   ├── migrations/
    │   │   ├── 1_user.sql
    │   │   ├── 2_post.sql
    │   │   └── 3_comment.sql
    │   ├── migrations_reversible/
    │   │   ├── 20220721124650_add_table.down.sql
    │   │   ├── 20220721124650_add_table.up.sql
    │   │   ├── 20220721125033_modify_column.down.sql
    │   │   └── 20220721125033_modify_column.up.sql
    │   ├── migrations_simple/
    │   │   ├── 20220721115250_add_test_table.sql
    │   │   └── 20220721115524_convert_type.sql
    │   ├── my.cnf
    │   ├── mysql.rs
    │   ├── rustsec.rs
    │   ├── setup-mariadb.sql
    │   ├── setup.sql
    │   ├── test-attr.rs
    │   └── types.rs
    ├── postgres/
    │   ├── Dockerfile
    │   ├── derives.rs
    │   ├── describe.rs
    │   ├── error.rs
    │   ├── fixtures/
    │   │   ├── comments.sql
    │   │   ├── posts.sql
    │   │   ├── rustsec/
    │   │   │   └── 2024_0363.sql
    │   │   └── users.sql
    │   ├── macros.rs
    │   ├── migrate.rs
    │   ├── migrations/
    │   │   ├── 0_setup.sql
    │   │   ├── 1_user.sql
    │   │   ├── 2_post.sql
    │   │   └── 3_comment.sql
    │   ├── migrations_no_tx/
    │   │   └── 0_create_db.sql
    │   ├── migrations_reversible/
    │   │   ├── 20220721124650_add_table.down.sql
    │   │   ├── 20220721124650_add_table.up.sql
    │   │   ├── 20220721125033_modify_column.down.sql
    │   │   └── 20220721125033_modify_column.up.sql
    │   ├── migrations_simple/
    │   │   ├── 20220721115250_add_test_table.sql
    │   │   └── 20220721115524_convert_type.sql
    │   ├── pg_hba.conf
    │   ├── postgres.rs
    │   ├── query_builder.rs
    │   ├── rustsec.rs
    │   ├── setup.sql
    │   ├── test-attr.rs
    │   ├── test-query.sql
    │   └── types.rs
    ├── sqlite/
    │   ├── .gitignore
    │   ├── any.rs
    │   ├── derives.rs
    │   ├── describe.rs
    │   ├── error.rs
    │   ├── fixtures/
    │   │   ├── comments.sql
    │   │   ├── posts.sql
    │   │   └── users.sql
    │   ├── macros.rs
    │   ├── migrate.rs
    │   ├── migrations/
    │   │   ├── 1_user.sql
    │   │   ├── 2_post.sql
    │   │   └── 3_comment.sql
    │   ├── migrations_no_tx/
    │   │   └── 0_vacuum.sql
    │   ├── migrations_no_tx_reversible/
    │   │   ├── 0_vacuum.down.sql
    │   │   └── 0_vacuum.up.sql
    │   ├── migrations_reversible/
    │   │   ├── 20220721124650_add_table.down.sql
    │   │   ├── 20220721124650_add_table.up.sql
    │   │   ├── 20220721125033_modify_column.down.sql
    │   │   └── 20220721125033_modify_column.up.sql
    │   ├── migrations_simple/
    │   │   ├── 20220721115250_add_test_table.sql
    │   │   └── 20220721115524_convert_type.sql
    │   ├── rustsec.rs
    │   ├── setup.sql
    │   ├── sqlcipher.rs
    │   ├── sqlite.rs
    │   ├── test-attr.rs
    │   └── types.rs
    ├── ui/
    │   ├── mysql/
    │   │   └── gated/
    │   │       ├── chrono.rs
    │   │       └── chrono.stderr
    │   ├── postgres/
    │   │   ├── deprecated_rename.rs
    │   │   ├── deprecated_rename.stderr
    │   │   ├── gated/
    │   │   │   ├── chrono.rs
    │   │   │   ├── chrono.stderr
    │   │   │   ├── ipnetwork.rs
    │   │   │   ├── ipnetwork.stderr
    │   │   │   ├── uuid.rs
    │   │   │   └── uuid.stderr
    │   │   ├── issue_30.rs
    │   │   ├── issue_30.stderr
    │   │   ├── unsupported-type.rs
    │   │   ├── unsupported-type.stderr
    │   │   ├── wrong_param_type.rs
    │   │   └── wrong_param_type.stderr
    │   └── sqlite/
    │       ├── expression-column-type.rs
    │       └── expression-column-type.stderr
    ├── ui-tests.rs
    └── x.py

SYMBOL INDEX (5028 symbols across 494 files)

FILE: benches/sqlite/describe.rs
  function do_describe_trivial (line 10) | async fn do_describe_trivial(db: &std::cell::RefCell<SqliteConnection>) {
  function do_describe_recursive (line 14) | async fn do_describe_recursive(db: &std::cell::RefCell<SqliteConnection>) {
  function do_describe_insert (line 36) | async fn do_describe_insert(db: &std::cell::RefCell<SqliteConnection>) {
  function do_describe_insert_fks (line 43) | async fn do_describe_insert_fks(db: &std::cell::RefCell<SqliteConnection...
  function init_connection (line 50) | async fn init_connection() -> SqliteConnection {
  function describe_trivial (line 78) | fn describe_trivial(c: &mut Criterion) {
  function describe_recursive (line 93) | fn describe_recursive(c: &mut Criterion) {
  function describe_insert (line 108) | fn describe_insert(c: &mut Criterion) {
  function describe_insert_fks (line 123) | fn describe_insert_fks(c: &mut Criterion) {

FILE: examples/mysql/todos/migrations/20200718111257_todos.sql
  type todos (line 1) | CREATE TABLE IF NOT EXISTS todos

FILE: examples/mysql/todos/src/main.rs
  type Args (line 6) | struct Args {
  type Command (line 12) | enum Command {
  function main (line 18) | async fn main() -> anyhow::Result<()> {
  function add_todo (line 45) | async fn add_todo(pool: &MySqlPool, description: String) -> anyhow::Resu...
  function complete_todo (line 61) | async fn complete_todo(pool: &MySqlPool, id: u64) -> anyhow::Result<bool> {
  function list_todos (line 77) | async fn list_todos(pool: &MySqlPool) -> anyhow::Result<()> {

FILE: examples/postgres/axum-social-with-tests/migrations/1_user.sql
  type "user" (line 1) | create table "user"

FILE: examples/postgres/axum-social-with-tests/migrations/2_post.sql
  type post (line 1) | create table post (
  type post (line 8) | create index on post(created_at desc)

FILE: examples/postgres/axum-social-with-tests/migrations/3_comment.sql
  type comment (line 1) | create table comment (
  type comment (line 9) | create index on comment(post_id, created_at)

FILE: examples/postgres/axum-social-with-tests/src/http/error.rs
  type Error (line 10) | pub enum Error {
    method status_code (line 66) | fn status_code(&self) -> StatusCode {
  method into_response (line 33) | fn into_response(self) -> Response {

FILE: examples/postgres/axum-social-with-tests/src/http/mod.rs
  type Result (line 12) | pub type Result<T, E = Error> = ::std::result::Result<T, E>;
  function app (line 14) | pub fn app(db: PgPool) -> Router {
  function serve (line 21) | pub async fn serve(db: PgPool) -> anyhow::Result<()> {

FILE: examples/postgres/axum-social-with-tests/src/http/post/comment.rs
  function router (line 18) | pub fn router() -> Router {
  type CreateCommentRequest (line 27) | struct CreateCommentRequest {
  type Comment (line 36) | struct Comment {
  function create_post_comment (line 46) | async fn create_post_comment(
  function get_post_comments (line 78) | async fn get_post_comments(

FILE: examples/postgres/axum-social-with-tests/src/http/post/mod.rs
  function router (line 19) | pub fn router() -> Router {
  type CreatePostRequest (line 27) | struct CreatePostRequest {
  type Post (line 36) | struct Post {
  function create_post (line 46) | async fn create_post(
  function get_posts (line 76) | async fn get_posts(db: Extension<PgPool>) -> Result<Json<Vec<Post>>> {

FILE: examples/postgres/axum-social-with-tests/src/http/user.rs
  type UserId (line 14) | pub type UserId = Uuid;
  function router (line 16) | pub fn router() -> Router {
  type UserAuth (line 26) | pub struct UserAuth {
    method verify (line 67) | pub async fn verify(self, db: impl PgExecutor<'_> + Send) -> Result<Us...
  function create_user (line 35) | async fn create_user(db: Extension<PgPool>, Json(req): Json<UserAuth>) -...

FILE: examples/postgres/axum-social-with-tests/src/main.rs
  function main (line 5) | async fn main() -> anyhow::Result<()> {

FILE: examples/postgres/axum-social-with-tests/src/password.rs
  function hash (line 7) | pub async fn hash(password: String) -> anyhow::Result<String> {
  function verify (line 19) | pub async fn verify(password: String, hash: String) -> anyhow::Result<bo...

FILE: examples/postgres/axum-social-with-tests/tests/comment.rs
  function test_create_comment (line 17) | async fn test_create_comment(db: PgPool) {
  function test_list_comments (line 94) | async fn test_list_comments(db: PgPool) {

FILE: examples/postgres/axum-social-with-tests/tests/common.rs
  type RequestBuilderExt (line 12) | pub trait RequestBuilderExt {
    method json (line 13) | fn json(self, json: serde_json::Value) -> Request<Body>;
    method empty_body (line 15) | fn empty_body(self) -> Request<Body>;
    method json (line 19) | fn json(self, json: serde_json::Value) -> Request<Body> {
    method empty_body (line 25) | fn empty_body(self) -> Request<Body> {
  function response_json (line 30) | pub async fn response_json(resp: &mut Response<BoxBody>) -> serde_json::...
  function expect_string (line 52) | pub fn expect_string(value: &serde_json::Value) -> &str {
  function expect_uuid (line 59) | pub fn expect_uuid(value: &serde_json::Value) -> Uuid {
  function expect_rfc3339_timestamp (line 66) | pub fn expect_rfc3339_timestamp(value: &serde_json::Value) -> OffsetDate...

FILE: examples/postgres/axum-social-with-tests/tests/post.rs
  function test_create_post (line 17) | async fn test_create_post(db: PgPool) {
  function test_list_posts (line 87) | async fn test_list_posts(db: PgPool) {

FILE: examples/postgres/axum-social-with-tests/tests/user.rs
  function test_create_user (line 17) | async fn test_create_user(db: PgPool) {

FILE: examples/postgres/chat/src/main.rs
  type ChatApp (line 22) | struct ChatApp {
    method new (line 29) | fn new(pool: PgPool) -> Self {
    method run (line 37) | async fn run<B: Backend>(
    method ui (line 89) | fn ui(&mut self, frame: &mut Frame, messages: Vec<ListItem>) {
  function main (line 131) | async fn main() -> Result<(), Box<dyn Error>> {
  function notify (line 167) | async fn notify(pool: &PgPool, s: &str) -> Result<(), sqlx::Error> {

FILE: examples/postgres/files/migrations/20220712221654_files.sql
  type users (line 1) | CREATE TABLE IF NOT EXISTS users
  type posts (line 7) | CREATE TABLE IF NOT EXISTS posts

FILE: examples/postgres/files/src/main.rs
  type PostWithAuthorQuery (line 5) | struct PostWithAuthorQuery {
  method fmt (line 14) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function main (line 30) | async fn main() -> anyhow::Result<()> {

FILE: examples/postgres/json/migrations/20200824190010_json.sql
  type people (line 1) | CREATE TABLE IF NOT EXISTS people

FILE: examples/postgres/json/src/main.rs
  type Args (line 10) | struct Args {
  type Command (line 16) | enum Command {
  type Person (line 21) | struct Person {
  type Row (line 28) | struct Row {
  function main (line 34) | async fn main() -> anyhow::Result<()> {
  function add_person (line 61) | async fn add_person(pool: &PgPool, person: Person) -> anyhow::Result<i64> {
  function list_people (line 76) | async fn list_people(pool: &PgPool) -> anyhow::Result<()> {

FILE: examples/postgres/listen/src/main.rs
  constant LISTEN_DURATION (line 11) | const LISTEN_DURATION: Duration = Duration::from_secs(5);
  function main (line 14) | async fn main() -> Result<(), Box<dyn std::error::Error>> {
  function notify (line 80) | async fn notify(pool: &PgPool) {

FILE: examples/postgres/mockable-todos/migrations/20200718111257_todos.sql
  type todos (line 1) | CREATE TABLE IF NOT EXISTS todos

FILE: examples/postgres/mockable-todos/src/main.rs
  type Args (line 7) | struct Args {
  type Command (line 13) | enum Command {
  function main (line 19) | async fn main() -> anyhow::Result<()> {
  function handle_command (line 29) | async fn handle_command(
  type TodoRepo (line 63) | pub trait TodoRepo {
    method add_todo (line 64) | async fn add_todo(&self, description: String) -> anyhow::Result<i64>;
    method complete_todo (line 65) | async fn complete_todo(&self, id: i64) -> anyhow::Result<bool>;
    method list_todos (line 66) | async fn list_todos(&self) -> anyhow::Result<()>;
    method add_todo (line 83) | async fn add_todo(&self, description: String) -> anyhow::Result<i64> {
    method complete_todo (line 98) | async fn complete_todo(&self, id: i64) -> anyhow::Result<bool> {
    method list_todos (line 114) | async fn list_todos(&self) -> anyhow::Result<()> {
  type PostgresTodoRepo (line 69) | struct PostgresTodoRepo {
    method new (line 74) | fn new(pg_pool: PgPool) -> Self {
  function test_mocked_add (line 144) | async fn test_mocked_add() {

FILE: examples/postgres/multi-database/accounts/migrations/01_setup.sql
  function set_updated_at (line 10) | create or replace function set_updated_at()

FILE: examples/postgres/multi-database/accounts/migrations/02_account.sql
  type account (line 1) | create table account

FILE: examples/postgres/multi-database/accounts/migrations/03_session.sql
  type session (line 1) | create table session

FILE: examples/postgres/multi-database/accounts/src/lib.rs
  type AccountId (line 13) | pub struct AccountId(pub Uuid);
  type SessionToken (line 17) | pub struct SessionToken(pub String);
    constant LEN (line 288) | const LEN: usize = 32;
    method generate (line 290) | fn generate() -> Self {
  type Session (line 19) | pub struct Session {
  type AccountsManager (line 25) | pub struct AccountsManager {
    method setup (line 112) | pub async fn setup(
    method hash_password (line 133) | async fn hash_password(&self, password: String) -> Result<PasswordHash...
    method verify_password (line 157) | async fn verify_password(
    method create (line 187) | pub async fn create(
    method create_session (line 218) | pub async fn create_session(
    method auth_session (line 273) | pub async fn auth_session(
  type CreateAccountError (line 64) | pub enum CreateAccountError {
  type CreateSessionError (line 76) | pub enum CreateSessionError {
  type GeneralError (line 90) | pub enum GeneralError {

FILE: examples/postgres/multi-database/payments/migrations/01_setup.sql
  function set_updated_at (line 10) | create or replace function set_updated_at()

FILE: examples/postgres/multi-database/payments/migrations/02_payment.sql
  type payment (line 17) | create table payment

FILE: examples/postgres/multi-database/payments/src/lib.rs
  type PaymentId (line 9) | pub struct PaymentId(pub Uuid);
  type PaymentStatus (line 14) | pub enum PaymentStatus {
  type Payment (line 27) | pub struct Payment {
  type PaymentsManager (line 39) | pub struct PaymentsManager {
    method setup (line 44) | pub async fn setup(opts: PgConnectOptions) -> sqlx::Result<Self> {
    method create (line 57) | pub async fn create(
    method get (line 117) | pub async fn get(&self, payment_id: PaymentId) -> sqlx::Result<Option<...

FILE: examples/postgres/multi-database/src/main.rs
  function main (line 9) | async fn main() -> eyre::Result<()> {

FILE: examples/postgres/multi-database/src/migrations/01_setup.sql
  function set_updated_at (line 10) | create or replace function set_updated_at()

FILE: examples/postgres/multi-database/src/migrations/02_purchase.sql
  type purchase (line 1) | create table purchase

FILE: examples/postgres/multi-tenant/accounts/migrations/01_setup.sql
  function accounts (line 10) | create or replace function accounts.set_updated_at()

FILE: examples/postgres/multi-tenant/accounts/migrations/02_account.sql
  type accounts (line 1) | create table accounts.account

FILE: examples/postgres/multi-tenant/accounts/migrations/03_session.sql
  type accounts (line 1) | create table accounts.session

FILE: examples/postgres/multi-tenant/accounts/src/lib.rs
  type AccountId (line 12) | pub struct AccountId(pub Uuid);
  type SessionToken (line 16) | pub struct SessionToken(pub String);
    constant LEN (line 279) | const LEN: usize = 32;
    method generate (line 281) | fn generate() -> Self {
  type Session (line 18) | pub struct Session {
  type AccountsManager (line 23) | pub struct AccountsManager {
    method setup (line 107) | pub async fn setup(
    method hash_password (line 121) | async fn hash_password(&self, password: String) -> Result<PasswordHash...
    method verify_password (line 145) | async fn verify_password(
    method create (line 175) | pub async fn create(
    method create_session (line 207) | pub async fn create_session(
    method auth_session (line 263) | pub async fn auth_session(
  type CreateAccountError (line 59) | pub enum CreateAccountError {
  type CreateSessionError (line 71) | pub enum CreateSessionError {
  type GeneralError (line 85) | pub enum GeneralError {

FILE: examples/postgres/multi-tenant/payments/migrations/01_setup.sql
  function payments (line 10) | create or replace function payments.set_updated_at()

FILE: examples/postgres/multi-tenant/payments/migrations/02_payment.sql
  type payments (line 17) | create table payments.payment

FILE: examples/postgres/multi-tenant/payments/src/lib.rs
  type PaymentId (line 8) | pub struct PaymentId(pub Uuid);
  type PaymentStatus (line 13) | pub enum PaymentStatus {
  type Payment (line 26) | pub struct Payment {
  function migrate (line 39) | pub async fn migrate(db: impl Acquire<'_, Database = Postgres>) -> sqlx:...
  function create (line 44) | pub async fn create(
  function get (line 101) | pub async fn get(db: &mut PgConnection, payment_id: PaymentId) -> sqlx::...

FILE: examples/postgres/multi-tenant/src/main.rs
  function main (line 8) | async fn main() -> eyre::Result<()> {

FILE: examples/postgres/multi-tenant/src/migrations/01_setup.sql
  function set_updated_at (line 10) | create or replace function set_updated_at()

FILE: examples/postgres/multi-tenant/src/migrations/02_purchase.sql
  type purchase (line 1) | create table purchase

FILE: examples/postgres/preferred-crates/src/main.rs
  type SessionData (line 8) | struct SessionData {
  type User (line 13) | struct User {
  constant SESSION_DURATION (line 23) | const SESSION_DURATION: Duration = Duration::from_secs(60 * 60);
  function main (line 26) | async fn main() -> anyhow::Result<()> {

FILE: examples/postgres/preferred-crates/src/migrations/01_setup.sql
  function set_updated_at (line 10) | create or replace function set_updated_at()

FILE: examples/postgres/preferred-crates/src/migrations/02_users.sql
  type users (line 1) | create table users(
  type users_username_unique (line 9) | create unique index users_username_unique on users(lower(username))

FILE: examples/postgres/preferred-crates/uses-rust-decimal/src/lib.rs
  type Purchase (line 5) | pub struct Purchase {
  function create_table (line 16) | pub async fn create_table(e: impl PgExecutor<'_>) -> sqlx::Result<()> {
  function create_purchase (line 34) | pub async fn create_purchase(
  function get_purchase (line 50) | pub async fn get_purchase(e: impl PgExecutor<'_>, id: Uuid) -> sqlx::Res...

FILE: examples/postgres/preferred-crates/uses-time/src/lib.rs
  type Session (line 11) | pub struct Session<D> {
  function create_table (line 19) | pub async fn create_table(e: impl PgExecutor<'_>) -> sqlx::Result<()> {
  function create_session (line 35) | pub async fn create_session<D: Serialize>(
  function get_session (line 67) | pub async fn get_session<D: DeserializeOwned + Send + Unpin + 'static>(

FILE: examples/postgres/todos/migrations/20200718111257_todos.sql
  type todos (line 1) | CREATE TABLE IF NOT EXISTS todos

FILE: examples/postgres/todos/src/main.rs
  type Args (line 6) | struct Args {
  type Command (line 12) | enum Command {
  function main (line 18) | async fn main() -> anyhow::Result<()> {
  function add_todo (line 45) | async fn add_todo(pool: &PgPool, description: String) -> anyhow::Result<...
  function complete_todo (line 60) | async fn complete_todo(pool: &PgPool, id: i64) -> anyhow::Result<bool> {
  function list_todos (line 76) | async fn list_todos(pool: &PgPool) -> anyhow::Result<()> {

FILE: examples/postgres/transaction/migrations/20200718111257_todos.sql
  type todos (line 1) | CREATE TABLE IF NOT EXISTS todos

FILE: examples/postgres/transaction/src/main.rs
  function insert_and_verify (line 3) | async fn insert_and_verify(
  function explicit_rollback_example (line 27) | async fn explicit_rollback_example(
  function implicit_rollback_example (line 40) | async fn implicit_rollback_example(
  function commit_example (line 52) | async fn commit_example(
  function main (line 66) | async fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: examples/sqlite/extension/migrations/20250203094951_addresses.sql
  type addresses (line 1) | create table addresses (address text, family integer)

FILE: examples/sqlite/extension/src/main.rs
  function main (line 9) | async fn main() -> anyhow::Result<()> {

FILE: examples/sqlite/todos/migrations/20200718111257_todos.sql
  type todos (line 1) | CREATE TABLE IF NOT EXISTS todos

FILE: examples/sqlite/todos/src/main.rs
  type Args (line 6) | struct Args {
  type Command (line 12) | enum Command {
  function main (line 18) | async fn main() -> anyhow::Result<()> {
  function add_todo (line 45) | async fn add_todo(pool: &SqlitePool, description: String) -> anyhow::Res...
  function complete_todo (line 63) | async fn complete_todo(pool: &SqlitePool, id: i64) -> anyhow::Result<boo...
  function list_todos (line 79) | async fn list_todos(pool: &SqlitePool) -> anyhow::Result<()> {

FILE: examples/x.py
  function run (line 28) | def run(command, env=None, cwd=None, display=None):
  function sqlx (line 45) | def sqlx(command, url, cwd=None):
  function project (line 50) | def project(name, database=None, driver=None):

FILE: sqlx-cli/src/bin/cargo-sqlx.rs
  type Cli (line 10) | enum Cli {
  function main (line 15) | async fn main() {

FILE: sqlx-cli/src/bin/sqlx.rs
  function main (line 6) | async fn main() {

FILE: sqlx-cli/src/completions.rs
  function run (line 8) | pub fn run(shell: Shell) {

FILE: sqlx-cli/src/database.rs
  function create (line 10) | pub async fn create(connect_opts: &ConnectOpts) -> anyhow::Result<()> {
  function drop (line 28) | pub async fn drop(connect_opts: &ConnectOpts, confirm: bool, force: bool...
  function reset (line 48) | pub async fn reset(
  function setup (line 59) | pub async fn setup(
  function ask_to_continue_drop (line 68) | async fn ask_to_continue_drop(db_url: String) -> bool {

FILE: sqlx-cli/src/lib.rs
  function maybe_apply_dotenv (line 47) | pub fn maybe_apply_dotenv() {
  function run (line 59) | pub async fn run(opt: Opt) -> anyhow::Result<()> {
  function do_run (line 79) | async fn do_run(opt: Opt) -> anyhow::Result<()> {
  function connect (line 215) | async fn connect(config: &Config, opts: &ConnectOpts) -> anyhow::Result<...
  function retry_connect_errors (line 226) | async fn retry_connect_errors<'a, F, Fut, T>(

FILE: sqlx-cli/src/metadata.rs
  type Package (line 19) | pub struct Package {
    method name (line 25) | pub fn name(&self) -> &str {
    method src_paths (line 29) | pub fn src_paths(&self) -> &[PathBuf] {
    method from (line 35) | fn from(package: &MetadataPackage) -> Self {
  type Metadata (line 48) | pub struct Metadata {
    method from_current_directory (line 70) | pub fn from_current_directory(cargo: &OsStr) -> anyhow::Result<Self> {
    method package (line 82) | pub fn package(&self, id: &MetadataId) -> Option<&Package> {
    method entries (line 86) | pub fn entries(&self) -> btree_map::Iter<'_, MetadataId, Package> {
    method workspace_members (line 90) | pub fn workspace_members(&self) -> &[MetadataId] {
    method workspace_root (line 94) | pub fn workspace_root(&self) -> &Path {
    method target_directory (line 98) | pub fn target_directory(&self) -> &Path {
    method current_package (line 102) | pub fn current_package(&self) -> Option<&Package> {
    method all_dependents_of (line 107) | pub fn all_dependents_of(&self, id: &MetadataId) -> BTreeSet<&Metadata...
    method all_dependents_of_helper (line 113) | fn all_dependents_of_helper<'this>(
  type Err (line 129) | type Err = anyhow::Error;
  method from_str (line 131) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function manifest_dir (line 183) | pub(crate) fn manifest_dir(cargo: &OsStr) -> anyhow::Result<PathBuf> {

FILE: sqlx-cli/src/migrate.rs
  function add (line 14) | pub async fn add(opts: AddMigrationOpts) -> anyhow::Result<()> {
  function create_file (line 92) | fn create_file(
  function short_checksum (line 118) | fn short_checksum(checksum: &[u8]) -> String {
  function info (line 126) | pub async fn info(
  function validate_applied_migrations (line 196) | fn validate_applied_migrations(
  function run (line 216) | pub async fn run(
  function revert (line 318) | pub async fn revert(
  function build_script (line 422) | pub fn build_script(

FILE: sqlx-cli/src/opt.rs
  constant HELP_STYLES (line 16) | const HELP_STYLES: Styles = Styles::styled()
  type Opt (line 24) | pub struct Opt {
  type Command (line 35) | pub enum Command {
  type DatabaseOpt (line 86) | pub struct DatabaseOpt {
  type DatabaseCommand (line 92) | pub enum DatabaseCommand {
  type MigrateOpt (line 152) | pub struct MigrateOpt {
  type MigrateCommand (line 158) | pub enum MigrateCommand {
  type AddMigrationOpts (line 304) | pub struct AddMigrationOpts {
    method reversible (line 516) | pub fn reversible(&self, config: &Config, migrator: &Migrator) -> bool {
    method version_prefix (line 534) | pub fn version_prefix(&self, config: &Config, migrator: &Migrator) -> ...
  type MigrationSourceOpt (line 336) | pub struct MigrationSourceOpt {
    method resolve_path (line 345) | pub fn resolve_path<'a>(&'a self, config: &'a Config) -> &'a str {
    method resolve (line 353) | pub async fn resolve(&self, config: &Config) -> Result<Migrator, Migra...
  type ConnectOpts (line 364) | pub struct ConnectOpts {
    method expect_db_url (line 417) | pub fn expect_db_url(&self) -> anyhow::Result<&str> {
    method populate_db_url (line 424) | pub fn populate_db_url(&mut self, config: &Config) -> anyhow::Result<(...
  type NoDotenvOpt (line 391) | pub struct NoDotenvOpt {
  type ConfigOpt (line 401) | pub struct ConfigOpt {
    method load_config (line 458) | pub async fn load_config(&self) -> anyhow::Result<Config> {
  type Confirmation (line 484) | pub struct Confirmation {
  type IgnoreMissing (line 493) | pub struct IgnoreMissing {
  type Target (line 500) | type Target = bool;
  method deref (line 502) | fn deref(&self) -> &Self::Target {
  type Output (line 508) | type Output = bool;
  method not (line 510) | fn not(self) -> Self::Output {
  function next_timestamp (line 571) | fn next_timestamp() -> String {
  function fmt_sequential (line 575) | fn fmt_sequential(version: i64) -> String {

FILE: sqlx-cli/src/prepare.rs
  type PrepareCtx (line 15) | pub struct PrepareCtx<'a> {
  function prepare_dir (line 27) | fn prepare_dir(&self) -> anyhow::Result<PathBuf> {
  function run (line 36) | pub async fn run(
  function prepare (line 71) | async fn prepare(ctx: &PrepareCtx<'_>) -> anyhow::Result<()> {
  function prepare_check (line 99) | async fn prepare_check(ctx: &PrepareCtx<'_>) -> anyhow::Result<()> {
  function run_prepare_step (line 153) | fn run_prepare_step(ctx: &PrepareCtx, cache_dir: &Path) -> anyhow::Resul...
  type ProjectRecompileAction (line 208) | struct ProjectRecompileAction {
  function setup_minimal_project_recompile (line 222) | fn setup_minimal_project_recompile(
  function minimal_project_clean (line 255) | fn minimal_project_clean(
  function minimal_project_recompile_action (line 285) | fn minimal_project_recompile_action(metadata: &Metadata, all: bool) -> P...
  function glob_query_files (line 344) | fn glob_query_files(path: impl AsRef<Path>) -> anyhow::Result<Vec<PathBu...
  function load_json_file (line 358) | fn load_json_file(path: impl AsRef<Path>) -> anyhow::Result<serde_json::...
  function check_backend (line 365) | async fn check_backend(config: &Config, opts: &ConnectOpts) -> anyhow::R...
  function minimal_project_recompile_action_works (line 376) | fn minimal_project_recompile_action_works() -> anyhow::Result<()> {

FILE: sqlx-cli/tests/add.rs
  type FileName (line 10) | struct FileName {
    method partial_cmp (line 17) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    method assert_is_timestamp (line 27) | fn assert_is_timestamp(&self) {
    method from (line 36) | fn from(path: PathBuf) -> Self {
  type AddMigrationsResult (line 49) | struct AddMigrationsResult(Vec<FileName>);
    method len (line 51) | fn len(&self) -> usize {
    method assert_is_reversible (line 54) | fn assert_is_reversible(&self) {
    method assert_is_not_reversible (line 69) | fn assert_is_not_reversible(&self) {
    type Output (line 78) | type Output = FileName;
    method index (line 80) | fn index(&self, index: usize) -> &Self::Output {
  type AddMigrations (line 85) | struct AddMigrations {
    method new (line 91) | fn new() -> anyhow::Result<Self> {
    method with_config (line 98) | fn with_config(mut self, filename: &str) -> anyhow::Result<Self> {
    method run (line 112) | fn run(
    method fs_output (line 150) | fn fs_output(&self) -> anyhow::Result<AddMigrationsResult> {
  function recurse_files (line 161) | fn recurse_files(path: impl AsRef<Path>) -> anyhow::Result<Vec<PathBuf>> {
  function add_migration_error_ambiguous (line 183) | fn add_migration_error_ambiguous() -> anyhow::Result<()> {
  function add_migration_sequential (line 197) | fn add_migration_sequential() -> anyhow::Result<()> {
  function add_migration_sequential_reversible (line 221) | fn add_migration_sequential_reversible() -> anyhow::Result<()> {
  function add_migration_timestamp (line 251) | fn add_migration_timestamp() -> anyhow::Result<()> {
  function add_migration_timestamp_reversible (line 275) | fn add_migration_timestamp_reversible() -> anyhow::Result<()> {
  function add_migration_config_default_type_reversible (line 322) | fn add_migration_config_default_type_reversible() -> anyhow::Result<()> {
  function add_migration_config_default_versioning_sequential (line 347) | fn add_migration_config_default_versioning_sequential() -> anyhow::Resul...
  function add_migration_config_default_versioning_timestamp (line 367) | fn add_migration_config_default_versioning_timestamp() -> anyhow::Result...

FILE: sqlx-cli/tests/common/mod.rs
  type TestDatabase (line 10) | pub struct TestDatabase {
    method new (line 17) | pub fn new(name: &str, migrations: &str) -> Self {
    method set_migrations (line 53) | pub fn set_migrations(&mut self, migrations: &str) {
    method connection_string (line 57) | pub fn connection_string(&self) -> String {
    method run_migration (line 61) | pub fn run_migration(&self, revert: bool, version: Option<i64>, dry_ru...
    method applied_migrations (line 91) | pub async fn applied_migrations(&self) -> Vec<i64> {
    method migrate_info (line 106) | pub fn migrate_info(&self) -> Assert {
  method drop (line 127) | fn drop(&mut self) {

FILE: sqlx-cli/tests/ignored-chars/BOM/1_user.sql
  type user (line 1) | create table user

FILE: sqlx-cli/tests/ignored-chars/BOM/2_post.sql
  type post (line 1) | create table post
  type post_created_at (line 10) | create index post_created_at on post (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/BOM/3_comment.sql
  type comment (line 1) | create table comment
  type comment_created_at (line 10) | create index comment_created_at on comment (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/CRLF/1_user.sql
  type user (line 1) | create table user

FILE: sqlx-cli/tests/ignored-chars/CRLF/2_post.sql
  type post (line 1) | create table post
  type post_created_at (line 10) | create index post_created_at on post (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/CRLF/3_comment.sql
  type comment (line 1) | create table comment
  type comment_created_at (line 10) | create index comment_created_at on comment (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/LF/1_user.sql
  type user (line 1) | create table user

FILE: sqlx-cli/tests/ignored-chars/LF/2_post.sql
  type post (line 1) | create table post
  type post_created_at (line 10) | create index post_created_at on post (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/LF/3_comment.sql
  type comment (line 1) | create table comment
  type comment_created_at (line 10) | create index comment_created_at on comment (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/oops-all-tabs/1_user.sql
  type user (line 1) | create table user

FILE: sqlx-cli/tests/ignored-chars/oops-all-tabs/2_post.sql
  type post (line 1) | create table post
  type post_created_at (line 10) | create index post_created_at on post (created_at desc)

FILE: sqlx-cli/tests/ignored-chars/oops-all-tabs/3_comment.sql
  type comment (line 1) | create table comment
  type comment_created_at (line 10) | create index comment_created_at on comment (created_at desc)

FILE: sqlx-cli/tests/migrate.rs
  function run_reversible_migrations (line 6) | async fn run_reversible_migrations() {
  function revert_migrations (line 78) | async fn revert_migrations() {
  function ignored_chars (line 144) | async fn ignored_chars() {

FILE: sqlx-cli/tests/migrations_reversible/20230101000000_test1.up.sql
  type test1 (line 1) | CREATE TABLE test1(x INTEGER PRIMARY KEY)

FILE: sqlx-cli/tests/migrations_reversible/20230201000000_test2.up.sql
  type test2 (line 1) | CREATE TABLE test2(x INTEGER PRIMARY KEY)

FILE: sqlx-cli/tests/migrations_reversible/20230301000000_test3.up.sql
  type test3 (line 1) | CREATE TABLE test3(x INTEGER PRIMARY KEY)

FILE: sqlx-cli/tests/migrations_reversible/20230401000000_test4.up.sql
  type test4 (line 1) | CREATE TABLE test4(x INTEGER PRIMARY KEY)

FILE: sqlx-cli/tests/migrations_reversible/20230501000000_test5.up.sql
  type test5 (line 1) | CREATE TABLE test5(x INTEGER PRIMARY KEY)

FILE: sqlx-core/src/acquire.rs
  type Acquire (line 70) | pub trait Acquire<'c> {
    method acquire (line 75) | fn acquire(self) -> BoxFuture<'c, Result<Self::Connection, Error>>;
    method begin (line 77) | fn begin(self) -> BoxFuture<'c, Result<Transaction<'c, Self::Database>...
  type Database (line 81) | type Database = DB;
  type Connection (line 83) | type Connection = PoolConnection<DB>;
  function acquire (line 85) | fn acquire(self) -> BoxFuture<'static, Result<Self::Connection, Error>> {
  function begin (line 89) | fn begin(self) -> BoxFuture<'static, Result<Transaction<'a, DB>, Error>> {

FILE: sqlx-core/src/any/arguments.rs
  type AnyArguments (line 10) | pub struct AnyArguments {
    method convert_into (line 40) | pub fn convert_into<'a, A: Arguments>(self) -> Result<A, BoxDynError>
  type Database (line 16) | type Database = Any;
  method reserve (line 18) | fn reserve(&mut self, additional: usize, _size: usize) {
  method add (line 22) | fn add<'t, T>(&mut self, value: T) -> Result<(), BoxDynError>
  method len (line 30) | fn len(&self) -> usize {
  type AnyArgumentBuffer (line 36) | pub struct AnyArgumentBuffer(#[doc(hidden)] pub Vec<AnyValueKind>);

FILE: sqlx-core/src/any/column.rs
  type AnyColumn (line 6) | pub struct AnyColumn {
  type Database (line 18) | type Database = Any;
  method ordinal (line 20) | fn ordinal(&self) -> usize {
  method name (line 24) | fn name(&self) -> &str {
  method type_info (line 28) | fn type_info(&self) -> &AnyTypeInfo {

FILE: sqlx-core/src/any/connection/backend.rs
  type AnyConnectionBackend (line 8) | pub trait AnyConnectionBackend: std::any::Any + Debug + Send + 'static {
    method name (line 10) | fn name(&self) -> &str;
    method close (line 17) | fn close(self: Box<Self>) -> BoxFuture<'static, crate::Result<()>>;
    method close_hard (line 23) | fn close_hard(self: Box<Self>) -> BoxFuture<'static, crate::Result<()>>;
    method ping (line 26) | fn ping(&mut self) -> BoxFuture<'_, crate::Result<()>>;
    method begin (line 35) | fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, crate:...
    method commit (line 37) | fn commit(&mut self) -> BoxFuture<'_, crate::Result<()>>;
    method rollback (line 39) | fn rollback(&mut self) -> BoxFuture<'_, crate::Result<()>>;
    method start_rollback (line 41) | fn start_rollback(&mut self);
    method get_transaction_depth (line 49) | fn get_transaction_depth(&self) -> usize {
    method is_in_transaction (line 59) | fn is_in_transaction(&self) -> bool {
    method cached_statements_size (line 64) | fn cached_statements_size(&self) -> usize {
    method clear_cached_statements (line 70) | fn clear_cached_statements(&mut self) -> BoxFuture<'_, crate::Result<(...
    method shrink_buffers (line 77) | fn shrink_buffers(&mut self);
    method flush (line 80) | fn flush(&mut self) -> BoxFuture<'_, crate::Result<()>>;
    method should_flush (line 83) | fn should_flush(&self) -> bool;
    method as_migrate (line 86) | fn as_migrate(&mut self) -> crate::Result<&mut (dyn crate::migrate::Mi...
    method fetch_many (line 96) | fn fetch_many(
    method fetch_optional (line 103) | fn fetch_optional(
    method prepare_with (line 110) | fn prepare_with<'c, 'q: 'c>(
    method describe (line 117) | fn describe(

FILE: sqlx-core/src/any/connection/executor.rs
  type Database (line 12) | type Database = Any;
  function fetch_many (line 14) | fn fetch_many<'e, 'q: 'e, E>(
  function fetch_optional (line 30) | fn fetch_optional<'e, 'q: 'e, E>(
  function prepare_with (line 47) | fn prepare_with<'e>(
  function describe (line 59) | fn describe<'e>(

FILE: sqlx-core/src/any/connection/mod.rs
  type AnyConnection (line 27) | pub struct AnyConnection {
    method backend_name (line 33) | pub fn backend_name(&self) -> &str {
    method connect (line 37) | pub(crate) fn connect(options: &AnyConnectOptions) -> BoxFuture<'_, cr...
    method connect_with_driver_config (line 49) | pub async fn connect_with_driver_config(
    method connect_with_db (line 62) | pub(crate) fn connect_with_db<'a, DB: Database>(
    method get_migrate (line 87) | pub(crate) fn get_migrate(
  type Database (line 95) | type Database = Any;
  type Options (line 97) | type Options = AnyConnectOptions;
  method close (line 99) | fn close(self) -> impl Future<Output = Result<(), Error>> + Send + 'stat...
  method close_hard (line 103) | fn close_hard(self) -> impl Future<Output = Result<(), Error>> + Send + ...
  method ping (line 107) | fn ping(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_ {
  method begin (line 111) | fn begin(
  method begin_with (line 120) | fn begin_with(
  method cached_statements_size (line 130) | fn cached_statements_size(&self) -> usize {
  method clear_cached_statements (line 134) | fn clear_cached_statements(&mut self) -> impl Future<Output = crate::Res...
  method shrink_buffers (line 138) | fn shrink_buffers(&mut self) {
  method flush (line 143) | fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + ...
  method should_flush (line 148) | fn should_flush(&self) -> bool {

FILE: sqlx-core/src/any/database.rs
  type Any (line 10) | pub struct Any;
  type Connection (line 13) | type Connection = AnyConnection;
  type TransactionManager (line 15) | type TransactionManager = AnyTransactionManager;
  type Row (line 17) | type Row = AnyRow;
  type QueryResult (line 19) | type QueryResult = AnyQueryResult;
  type Column (line 21) | type Column = AnyColumn;
  type TypeInfo (line 23) | type TypeInfo = AnyTypeInfo;
  type Value (line 25) | type Value = AnyValue;
  type ValueRef (line 26) | type ValueRef<'r> = AnyValueRef<'r>;
  type Arguments (line 28) | type Arguments = AnyArguments;
  type ArgumentBuffer (line 29) | type ArgumentBuffer = AnyArgumentBuffer;
  type Statement (line 31) | type Statement = AnyStatement;
  constant NAME (line 33) | const NAME: &'static str = "Any";
  constant URL_SCHEMES (line 35) | const URL_SCHEMES: &'static [&'static str] = &[];

FILE: sqlx-core/src/any/driver.rs
  type AnyDriver (line 28) | pub struct AnyDriver {
    method without_migrate (line 41) | pub const fn without_migrate<DB: Database>() -> Self
    method with_migrate (line 56) | pub const fn with_migrate<DB: Database>() -> Self
    method with_migrate (line 66) | pub const fn with_migrate<DB: Database + crate::migrate::MigrateDataba...
    method get_migrate_database (line 83) | pub fn get_migrate_database(&self) -> crate::Result<&AnyMigrateDatabas...
  method fmt (line 90) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type AnyMigrateDatabase (line 98) | pub struct AnyMigrateDatabase {
    method create_database (line 106) | pub fn create_database<'a>(&self, url: &'a str) -> BoxFuture<'a, crate...
    method database_exists (line 110) | pub fn database_exists<'a>(&self, url: &'a str) -> BoxFuture<'a, crate...
    method drop_database (line 114) | pub fn drop_database<'a>(&self, url: &'a str) -> BoxFuture<'a, crate::...
    method force_drop_database (line 118) | pub fn force_drop_database<'a>(&self, url: &'a str) -> BoxFuture<'a, c...
  function install_drivers (line 129) | pub fn install_drivers(
  function from_url_str (line 138) | pub(crate) fn from_url_str(url: &str) -> crate::Result<&'static AnyDrive...
  function from_url (line 142) | pub(crate) fn from_url(url: &Url) -> crate::Result<&'static AnyDriver> {

FILE: sqlx-core/src/any/error.rs
  function mismatched_types (line 9) | pub(super) fn mismatched_types<T: Type<Any>>(ty: &AnyTypeInfo) -> BoxDyn...

FILE: sqlx-core/src/any/kind.rs
  type AnyKind (line 12) | pub enum AnyKind {
  type Err (line 27) | type Err = Error;
  method from_str (line 29) | fn from_str(url: &str) -> Result<Self, Self::Err> {

FILE: sqlx-core/src/any/migrate.rs
  method create_database (line 9) | async fn create_database(url: &str) -> Result<(), Error> {
  method database_exists (line 16) | async fn database_exists(url: &str) -> Result<bool, Error> {
  method drop_database (line 23) | async fn drop_database(url: &str) -> Result<(), Error> {
  method force_drop_database (line 30) | async fn force_drop_database(url: &str) -> Result<(), Error> {
  method create_schema_if_not_exists (line 39) | fn create_schema_if_not_exists<'e>(
  method ensure_migrations_table (line 50) | fn ensure_migrations_table<'e>(
  method dirty_version (line 61) | fn dirty_version<'e>(
  method list_applied_migrations (line 68) | fn list_applied_migrations<'e>(
  method lock (line 79) | fn lock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method unlock (line 83) | fn unlock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method apply (line 87) | fn apply<'e>(
  method revert (line 95) | fn revert<'e>(

FILE: sqlx-core/src/any/mod.rs
  type AnyPool (line 50) | pub type AnyPool = crate::pool::Pool<Any>;
  type AnyPoolOptions (line 52) | pub type AnyPoolOptions = crate::pool::PoolOptions<Any>;
  type AnyExecutor (line 55) | pub trait AnyExecutor<'c>: Executor<'c, Database = Any> {}
  function encode_by_ref (line 72) | fn encode_by_ref(

FILE: sqlx-core/src/any/options.rs
  type AnyConnectOptions (line 19) | pub struct AnyConnectOptions {
  type Err (line 24) | type Err = Error;
  method from_str (line 26) | fn from_str(url: &str) -> Result<Self, Self::Err> {
  type Connection (line 37) | type Connection = AnyConnection;
  method from_url (line 39) | fn from_url(url: &Url) -> Result<Self, Error> {
  method to_url_lossy (line 46) | fn to_url_lossy(&self) -> Url {
  method connect (line 51) | fn connect(&self) -> impl Future<Output = Result<AnyConnection, Error>> ...
  method log_statements (line 55) | fn log_statements(mut self, level: LevelFilter) -> Self {
  method log_slow_statements (line 60) | fn log_slow_statements(mut self, level: LevelFilter, duration: Duration)...

FILE: sqlx-core/src/any/query_result.rs
  type AnyQueryResult (line 4) | pub struct AnyQueryResult {
    method rows_affected (line 12) | pub fn rows_affected(&self) -> u64 {
    method last_insert_id (line 16) | pub fn last_insert_id(&self) -> Option<i64> {
    method extend (line 22) | fn extend<T: IntoIterator<Item = AnyQueryResult>>(&mut self, iter: T) {

FILE: sqlx-core/src/any/row.rs
  type AnyRow (line 15) | pub struct AnyRow {
    method map_from (line 82) | pub fn map_from<'a, R: Row>(
  type Database (line 25) | type Database = Any;
  method columns (line 27) | fn columns(&self) -> &[AnyColumn] {
  method try_get_raw (line 31) | fn try_get_raw<I>(&self, index: I) -> Result<<Self::Database as Database...
  method try_get (line 46) | fn try_get<'r, T, I>(&'r self, index: I) -> Result<T, Error>
  function index (line 67) | fn index(&self, row: &AnyRow) -> Result<usize, Error> {
  function decode (line 140) | fn decode<'r, DB: Database, T: Decode<'r, DB>>(

FILE: sqlx-core/src/any/statement.rs
  type AnyStatement (line 13) | pub struct AnyStatement {
    method try_from_statement (line 62) | pub fn try_from_statement<S>(
  type Database (line 25) | type Database = Any;
  method into_sql (line 27) | fn into_sql(self) -> SqlStr {
  method sql (line 31) | fn sql(&self) -> &SqlStr {
  method parameters (line 35) | fn parameters(&self) -> Option<Either<&[AnyTypeInfo], usize>> {
  method columns (line 43) | fn columns(&self) -> &[AnyColumn] {
  function index (line 51) | fn index(&self, statement: &AnyStatement) -> Result<usize, Error> {

FILE: sqlx-core/src/any/transaction.rs
  type AnyTransactionManager (line 9) | pub struct AnyTransactionManager;
  type Database (line 12) | type Database = Any;
  method begin (line 14) | fn begin(
  method commit (line 21) | fn commit(conn: &mut AnyConnection) -> impl Future<Output = Result<(), E...
  method rollback (line 25) | fn rollback(conn: &mut AnyConnection) -> impl Future<Output = Result<(),...
  method start_rollback (line 29) | fn start_rollback(conn: &mut AnyConnection) {
  method get_transaction_depth (line 33) | fn get_transaction_depth(conn: &<Self::Database as Database>::Connection...

FILE: sqlx-core/src/any/type_info.rs
  type AnyTypeInfo (line 8) | pub struct AnyTypeInfo {
    method kind (line 14) | pub fn kind(&self) -> AnyTypeInfoKind {
  type AnyTypeInfoKind (line 20) | pub enum AnyTypeInfoKind {
    method is_integer (line 61) | pub fn is_integer(&self) -> bool {
  method is_null (line 33) | fn is_null(&self) -> bool {
  method name (line 37) | fn name(&self) -> &str {
  method fmt (line 55) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: sqlx-core/src/any/types/blob.rs
  function type_info (line 10) | fn type_info() -> AnyTypeInfo {
  function encode_by_ref (line 18) | fn encode_by_ref(
  function decode (line 28) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...
  function type_info (line 37) | fn type_info() -> AnyTypeInfo {
  function encode_by_ref (line 43) | fn encode_by_ref(
  function decode (line 53) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...

FILE: sqlx-core/src/any/types/bool.rs
  function type_info (line 9) | fn type_info() -> AnyTypeInfo {
  function encode_by_ref (line 17) | fn encode_by_ref(
  function decode (line 27) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...

FILE: sqlx-core/src/any/types/float.rs
  function type_info (line 9) | fn type_info() -> AnyTypeInfo {
  function encode_by_ref (line 17) | fn encode_by_ref(&self, buf: &mut AnyArgumentBuffer) -> Result<IsNull, B...
  function decode (line 24) | fn decode(value: AnyValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 33) | fn type_info() -> AnyTypeInfo {
  function encode_by_ref (line 41) | fn encode_by_ref(
  function decode (line 51) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...

FILE: sqlx-core/src/any/types/int.rs
  function type_info (line 9) | fn type_info() -> AnyTypeInfo {
  function compatible (line 15) | fn compatible(ty: &AnyTypeInfo) -> bool {
  function encode_by_ref (line 21) | fn encode_by_ref(
  function decode (line 31) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...
  function type_info (line 37) | fn type_info() -> AnyTypeInfo {
  function compatible (line 43) | fn compatible(ty: &AnyTypeInfo) -> bool {
  function encode_by_ref (line 49) | fn encode_by_ref(
  function decode (line 59) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...
  function type_info (line 65) | fn type_info() -> AnyTypeInfo {
  function compatible (line 71) | fn compatible(ty: &AnyTypeInfo) -> bool {
  function encode_by_ref (line 77) | fn encode_by_ref(
  function decode (line 87) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...

FILE: sqlx-core/src/any/types/mod.rs
  function test_type_impls (line 27) | fn test_type_impls() {

FILE: sqlx-core/src/any/types/str.rs
  function type_info (line 11) | fn type_info() -> AnyTypeInfo {
  function encode (line 19) | fn encode(self, buf: &mut <Any as Database>::ArgumentBuffer) -> Result<I...
  function encode_by_ref (line 27) | fn encode_by_ref(
  function decode (line 36) | fn decode(value: <Any as Database>::ValueRef<'a>) -> Result<Self, BoxDyn...
  method type_info (line 45) | fn type_info() -> AnyTypeInfo {
  method encode (line 51) | fn encode(self, buf: &mut <Any as Database>::ArgumentBuffer) -> Result<I...
  method encode_by_ref (line 56) | fn encode_by_ref(
  method decode (line 66) | fn decode(value: <Any as Database>::ValueRef<'r>) -> Result<Self, BoxDyn...

FILE: sqlx-core/src/any/value.rs
  type AnyValueKind (line 11) | pub enum AnyValueKind {
    method type_info (line 25) | fn type_info(&self) -> AnyTypeInfo {
    method unexpected (line 42) | pub(in crate::any) fn unexpected<Expected: Type<Any>>(&self) -> Result...
    method try_integer (line 46) | pub(in crate::any) fn try_integer<T>(&self) -> Result<T, BoxDynError>
  type AnyValue (line 63) | pub struct AnyValue {
  type AnyValueRef (line 69) | pub struct AnyValueRef<'a> {
  type Database (line 74) | type Database = Any;
  method as_ref (line 76) | fn as_ref(&self) -> <Self::Database as Database>::ValueRef<'_> {
  method type_info (line 80) | fn type_info(&self) -> Cow<'_, <Self::Database as Database>::TypeInfo> {
  method is_null (line 84) | fn is_null(&self) -> bool {
  type Database (line 90) | type Database = Any;
  function to_owned (line 92) | fn to_owned(&self) -> <Self::Database as Database>::Value {
  function type_info (line 98) | fn type_info(&self) -> Cow<'_, <Self::Database as Database>::TypeInfo> {
  function is_null (line 102) | fn is_null(&self) -> bool {

FILE: sqlx-core/src/arguments.rs
  type Arguments (line 12) | pub trait Arguments: Send + Sized + Default {
    method reserve (line 17) | fn reserve(&mut self, additional: usize, size: usize);
    method add (line 20) | fn add<'t, T>(&mut self, value: T) -> Result<(), BoxDynError>
    method len (line 25) | fn len(&self) -> usize;
    method format_placeholder (line 27) | fn format_placeholder<W: Write>(&self, writer: &mut W) -> fmt::Result {
  type IntoArguments (line 32) | pub trait IntoArguments<DB: Database>: Sized + Send {
    method into_arguments (line 33) | fn into_arguments(self) -> <DB as Database>::Arguments;
  type ImmutableArguments (line 52) | pub struct ImmutableArguments<DB: Database>(pub <DB as Database>::Argume...
  function into_arguments (line 55) | fn into_arguments(self) -> <DB as Database>::Arguments {

FILE: sqlx-core/src/column.rs
  type Column (line 7) | pub trait Column: 'static + Send + Sync + Debug {
    method ordinal (line 14) | fn ordinal(&self) -> usize;
    method name (line 20) | fn name(&self) -> &str;
    method type_info (line 23) | fn type_info(&self) -> &<Self::Database as Database>::TypeInfo;
    method origin (line 34) | fn origin(&self) -> ColumnOrigin {
  type TableColumn (line 42) | pub struct TableColumn {
  type ColumnOrigin (line 52) | pub enum ColumnOrigin {
    method table_column (line 72) | pub fn table_column(&self) -> Option<&TableColumn> {
  type ColumnIndex (line 92) | pub trait ColumnIndex<T: ?Sized>: Debug {
    method index (line 98) | fn index(&self, container: &T) -> Result<usize, Error>;
  function index (line 103) | fn index(&self, row: &T) -> Result<usize, Error> {

FILE: sqlx-core/src/common/mod.rs
  type DebugFn (line 8) | pub struct DebugFn<F: ?Sized>(pub F);
  type Target (line 11) | type Target = F;
  method deref (line 13) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 19) | fn deref_mut(&mut self) -> &mut Self::Target {
  method fmt (line 25) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

FILE: sqlx-core/src/common/statement_cache.rs
  type StatementCache (line 6) | pub struct StatementCache<T> {
  function new (line 12) | pub fn new(capacity: usize) -> Self {
  function get_mut (line 20) | pub fn get_mut(&mut self, k: &str) -> Option<&mut T> {
  function insert (line 27) | pub fn insert(&mut self, k: &str, v: T) -> Option<T> {
  function len (line 42) | pub fn len(&self) -> usize {
  function is_empty (line 46) | pub fn is_empty(&self) -> bool {
  function remove_lru (line 51) | pub fn remove_lru(&mut self) -> Option<T> {
  function clear (line 56) | pub fn clear(&mut self) {
  function contains_key (line 61) | pub fn contains_key(&mut self, k: &str) -> bool {
  function capacity (line 66) | pub fn capacity(&self) -> usize {
  function is_enabled (line 72) | pub fn is_enabled(&self) -> bool {

FILE: sqlx-core/src/config/common.rs
  type Config (line 8) | pub struct Config {
    method database_url_var (line 46) | pub fn database_url_var(&self) -> &str {

FILE: sqlx-core/src/config/drivers.rs
  type Config (line 20) | pub struct Config {
  type MySqlConfig (line 49) | pub struct MySqlConfig {
  type PgConfig (line 60) | pub struct PgConfig {
  type SqliteConfig (line 71) | pub struct SqliteConfig {
  type ExternalDriverConfig (line 111) | pub struct ExternalDriverConfig {
    method try_parse (line 122) | pub fn try_parse<T: serde::de::DeserializeOwned>(
    method try_parse (line 137) | pub fn try_parse<T>(&self, _name: &str) -> Result<Option<T>, TryParseE...
  type TryParseError (line 117) | pub type TryParseError = Box<dyn Error + Send + Sync + 'static>;

FILE: sqlx-core/src/config/macros.rs
  type Config (line 12) | pub struct Config {
    method type_override (line 372) | pub fn type_override(&self, type_name: &str) -> Option<&str> {
    method column_override (line 378) | pub fn column_override(&self, table: &str, column: &str) -> Option<&st...
  type PreferredCrates (line 236) | pub struct PreferredCrates {
  type DateTimeCrate (line 297) | pub enum DateTimeCrate {
    method is_inferred (line 389) | pub fn is_inferred(&self) -> bool {
    method crate_name (line 394) | pub fn crate_name(&self) -> Option<&str> {
  type NumericCrate (line 326) | pub enum NumericCrate {
    method is_inferred (line 406) | pub fn is_inferred(&self) -> bool {
    method crate_name (line 411) | pub fn crate_name(&self) -> Option<&str> {
  type SqlType (line 352) | pub type SqlType = Box<str>;
  type TableName (line 357) | pub type TableName = Box<str>;
  type ColumnName (line 362) | pub type ColumnName = Box<str>;
  type RustType (line 367) | pub type RustType = Box<str>;

FILE: sqlx-core/src/config/migrate.rs
  type Config (line 21) | pub struct Config {
    method migrations_dir (line 199) | pub fn migrations_dir(&self) -> &str {
    method table_name (line 203) | pub fn table_name(&self) -> &str {
    method to_resolve_config (line 207) | pub fn to_resolve_config(&self) -> crate::migrate::ResolveConfig {
  type MigrationDefaults (line 127) | pub struct MigrationDefaults {
  type DefaultMigrationType (line 156) | pub enum DefaultMigrationType {
  type DefaultVersioning (line 176) | pub enum DefaultVersioning {

FILE: sqlx-core/src/config/mod.rs
  type Config (line 55) | pub struct Config {
    method try_from_crate_or_default (line 160) | pub fn try_from_crate_or_default() -> Result<Self, ConfigError> {
    method try_from_path_or_default (line 169) | pub fn try_from_path_or_default(path: PathBuf) -> Result<Self, ConfigE...
    method try_from_path (line 185) | pub fn try_from_path(path: PathBuf) -> Result<Self, ConfigError> {
    method read_from (line 190) | fn read_from(path: PathBuf) -> Result<Self, ConfigError> {
    method read_from (line 210) | fn read_from(path: PathBuf) -> Result<Self, ConfigError> {
  type ConfigError (line 79) | pub enum ConfigError {
    method from_io (line 130) | pub fn from_io(path: impl Into<PathBuf>, error: io::Error) -> Self {
    method not_found_path (line 142) | pub fn not_found_path(&self) -> Option<&Path> {
  function get_crate_path (line 219) | fn get_crate_path() -> Result<PathBuf, ConfigError> {

FILE: sqlx-core/src/config/tests.rs
  function reference_parses_as_config (line 5) | fn reference_parses_as_config() {
  function assert_common_config (line 16) | fn assert_common_config(config: &config::common::Config) {
  function assert_drivers_config (line 20) | fn assert_drivers_config(config: &config::drivers::Config) {
  function assert_macros_config (line 39) | fn assert_macros_config(config: &config::macros::Config) {
  function assert_migrate_config (line 95) | fn assert_migrate_config(config: &config::migrate::Config) {

FILE: sqlx-core/src/connection.rs
  type Connection (line 16) | pub trait Connection: Send {
    method close (line 37) | fn close(self) -> impl Future<Output = Result<(), Error>> + Send + 'st...
    method close_hard (line 43) | fn close_hard(self) -> impl Future<Output = Result<(), Error>> + Send ...
    method ping (line 46) | fn ping(&mut self) -> impl Future<Output = Result<(), Error>> + Send +...
    method begin (line 51) | fn begin(
    method begin_with (line 61) | fn begin_with(
    method is_in_transaction (line 78) | fn is_in_transaction(&self) -> bool {
    method transaction (line 99) | fn transaction<'a, F, R, E>(
    method cached_statements_size (line 132) | fn cached_statements_size(&self) -> usize
    method clear_cached_statements (line 141) | fn clear_cached_statements(&mut self) -> impl Future<Output = Result<(...
    method shrink_buffers (line 160) | fn shrink_buffers(&mut self);
    method flush (line 163) | fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send ...
    method should_flush (line 166) | fn should_flush(&self) -> bool;
    method connect (line 173) | fn connect(url: &str) -> impl Future<Output = Result<Self, Error>> + S...
    method connect_with (line 183) | fn connect_with(
  type LogSettings (line 195) | pub struct LogSettings {
    method log_statements (line 212) | pub fn log_statements(&mut self, level: LevelFilter) {
    method log_slow_statements (line 215) | pub fn log_slow_statements(&mut self, level: LevelFilter, duration: Du...
  method default (line 202) | fn default() -> Self {
  type ConnectOptions (line 221) | pub trait ConnectOptions: 'static + Send + Sync + FromStr<Err = Error> +...
    method from_url (line 225) | fn from_url(url: &Url) -> Result<Self, Error>;
    method to_url_lossy (line 252) | fn to_url_lossy(&self) -> Url {
    method connect (line 257) | fn connect(&self) -> impl Future<Output = Result<Self::Connection, Err...
    method log_statements (line 262) | fn log_statements(self, level: LevelFilter) -> Self;
    method log_slow_statements (line 266) | fn log_slow_statements(self, level: LevelFilter, duration: Duration) -...
    method disable_statement_logging (line 269) | fn disable_statement_logging(self) -> Self {
    method __unstable_apply_driver_config (line 275) | fn __unstable_apply_driver_config(

FILE: sqlx-core/src/database.rs
  type Database (line 72) | pub trait Database: 'static + Sized + Send + Debug {
    constant NAME (line 107) | const NAME: &'static str;
    constant URL_SCHEMES (line 110) | const URL_SCHEMES: &'static [&'static str];
  type HasStatementCache (line 114) | pub trait HasStatementCache {}

FILE: sqlx-core/src/decode.rs
  type Decode (line 65) | pub trait Decode<'r, DB: Database>: Sized {
    method decode (line 67) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDy...
  function decode (line 76) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynE...
  function decode (line 135) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynE...

FILE: sqlx-core/src/describe.rs
  type Describe (line 21) | pub struct Describe<DB: Database> {
  function columns (line 29) | pub fn columns(&self) -> &[DB::Column] {
  function column (line 36) | pub fn column(&self, index: usize) -> &DB::Column {
  function parameters (line 45) | pub fn parameters(&self) -> Option<Either<&[DB::TypeInfo], usize>> {
  function nullable (line 53) | pub fn nullable(&self, column: usize) -> Option<bool> {
  function try_into_any (line 61) | pub fn try_into_any(self) -> crate::Result<Describe<crate::any::Any>>

FILE: sqlx-core/src/encode.rs
  type IsNull (line 13) | pub enum IsNull {
    method is_null (line 24) | pub fn is_null(&self) -> bool {
  type Encode (line 30) | pub trait Encode<'q, DB: Database> {
    method encode (line 32) | fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer) -> Result<...
    method encode_by_ref (line 43) | fn encode_by_ref(
    method produces (line 48) | fn produces(&self) -> Option<DB::TypeInfo> {
    method size_hint (line 55) | fn size_hint(&self) -> usize {
  function encode (line 65) | fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer) -> Result<Is...
  function encode_by_ref (line 70) | fn encode_by_ref(
  function produces (line 78) | fn produces(&self) -> Option<DB::TypeInfo> {
  function size_hint (line 83) | fn size_hint(&self) -> usize {
  function encode (line 181) | fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer) -> Result<Is...
  function encode_by_ref (line 186) | fn encode_by_ref(
  function produces (line 194) | fn produces(&self) -> Option<DB::TypeInfo> {
  function size_hint (line 199) | fn size_hint(&self) -> usize {

FILE: sqlx-core/src/error.rs
  type Result (line 15) | pub type Result<T, E = Error> = ::std::result::Result<T, E>;
  type BoxDynError (line 19) | pub type BoxDynError = Box<dyn StdError + 'static + Send + Sync>;
  type UnexpectedNullError (line 27) | pub struct UnexpectedNullError;
  type Error (line 32) | pub enum Error {
    method into_database_error (line 137) | pub fn into_database_error(self) -> Option<Box<dyn DatabaseError + 'st...
    method as_database_error (line 144) | pub fn as_database_error(&self) -> Option<&(dyn DatabaseError + 'stati...
    method protocol (line 153) | pub fn protocol(err: impl Display) -> Self {
    method database (line 159) | pub fn database(err: impl DatabaseError) -> Self {
    method config (line 165) | pub fn config(err: impl StdError + Send + Sync + 'static) -> Self {
    method tls (line 169) | pub(crate) fn tls(err: impl Into<Box<dyn StdError + Send + Sync + 'sta...
    method decode (line 175) | pub fn decode(err: impl Into<Box<dyn StdError + Send + Sync + 'static>...
    method from (line 325) | fn from(error: E) -> Self {
    method from (line 333) | fn from(error: crate::migrate::MigrateError) -> Self {
  function mismatched_types (line 180) | pub fn mismatched_types<DB: Database, T: Type<DB>>(ty: &DB::TypeInfo) ->...
  type ErrorKind (line 197) | pub enum ErrorKind {
  type DatabaseError (line 213) | pub trait DatabaseError: 'static + Send + Sync + StdError {
    method message (line 215) | fn message(&self) -> &str;
    method code (line 218) | fn code(&self) -> Option<Cow<'_, str>> {
    method as_error (line 223) | fn as_error(&self) -> &(dyn StdError + Send + Sync + 'static);
    method as_error_mut (line 226) | fn as_error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'stat...
    method into_error (line 229) | fn into_error(self: Box<Self>) -> Box<dyn StdError + Send + Sync + 'st...
    method is_transient_in_connect_phase (line 232) | fn is_transient_in_connect_phase(&self) -> bool {
    method constraint (line 241) | fn constraint(&self) -> Option<&str> {
    method table (line 249) | fn table(&self) -> Option<&str> {
    method kind (line 257) | fn kind(&self) -> ErrorKind;
    method is_unique_violation (line 260) | fn is_unique_violation(&self) -> bool {
    method is_foreign_key_violation (line 265) | fn is_foreign_key_violation(&self) -> bool {
    method is_check_violation (line 270) | fn is_check_violation(&self) -> bool {
  function downcast_ref (line 284) | pub fn downcast_ref<E: DatabaseError>(&self) -> &E {
  function downcast (line 297) | pub fn downcast<E: DatabaseError>(self: Box<Self>) -> Box<E> {
  function try_downcast_ref (line 305) | pub fn try_downcast_ref<E: DatabaseError>(&self) -> Option<&E> {
  function try_downcast (line 311) | pub fn try_downcast<E: DatabaseError>(self: Box<Self>) -> Result<Box<E>,...

FILE: sqlx-core/src/executor.rs
  type Executor (line 33) | pub trait Executor<'c>: Send + Debug + Sized {
    method execute (line 37) | fn execute<'e, 'q: 'e, E>(
    method execute_many (line 49) | fn execute_many<'e, 'q: 'e, E>(
    method fetch (line 68) | fn fetch<'e, 'q: 'e, E>(
    method fetch_many (line 88) | fn fetch_many<'e, 'q: 'e, E>(
    method fetch_all (line 103) | fn fetch_all<'e, 'q: 'e, E>(
    method fetch_one (line 115) | fn fetch_one<'e, 'q: 'e, E>(
    method fetch_optional (line 134) | fn fetch_optional<'e, 'q: 'e, E>(
    method prepare (line 151) | fn prepare<'e>(
    method prepare_with (line 166) | fn prepare_with<'e>(
    method describe (line 181) | fn describe<'e>(
  type Execute (line 196) | pub trait Execute<'q, DB: Database>: Send + Sized {
    method sql (line 198) | fn sql(self) -> SqlStr;
    method statement (line 201) | fn statement(&self) -> Option<&DB::Statement>;
    method take_arguments (line 210) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argume...
    method persistent (line 213) | fn persistent(&self) -> bool;
  method sql (line 221) | fn sql(self) -> SqlStr {
  method statement (line 226) | fn statement(&self) -> Option<&DB::Statement> {
  method take_arguments (line 231) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argument...
  method persistent (line 236) | fn persistent(&self) -> bool {
  function sql (line 246) | fn sql(self) -> SqlStr {
  function statement (line 251) | fn statement(&self) -> Option<&DB::Statement> {
  function take_arguments (line 256) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argument...
  function persistent (line 261) | fn persistent(&self) -> bool {

FILE: sqlx-core/src/ext/async_stream.rs
  type TryAsyncStream (line 19) | pub struct TryAsyncStream<'a, T> {
  function new (line 25) | pub fn new<F, Fut>(f: F) -> Self
  type Yielder (line 39) | pub struct Yielder<T> {
  function new (line 46) | fn new() -> Self {
  function duplicate (line 53) | fn duplicate(&self) -> Self {
  function r#yield (line 60) | pub async fn r#yield(&self, val: T) {
  function take (line 90) | fn take(&self) -> Option<T> {
  type Item (line 99) | type Item = Result<T, Error>;
  method poll_next (line 101) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: sqlx-core/src/ext/ustr.rs
  type UStr (line 11) | pub enum UStr {
    method new (line 17) | pub fn new(s: &str) -> Self {
    method strip_prefix (line 22) | pub fn strip_prefix(this: &Self, prefix: &str) -> Option<Self> {
    method borrow (line 53) | fn borrow(&self) -> &str {
    method eq (line 59) | fn eq(&self, other: &UStr) -> bool {
    method from (line 66) | fn from(s: &'static str) -> Self {
    method from (line 72) | fn from(value: &'a UStr) -> Self {
    method from (line 79) | fn from(s: String) -> Self {
    method deserialize (line 102) | fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deseri...
    method serialize (line 112) | fn serialize<S>(
  type Target (line 31) | type Target = str;
  method deref (line 34) | fn deref(&self) -> &str {
  method hash (line 44) | fn hash<H: Hasher>(&self, state: &mut H) {
  method fmt (line 86) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method fmt (line 93) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: sqlx-core/src/from_row.rs
  type FromRow (line 309) | pub trait FromRow<'r, R: Row>: Sized {
    method from_row (line 310) | fn from_row(row: &'r R) -> Result<Self, Error>;
  function from_row (line 318) | fn from_row(_: &'r R) -> Result<Self, Error> {

FILE: sqlx-core/src/fs.rs
  type ReadDir (line 8) | pub struct ReadDir {
    method next (line 63) | pub async fn next(&mut self) -> io::Result<Option<DirEntry>> {
  type DirEntry (line 12) | pub struct DirEntry {
  function read (line 24) | pub async fn read<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
  function read_to_string (line 29) | pub async fn read_to_string<P: AsRef<Path>>(path: P) -> io::Result<Strin...
  function create_dir_all (line 34) | pub async fn create_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
  function remove_file (line 39) | pub async fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {
  function remove_dir (line 44) | pub async fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
  function remove_dir_all (line 49) | pub async fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
  function read_dir (line 54) | pub async fn read_dir(path: PathBuf) -> io::Result<ReadDir> {

FILE: sqlx-core/src/io/buf.rs
  type BufExt (line 8) | pub trait BufExt: Buf {
    method get_bytes_nul (line 10) | fn get_bytes_nul(&mut self) -> Result<Bytes, Error>;
    method get_bytes (line 13) | fn get_bytes(&mut self, len: usize) -> Bytes;
    method get_str_nul (line 16) | fn get_str_nul(&mut self) -> Result<String, Error>;
    method get_str (line 19) | fn get_str(&mut self, len: usize) -> Result<String, Error>;
    method get_bytes_nul (line 23) | fn get_bytes_nul(&mut self) -> Result<Bytes, Error> {
    method get_bytes (line 34) | fn get_bytes(&mut self, len: usize) -> Bytes {
    method get_str_nul (line 41) | fn get_str_nul(&mut self) -> Result<String, Error> {
    method get_str (line 49) | fn get_str(&mut self, len: usize) -> Result<String, Error> {

FILE: sqlx-core/src/io/buf_mut.rs
  type BufMutExt (line 3) | pub trait BufMutExt: BufMut {
    method put_str_nul (line 4) | fn put_str_nul(&mut self, s: &str);
    method put_str_nul (line 8) | fn put_str_nul(&mut self, s: &str) {

FILE: sqlx-core/src/io/buf_stream.rs
  type BufStream (line 14) | pub struct BufStream<S>
  function new (line 32) | pub fn new(stream: S) -> Self {
  function write (line 40) | pub fn write<'en, T>(&mut self, value: T)
  function write_with (line 47) | pub fn write_with<'en, T, C>(&mut self, value: T, context: C)
  function flush (line 54) | pub fn flush(&mut self) -> WriteAndFlush<'_, S> {
  function read (line 61) | pub async fn read<'de, T>(&mut self, cnt: usize) -> Result<T, Error>
  function read_with (line 68) | pub async fn read_with<'de, T, C>(&mut self, cnt: usize, context: C) -> ...
  function read_raw (line 75) | pub async fn read_raw(&mut self, cnt: usize) -> Result<BytesMut, Error> {
  function read_raw_into (line 82) | pub async fn read_raw_into(&mut self, buf: &mut BytesMut, cnt: usize) ->...
  type Target (line 91) | type Target = S;
  method deref (line 93) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 102) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: sqlx-core/src/io/decode.rs
  type ProtocolDecode (line 5) | pub trait ProtocolDecode<'de, Context = ()>
    method decode (line 9) | fn decode(buf: Bytes) -> Result<Self, Error>
    method decode_with (line 16) | fn decode_with(buf: Bytes, context: Context) -> Result<Self, Error>;
  method decode_with (line 20) | fn decode_with(buf: Bytes, _: ()) -> Result<Self, Error> {
  function decode_with (line 26) | fn decode_with(_: Bytes, _: ()) -> Result<(), Error> {

FILE: sqlx-core/src/io/encode.rs
  type ProtocolEncode (line 1) | pub trait ProtocolEncode<'en, Context = ()> {
    method encode (line 2) | fn encode(&self, buf: &mut Vec<u8>) -> Result<(), crate::Error>
    method encode_with (line 9) | fn encode_with(&self, buf: &mut Vec<u8>, context: Context) -> Result<(...
  function encode_with (line 13) | fn encode_with(&self, buf: &mut Vec<u8>, _context: C) -> Result<(), crat...

FILE: sqlx-core/src/io/read_buf.rs
  type ReadBuf (line 4) | pub trait ReadBuf: BufMut {
    method init_mut (line 6) | fn init_mut(&mut self) -> &mut [u8];
    method init_mut (line 11) | fn init_mut(&mut self) -> &mut [u8] {
    method init_mut (line 18) | fn init_mut(&mut self) -> &mut [u8] {
  function test_read_buf_bytes_mut (line 30) | fn test_read_buf_bytes_mut() {

FILE: sqlx-core/src/io/write_and_flush.rs
  type WriteAndFlush (line 10) | pub struct WriteAndFlush<'a, S> {
  type Output (line 16) | type Output = Result<(), Error>;
  method poll (line 18) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method drop (line 40) | fn drop(&mut self) {

FILE: sqlx-core/src/logger.rs
  function private_level_filter_to_levels (line 42) | pub fn private_level_filter_to_levels(
  function private_level_filter_to_trace_level (line 57) | pub(crate) fn private_level_filter_to_trace_level(
  type QueryLogger (line 63) | pub struct QueryLogger {
    method new (line 72) | pub fn new(sql: SqlStr, settings: LogSettings) -> Self {
    method increment_rows_returned (line 82) | pub fn increment_rows_returned(&mut self) {
    method increase_rows_affected (line 86) | pub fn increase_rows_affected(&mut self, n: u64) {
    method sql (line 90) | pub fn sql(&self) -> &SqlStr {
    method finish (line 94) | pub fn finish(&self) {
  method drop (line 158) | fn drop(&mut self) {
  function parse_query_summary (line 163) | pub fn parse_query_summary(sql: &str) -> String {

FILE: sqlx-core/src/migrate/error.rs
  type MigrateError (line 5) | pub enum MigrateError {

FILE: sqlx-core/src/migrate/migrate.rs
  type MigrateDatabase (line 7) | pub trait MigrateDatabase {
    method create_database (line 10) | fn create_database(url: &str) -> impl Future<Output = Result<(), Error...
    method database_exists (line 14) | fn database_exists(url: &str) -> impl Future<Output = Result<bool, Err...
    method drop_database (line 18) | fn drop_database(url: &str) -> impl Future<Output = Result<(), Error>>...
    method force_drop_database (line 22) | fn force_drop_database(_url: &str) -> impl Future<Output = Result<(), ...
  type Migrate (line 28) | pub trait Migrate {
    method create_schema_if_not_exists (line 30) | fn create_schema_if_not_exists<'e>(
    method ensure_migrations_table (line 37) | fn ensure_migrations_table<'e>(
    method dirty_version (line 44) | fn dirty_version<'e>(
    method list_applied_migrations (line 50) | fn list_applied_migrations<'e>(
    method lock (line 58) | fn lock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>>;
    method unlock (line 62) | fn unlock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>>;
    method apply (line 67) | fn apply<'e>(
    method revert (line 76) | fn revert<'e>(

FILE: sqlx-core/src/migrate/migration.rs
  type Migration (line 9) | pub struct Migration {
    method new (line 19) | pub fn new(
    method with_checksum (line 38) | pub(crate) fn with_checksum(
  type AppliedMigration (line 58) | pub struct AppliedMigration {
  function checksum (line 63) | pub fn checksum(sql: &str) -> Vec<u8> {
  function checksum_fragments (line 67) | pub fn checksum_fragments<'a>(fragments: impl Iterator<Item = &'a str>) ...
  function fragments_checksum_equals_full_checksum (line 78) | fn fragments_checksum_equals_full_checksum() {

FILE: sqlx-core/src/migrate/migration_type.rs
  type MigrationType (line 5) | pub enum MigrationType {
    method from_filename (line 19) | pub fn from_filename(filename: &str) -> Self {
    method is_reversible (line 29) | pub fn is_reversible(&self) -> bool {
    method is_up_migration (line 37) | pub fn is_up_migration(&self) -> bool {
    method is_down_migration (line 45) | pub fn is_down_migration(&self) -> bool {
    method label (line 53) | pub fn label(&self) -> &'static str {
    method suffix (line 61) | pub fn suffix(&self) -> &'static str {
    method file_content (line 69) | pub fn file_content(&self) -> &'static str {
    method infer (line 78) | pub fn infer(migrator: &Migrator, reversible: bool) -> MigrationType {

FILE: sqlx-core/src/migrate/migrator.rs
  type Migrator (line 14) | pub struct Migrator {
    constant DEFAULT (line 35) | pub const DEFAULT: Migrator = Migrator {
    method new (line 62) | pub async fn new<'s, S>(source: S) -> Result<Self, MigrateError>
    method with_migrations (line 89) | pub fn with_migrations(mut migrations: Vec<Migration>) -> Self {
    method dangerous_set_table_name (line 112) | pub fn dangerous_set_table_name(&mut self, table_name: impl Into<Cow<'...
    method create_schema (line 125) | pub fn create_schema(&mut self, schema_name: impl Into<Cow<'static, st...
    method set_ignore_missing (line 131) | pub fn set_ignore_missing(&mut self, ignore_missing: bool) -> &mut Self {
    method set_locking (line 144) | pub fn set_locking(&mut self, locking: bool) -> &mut Self {
    method iter (line 150) | pub fn iter(&self) -> slice::Iter<'_, Migration> {
    method version_exists (line 155) | pub fn version_exists(&self, version: i64) -> bool {
    method run (line 177) | pub async fn run<'a, A>(&self, migrator: A) -> Result<(), MigrateError>
    method run_to (line 186) | pub async fn run_to<'a, A>(&self, target: i64, migrator: A) -> Result<...
    method run_direct (line 197) | pub async fn run_direct<C>(&self, target: Option<i64>, conn: &mut C) -...
    method undo (line 275) | pub async fn undo<'a, A>(&self, migrator: A, target: i64) -> Result<()...
  function validate_applied_migrations (line 324) | fn validate_applied_migrations(

FILE: sqlx-core/src/migrate/source.rs
  type MigrationSource (line 27) | pub trait MigrationSource<'s>: Debug {
    method resolve (line 28) | fn resolve(self) -> BoxFuture<'s, Result<Vec<Migration>, BoxDynError>>;
  function resolve (line 32) | fn resolve(self) -> BoxFuture<'s, Result<Vec<Migration>, BoxDynError>> {
  method resolve (line 40) | fn resolve(self) -> BoxFuture<'static, Result<Vec<Migration>, BoxDynErro...
  type ResolveWith (line 61) | pub struct ResolveWith<S>(pub S, pub ResolveConfig);
  function resolve (line 64) | fn resolve(self) -> BoxFuture<'s, Result<Vec<Migration>, BoxDynError>> {
  type ResolveError (line 80) | pub struct ResolveError {
  type ResolveConfig (line 88) | pub struct ResolveConfig {
    method new (line 94) | pub fn new() -> Self {
    method ignore_char (line 115) | pub fn ignore_char(&mut self, c: char) -> &mut Self {
    method ignore_chars (line 135) | pub fn ignore_chars(&mut self, chars: impl IntoIterator<Item = char>) ...
    method ignored_chars (line 143) | pub fn ignored_chars(&self) -> impl Iterator<Item = char> + '_ {
  function resolve_blocking (line 151) | pub fn resolve_blocking(path: &Path) -> Result<Vec<(Migration, PathBuf)>...
  function resolve_blocking_with_config (line 156) | pub fn resolve_blocking_with_config(
  function checksum_with (line 257) | fn checksum_with(sql: &str, ignored_chars: &BTreeSet<char>) -> Vec<u8> {
  function checksum_with_ignored_chars (line 267) | fn checksum_with_ignored_chars() {

FILE: sqlx-core/src/net/socket/buffered.rs
  constant DEFAULT_BUF_SIZE (line 10) | const DEFAULT_BUF_SIZE: usize = 8192;
  type BufferedSocket (line 12) | pub struct BufferedSocket<S> {
  type WriteBuffer (line 18) | pub struct WriteBuffer {
    method sanity_check (line 162) | fn sanity_check(&self) {
    method buf_mut (line 168) | pub fn buf_mut(&mut self) -> &mut Vec<u8> {
    method init_remaining_mut (line 174) | pub fn init_remaining_mut(&mut self) -> &mut [u8] {
    method put_slice (line 180) | pub fn put_slice(&mut self, slice: &[u8]) {
    method advance (line 193) | pub fn advance(&mut self, amt: usize) {
    method read_from (line 209) | pub async fn read_from(&mut self, mut source: impl AsyncRead + Unpin) ...
    method is_empty (line 225) | pub fn is_empty(&self) -> bool {
    method is_full (line 229) | pub fn is_full(&self) -> bool {
    method get (line 233) | pub fn get(&self) -> &[u8] {
    method get_mut (line 237) | pub fn get_mut(&mut self) -> &mut [u8] {
    method shrink (line 241) | pub fn shrink(&mut self) {
    method consume (line 257) | fn consume(&mut self, amt: usize) {
  type ReadBuffer (line 24) | pub struct ReadBuffer {
    method read (line 278) | async fn read(&mut self, len: usize, socket: &mut impl Socket) -> io::...
    method reserve (line 303) | fn reserve(&mut self, amt: usize) {
    method advance (line 309) | fn advance(&mut self, amt: usize) {
    method shrink (line 313) | fn shrink(&mut self) {
  function new (line 30) | pub fn new(socket: S) -> Self
  function read_buffered (line 48) | pub async fn read_buffered(&mut self, len: usize) -> Result<BytesMut, Er...
  function try_read (line 69) | pub async fn try_read<F, R>(&mut self, mut try_read: F) -> Result<R, Error>
  function write_buffer (line 83) | pub fn write_buffer(&self) -> &WriteBuffer {
  function write_buffer_mut (line 87) | pub fn write_buffer_mut(&mut self) -> &mut WriteBuffer {
  function read (line 91) | pub async fn read<'de, T>(&mut self, byte_len: usize) -> Result<T, Error>
  function read_with (line 98) | pub async fn read_with<'de, T, C>(&mut self, byte_len: usize, context: C...
  function write (line 106) | pub fn write<'en, T>(&mut self, value: T) -> Result<(), Error>
  function write_with (line 114) | pub fn write_with<'en, T, C>(&mut self, value: T, context: C) -> Result<...
  function flush (line 125) | pub async fn flush(&mut self) -> io::Result<()> {
  function shutdown (line 137) | pub async fn shutdown(&mut self) -> io::Result<()> {
  function shrink_buffers (line 142) | pub fn shrink_buffers(&mut self) {
  function into_inner (line 148) | pub fn into_inner(self) -> S {
  function boxed (line 152) | pub fn boxed(self) -> BufferedSocket<Box<dyn Socket>> {

FILE: sqlx-core/src/net/socket/mod.rs
  type Socket (line 15) | pub trait Socket: Send + Sync + Unpin + 'static {
    method try_read (line 16) | fn try_read(&mut self, buf: &mut dyn ReadBuf) -> io::Result<usize>;
    method try_write (line 18) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize>;
    method poll_read_ready (line 20) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result...
    method poll_write_ready (line 22) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Resul...
    method poll_flush (line 24) | fn poll_flush(&mut self, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
    method poll_shutdown (line 29) | fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
    method read (line 31) | fn read<'a, B: ReadBuf>(&'a mut self, buf: &'a mut B) -> Read<'a, Self...
    method write (line 38) | fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self>
    method flush (line 45) | fn flush(&mut self) -> Flush<'_, Self>
    method shutdown (line 52) | fn shutdown(&mut self) -> Shutdown<'_, Self>
    method try_read (line 159) | fn try_read(&mut self, buf: &mut dyn ReadBuf) -> io::Result<usize> {
    method try_write (line 163) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
    method poll_read_ready (line 167) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result...
    method poll_write_ready (line 171) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Resul...
    method poll_flush (line 175) | fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
    method poll_shutdown (line 179) | fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  type Read (line 60) | pub struct Read<'a, S: ?Sized, B> {
  type Output (line 70) | type Output = io::Result<usize>;
  method poll (line 72) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Write (line 88) | pub struct Write<'a, S: ?Sized> {
  type Output (line 97) | type Output = io::Result<usize>;
  method poll (line 99) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Flush (line 115) | pub struct Flush<'a, S: ?Sized> {
  type Output (line 120) | type Output = io::Result<()>;
  method poll (line 122) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Shutdown (line 127) | pub struct Shutdown<'a, S: ?Sized> {
  type Output (line 135) | type Output = io::Result<()>;
  method poll (line 137) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type WithSocket (line 142) | pub trait WithSocket {
    method with_socket (line 145) | fn with_socket<S: Socket>(self, socket: S) -> impl Future<Output = Sel...
    type Output (line 151) | type Output = Box<dyn Socket>;
    method with_socket (line 153) | async fn with_socket<S: Socket>(self, socket: S) -> Self::Output {
  type SocketIntoBox (line 148) | pub struct SocketIntoBox;
  function connect_tcp (line 184) | pub async fn connect_tcp<Ws: WithSocket>(
  function connect_tcp_async_io (line 211) | async fn connect_tcp_async_io(host: &str, port: u16) -> crate::Result<im...
  function connect_uds (line 255) | pub async fn connect_uds<P: AsRef<Path>, Ws: WithSocket>(

FILE: sqlx-core/src/net/tls/mod.rs
  type CertificateInput (line 19) | pub enum CertificateInput {
    method from (line 27) | fn from(value: String) -> Self {
    method data (line 42) | async fn data(&self) -> Result<Vec<u8>, std::io::Error> {
    method fmt (line 52) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TlsConfig (line 60) | pub struct TlsConfig<'a> {
  function handshake (line 69) | pub async fn handshake<S, Ws>(
  function available (line 95) | pub fn available() -> bool {
  function error_if_unavailable (line 99) | pub fn error_if_unavailable() -> crate::Result<()> {

FILE: sqlx-core/src/net/tls/tls_native_tls.rs
  type NativeTlsSocket (line 13) | pub struct NativeTlsSocket<S: Socket> {
  method try_read (line 18) | fn try_read(&mut self, buf: &mut dyn ReadBuf) -> io::Result<usize> {
  method try_write (line 22) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method poll_read_ready (line 26) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method poll_write_ready (line 30) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method poll_shutdown (line 34) | fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
  function handshake (line 42) | pub async fn handshake<S: Socket>(

FILE: sqlx-core/src/net/tls/tls_rustls.rs
  type RustlsSocket (line 25) | pub struct RustlsSocket<S: Socket> {
  function poll_complete_io (line 32) | fn poll_complete_io(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  function complete_io (line 43) | async fn complete_io(&mut self) -> io::Result<()> {
  method try_read (line 49) | fn try_read(&mut self, buf: &mut dyn ReadBuf) -> io::Result<usize> {
  method try_write (line 53) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method poll_read_ready (line 61) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method poll_write_ready (line 65) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method poll_flush (line 69) | fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
  method poll_shutdown (line 73) | fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
  function handshake (line 90) | pub async fn handshake<S>(socket: S, tls_config: TlsConfig<'_>) -> Resul...
  function certs_from_pem (line 197) | fn certs_from_pem(pem: Vec<u8>) -> Result<Vec<CertificateDer<'static>>, ...
  function private_key_from_pem (line 203) | fn private_key_from_pem(pem: Vec<u8>) -> Result<PrivateKeyDer<'static>, ...
  function import_root_certs (line 212) | fn import_root_certs() -> RootCertStore {
  function import_root_certs (line 217) | fn import_root_certs() -> RootCertStore {
  function import_root_certs (line 235) | fn import_root_certs() -> RootCertStore {
  type DummyTlsVerifier (line 240) | struct DummyTlsVerifier {
  method verify_server_cert (line 245) | fn verify_server_cert(
  method verify_tls12_signature (line 256) | fn verify_tls12_signature(
  method verify_tls13_signature (line 270) | fn verify_tls13_signature(
  method supported_verify_schemes (line 284) | fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
  type NoHostnameTlsVerifier (line 292) | pub struct NoHostnameTlsVerifier {
  method verify_server_cert (line 297) | fn verify_server_cert(
  method verify_tls12_signature (line 319) | fn verify_tls12_signature(
  method verify_tls13_signature (line 328) | fn verify_tls13_signature(
  method supported_verify_schemes (line 337) | fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {

FILE: sqlx-core/src/net/tls/util.rs
  type StdSocket (line 7) | pub struct StdSocket<S> {
  function new (line 14) | pub fn new(socket: S) -> Self {
  function poll_ready (line 22) | pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()...
  function ready (line 36) | pub async fn ready(&mut self) -> io::Result<()> {
  method read (line 42) | fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
  method write (line 52) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 59) | fn flush(&mut self) -> io::Result<()> {

FILE: sqlx-core/src/pool/connection.rs
  constant CLOSE_ON_DROP_TIMEOUT (line 16) | const CLOSE_ON_DROP_TIMEOUT: Duration = Duration::from_secs(5);
  type PoolConnection (line 21) | pub struct PoolConnection<DB: Database> {
  type Live (line 27) | pub(super) struct Live<DB: Database> {
  type Idle (line 32) | pub(super) struct Idle<DB: Database> {
  type Floating (line 38) | pub(super) struct Floating<DB: Database, C> {
  constant EXPECT_MSG (line 43) | const EXPECT_MSG: &str = "BUG: inner connection already taken!";
  method fmt (line 46) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Target (line 53) | type Target = DB::Connection;
  method deref (line 55) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 61) | fn deref_mut(&mut self) -> &mut Self::Target {
  function as_ref (line 67) | fn as_ref(&self) -> &DB::Connection {
  function as_mut (line 73) | fn as_mut(&mut self) -> &mut DB::Connection {
  function close (line 86) | pub async fn close(mut self) -> Result<(), Error> {
  function close_on_drop (line 97) | pub fn close_on_drop(&mut self) {
  function detach (line 113) | pub fn detach(mut self) -> DB::Connection {
  function leak (line 122) | pub fn leak(mut self) -> DB::Connection {
  function take_live (line 126) | fn take_live(&mut self) -> Live<DB> {
  function return_to_pool (line 134) | pub fn return_to_pool(&mut self) -> impl Future<Output = ()> + Send + 's...
  function take_and_close (line 157) | fn take_and_close(&mut self) -> impl Future<Output = ()> + Send + 'static {
  type Database (line 180) | type Database = DB;
  type Connection (line 182) | type Connection = &'c mut <DB as Database>::Connection;
  function acquire (line 185) | fn acquire(self) -> futures_core::future::BoxFuture<'c, Result<Self::Con...
  function begin (line 190) | fn begin(
  method drop (line 200) | fn drop(&mut self) {
  function float (line 214) | pub fn float(self, pool: Arc<PoolInner<DB>>) -> Floating<DB, Self> {
  function into_idle (line 222) | pub fn into_idle(self) -> Idle<DB> {
  type Target (line 231) | type Target = Live<DB>;
  method deref (line 233) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 239) | fn deref_mut(&mut self) -> &mut Self::Target {
  function new_live (line 245) | pub fn new_live(conn: DB::Connection, guard: DecrementSizeGuard<DB>) -> ...
  function reattach (line 255) | pub fn reattach(self) -> PoolConnection<DB> {
  function release (line 268) | pub fn release(self) {
  function return_to_pool (line 275) | async fn return_to_pool(mut self) -> bool {
  function close (line 330) | pub async fn close(self) {
  function close_hard (line 337) | pub async fn close_hard(self) {
  function detach (line 341) | pub fn detach(self) -> DB::Connection {
  function into_idle (line 345) | pub fn into_idle(self) -> Floating<DB, Idle<DB>> {
  function metadata (line 352) | pub fn metadata(&self) -> PoolConnectionMetadata {
  function from_idle (line 361) | pub fn from_idle(
  function ping (line 372) | pub async fn ping(&mut self) -> Result<(), Error> {
  function into_live (line 376) | pub fn into_live(self) -> Floating<DB, Live<DB>> {
  function close (line 383) | pub async fn close(self) -> DecrementSizeGuard<DB> {
  function close_hard (line 390) | pub async fn close_hard(self) -> DecrementSizeGuard<DB> {
  function metadata (line 396) | pub fn metadata(&self) -> PoolConnectionMetadata {
  type Target (line 410) | type Target = C;
  method deref (line 412) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 418) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: sqlx-core/src/pool/executor.rs
  type Database (line 16) | type Database = DB;
  function fetch_many (line 18) | fn fetch_many<'e, 'q: 'e, E>(
  function fetch_optional (line 39) | fn fetch_optional<'e, 'q: 'e, E>(
  function prepare_with (line 51) | fn prepare_with<'e>(
  function describe (line 66) | fn describe<'e>(

FILE: sqlx-core/src/pool/inner.rs
  type PoolInner (line 25) | pub(crate) struct PoolInner<DB: Database> {
  function new_arc (line 39) | pub(super) fn new_arc(
  function size (line 74) | pub(super) fn size(&self) -> u32 {
  function num_idle (line 78) | pub(super) fn num_idle(&self) -> usize {
  function is_closed (line 87) | pub(super) fn is_closed(&self) -> bool {
  function mark_closed (line 91) | fn mark_closed(&self) {
  function close (line 96) | pub(super) fn close(self: &Arc<Self>) -> impl Future<Output = ()> + '_ {
  function close_event (line 121) | pub(crate) fn close_event(&self) -> CloseEvent {
  function acquire_permit (line 131) | async fn acquire_permit(self: &Arc<Self>) -> Result<AsyncSemaphoreReleas...
  function parent (line 177) | fn parent(&self) -> Option<&Pool<DB>> {
  function try_acquire (line 182) | pub(super) fn try_acquire(self: &Arc<Self>) -> Option<Floating<DB, Idle<...
  function pop_idle (line 192) | fn pop_idle<'a>(
  function release (line 204) | pub(super) fn release(&self, floating: Floating<DB, Live<DB>>) {
  function try_increment_size (line 223) | pub(super) fn try_increment_size<'a>(
  function acquire (line 246) | pub(super) async fn acquire(self: &Arc<Self>) -> Result<Floating<DB, Liv...
  function connect (line 325) | pub(super) async fn connect(
  function try_min_connections (line 400) | pub async fn try_min_connections(self: &Arc<Self>, deadline: Instant) ->...
  function min_connections_maintenance (line 424) | pub async fn min_connections_maintenance(self: &Arc<Self>, deadline: Opt...
  method drop (line 442) | fn drop(&mut self) {
  function is_beyond_max_lifetime (line 453) | pub(super) fn is_beyond_max_lifetime<DB: Database>(
  function is_beyond_idle_timeout (line 463) | fn is_beyond_idle_timeout<DB: Database>(idle: &Idle<DB>, options: &PoolO...
  function check_idle_conn (line 469) | async fn check_idle_conn<DB: Database>(
  function spawn_maintenance_tasks (line 507) | fn spawn_maintenance_tasks<DB: Database>(pool: &Arc<PoolInner<DB>>) {
  type DecrementSizeGuard (line 581) | pub(in crate::pool) struct DecrementSizeGuard<DB: Database> {
  function new_permit (line 588) | pub fn new_permit(pool: Arc<PoolInner<DB>>) -> Self {
  function from_permit (line 595) | pub fn from_permit(pool: Arc<PoolInner<DB>>, permit: AsyncSemaphoreRelea...
  function release_permit (line 604) | fn release_permit(self) {
  function cancel (line 609) | pub fn cancel(mut self) {
  method drop (line 615) | fn drop(&mut self) {

FILE: sqlx-core/src/pool/maybe.rs
  type MaybePoolConnection (line 5) | pub enum MaybePoolConnection<'c, DB: Database> {
  type Target (line 12) | type Target = DB::Connection;
  method deref (line 15) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 25) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 34) | fn from(v: PoolConnection<DB>) -> Self {
  function from (line 40) | fn from(v: &'c mut DB::Connection) -> Self {

FILE: sqlx-core/src/pool/mod.rs
  type Pool (line 260) | pub struct Pool<DB: Database>(pub(crate) Arc<PoolInner<DB>>);
  type CloseEvent (line 265) | pub struct CloseEvent {
    method do_until (line 595) | pub async fn do_until<Fut: Future>(&mut self, fut: Fut) -> Result<Fut:...
  function connect (line 284) | pub async fn connect(url: &str) -> Result<Self, Error> {
  function connect_with (line 295) | pub async fn connect_with(
  function connect_lazy (line 317) | pub fn connect_lazy(url: &str) -> Result<Self, Error> {
  function connect_lazy_with (line 330) | pub fn connect_lazy_with(options: <DB::Connection as Connection>::Option...
  function acquire (line 357) | pub fn acquire(&self) -> impl Future<Output = Result<PoolConnection<DB>,...
  function try_acquire (line 366) | pub fn try_acquire(&self) -> Option<PoolConnection<DB>> {
  function begin (line 371) | pub async fn begin(&self) -> Result<Transaction<'static, DB>, Error> {
  function try_begin (line 380) | pub async fn try_begin(&self) -> Result<Option<Transaction<'static, DB>>...
  function begin_with (line 391) | pub async fn begin_with(
  function try_begin_with (line 404) | pub async fn try_begin_with(
  function close (line 441) | pub fn close(&self) -> impl Future<Output = ()> + '_ {
  function is_closed (line 446) | pub fn is_closed(&self) -> bool {
  function close_event (line 530) | pub fn close_event(&self) -> CloseEvent {
  function size (line 535) | pub fn size(&self) -> u32 {
  function num_idle (line 540) | pub fn num_idle(&self) -> usize {
  function connect_options (line 545) | pub fn connect_options(&self) -> Arc<<DB::Connection as Connection>::Opt...
  function set_connect_options (line 555) | pub fn set_connect_options(&self, connect_options: <DB::Connection as Co...
  function options (line 567) | pub fn options(&self) -> &PoolOptions<DB> {
  method clone (line 574) | fn clone(&self) -> Self {
  function fmt (line 580) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Output (line 626) | type Output = ();
  method poll (line 628) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method is_terminated (line 644) | fn is_terminated(&self) -> bool {
  function deadline_as_timeout (line 652) | fn deadline_as_timeout(deadline: Instant) -> Result<Duration, Error> {
  function assert_pool_traits (line 660) | fn assert_pool_traits() {

FILE: sqlx-core/src/pool/options.rs
  type PoolOptions (line 45) | pub struct PoolOptions<DB: Database> {
  method clone (line 94) | fn clone(&self) -> Self {
  type PoolConnectionMetadata (line 117) | pub struct PoolConnectionMetadata {
  method default (line 131) | fn default() -> Self {
  function new (line 143) | pub fn new() -> Self {
  function max_connections (line 173) | pub fn max_connections(mut self, max: u32) -> Self {
  function get_max_connections (line 179) | pub fn get_max_connections(&self) -> u32 {
  function min_connections (line 205) | pub fn min_connections(mut self, min: u32) -> Self {
  function get_min_connections (line 211) | pub fn get_min_connections(&self) -> u32 {
  function acquire_time_level (line 220) | pub fn acquire_time_level(mut self, level: LevelFilter) -> Self {
  function acquire_slow_level (line 227) | pub fn acquire_slow_level(mut self, level: LevelFilter) -> Self {
  function acquire_slow_threshold (line 237) | pub fn acquire_slow_threshold(mut self, threshold: Duration) -> Self {
  function get_acquire_slow_threshold (line 244) | pub fn get_acquire_slow_threshold(&self) -> Duration {
  function acquire_timeout (line 261) | pub fn acquire_timeout(mut self, timeout: Duration) -> Self {
  function get_acquire_timeout (line 267) | pub fn get_acquire_timeout(&self) -> Duration {
  function max_lifetime (line 285) | pub fn max_lifetime(mut self, lifetime: impl Into<Option<Duration>>) -> ...
  function get_max_lifetime (line 291) | pub fn get_max_lifetime(&self) -> Option<Duration> {
  function idle_timeout (line 300) | pub fn idle_timeout(mut self, timeout: impl Into<Option<Duration>>) -> S...
  function get_idle_timeout (line 306) | pub fn get_idle_timeout(&self) -> Option<Duration> {
  function test_before_acquire (line 314) | pub fn test_before_acquire(mut self, test: bool) -> Self {
  function get_test_before_acquire (line 320) | pub fn get_test_before_acquire(&self) -> bool {
  function __fair (line 337) | pub fn __fair(mut self, fair: bool) -> Self {
  function after_connect (line 380) | pub fn after_connect<F>(mut self, callback: F) -> Self
  function before_acquire (line 435) | pub fn before_acquire<F>(mut self, callback: F) -> Self
  function after_release (line 492) | pub fn after_release<F>(mut self, callback: F) -> Self
  function parent (line 511) | pub fn parent(mut self, pool: Pool<DB>) -> Self {
  function connect (line 528) | pub async fn connect(self, url: &str) -> Result<Pool<DB>, Error> {
  function connect_with (line 537) | pub async fn connect_with(
  function connect_lazy (line 571) | pub fn connect_lazy(self, url: &str) -> Result<Pool<DB>, Error> {
  function connect_lazy_with (line 579) | pub fn connect_lazy_with(self, options: <DB::Connection as Connection>::...
  method fmt (line 586) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: sqlx-core/src/query.rs
  type Query (line 18) | pub struct Query<'q, DB: Database, A> {
  type Map (line 37) | pub struct Map<'q, DB: Database, F, A> {
  function sql (line 48) | fn sql(self) -> SqlStr {
  function statement (line 55) | fn statement(&self) -> Option<&DB::Statement> {
  function take_arguments (line 63) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argument...
  function persistent (line 71) | fn persistent(&self) -> bool {
  function bind (line 87) | pub fn bind<'t, T: Encode<'t, DB> + Type<DB>>(mut self, value: T) -> Self {
  function try_bind (line 104) | pub fn try_bind<'t, T: Encode<'t, DB> + Type<DB>>(
  function get_arguments (line 113) | fn get_arguments(&mut self) -> Result<&mut DB::Arguments, BoxDynError> {
  function persistent (line 138) | pub fn persistent(mut self, value: bool) -> Self {
  function map (line 156) | pub fn map<F, O>(
  function try_map (line 172) | pub fn try_map<F, O>(self, f: F) -> Map<'q, DB, F, A>
  function execute (line 185) | pub async fn execute<'e, 'c: 'e, E>(self, executor: E) -> Result<DB::Que...
  function execute_many (line 197) | pub async fn execute_many<'e, 'c: 'e, E>(
  function fetch (line 211) | pub fn fetch<'e, 'c: 'e, E>(self, executor: E) -> BoxStream<'e, Result<D...
  function fetch_many (line 227) | pub fn fetch_many<'e, 'c: 'e, E>(
  function fetch_all (line 247) | pub async fn fetch_all<'e, 'c: 'e, E>(self, executor: E) -> Result<Vec<D...
  function fetch_one (line 269) | pub async fn fetch_one<'e, 'c: 'e, E>(self, executor: E) -> Result<DB::R...
  function fetch_optional (line 291) | pub async fn fetch_optional<'e, 'c: 'e, E>(self, executor: E) -> Result<...
  function sql (line 307) | fn sql(self) -> SqlStr {
  function statement (line 312) | fn statement(&self) -> Option<&DB::Statement> {
  function take_arguments (line 317) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argument...
  function persistent (line 322) | fn persistent(&self) -> bool {
  function map (line 341) | pub fn map<G, P>(
  function try_map (line 357) | pub fn try_map<G, P>(
  function fetch (line 373) | pub fn fetch<'e, 'c: 'e, E>(self, executor: E) -> BoxStream<'e, Result<O...
  function fetch_many (line 397) | pub fn fetch_many<'e, 'c: 'e, E>(
  function fetch_all (line 431) | pub async fn fetch_all<'e, 'c: 'e, E>(self, executor: E) -> Result<Vec<O...
  function fetch_one (line 454) | pub async fn fetch_one<'e, 'c: 'e, E>(self, executor: E) -> Result<O, Er...
  function fetch_optional (line 484) | pub async fn fetch_optional<'e, 'c: 'e, E>(mut self, executor: E) -> Res...
  function query_statement (line 503) | pub fn query_statement<DB>(statement: &DB::Statement) -> Query<'_, DB, <...
  function query_statement_with (line 516) | pub fn query_statement_with<DB, A>(statement: &DB::Statement, arguments:...
  function query (line 653) | pub fn query<'a, DB>(sql: impl SqlSafeStr) -> Query<'a, DB, <DB as Datab...
  function query_with (line 668) | pub fn query_with<'q, DB, A>(sql: impl SqlSafeStr, arguments: A) -> Quer...
  function query_with_result (line 677) | pub fn query_with_result<'q, DB, A>(

FILE: sqlx-core/src/query_as.rs
  type QueryAs (line 20) | pub struct QueryAs<'q, DB: Database, O, A> {
  function sql (line 31) | fn sql(self) -> SqlStr {
  function statement (line 36) | fn statement(&self) -> Option<&DB::Statement> {
  function take_arguments (line 41) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argument...
  function persistent (line 46) | fn persistent(&self) -> bool {
  function bind (line 55) | pub fn bind<T: 'q + Encode<'q, DB> + Type<DB>>(mut self, value: T) -> Se...
  function persistent (line 75) | pub fn persistent(mut self, value: bool) -> Self {
  function fetch (line 90) | pub fn fetch<'e, 'c: 'e, E>(self, executor: E) -> BoxStream<'e, Result<O...
  function fetch_many (line 107) | pub fn fetch_many<'e, 'c: 'e, E>(
  function fetch_all (line 136) | pub async fn fetch_all<'e, 'c: 'e, E>(self, executor: E) -> Result<Vec<O...
  function fetch_one (line 159) | pub async fn fetch_one<'e, 'c: 'e, E>(self, executor: E) -> Result<O, Er...
  function fetch_optional (line 184) | pub async fn fetch_optional<'e, 'c: 'e, E>(self, executor: E) -> Result<...
  function query_as (line 341) | pub fn query_as<'q, DB, O>(sql: impl SqlSafeStr) -> QueryAs<'q, DB, O, <...
  function query_as_with (line 359) | pub fn query_as_with<'q, DB, O, A>(sql: impl SqlSafeStr, arguments: A) -...
  function query_as_with_result (line 370) | pub fn query_as_with_result<'q, DB, O, A>(
  function query_statement_as (line 386) | pub fn query_statement_as<DB, O>(
  function query_statement_as_with (line 400) | pub fn query_statement_as_with<'q, DB, O, A>(

FILE: sqlx-core/src/query_builder.rs
  type QueryBuilder (line 28) | pub struct QueryBuilder<DB>
  method default (line 38) | fn default() -> Self {
  constant ERROR (line 47) | const ERROR: &str = "BUG: query must not be shared at this point in time";
  function new (line 56) | pub fn new(init: impl Into<String>) -> Self
  function with_arguments (line 73) | pub fn with_arguments<A>(init: impl Into<String>, arguments: A) -> Self
  function sanity_check (line 88) | fn sanity_check(&self) {
  function push (line 122) | pub fn push(&mut self, sql: impl Display) -> &mut Self {
  function push_bind (line 155) | pub fn push_bind<'t, T>(&mut self, value: T) -> &mut Self
  function separated (line 202) | pub fn separated<Sep>(&mut self, separator: Sep) -> Separated<'_, DB, Sep>
  function push_values (line 312) | pub fn push_values<I, F>(&mut self, tuples: I, mut push_tuple: F) -> &mu...
  function push_tuples (line 424) | pub fn push_tuples<I, F>(&mut self, tuples: I, mut push_tuple: F) -> &mu...
  function build (line 459) | pub fn build(&mut self) -> Query<'_, DB, <DB as Database>::Arguments> {
  function build_query_as (line 482) | pub fn build_query_as<'q, T: FromRow<'q, DB::Row>>(
  function build_query_scalar (line 503) | pub fn build_query_scalar<'q, T>(
  function reset (line 519) | pub fn reset(&mut self) -> &mut Self {
  function sql (line 530) | pub fn sql(&self) -> SqlStr {
  function into_string (line 535) | pub fn into_string(self) -> String {
  function into_sql (line 540) | pub fn into_sql(self) -> SqlStr {
  type Separated (line 549) | pub struct Separated<'qb, DB, Sep>
  function push (line 566) | pub fn push(&mut self, sql: impl Display) -> &mut Self {
  function push_unseparated (line 581) | pub fn push_unseparated(&mut self, sql: impl Display) -> &mut Self {
  function push_bind (line 589) | pub fn push_bind<'t, T>(&mut self, value: T) -> &mut Self
  function push_bind_unseparated (line 607) | pub fn push_bind_unseparated<'t, T>(&mut self, value: T) -> &mut Self

FILE: sqlx-core/src/query_scalar.rs
  type QueryScalar (line 20) | pub struct QueryScalar<'q, DB: Database, O, A> {
  function sql (line 29) | fn sql(self) -> SqlStr {
  function statement (line 33) | fn statement(&self) -> Option<&DB::Statement> {
  function take_arguments (line 38) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argument...
  function persistent (line 43) | fn persistent(&self) -> bool {
  function bind (line 52) | pub fn bind<T: 'q + Encode<'q, DB> + Type<DB>>(mut self, value: T) -> Se...
  function persistent (line 72) | pub fn persistent(mut self, value: bool) -> Self {
  function fetch (line 89) | pub fn fetch<'e, 'c: 'e, E>(self, executor: E) -> BoxStream<'e, Result<O...
  function fetch_many (line 104) | pub fn fetch_many<'e, 'c: 'e, E>(
  function fetch_all (line 130) | pub async fn fetch_all<'e, 'c: 'e, E>(self, executor: E) -> Result<Vec<O...
  function fetch_one (line 158) | pub async fn fetch_one<'e, 'c: 'e, E>(self, executor: E) -> Result<O, Er...
  function fetch_optional (line 182) | pub async fn fetch_optional<'e, 'c: 'e, E>(self, executor: E) -> Result<...
  function query_scalar (line 322) | pub fn query_scalar<'q, DB, O>(
  function query_scalar_with (line 341) | pub fn query_scalar_with<'q, DB, O, A>(
  function query_scalar_with_result (line 355) | pub fn query_scalar_with_result<'q, DB, O, A>(
  function query_statement_scalar (line 370) | pub fn query_statement_scalar<DB, O>(
  function query_statement_scalar_with (line 383) | pub fn query_statement_scalar_with<'q, DB, O, A>(

FILE: sqlx-core/src/raw_sql.rs
  type RawSql (line 20) | pub struct RawSql(SqlStr);
    method sql (line 124) | fn sql(self) -> SqlStr {
    method statement (line 128) | fn statement(&self) -> Option<&<DB as Database>::Statement> {
    method take_arguments (line 132) | fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Argume...
    method persistent (line 136) | fn persistent(&self) -> bool {
    method execute (line 144) | pub async fn execute<'e, E, DB>(self, executor: E) -> crate::Result<DB...
    method execute_many (line 154) | pub fn execute_many<'e, E, DB>(
    method fetch (line 169) | pub fn fetch<'e, E, DB>(self, executor: E) -> BoxStream<'e, Result<DB:...
    method fetch_many (line 182) | pub fn fetch_many<'e, E, DB>(
    method fetch_all (line 201) | pub fn fetch_all<'e, E, DB>(self, executor: E) -> BoxFuture<'e, crate:...
    method fetch_one (line 222) | pub fn fetch_one<'e, E, DB>(self, executor: E) -> BoxFuture<'e, crate:...
    method fetch_optional (line 243) | pub async fn fetch_optional<'e, E, DB>(self, executor: E) -> crate::Re...
  function raw_sql (line 119) | pub fn raw_sql(sql: impl SqlSafeStr) -> RawSql {

FILE: sqlx-core/src/row.rs
  type Row (line 15) | pub trait Row: Unpin + Send + Sync + 'static {
    method is_empty (line 20) | fn is_empty(&self) -> bool {
    method len (line 26) | fn len(&self) -> usize {
    method column (line 39) | fn column<I>(&self, index: I) -> &<Self::Database as Database>::Column
    method try_column (line 47) | fn try_column<I>(&self, index: I) -> Result<&<Self::Database as Databa...
    method columns (line 55) | fn columns(&self) -> &[<Self::Database as Database>::Column];
    method get (line 69) | fn get<'r, T, I>(&'r self, index: I) -> T
    method get_unchecked (line 89) | fn get_unchecked<'r, T, I>(&'r self, index: I) -> T
    method try_get (line 112) | fn try_get<'r, T, I>(&'r self, index: I) -> Result<T, Error>
    method try_get_unchecked (line 153) | fn try_get_unchecked<'r, T, I>(&'r self, index: I) -> Result<T, Error>
    method try_get_raw (line 176) | fn try_get_raw<I>(&self, index: I) -> Result<<Self::Database as Databa...
  function debug_row (line 181) | pub fn debug_row<R>(row: &R, f: &mut std::fmt::Formatter<'_>) -> std::fm...

FILE: sqlx-core/src/rt/mod.rs
  type TimeoutError (line 17) | pub struct TimeoutError;
  type JoinHandle (line 19) | pub enum JoinHandle<T> {
  function timeout (line 34) | pub async fn timeout<F: Future>(duration: Duration, f: F) -> Result<F::O...
  function sleep (line 54) | pub async fn sleep(duration: Duration) {
  function spawn (line 70) | pub fn spawn<F>(fut: F) -> JoinHandle<F::Output>
  function spawn_blocking (line 94) | pub fn spawn_blocking<F, R>(f: F) -> JoinHandle<R>
  function yield_now (line 117) | pub async fn yield_now() {
  function test_block_on (line 147) | pub fn test_block_on<F: Future>(f: F) -> F::Output {
  function missing_rt (line 164) | pub const fn missing_rt<T>(_unused: T) -> ! {
  type Output (line 173) | type Output = T;
  method poll (line 176) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method drop (line 201) | fn drop(&mut self) {

FILE: sqlx-core/src/rt/rt_async_io/socket.rs
  method try_read (line 13) | fn try_read(&mut self, buf: &mut dyn ReadBuf) -> io::Result<usize> {
  method try_write (line 17) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method poll_read_ready (line 21) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method poll_write_ready (line 25) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method poll_shutdown (line 29) | fn poll_shutdown(&mut self, _cx: &mut Context<'_>) -> Poll<io::Result<()...
  method try_read (line 36) | fn try_read(&mut self, buf: &mut dyn ReadBuf) -> io::Result<usize> {
  method try_write (line 40) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method poll_read_ready (line 44) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method poll_write_ready (line 48) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method poll_shutdown (line 52) | fn poll_shutdown(&mut self, _cx: &mut Context<'_>) -> Poll<io::Result<()...

FILE: sqlx-core/src/rt/rt_async_io/timeout.rs
  function sleep (line 7) | pub async fn sleep(duration: Duration) {
  function timeout (line 11) | pub async fn timeout<F: Future>(duration: Duration, future: F) -> Result...
  function timeout_future (line 18) | fn timeout_future(duration: Duration) -> impl Future {

FILE: sqlx-core/src/rt/rt_tokio/mod.rs
  function available (line 3) | pub fn available() -> bool {

FILE: sqlx-core/src/rt/rt_tokio/socket.rs
  method try_read (line 12) | fn try_read(&mut self, mut buf: &mut dyn ReadBuf) -> io::Result<usize> {
  method try_write (line 17) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method poll_read_ready (line 21) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method poll_write_ready (line 25) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method poll_shutdown (line 29) | fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
  method try_read (line 36) | fn try_read(&mut self, mut buf: &mut dyn ReadBuf) -> io::Result<usize> {
  method try_write (line 40) | fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method poll_read_ready (line 44) | fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<(...
  method poll_write_ready (line 48) | fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<...
  method poll_shutdown (line 52) | fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {

FILE: sqlx-core/src/sql_str.rs
  type SqlSafeStr (line 47) | pub trait SqlSafeStr {
    method into_sql_str (line 49) | fn into_sql_str(self) -> SqlStr;
    method into_sql_str (line 54) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 81) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 87) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 94) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 102) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 109) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 115) | fn into_sql_str(self) -> SqlStr {
    method into_sql_str (line 158) | fn into_sql_str(self) -> SqlStr {
  type AssertSqlSafe (line 74) | pub struct AssertSqlSafe<T>(pub T);
  type SqlStr (line 130) | pub struct SqlStr(Repr);
    method as_str (line 166) | pub fn as_str(&self) -> &str {
    method from_static (line 176) | pub const fn from_static(sql: &'static str) -> Self {
    method as_ref (line 183) | fn as_ref(&self) -> &str {
    method borrow (line 190) | fn borrow(&self) -> &str {
    method eq (line 199) | fn eq(&self, other: &T) -> bool {
  type Repr (line 133) | enum Repr {
  method clone (line 146) | fn clone(&self) -> Self {
  method hash (line 207) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: sqlx-core/src/statement.rs
  type Statement (line 20) | pub trait Statement: Send + Sync + Clone {
    method into_sql (line 24) | fn into_sql(self) -> SqlStr;
    method sql (line 27) | fn sql(&self) -> &SqlStr;
    method parameters (line 33) | fn parameters(&self) -> Option<Either<&[<Self::Database as Database>::...
    method columns (line 36) | fn columns(&self) -> &[<Self::Database as Database>::Column];
    method column (line 47) | fn column<I>(&self, index: I) -> &<Self::Database as Database>::Column
    method try_column (line 55) | fn try_column<I>(&self, index: I) -> Result<&<Self::Database as Databa...
    method query (line 62) | fn query(&self) -> Query<'_, Self::Database, <Self::Database as Databa...
    method query_with (line 64) | fn query_with<A>(&self, arguments: A) -> Query<'_, Self::Database, A>
    method query_as (line 68) | fn query_as<O>(
    method query_as_with (line 74) | fn query_as_with<'s, O, A>(&'s self, arguments: A) -> QueryAs<'s, Self...
    method query_scalar (line 79) | fn query_scalar<O>(
    method query_scalar_with (line 85) | fn query_scalar_with<'s, O, A>(&'s self, arguments: A) -> QueryScalar<...

FILE: sqlx-core/src/sync.rs
  type AsyncSemaphore (line 9) | pub struct AsyncSemaphore {
    method new (line 35) | pub fn new(fair: bool, permits: usize) -> Self {
    method permits (line 63) | pub fn permits(&self) -> usize {
    method acquire (line 82) | pub async fn acquire(&self, permits: u32) -> AsyncSemaphoreReleaser<'_> {
    method try_acquire (line 111) | pub fn try_acquire(&self, permits: u32) -> Option<AsyncSemaphoreReleas...
    method release (line 134) | pub fn release(&self, permits: usize) {
  type AsyncSemaphoreReleaser (line 154) | pub struct AsyncSemaphoreReleaser<'a> {
  function disarm (line 187) | pub fn disarm(self) {

FILE: sqlx-core/src/testing/fixtures.rs
  type Result (line 13) | pub type Result<T, E = FixtureError> = std::result::Result<T, E>;
  type FixtureSnapshot (line 20) | pub struct FixtureSnapshot<DB> {
  type FixtureError (line 27) | pub struct FixtureError(String);
  type Fixture (line 29) | pub struct Fixture<DB> {
  type FixtureOp (line 34) | enum FixtureOp {
  type TableName (line 43) | type TableName = Arc<str>;
  type ColumnName (line 44) | type ColumnName = Arc<str>;
  type Value (line 45) | type Value = String;
  type Table (line 47) | struct Table {
  function additive_fixture (line 73) | pub fn additive_fixture(&self) -> Result<Fixture<DB>> {
  function calculate_visit_order (line 95) | fn calculate_visit_order(&self) -> Result<Vec<TableName>> {
  method to_string (line 117) | fn to_string(&self) -> String {
  function foreign_key_depth (line 157) | fn foreign_key_depth(
  function test_additive_fixture (line 200) | fn test_additive_fixture() -> Result<()> {

FILE: sqlx-core/src/testing/mod.rs
  type TestSupport (line 17) | pub trait TestSupport: Database {
    method test_context (line 27) | fn test_context(
    method cleanup_test (line 31) | fn cleanup_test(db_name: &str) -> impl Future<Output = Result<(), Erro...
    method cleanup_test_dbs (line 39) | fn cleanup_test_dbs() -> impl Future<Output = Result<Option<usize>, Er...
    method snapshot (line 44) | fn snapshot(
    method db_name (line 49) | fn db_name(args: &TestArgs) -> String {
  type TestFixture (line 60) | pub struct TestFixture {
  type TestArgs (line 65) | pub struct TestArgs {
    method new (line 156) | pub fn new(test_path: &'static str) -> Self {
    method migrator (line 164) | pub fn migrator(&mut self, migrator: &'static Migrator) {
    method fixtures (line 168) | pub fn fixtures(&mut self, fixtures: &'static [TestFixture]) {
  type TestFn (line 71) | pub trait TestFn {
    method run_test (line 74) | fn run_test(self, args: TestArgs) -> Self::Output;
    type Output (line 95) | type Output = Fut::Output;
    method run_test (line 97) | fn run_test(self, args: TestArgs) -> Self::Output {
    type Output (line 110) | type Output = Fut::Output;
    method run_test (line 112) | fn run_test(self, args: TestArgs) -> Self::Output {
    type Output (line 133) | type Output = Fut::Output;
    method run_test (line 135) | fn run_test(self, args: TestArgs) -> Self::Output {
    type Output (line 144) | type Output = Fut::Output;
    method run_test (line 146) | fn run_test(self, args: TestArgs) -> Self::Output {
  type TestTermination (line 77) | pub trait TestTermination {
    method is_success (line 78) | fn is_success(&self) -> bool;
    method is_success (line 174) | fn is_success(&self) -> bool {
    method is_success (line 180) | fn is_success(&self) -> bool {
  type TestContext (line 81) | pub struct TestContext<DB: Database> {
  function run_test_with_pool (line 185) | fn run_test_with_pool<DB, F, Fut>(args: TestArgs, test_fn: F) -> Fut::Ou...
  function run_test (line 215) | fn run_test<DB, F, Fut>(args: TestArgs, test_fn: F) -> Fut::Output
  function setup_test_db (line 246) | async fn setup_test_db<DB: Database>(

FILE: sqlx-core/src/transaction.rs
  type TransactionManager (line 15) | pub trait TransactionManager {
    method begin (line 25) | fn begin(
    method commit (line 31) | fn commit(
    method rollback (line 36) | fn rollback(
    method start_rollback (line 41) | fn start_rollback(conn: &mut <Self::Database as Database>::Connection);
    method get_transaction_depth (line 49) | fn get_transaction_depth(conn: &<Self::Database as Database>::Connecti...
  type Transaction (line 86) | pub struct Transaction<'c, DB>
  function begin (line 99) | pub fn begin(
  function commit (line 120) | pub async fn commit(mut self) -> Result<(), Error> {
  function rollback (line 128) | pub async fn rollback(mut self) -> Result<(), Error> {
  method fmt (line 211) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Target (line 221) | type Target = DB::Connection;
  method deref (line 224) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 234) | fn deref_mut(&mut self) -> &mut Self::Target {
  function as_mut (line 244) | fn as_mut(&mut self) -> &mut DB::Connection {
  type Database (line 250) | type Database = DB;
  type Connection (line 252) | type Connection = &'t mut <DB as Database>::Connection;
  function acquire (line 255) | fn acquire(self) -> BoxFuture<'t, Result<Self::Connection, Error>> {
  function begin (line 260) | fn begin(self) -> BoxFuture<'t, Result<Transaction<'t, DB>, Error>> {
  method drop (line 269) | fn drop(&mut self) {
  function begin_ansi_transaction_sql (line 282) | pub fn begin_ansi_transaction_sql(depth: usize) -> SqlStr {
  function commit_ansi_transaction_sql (line 290) | pub fn commit_ansi_transaction_sql(depth: usize) -> SqlStr {
  function rollback_ansi_transaction_sql (line 298) | pub fn rollback_ansi_transaction_sql(depth: usize) -> SqlStr {

FILE: sqlx-core/src/type_checking.rs
  type ParamChecking (line 12) | pub enum ParamChecking {
  type TypeChecking (line 22) | pub trait TypeChecking: Database {
    constant PARAM_CHECKING (line 24) | const PARAM_CHECKING: ParamChecking;
    method param_type_for_id (line 30) | fn param_type_for_id(
    method return_type_for_id (line 38) | fn return_type_for_id(
    method get_feature_gate (line 45) | fn get_feature_gate(info: &Self::TypeInfo) -> Option<&'static str>;
    method fmt_value_debug (line 50) | fn fmt_value_debug(value: &<Self as Database>::Value) -> FmtValue<'_, ...
  type Result (line 53) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  type Error (line 56) | pub enum Error {
  type FmtValue (line 70) | pub struct FmtValue<'v, DB>
  function debug (line 87) | pub fn debug<T>(value: &'v <DB as Database>::Value) -> Self
  function unknown (line 116) | pub fn unknown(value: &'v <DB as Database>::Value) -> Self
  method fmt (line 142) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: sqlx-core/src/type_info.rs
  type TypeInfo (line 4) | pub trait TypeInfo: Debug + Display + Clone + PartialEq<Self> + Send + S...
    method is_null (line 5) | fn is_null(&self) -> bool;
    method name (line 10) | fn name(&self) -> &str;
    method type_compatible (line 15) | fn type_compatible(&self, other: &Self) -> bool
    method is_void (line 23) | fn is_void(&self) -> bool {

FILE: sqlx-core/src/types/bstr.rs
  method type_info (line 16) | fn type_info() -> DB::TypeInfo {
  method compatible (line 20) | fn compatible(ty: &DB::TypeInfo) -> bool {
  method decode (line 30) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynE...
  function encode_by_ref (line 40) | fn encode_by_ref(
  method encode_by_ref (line 53) | fn encode_by_ref(

FILE: sqlx-core/src/types/json.rs
  type Json (line 87) | pub struct Json<T: ?Sized>(pub T);
  function into_inner (line 91) | pub fn into_inner(self) -> T {
  function from (line 97) | fn from(value: T) -> Self {
  type Target (line 103) | type Target = T;
  method deref (line 105) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 111) | fn deref_mut(&mut self) -> &mut Self::Target {
  function as_ref (line 117) | fn as_ref(&self) -> &T {
  function as_mut (line 123) | fn as_mut(&mut self) -> &mut T {
  function encode_to_string (line 131) | pub fn encode_to_string(&self) -> Result<String, serde_json::Error> {
  function encode_to (line 135) | pub fn encode_to(&self, buf: &mut Vec<u8>) -> Result<(), serde_json::Err...
  function decode_from_string (line 146) | pub fn decode_from_string(s: &'a str) -> Result<Self, BoxDynError> {
  function decode_from_bytes (line 150) | pub fn decode_from_bytes(bytes: &'a [u8]) -> Result<Self, BoxDynError> {
  method type_info (line 160) | fn type_info() -> DB::TypeInfo {
  method compatible (line 164) | fn compatible(ty: &DB::TypeInfo) -> bool {
  method encode_by_ref (line 174) | fn encode_by_ref(
  method decode (line 187) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynE...
  method type_info (line 197) | fn type_info() -> DB::TypeInfo {
  method compatible (line 201) | fn compatible(ty: &DB::TypeInfo) -> bool {
  method encode_by_ref (line 211) | fn encode_by_ref(
  function encode_by_ref (line 224) | fn encode_by_ref(
  function encode_by_ref (line 237) | fn encode_by_ref(
  function decode (line 250) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynE...
  function decode (line 260) | fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynE...

FILE: sqlx-core/src/types/mod.rs
  type Type (line 211) | pub trait Type<DB: Database> {
    method type_info (line 219) | fn type_info() -> DB::TypeInfo;
    method compatible (line 230) | fn compatible(ty: &DB::TypeInfo) -> bool {
  function type_info (line 237) | fn type_info() -> DB::TypeInfo {
  function compatible (line 241) | fn compatible(ty: &DB::TypeInfo) -> bool {
  function type_info (line 248) | fn type_info() -> DB::TypeInfo {
  function compatible (line 252) | fn compatible(ty: &DB::TypeInfo) -> bool {
  function type_info (line 283) | fn type_info() -> DB::TypeInfo {
  function compatible (line 287) | fn compatible(ty: &DB::TypeInfo) -> bool {

FILE: sqlx-core/src/types/text.rs
  type Text (line 74) | pub struct Text<T>(pub T);
  function into_inner (line 78) | pub fn into_inner(self) -> T {
  type Target (line 84) | type Target = T;
  method deref (line 86) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 92) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: sqlx-core/src/value.rs
  type Value (line 9) | pub trait Value {
    method as_ref (line 13) | fn as_ref(&self) -> <Self::Database as Database>::ValueRef<'_>;
    method type_info (line 16) | fn type_info(&self) -> Cow<'_, <Self::Database as Database>::TypeInfo>;
    method is_null (line 19) | fn is_null(&self) -> bool;
    method decode (line 29) | fn decode<'r, T>(&'r self) -> T
    method decode_unchecked (line 47) | fn decode_unchecked<'r, T>(&'r self) -> T
    method try_decode (line 63) | fn try_decode<'r, T>(&'r self) -> Result<T, Error>
    method try_decode_unchecked (line 90) | fn try_decode_unchecked<'r, T>(&'r self) -> Result<T, Error>
  type ValueRef (line 99) | pub trait ValueRef<'r>: Sized {
    method to_owned (line 106) | fn to_owned(&self) -> <Self::Database as Database>::Value;
    method type_info (line 109) | fn type_info(&self) -> Cow<'_, <Self::Database as Database>::TypeInfo>;
    method is_null (line 112) | fn is_null(&self) -> bool;

FILE: sqlx-macros-core/src/common.rs
  function resolve_path (line 4) | pub(crate) fn resolve_path(path: impl AsRef<Path>, err_span: Span) -> sy...

FILE: sqlx-macros-core/src/database/mod.rs
  type DatabaseExt (line 16) | pub trait DatabaseExt: Database + TypeChecking {
    constant DATABASE_PATH (line 17) | const DATABASE_PATH: &'static str;
    constant ROW_PATH (line 18) | const ROW_PATH: &'static str;
    method db_path (line 20) | fn db_path() -> syn::Path {
    method row_path (line 24) | fn row_path() -> syn::Path {
    method describe_blocking (line 28) | fn describe_blocking(
  type CachingDescribeBlocking (line 36) | pub struct CachingDescribeBlocking<DB: DatabaseExt> {
  function new (line 43) | pub const fn new() -> Self {
  function describe (line 49) | pub fn describe(

FILE: sqlx-macros-core/src/derives/attributes.rs
  type TypeName (line 31) | pub struct TypeName {
    method get (line 37) | pub fn get(&self) -> TokenStream {
  type RenameAll (line 45) | pub enum RenameAll {
  type SqlxContainerAttributes (line 55) | pub struct SqlxContainerAttributes {
  type JsonAttribute (line 64) | pub enum JsonAttribute {
  type SqlxChildAttributes (line 69) | pub struct SqlxChildAttributes {
  function parse_container_attributes (line 78) | pub fn parse_container_attributes(input: &[Attribute]) -> syn::Result<Sq...
  function parse_child_attributes (line 146) | pub fn parse_child_attributes(input: &[Attribute]) -> syn::Result<SqlxCh...
  function check_transparent_attributes (line 203) | pub fn check_transparent_attributes(
  function check_enum_attributes (line 226) | pub fn check_enum_attributes(input: &DeriveInput) -> syn::Result<SqlxCon...
  function check_weak_enum_attributes (line 238) | pub fn check_weak_enum_attributes(
  function check_strong_enum_attributes (line 265) | pub fn check_strong_enum_attributes(
  function check_struct_attributes (line 276) | pub fn check_struct_attributes(

FILE: sqlx-macros-core/src/derives/decode.rs
  function expand_derive_decode (line 15) | pub fn expand_derive_decode(input: &DeriveInput) -> syn::Result<TokenStr...
  function expand_derive_decode_transparent (line 49) | fn expand_derive_decode_transparent(
  function expand_derive_decode_weak_enum (line 100) | fn expand_derive_decode_weak_enum(
  function expand_derive_decode_strong_enum (line 147) | fn expand_derive_decode_strong_enum(
  function expand_derive_decode_struct (line 263) | fn expand_derive_decode_struct(

FILE: sqlx-macros-core/src/derives/encode.rs
  function expand_derive_encode (line 15) | pub fn expand_derive_encode(input: &DeriveInput) -> syn::Result<TokenStr...
  function expand_derive_encode_transparent (line 50) | fn expand_derive_encode_transparent(
  function expand_derive_encode_weak_enum (line 108) | fn expand_derive_encode_weak_enum(
  function expand_derive_encode_strong_enum (line 147) | fn expand_derive_encode_strong_enum(
  function expand_derive_encode_struct (line 201) | fn expand_derive_encode_struct(

FILE: sqlx-macros-core/src/derives/mod.rs
  function expand_derive_type_encode_decode (line 17) | pub fn expand_derive_type_encode_decode(input: &DeriveInput) -> syn::Res...
  function rename_all (line 27) | pub(crate) fn rename_all(s: &str, pattern: RenameAll) -> String {

FILE: sqlx-macros-core/src/derives/row.rs
  function expand_derive_from_row (line 13) | pub fn expand_derive_from_row(input: &DeriveInput) -> syn::Result<TokenS...
  function expand_derive_from_row_struct (line 39) | fn expand_derive_from_row_struct(
  function expand_derive_from_row_struct_unnamed (line 245) | fn expand_derive_from_row_struct_unnamed(

FILE: sqlx-macros-core/src/derives/type.rs
  function expand_derive_type (line 13) | pub fn expand_derive_type(input: &DeriveInput) -> syn::Result<TokenStrea...
  function expand_derive_has_sql_type_transparent (line 55) | fn expand_derive_has_sql_type_transparent(
  function expand_derive_has_sql_type_weak_enum (line 143) | fn expand_derive_has_sql_type_weak_enum(
  function expand_derive_has_sql_type_strong_enum (line 180) | fn expand_derive_has_sql_type_strong_enum(
  function expand_derive_has_sql_type_struct (line 242) | fn expand_derive_has_sql_type_struct(
  function type_name (line 278) | fn type_name(ident: &Ident, explicit_name: Option<&TypeName>) -> TokenSt...

FILE: sqlx-macros-core/src/lib.rs
  type Error (line 28) | pub type Error = Box<dyn std::error::Error>;
  type Result (line 30) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  constant FOSS_DRIVERS (line 48) | pub const FOSS_DRIVERS: &[QueryDriver] = &[
  function block_on (line 57) | pub fn block_on<F>(f: F) -> F::Output
  function env (line 89) | pub fn env(var: &str) -> Result<String> {
  function env_opt (line 95) | pub fn env_opt(var: &str) -> Result<Option<String>> {
  function manifest_dir (line 111) | pub fn manifest_dir() -> Result<PathBuf> {

FILE: sqlx-macros-core/src/migrate.rs
  constant DEFAULT_PATH (line 12) | pub const DEFAULT_PATH: &str = "./migrations";
  type QuoteMigrationType (line 14) | pub struct QuoteMigrationType(MigrationType);
  method to_tokens (line 17) | fn to_tokens(&self, tokens: &mut TokenStream) {
  type QuoteMigration (line 29) | struct QuoteMigration {
  method to_tokens (line 35) | fn to_tokens(&self, tokens: &mut TokenStream) {
  function default_path (line 86) | pub fn default_path(config: &Config) -> &str {
  function expand (line 94) | pub fn expand(path_arg: Option<LitStr>) -> crate::Result<TokenStream> {
  function expand_with_path (line 105) | pub fn expand_with_path(config: &Config, path: &Path) -> crate::Result<T...

FILE: sqlx-macros-core/src/query/args.rs
  function quote_args (line 15) | pub fn quote_args<DB: DatabaseExt>(
  function get_param_type (line 108) | fn get_param_type<DB: DatabaseExt>(
  function get_type_override (line 179) | fn get_type_override(expr: &Expr) -> Option<&Type> {
  function strip_wildcard (line 187) | fn strip_wildcard(expr: Expr) -> Expr {

FILE: sqlx-macros-core/src/query/cache.rs
  type MtimeCache (line 7) | pub struct MtimeCache<T> {
  type MtimeCacheBuilder (line 11) | pub struct MtimeCacheBuilder {
    method new (line 59) | fn new() -> Self {
    method add_path (line 69) | pub fn add_path(&mut self, path: PathBuf) {
    method any_modified (line 80) | fn any_modified(&self) -> bool {
  type MtimeCacheInner (line 15) | struct MtimeCacheInner<T> {
  function new (line 21) | pub fn new() -> Self {
  function get_or_try_init (line 28) | pub fn get_or_try_init<E>(
  function get_mtime (line 93) | fn get_mtime(path: &Path) -> Option<SystemTime> {

FILE: sqlx-macros-core/src/query/data.rs
  type QueryData (line 20) | pub struct QueryData<DB: Database> {
  function from_describe (line 29) | pub fn from_describe(query: &str, describe: Describe<DB>) -> Self {
  type SerializeDbName (line 39) | struct SerializeDbName<DB>(PhantomData<DB>);
  method default (line 42) | fn default() -> Self {
  method fmt (line 48) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method fmt (line 54) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method serialize (line 60) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type DynQueryData (line 73) | pub struct DynQueryData {
    method from_data_file (line 83) | pub fn from_data_file(path: &Path, query: &str) -> crate::Result<Self> {
  function from_dyn_data (line 117) | pub fn from_dyn_data(dyn_data: DynQueryData) -> crate::Result<Self> {
  function save_in (line 139) | pub(super) fn save_in(&self, dir: &Path) -> crate::Result<()> {
  function hash_string (line 209) | pub(super) fn hash_string(query: &str) -> String {

FILE: sqlx-macros-core/src/query/input.rs
  type QueryMacroInput (line 10) | pub struct QueryMacroInput {
  type QuerySrc (line 24) | enum QuerySrc {
    method resolve (line 113) | fn resolve(self, source_span: Span) -> syn::Result<String> {
    method file_path (line 120) | fn file_path(&self, source_span: Span) -> syn::Result<Option<String>> {
  type RecordType (line 29) | pub enum RecordType {
  method parse (line 36) | fn parse(input: ParseStream) -> syn::Result<Self> {
  function read_file_src (line 142) | fn read_file_src(source: &str, source_span: Span) -> syn::Result<String> {

FILE: sqlx-macros-core/src/query/metadata.rs
  type Metadata (line 10) | pub struct Metadata {
    method env (line 24) | pub fn env(&self) -> crate::Result<Arc<MacrosEnv>> {
    method workspace_root (line 29) | pub fn workspace_root(&self) -> PathBuf {
  type MacrosEnv (line 17) | pub struct MacrosEnv {
  function try_for_crate (line 58) | pub fn try_for_crate() -> crate::Result<Arc<Metadata>> {
  function load_env (line 92) | fn load_env(
  function is_truthy_bool (line 160) | fn is_truthy_bool(val: &str) -> bool {

FILE: sqlx-macros-core/src/query/mod.rs
  type QueryDriver (line 28) | pub struct QueryDriver {
    method new (line 36) | pub const fn new<DB: DatabaseExt>() -> Self
  type QueryDataSource (line 47) | pub enum QueryDataSource<'a> {
  function live (line 56) | pub fn live(database_url: &'a str) -> crate::Result<Self> {
  function matches_driver (line 63) | pub fn matches_driver(&self, driver: &QueryDriver) -> bool {
  function expand_input (line 73) | pub fn expand_input<'a>(
  function expand_with (line 151) | fn expand_with<DB: DatabaseExt>(
  type DescribeExt (line 173) | trait DescribeExt: serde::Serialize + serde::de::DeserializeOwned {}
  type Warnings (line 181) | struct Warnings {
  function expand_with_data (line 186) | fn expand_with_data<DB: DatabaseExt>(

FILE: sqlx-macros-core/src/query/output.rs
  type RustColumn (line 19) | pub struct RustColumn {
  type ColumnType (line 25) | pub(super) enum ColumnType {
    method is_wildcard (line 32) | pub(super) fn is_wildcard(&self) -> bool {
  method to_tokens (line 38) | fn to_tokens(&self, tokens: &mut TokenStream) {
  type DisplayColumn (line 47) | struct DisplayColumn<'a> {
  type ColumnDecl (line 53) | struct ColumnDecl {
    method parse (line 347) | fn parse(col_name: &str) -> crate::Result<Self> {
  type ColumnOverride (line 58) | struct ColumnOverride {
  type ColumnNullabilityOverride (line 64) | enum ColumnNullabilityOverride {
  type ColumnTypeOverride (line 70) | enum ColumnTypeOverride {
  method fmt (line 77) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function columns_to_rust (line 82) | pub fn columns_to_rust<DB: DatabaseExt>(
  function column_to_rust (line 92) | fn column_to_rust<DB: DatabaseExt>(
  function quote_query_as (line 139) | pub fn quote_query_as<DB: DatabaseExt>(
  function quote_query_scalar (line 206) | pub fn quote_query_scalar<DB: DatabaseExt>(
  function get_column_type (line 245) | fn get_column_type<DB: DatabaseExt>(
  method parse (line 374) | fn parse(input: ParseStream) -> syn::Result<Self> {
  function parse_ident (line 407) | fn parse_ident(name: &str) -> crate::Result<Ident> {

FILE: sqlx-macros-core/src/test_attr.rs
  type Args (line 6) | struct Args {
  type FixturesType (line 12) | enum FixturesType {
  type MigrationsOpt (line 20) | enum MigrationsOpt {
  type AttributeArgs (line 27) | type AttributeArgs = syn::punctuated::Punctuated<syn::Meta, syn::Token![...
  function expand (line 29) | pub fn expand(args: TokenStream, input: syn::ItemFn) -> crate::Result<To...
  function expand_simple (line 63) | fn expand_simple(input: syn::ItemFn) -> TokenStream {
  function expand_advanced (line 79) | fn expand_advanced(args: AttributeArgs, input: syn::ItemFn) -> crate::Re...
  function parse_args (line 192) | fn parse_args(attr_args: AttributeArgs) -> syn::Result<Args> {
  function parse_fixtures_args (line 311) | fn parse_fixtures_args(
  function parse_fixtures_path_args (line 364) | fn parse_fixtures_path_args(
  function parse_fixtures_scripts_args (line 379) | fn parse_fixtures_scripts_args(
  function add_sql_extension_if_missing (line 398) | fn add_sql_extension_if_missing(fixture: &mut String) {

FILE: sqlx-macros/src/lib.rs
  function expand_query (line 9) | pub fn expand_query(input: TokenStream) -> TokenStream {
  function derive_encode (line 27) | pub fn derive_encode(tokenstream: TokenStream) -> TokenStream {
  function derive_decode (line 37) | pub fn derive_decode(tokenstream: TokenStream) -> TokenStream {
  function derive_type (line 47) | pub fn derive_type(tokenstream: TokenStream) -> TokenStream {
  function derive_from_row (line 57) | pub fn derive_from_row(input: TokenStream) -> TokenStream {
  function migrate (line 68) | pub fn migrate(input: TokenStream) -> TokenStream {
  function test (line 87) | pub fn test(args: TokenStream, input: TokenStream) -> TokenStream {

FILE: sqlx-mysql/src/any.rs
  method name (line 24) | fn name(&self) -> &str {
  method close (line 28) | fn close(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<()>> {
  method close_hard (line 32) | fn close_hard(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<(...
  method ping (line 36) | fn ping(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method begin (line 40) | fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, sqlx_cor...
  method commit (line 44) | fn commit(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method rollback (line 48) | fn rollback(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method start_rollback (line 52) | fn start_rollback(&mut self) {
  method get_transaction_depth (line 56) | fn get_transaction_depth(&self) -> usize {
  method shrink_buffers (line 60) | fn shrink_buffers(&mut self) {
  method flush (line 64) | fn flush(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method should_flush (line 68) | fn should_flush(&self) -> bool {
  method as_migrate (line 73) | fn as_migrate(
  method fetch_many (line 79) | fn fetch_many(
  method fetch_optional (line 105) | fn fetch_optional(
  method prepare_with (line 131) | fn prepare_with<'c, 'q: 'c>(
  method describe (line 144) | fn describe(
  type Error (line 156) | type Error = sqlx_core::Error;
  method try_from (line 158) | fn try_from(type_info: &'a MySqlTypeInfo) -> Result<Self, Self::Error> {
  type Error (line 185) | type Error = sqlx_core::Error;
  method try_from (line 187) | fn try_from(column: &'a MySqlColumn) -> Result<Self, Self::Error> {
  type Error (line 199) | type Error = sqlx_core::Error;
  method try_from (line 201) | fn try_from(row: &'a MySqlRow) -> Result<Self, Self::Error> {
  type Error (line 207) | type Error = sqlx_core::Error;
  method try_from (line 209) | fn try_from(any_opts: &'a AnyConnectOptions) -> Result<Self, Self::Error> {
  function map_result (line 216) | fn map_result(result: MySqlQueryResult) -> AnyQueryResult {

FILE: sqlx-mysql/src/arguments.rs
  type MySqlArguments (line 10) | pub struct MySqlArguments {
    method add (line 17) | pub(crate) fn add<'q, T>(&mut self, value: T) -> Result<(), BoxDynError>
  type Database (line 41) | type Database = MySql;
  method reserve (line 43) | fn reserve(&mut self, len: usize, size: usize) {
  method add (line 48) | fn add<'t, T>(&mut self, value: T) -> Result<(), BoxDynError>
  method len (line 55) | fn len(&self) -> usize {
  type NullBitMap (line 61) | pub(crate) struct NullBitMap {
    method push (line 67) | fn push(&mut self, is_null: IsNull) {
  type Target (line 81) | type Target = [u8];
  method deref (line 83) | fn deref(&self) -> &Self::Target {
  function null_bit_map_should_push_is_null (line 93) | fn null_bit_map_should_push_is_null() {

FILE: sqlx-mysql/src/collation.rs
  type Collation (line 41) | pub struct Collation(pub u16);
    constant BINARY (line 45) | pub const BINARY: Self = Collation(63);
    constant UTF8MB4_GENERAL_CI (line 48) | pub const UTF8MB4_GENERAL_CI: Self = Collation(45);

FILE: sqlx-mysql/src/column.rs
  type MySqlColumn (line 8) | pub struct MySqlColumn {
  type Database (line 22) | type Database = MySql;
  method ordinal (line 24) | fn ordinal(&self) -> usize {
  method name (line 28) | fn name(&self) -> &str {
  method type_info (line 32) | fn type_info(&self) -> &MySqlTypeInfo {
  method origin (line 36) | fn origin(&self) -> ColumnOrigin {

FILE: sqlx-mysql/src/connection/auth.rs
  method scramble (line 16) | pub(super) async fn scramble(
  method handle (line 39) | pub(super) async fn handle(
  function scramble_sha1 (line 77) | fn scramble_sha1(
  function scramble_sha256 (line 105) | fn scramble_sha256(
  function encrypt_rsa (line 132) | async fn encrypt_rsa<'s>(
  function xor_eq (line 172) | fn xor_eq(x: &mut [u8], y: &[u8]) {
  function to_asciz (line 180) | fn to_asciz(s: &str) -> Vec<u8> {
  function parse_rsa_pub_key (line 189) | fn parse_rsa_pub_key(key: &[u8]) -> Result<RsaPublicKey, Error> {

FILE: sqlx-mysql/src/connection/establish.rs
  method establish (line 15) | pub(crate) async fn establish(options: &MySqlConnectOptions) -> Result<S...
  type DoHandshake (line 37) | struct DoHandshake<'a> {
  function new (line 42) | fn new(options: &'a MySqlConnectOptions) -> Result<Self, Error> {
  function do_handshake (line 55) | async fn do_handshake<S: Socket>(self, socket: S) -> Result<MySqlStream,...
  type Output (line 171) | type Output = Result<MySqlStream, Error>;
  method with_socket (line 173) | async fn with_socket<S: Socket>(self, socket: S) -> Self::Output {

FILE: sqlx-mysql/src/connection/executor.rs
  method prepare_statement (line 29) | async fn prepare_statement(
  method get_or_prepare_statement (line 76) | async fn get_or_prepare_statement(
  method run (line 103) | pub(crate) async fn run<'e, 'c: 'e, 'q: 'e>(
  type Database (line 280) | type Database = MySql;
  function fetch_many (line 282) | fn fetch_many<'e, 'q, E>(
  function fetch_optional (line 308) | fn fetch_optional<'e, 'q, E>(self, query: E) -> BoxFuture<'e, Result<Opt...
  function prepare_with (line 328) | fn prepare_with<'e>(
  function describe (line 362) | fn describe<'e>(
  function recv_result_columns (line 398) | async fn recv_result_columns(
  function recv_next_result_column (line 417) | fn recv_next_result_column(def: &ColumnDefinition, ordinal: usize) -> Re...
  function recv_result_metadata (line 455) | async fn recv_result_metadata(

FILE: sqlx-mysql/src/connection/mod.rs
  constant MAX_PACKET_SIZE (line 24) | const MAX_PACKET_SIZE: u32 = 1024;
  constant INITIAL_CHARSET (line 31) | const INITIAL_CHARSET: u8 = Collation::UTF8MB4_GENERAL_CI.0 as u8;
  type MySqlConnection (line 34) | pub struct MySqlConnection {
    method in_transaction (line 55) | pub(crate) fn in_transaction(&self) -> bool {
  type MySqlConnectionInner (line 38) | pub(crate) struct MySqlConnectionInner {
  method fmt (line 63) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Database (line 69) | type Database = MySql;
  type Options (line 71) | type Options = MySqlConnectOptions;
  method close (line 73) | async fn close(mut self) -> Result<(), Error> {
  method close_hard (line 80) | async fn close_hard(mut self) -> Result<(), Error> {
  method ping (line 85) | async fn ping(&mut self) -> Result<(), Error> {
  method flush (line 94) | fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + ...
  method cached_statements_size (line 98) | fn cached_statements_size(&self) -> usize {
  method clear_cached_statements (line 102) | async fn clear_cached_statements(&mut self) -> Result<(), Error> {
  method should_flush (line 116) | fn should_flush(&self) -> bool {
  method begin (line 120) | fn begin(
  method begin_with (line 126) | fn begin_with(
  method shrink_buffers (line 136) | fn shrink_buffers(&mut self) {

FILE: sqlx-mysql/src/connection/stream.rs
  type MySqlStream (line 14) | pub struct MySqlStream<S = Box<dyn Socket>> {
  type Waiting (line 25) | pub(crate) enum Waiting {
  function with_socket (line 34) | pub(crate) fn with_socket(options: &MySqlConnectOptions, socket: S) -> S...
  function wait_until_ready (line 62) | pub(crate) async fn wait_until_ready(&mut self) -> Result<(), Error> {
  function send_packet (line 101) | pub(crate) async fn send_packet<'en, T>(&mut self, payload: T) -> Result...
  function write_packet (line 111) | pub(crate) fn write_packet<'en, T>(&mut self, payload: T) -> Result<(), ...
  function recv_packet_part (line 119) | async fn recv_packet_part(&mut self) -> Result<Bytes, Error> {
  function recv_packet (line 141) | pub(crate) async fn recv_packet(&mut self) -> Result<Packet<Bytes>, Erro...
  function recv (line 177) | pub(crate) async fn recv<'de, T>(&mut self) -> Result<T, Error>
  function recv_ok (line 184) | pub(crate) async fn recv_ok(&mut self) -> Result<OkPacket, Error> {
  function maybe_recv_eof (line 188) | pub(crate) async fn maybe_recv_eof(&mut self) -> Result<Option<EofPacket...
  function skip_result_metadata (line 196) | async fn skip_result_metadata(&mut self, mut packet: Packet<Bytes>) -> R...
  function boxed_socket (line 208) | pub fn boxed_socket(self) -> MySqlStream {
  type Target (line 221) | type Target = BufferedSocket<S>;
  method deref (line 223) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 229) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: sqlx-mysql/src/connection/tls.rs
  type MapStream (line 10) | struct MapStream {
  function maybe_upgrade (line 17) | pub(super) async fn maybe_upgrade<S: Socket>(
  type Output (line 90) | type Output = MySqlStream;
  method with_socket (line 92) | async fn with_socket<S: Socket>(self, socket: S) -> Self::Output {

FILE: sqlx-mysql/src/database.rs
  type MySql (line 10) | pub struct MySql;
  type Connection (line 13) | type Connection = MySqlConnection;
  type TransactionManager (line 15) | type TransactionManager = MySqlTransactionManager;
  type Row (line 17) | type Row = MySqlRow;
  type QueryResult (line 19) | type QueryResult = MySqlQueryResult;
  type Column (line 21) | type Column = MySqlColumn;
  type TypeInfo (line 23) | type TypeInfo = MySqlTypeInfo;
  type Value (line 25) | type Value = MySqlValue;
  type ValueRef (line 26) | type ValueRef<'r> = MySqlValueRef<'r>;
  type Arguments (line 28) | type Arguments = MySqlArguments;
  type ArgumentBuffer (line 29) | type ArgumentBuffer = Vec<u8>;
  type Statement (line 31) | type Statement = MySqlStatement;
  constant NAME (line 33) | const NAME: &'static str = "MySQL";
  constant URL_SCHEMES (line 35) | const URL_SCHEMES: &'static [&'static str] = &["mysql", "mariadb"];

FILE: sqlx-mysql/src/error.rs
  type MySqlDatabaseError (line 11) | pub struct MySqlDatabaseError(pub(super) ErrPacket);
    method code (line 15) | pub fn code(&self) -> Option<&str> {
    method number (line 24) | pub fn number(&self) -> u16 {
    method message (line 29) | pub fn message(&self) -> &str {
  method fmt (line 35) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method fmt (line 45) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method message (line 58) | fn message(&self) -> &str {
  method code (line 63) | fn code(&self) -> Option<Cow<'_, str>> {
  method as_error (line 68) | fn as_error(&self) -> &(dyn StdError + Send + Sync + 'static) {
  method as_error_mut (line 73) | fn as_error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {
  method into_error (line 78) | fn into_error(self: Box<Self>) -> Box<dyn StdError + Send + Sync + 'stat...
  method kind (line 82) | fn kind(&self) -> ErrorKind {
  constant ER_DUP_KEY (line 124) | pub const ER_DUP_KEY: u16 = 1022;
  constant ER_DUP_ENTRY (line 127) | pub const ER_DUP_ENTRY: u16 = 1062;
  constant ER_DUP_UNIQUE (line 131) | pub const ER_DUP_UNIQUE: u16 = 1169;
  constant ER_DUP_ENTRY_WITH_KEY_NAME (line 135) | pub const ER_DUP_ENTRY_WITH_KEY_NAME: u16 = 1586;
  constant ER_DUP_UNKNOWN_IN_INDEX (line 141) | pub const ER_DUP_UNKNOWN_IN_INDEX: u16 = 1859;
  constant ER_NO_REFERENCED_ROW (line 144) | pub const ER_NO_REFERENCED_ROW: u16 = 1216;
  constant ER_ROW_IS_REFERENCED (line 146) | pub const ER_ROW_IS_REFERENCED: u16 = 1217;
  constant ER_ROW_IS_REFERENCED_2 (line 149) | pub const ER_ROW_IS_REFERENCED_2: u16 = 1451;
  constant ER_NO_REFERENCED_ROW_2 (line 152) | pub const ER_NO_REFERENCED_ROW_2: u16 = 1452;
  constant ER_FK_COLUMN_NOT_NULL (line 154) | pub const ER_FK_COLUMN_NOT_NULL: u16 = 1830;
  constant ER_FK_CANNOT_DELETE_PARENT (line 156) | pub const ER_FK_CANNOT_DELETE_PARENT: u16 = 1834;
  constant ER_BAD_NULL_ERROR (line 159) | pub const ER_BAD_NULL_ERROR: u16 = 1048;
  constant ER_NO_DEFAULT_FOR_FIELD (line 161) | pub const ER_NO_DEFAULT_FOR_FIELD: u16 = 1364;
  constant ER_CHECK_CONSTRAINT_VIOLATED (line 166) | pub const ER_CHECK_CONSTRAINT_VIOLATED: u16 = 3819;
  constant ER_CONSTRAINT_FAILED (line 175) | pub const ER_CONSTRAINT_FAILED: u16 = 4025;

FILE: sqlx-mysql/src/io/buf.rs
  type MySqlBufExt (line 6) | pub trait MySqlBufExt: Buf {
    method get_uint_lenenc (line 11) | fn get_uint_lenenc(&mut self) -> Result<u64, Error>;
    method get_str_lenenc (line 15) | fn get_str_lenenc(&mut self) -> Result<String, Error>;
    method get_bytes_lenenc (line 18) | fn get_bytes_lenenc(&mut self) -> Result<Bytes, Error>;
    method get_uint_lenenc (line 22) | fn get_uint_lenenc(&mut self) -> Result<u64, Error> {
    method get_str_lenenc (line 60) | fn get_str_lenenc(&mut self) -> Result<String, Error> {
    method get_bytes_lenenc (line 68) | fn get_bytes_lenenc(&mut self) -> Result<Bytes, Error> {

FILE: sqlx-mysql/src/io/buf_mut.rs
  type MySqlBufMutExt (line 3) | pub trait MySqlBufMutExt: BufMut {
    method put_uint_lenenc (line 4) | fn put_uint_lenenc(&mut self, v: u64);
    method put_str_lenenc (line 6) | fn put_str_lenenc(&mut self, v: &str);
    method put_bytes_lenenc (line 8) | fn put_bytes_lenenc(&mut self, v: &[u8]);
    method put_uint_lenenc (line 12) | fn put_uint_lenenc(&mut self, v: u64) {
    method put_str_lenenc (line 35) | fn put_str_lenenc(&mut self, v: &str) {
    method put_bytes_lenenc (line 39) | fn put_bytes_lenenc(&mut self, v: &[u8]) {
  function test_encodes_int_lenenc_u8 (line 46) | fn test_encodes_int_lenenc_u8() {
  function test_encodes_int_lenenc_u16 (line 54) | fn test_encodes_int_lenenc_u16() {
  function test_encodes_int_lenenc_u24 (line 62) | fn test_encodes_int_lenenc_u24() {
  function test_encodes_int_lenenc_u64 (line 70) | fn test_encodes_int_lenenc_u64() {
  function test_encodes_int_lenenc_fb (line 78) | fn test_encodes_int_lenenc_fb() {
  function test_encodes_int_lenenc_fc (line 86) | fn test_encodes_int_lenenc_fc() {
  function test_encodes_int_lenenc_fd (line 94) | fn test_encodes_int_lenenc_fd() {
  function test_encodes_int_lenenc_fe (line 102) | fn test_encodes_int_lenenc_fe() {
  function test_encodes_int_lenenc_ff (line 110) | fn test_encodes_int_lenenc_ff() {
  function test_encodes_string_lenenc (line 118) | fn test_encodes_string_lenenc() {
  function test_encodes_byte_lenenc (line 126) | fn test_encodes_byte_lenenc() {

FILE: sqlx-mysql/src/lib.rs
  type MySqlPool (line 54) | pub type MySqlPool = crate::pool::Pool<MySql>;
  type MySqlPoolOptions (line 57) | pub type MySqlPoolOptions = crate::pool::PoolOptions<MySql>;
  type MySqlExecutor (line 60) | pub trait MySqlExecutor<'c>: Executor<'c, Database = MySql> {}
  type MySqlTransaction (line 64) | pub type MySqlTransaction<'c> = crate::transaction::Transaction<'c, MySql>;

FILE: sqlx-mysql/src/migrate.rs
  function parse_for_maintenance (line 17) | fn parse_for_maintenance(url: &str) -> Result<(MySqlConnectOptions, Stri...
  method create_database (line 35) | async fn create_database(url: &str) -> Result<(), Error> {
  method database_exists (line 46) | async fn database_exists(url: &str) -> Result<bool, Error> {
  method drop_database (line 60) | async fn drop_database(url: &str) -> Result<(), Error> {
  method create_schema_if_not_exists (line 75) | fn create_schema_if_not_exists<'e>(
  method ensure_migrations_table (line 90) | fn ensure_migrations_table<'e>(
  method dirty_version (line 114) | fn dirty_version<'e>(
  method list_applied_migrations (line 130) | fn list_applied_migrations<'e>(
  method lock (line 154) | fn lock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method unlock (line 175) | fn unlock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method apply (line 190) | fn apply<'e>(
  method revert (line 265) | fn revert<'e>(
  function current_database (line 313) | async fn current_database(conn: &mut MySqlConnection) -> Result<String, ...
  function generate_lock_id (line 319) | fn generate_lock_id(database_name: &str) -> String {

FILE: sqlx-mysql/src/options/connect.rs
  type Connection (line 11) | type Connection = MySqlConnection;
  method from_url (line 13) | fn from_url(url: &Url) -> Result<Self, Error> {
  method to_url_lossy (line 17) | fn to_url_lossy(&self) -> Url {
  method connect (line 21) | async fn connect(&self) -> Result<Self::Connection, Error>
  method log_statements (line 94) | fn log_statements(mut self, level: LevelFilter) -> Self {
  method log_slow_statements (line 99) | fn log_slow_statements(mut self, level: LevelFilter, duration: Duration)...

FILE: sqlx-mysql/src/options/mod.rs
  type MySqlConnectOptions (line 63) | pub struct MySqlConnectOptions {
    method new (line 93) | pub fn new() -> Self {
    method host (line 121) | pub fn host(mut self, host: &str) -> Self {
    method port (line 129) | pub fn port(mut self, port: u16) -> Self {
    method socket (line 138) | pub fn socket(mut self, path: impl AsRef<Path>) -> Self {
    method username (line 144) | pub fn username(mut self, username: &str) -> Self {
    method password (line 150) | pub fn password(mut self, password: &str) -> Self {
    method database (line 156) | pub fn database(mut self, database: &str) -> Self {
    method ssl_mode (line 174) | pub fn ssl_mode(mut self, mode: MySqlSslMode) -> Self {
    method ssl_ca (line 189) | pub fn ssl_ca(mut self, file_name: impl AsRef<Path>) -> Self {
    method ssl_ca_from_pem (line 204) | pub fn ssl_ca_from_pem(mut self, pem_certificate: Vec<u8>) -> Self {
    method ssl_client_cert (line 219) | pub fn ssl_client_cert(mut self, cert: impl AsRef<Path>) -> Self {
    method ssl_client_cert_from_pem (line 244) | pub fn ssl_client_cert_from_pem(mut self, cert: impl AsRef<[u8]>) -> S...
    method ssl_client_key (line 259) | pub fn ssl_client_key(mut self, key: impl AsRef<Path>) -> Self {
    method ssl_client_key_from_pem (line 284) | pub fn ssl_client_key_from_pem(mut self, key: impl AsRef<[u8]>) -> Self {
    method statement_cache_capacity (line 295) | pub fn statement_cache_capacity(mut self, capacity: usize) -> Self {
    method charset (line 306) | pub fn charset(mut self, charset: &str) -> Self {
    method collation (line 320) | pub fn collation(mut self, collation: &str) -> Self {
    method pipes_as_concat (line 331) | pub fn pipes_as_concat(mut self, flag_val: bool) -> Self {
    method enable_cleartext_plugin (line 346) | pub fn enable_cleartext_plugin(mut self, flag_val: bool) -> Self {
    method no_engine_subsitution (line 352) | pub fn no_engine_subsitution(self, flag_val: bool) -> Self {
    method no_engine_substitution (line 366) | pub fn no_engine_substitution(mut self, flag_val: bool) -> Self {
    method timezone (line 387) | pub fn timezone(mut self, value: impl Into<Option<String>>) -> Self {
    method set_names (line 413) | pub fn set_names(mut self, flag_val: bool) -> Self {
    method get_host (line 430) | pub fn get_host(&self) -> &str {
    method get_port (line 444) | pub fn get_port(&self) -> u16 {
    method get_socket (line 458) | pub fn get_socket(&self) -> Option<&PathBuf> {
    method get_username (line 472) | pub fn get_username(&self) -> &str {
    method get_database (line 486) | pub fn get_database(&self) -> Option<&str> {
    method get_ssl_mode (line 499) | pub fn get_ssl_mode(&self) -> MySqlSslMode {
    method get_charset (line 512) | pub fn get_charset(&self) -> &str {
    method get_collation (line 526) | pub fn get_collation(&self) -> Option<&str> {
  method default (line 86) | fn default() -> Self {

FILE: sqlx-mysql/src/options/parse.rs
  method parse_from_url (line 11) | pub(crate) fn parse_from_url(url: &Url) -> Result<Self, Error> {
  method build_url (line 90) | pub(crate) fn build_url(&self) -> Url {
  type Err (line 151) | type Err = Error;
  method from_str (line 153) | fn from_str(s: &str) -> Result<Self, Error> {
  function it_parses_username_with_at_sign_correctly (line 160) | fn it_parses_username_with_at_sign_correctly() {
  function it_parses_password_with_non_ascii_chars_correctly (line 168) | fn it_parses_password_with_non_ascii_chars_correctly() {
  function it_returns_the_parsed_url (line 176) | fn it_returns_the_parsed_url() {
  function it_parses_timezone (line 189) | fn it_parses_timezone() {

FILE: sqlx-mysql/src/options/ssl_mode.rs
  type MySqlSslMode (line 8) | pub enum MySqlSslMode {
  type Err (line 35) | type Err = Error;
  method from_str (line 37) | fn from_str(s: &str) -> Result<Self, Error> {

FILE: sqlx-mysql/src/protocol/auth.rs
  type AuthPlugin (line 8) | pub enum AuthPlugin {
    method name (line 16) | pub(crate) fn name(self) -> &'static str {
  type Err (line 27) | type Err = Error;
  method from_str (line 29) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: sqlx-mysql/src/protocol/connect/auth_switch.rs
  type AuthSwitchRequest (line 12) | pub struct AuthSwitchRequest {
    method decode_with (line 18) | fn decode_with(mut buf: Bytes, enable_cleartext_plugin: bool) -> Resul...
  type AuthSwitchResponse (line 59) | pub struct AuthSwitchResponse(pub Vec<u8>);
    method encode_with (line 62) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<()...
  function test_decode_auth_switch_packet_data (line 69) | fn test_decode_auth_switch_packet_data() {
  function test_decode_auth_switch_cleartext_disabled (line 79) | fn test_decode_auth_switch_cleartext_disabled() {
  function test_decode_auth_switch_packet_no_data (line 96) | fn test_decode_auth_switch_packet_no_data() {

FILE: sqlx-mysql/src/protocol/connect/handshake.rs
  type Handshake (line 15) | pub(crate) struct Handshake {
    method decode_with (line 31) | fn decode_with(mut buf: Bytes, _: ()) -> Result<Self, Error> {
  function test_decode_handshake_mysql_8_0_18 (line 94) | fn test_decode_handshake_mysql_8_0_18() {
  function test_decode_handshake_mariadb_10_4_7 (line 147) | fn test_decode_handshake_mariadb_10_4_7() {

FILE: sqlx-mysql/src/protocol/connect/handshake_response.rs
  type HandshakeResponse (line 11) | pub struct HandshakeResponse<'a> {
  function encode_with (line 31) | fn encode_with(

FILE: sqlx-mysql/src/protocol/connect/ssl_request.rs
  type SslRequest (line 8) | pub struct SslRequest {
    method encode_with (line 14) | fn encode_with(&self, buf: &mut Vec<u8>, context: Capabilities) -> Res...

FILE: sqlx-mysql/src/protocol/packet.rs
  type Packet (line 12) | pub struct Packet<T>(pub(crate) T);
  function encode_with (line 18) | fn encode_with(
  function decode (line 76) | pub(crate) fn decode<'de, T>(self) -> Result<T, Error>
  function decode_with (line 83) | pub(crate) fn decode_with<'de, T, C>(self, context: C) -> Result<T, Error>
  function ok (line 90) | pub(crate) fn ok(self) -> Result<OkPacket, Error> {
  function eof (line 94) | pub(crate) fn eof(self, capabilities: Capabilities) -> Result<EofPacket,...
  type Target (line 109) | type Target = Bytes;
  method deref (line 111) | fn deref(&self) -> &Bytes {
  method deref_mut (line 117) | fn deref_mut(&mut self) -> &mut Bytes {

FILE: sqlx-mysql/src/protocol/response/eof.rs
  type EofPacket (line 15) | pub struct EofPacket {
    method decode_with (line 22) | fn decode_with(mut buf: Bytes, _: Capabilities) -> Result<Self, Error> {

FILE: sqlx-mysql/src/protocol/response/err.rs
  type ErrPacket (line 12) | pub struct ErrPacket {
    method decode_with (line 19) | fn decode_with(mut buf: Bytes, capabilities: Capabilities) -> Result<S...
  function test_decode_err_packet_out_of_order (line 50) | fn test_decode_err_packet_out_of_order() {
  function test_decode_err_packet_unknown_database (line 62) | fn test_decode_err_packet_unknown_database() {

FILE: sqlx-mysql/src/protocol/response/ok.rs
  type OkPacket (line 10) | pub struct OkPacket {
    method decode_with (line 18) | fn decode_with(mut buf: Bytes, _: ()) -> Result<Self, Error> {
  function test_decode_ok_packet (line 50) | fn test_decode_ok_packet() {
  function test_decode_ok_packet_with_info (line 63) | fn test_decode_ok_packet_with_info() {
  function test_decode_ok_packet_with_extended_info (line 76) | fn test_decode_ok_packet_with_extended_info() {
  function test_decode_ok_packet_truncated (line 89) | fn test_decode_ok_packet_truncated() {

FILE: sqlx-mysql/src/protocol/row.rs
  type Row (line 6) | pub(crate) struct Row {
    method get (line 12) | pub(crate) fn get(&self, index: usize) -> Option<&[u8]> {

FILE: sqlx-mysql/src/protocol/statement/execute.rs
  type Execute (line 9) | pub struct Execute<'q> {
  function encode_with (line 15) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<(), ...

FILE: sqlx-mysql/src/protocol/statement/prepare.rs
  type Prepare (line 6) | pub struct Prepare<'a> {
  function encode_with (line 11) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<(), ...

FILE: sqlx-mysql/src/protocol/statement/prepare_ok.rs
  type PrepareOk (line 10) | pub(crate) struct PrepareOk {
    method decode_with (line 19) | fn decode_with(buf: Bytes, _: Capabilities) -> Result<Self, Error> {

FILE: sqlx-mysql/src/protocol/statement/row.rs
  type BinaryRow (line 14) | pub(crate) struct BinaryRow(pub(crate) Row);
    method decode_with (line 17) | fn decode_with(mut buf: Bytes, columns: &'de [MySqlColumn]) -> Result<...

FILE: sqlx-mysql/src/protocol/statement/stmt_close.rs
  type StmtClose (line 7) | pub struct StmtClose {
    method encode_with (line 12) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<()...

FILE: sqlx-mysql/src/protocol/text/column.rs
  type ColumnType (line 69) | pub enum ColumnType {
    method name (line 174) | pub(crate) fn name(self, flags: ColumnFlags, max_size: Option<u32>) ->...
    method try_from_u16 (line 227) | pub(crate) fn try_from_u16(id: u8) -> Result<Self, Error> {
  type ColumnDefinition (line 104) | pub(crate) struct ColumnDefinition {
    method schema (line 125) | pub(crate) fn schema(&self) -> Result<&str, Error> {
    method table (line 129) | pub(crate) fn table(&self) -> Result<&str, Error> {
    method name (line 133) | pub(crate) fn name(&self) -> Result<&str, Error> {
    method alias (line 137) | pub(crate) fn alias(&self) -> Result<&str, Error> {
    method decode_with (line 143) | fn decode_with(mut buf: Bytes, _: Capabilities) -> Result<Self, Error> {

FILE: sqlx-mysql/src/protocol/text/ping.rs
  type Ping (line 7) | pub(crate) struct Ping;
    method encode_with (line 10) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<()...

FILE: sqlx-mysql/src/protocol/text/query.rs
  type Query (line 7) | pub(crate) struct Query<'q>(pub(crate) &'q str);
  function encode_with (line 10) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<(), ...

FILE: sqlx-mysql/src/protocol/text/quit.rs
  type Quit (line 7) | pub(crate) struct Quit;
    method encode_with (line 10) | fn encode_with(&self, buf: &mut Vec<u8>, _: Capabilities) -> Result<()...

FILE: sqlx-mysql/src/protocol/text/row.rs
  type TextRow (line 10) | pub(crate) struct TextRow(pub(crate) Row);
    method decode_with (line 13) | fn decode_with(mut buf: Bytes, columns: &'de [MySqlColumn]) -> Result<...

FILE: sqlx-mysql/src/query_result.rs
  type MySqlQueryResult (line 4) | pub struct MySqlQueryResult {
    method last_insert_id (line 10) | pub fn last_insert_id(&self) -> u64 {
    method rows_affected (line 14) | pub fn rows_affected(&self) -> u64 {
    method extend (line 20) | fn extend<T: IntoIterator<Item = MySqlQueryResult>>(&mut self, iter: T) {
  function from (line 30) | fn from(done: MySqlQueryResult) -> Self {

FILE: sqlx-mysql/src/row.rs
  type MySqlRow (line 12) | pub struct MySqlRow {
    method fmt (line 53) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Database (line 20) | type Database = MySql;
  method columns (line 22) | fn columns(&self) -> &[MySqlColumn] {
  method try_get_raw (line 26) | fn try_get_raw<I>(&self, index: I) -> Result<MySqlValueRef<'_>, Error>
  function index (line 44) | fn index(&self, row: &MySqlRow) -> Result<usize, Error> {

FILE: sqlx-mysql/src/statement.rs
  type MySqlStatement (line 14) | pub struct MySqlStatement {
  type MySqlStatementMetadata (line 20) | pub(crate) struct MySqlStatementMetadata {
  type Database (line 27) | type Database = MySql;
  method into_sql (line 29) | fn into_sql(self) -> SqlStr {
  method sql (line 33) | fn sql(&self) -> &SqlStr {
  method parameters (line 37) | fn parameters(&self) -> Option<Either<&[MySqlTypeInfo], usize>> {
  method columns (line 41) | fn columns(&self) -> &[MySqlColumn] {
  function index (line 49) | fn index(&self, statement: &MySqlStatement) -> Result<usize, Error> {

FILE: sqlx-mysql/src/testing/mod.rs
  method test_context (line 23) | fn test_context(
  method cleanup_test (line 29) | async fn cleanup_test(db_name: &str) -> Result<(), Error> {
  method cleanup_test_dbs (line 39) | async fn cleanup_test_dbs() -> Result<Option<usize>, Error> {
  method snapshot (line 92) | async fn snapshot(_conn: &mut Self::Connection) -> Result<FixtureSnapsho...
  function test_context (line 99) | async fn test_context(args: &TestArgs) -> Result<TestContext<MySql>, Err...
  function do_cleanup (line 184) | async fn do_cleanup(conn: &mut MySqlConnection, db_name: &str) -> Result...
  function cleanup_old_dbs (line 195) | async fn cleanup_old_dbs(conn: &mut MySqlConnection) -> Result<(), Error> {
  function once_lock_try_insert_polyfill (line 246) | fn once_lock_try_insert_polyfill<T>(this: &OnceLock<T>, value: T) -> Res...

FILE: sqlx-mysql/src/transaction.rs
  type MySqlTransactionManager (line 12) | pub struct MySqlTransactionManager;
  type Database (line 15) | type Database = MySql;
  method begin (line 17) | async fn begin(conn: &mut MySqlConnection, statement: Option<SqlStr>) ->...
  method commit (line 36) | async fn commit(conn: &mut MySqlConnection) -> Result<(), Error> {
  method rollback (line 47) | async fn rollback(conn: &mut MySqlConnection) -> Result<(), Error> {
  method start_rollback (line 58) | fn start_rollback(conn: &mut MySqlConnection) {
  method get_transaction_depth (line 73) | fn get_transaction_depth(conn: &MySqlConnection) -> usize {

FILE: sqlx-mysql/src/type_info.rs
  type MySqlTypeInfo (line 10) | pub struct MySqlTypeInfo {
    method binary (line 21) | pub(crate) const fn binary(ty: ColumnType) -> Self {
    method __enum (line 31) | pub const fn __enum() -> Self {
    method __type_feature_gate (line 49) | pub fn __type_feature_gate(&self) -> Option<&'static str> {
    method from_column (line 62) | pub(crate) fn from_column(column: &ColumnDefinition) -> Self {
    method eq (line 89) | fn eq(&self, other: &MySqlTypeInfo) -> bool {
  method fmt (line 73) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method is_null (line 79) | fn is_null(&self) -> bool {
  method name (line 83) | fn name(&self) -> &str {

FILE: sqlx-mysql/src/types/bigdecimal.rs
  method type_info (line 12) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 16) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 22) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 30) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/bool.rs
  function type_info (line 12) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 22) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 36) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 42) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/bytes.rs
  function type_info (line 14) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 18) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 34) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 42) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 48) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 52) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 58) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 64) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/chrono.rs
  function type_info (line 16) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 20) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 27) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 34) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 42) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 46) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 53) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 60) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  method type_info (line 66) | fn type_info() -> MySqlTypeInfo {
  method encode_by_ref (line 72) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method size_hint (line 88) | fn size_hint(&self) -> usize {
  method decode (line 98) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  type Error (line 114) | type Error = BoxDynError;
  method try_from (line 116) | fn try_from(time: MySqlTime) -> Result<Self, Self::Error> {
  function from (line 128) | fn from(time: MySqlTime) -> Self {
  type Error (line 135) | type Error = BoxDynError;
  method try_from (line 137) | fn try_from(value: chrono::TimeDelta) -> Result<Self, Self::Error> {
  function type_info (line 153) | fn type_info() -> MySqlTypeInfo {
  function decode (line 159) | fn decode(value: <MySql as Database>::ValueRef<'r>) -> Result<Self, BoxD...
  method type_info (line 165) | fn type_info() -> MySqlTypeInfo {
  method encode_by_ref (line 171) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method size_hint (line 179) | fn size_hint(&self) -> usize {
  method decode (line 185) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  method type_info (line 207) | fn type_info() -> MySqlTypeInfo {
  method encode_by_ref (line 213) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method size_hint (line 226) | fn size_hint(&self) -> usize {
  method decode (line 232) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode_date (line 262) | fn encode_date(date: &NaiveDate, buf: &mut Vec<u8>) -> Result<(), BoxDyn...
  function decode_date (line 279) | fn decode_date(mut buf: &[u8]) -> Result<Option<NaiveDate>, BoxDynError> {
  function encode_time (line 297) | fn encode_time(time: &NaiveTime, include_micros: bool, buf: &mut Vec<u8>) {
  function decode_time (line 311) | fn decode_time(len: u8, mut buf: &[u8]) -> Result<NaiveTime, BoxDynError> {
  function naive_dt_encoded_len (line 331) | fn naive_dt_encoded_len(time: &NaiveDateTime) -> u8 {
  function naive_time_encoded_len (line 354) | fn naive_time_encoded_len(time: &NaiveTime) -> u8 {

FILE: sqlx-mysql/src/types/float.rs
  function real_compatible (line 10) | fn real_compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 16) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 20) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 26) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 30) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 36) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 44) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 52) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 83) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/inet.rs
  method type_info (line 11) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 15) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 21) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 29) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  method type_info (line 39) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 43) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 49) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 57) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  method type_info (line 67) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 71) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 77) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 85) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/int.rs
  function int_compatible (line 10) | fn int_compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 22) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 26) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 32) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 36) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 42) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 46) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 52) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 56) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 62) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 70) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 78) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 86) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function int_decode (line 93) | fn int_decode(value: MySqlValueRef<'_>) -> Result<i64, BoxDynError> {
  function decode (line 118) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 124) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 130) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 136) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/json.rs
  function type_info (line 11) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 18) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 29) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 65) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/mysql_time.rs
  type MySqlTime (line 26) | pub struct MySqlTime {
    constant ZERO (line 104) | pub const ZERO: Self = MySqlTime {
    constant MAX (line 110) | pub const MAX: Self = MySqlTime {
    constant MIN (line 116) | pub const MIN: Self = MySqlTime {
    constant HOURS_MAX (line 123) | pub(crate) const HOURS_MAX: u32 = 838;
    method new (line 136) | pub fn new(
    method with_sign (line 195) | pub fn with_sign(self, sign: MySqlTimeSign) -> Self {
    method sign (line 200) | pub fn sign(&self) -> MySqlTimeSign {
    method is_zero (line 205) | pub fn is_zero(&self) -> bool {
    method is_positive (line 210) | pub fn is_positive(&self) -> bool {
    method is_negative (line 215) | pub fn is_negative(&self) -> bool {
    method is_valid_time_of_day (line 222) | pub fn is_valid_time_of_day(&self) -> bool {
    method hours (line 229) | pub fn hours(&self) -> u32 {
    method minutes (line 234) | pub fn minutes(&self) -> u8 {
    method seconds (line 239) | pub fn seconds(&self) -> u8 {
    method microseconds (line 244) | pub fn microseconds(&self) -> u32 {
    method to_duration (line 251) | pub fn to_duration(&self) -> Option<Duration> {
    method whole_seconds (line 259) | pub(crate) fn whole_seconds(&self) -> u32 {
    method whole_seconds_signed (line 265) | pub(crate) fn whole_seconds_signed(&self) -> i64 {
    method subsec_nanos (line 269) | pub(crate) fn subsec_nanos(&self) -> u32 {
    method encoded_len (line 273) | fn encoded_len(&self) -> u8 {
    method partial_cmp (line 285) | fn partial_cmp(&self, other: &MySqlTime) -> Option<Ordering> {
    method type_info (line 353) | fn type_info() -> MySqlTypeInfo {
    method decode (line 359) | fn decode(value: <MySql as Database>::ValueRef<'r>) -> Result<Self, Bo...
    method encode_by_ref (line 413) | fn encode_by_ref(
    method size_hint (line 447) | fn size_hint(&self) -> usize {
    type Error (line 467) | type Error = MySqlTimeError;
    method try_from (line 469) | fn try_from(value: Duration) -> Result<Self, Self::Error> {
  type TimeMagnitude (line 34) | pub(crate) struct TimeMagnitude {
  constant MAGNITUDE_ZERO (line 41) | const MAGNITUDE_ZERO: TimeMagnitude = TimeMagnitude {
  constant MAGNITUDE_MAX (line 49) | const MAGNITUDE_MAX: TimeMagnitude = TimeMagnitude {
  type MySqlTimeSign (line 59) | pub enum MySqlTimeSign {
    method from_byte (line 493) | fn from_byte(b: u8) -> Result<Self, BoxDynError> {
    method to_byte (line 501) | fn to_byte(self) -> u8 {
    method signum (line 509) | fn signum(&self) -> i32 {
    method is_positive (line 517) | pub fn is_positive(&self) -> bool {
    method is_negative (line 522) | pub fn is_negative(&self) -> bool {
  type MySqlTimeError (line 70) | pub enum MySqlTimeError {
  method cmp (line 291) | fn cmp(&self, other: &Self) -> Ordering {
  method fmt (line 307) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method fmt (line 528) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method type_info (line 538) | fn type_info() -> MySqlTypeInfo {
  method decode (line 544) | fn decode(value: <MySql as Database>::ValueRef<'r>) -> Result<Self, BoxD...
  function parse (line 555) | fn parse(text: &str) -> Result<MySqlTime, BoxDynError> {
  function parse_microseconds (line 612) | fn parse_microseconds(micros: &str) -> Result<u32, BoxDynError> {
  function test_display (line 637) | fn test_display() {
  function test_parse_microseconds (line 695) | fn test_parse_microseconds() {

FILE: sqlx-mysql/src/types/rust_decimal.rs
  method type_info (line 12) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 16) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 22) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 30) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/str.rs
  function type_info (line 15) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 25) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 48) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 56) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  method type_info (line 62) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 66) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method decode (line 72) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/text.rs
  function type_info (line 10) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 14) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 23) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function decode (line 45) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/time.rs
  method type_info (line 16) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 20) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 26) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 35) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  method type_info (line 43) | fn type_info() -> MySqlTypeInfo {
  method encode_by_ref (line 49) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method size_hint (line 65) | fn size_hint(&self) -> usize {
  method decode (line 71) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  type Error (line 89) | type Error = BoxDynError;
  method try_from (line 91) | fn try_from(time: MySqlTime) -> Result<Self, Self::Error> {
  function from (line 108) | fn from(time: MySqlTime) -> Self {
  type Error (line 116) | type Error = BoxDynError;
  method try_from (line 118) | fn try_from(value: time::Duration) -> Result<Self, Self::Error> {
  function type_info (line 131) | fn type_info() -> MySqlTypeInfo {
  function decode (line 137) | fn decode(value: <MySql as Database>::ValueRef<'r>) -> Result<Self, BoxD...
  method type_info (line 143) | fn type_info() -> MySqlTypeInfo {
  method encode_by_ref (line 149) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method size_hint (line 157) | fn size_hint(&self) -> usize {
  method decode (line 163) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  method type_info (line 184) | fn type_info() -> MySqlTypeInfo {
  method encode_by_ref (line 190) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method size_hint (line 203) | fn size_hint(&self) -> usize {
  method decode (line 209) | fn decode(value: MySqlValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode_date (line 255) | fn encode_date(date: &Date, buf: &mut Vec<u8>) -> Result<(), BoxDynError> {
  function decode_date (line 267) | fn decode_date(buf: &[u8]) -> Result<Option<Date>, BoxDynError> {
  function encode_time (line 282) | fn encode_time(time: &Time, include_micros: bool, buf: &mut Vec<u8>) {
  function decode_time (line 292) | fn decode_time(mut buf: &[u8]) -> Result<Time, BoxDynError> {
  function primitive_dt_encoded_len (line 312) | fn primitive_dt_encoded_len(time: &PrimitiveDateTime) -> u8 {
  function time_encoded_len (line 329) | fn time_encoded_len(time: &Time) -> u8 {

FILE: sqlx-mysql/src/types/uint.rs
  function uint_type_info (line 10) | fn uint_type_info(ty: ColumnType) -> MySqlTypeInfo {
  function uint_compatible (line 19) | fn uint_compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 33) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 37) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 43) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 47) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 53) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 57) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function type_info (line 63) | fn type_info() -> MySqlTypeInfo {
  function compatible (line 67) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  function encode_by_ref (line 73) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 81) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 89) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function encode_by_ref (line 97) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  function uint_decode (line 104) | fn uint_decode(value: MySqlValueRef<'_>) -> Result<u64, BoxDynError> {
  function decode (line 143) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 149) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 155) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 161) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/types/uuid.rs
  method type_info (line 14) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 18) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 24) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 32) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  method type_info (line 51) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 55) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 61) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 69) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {
  method type_info (line 81) | fn type_info() -> MySqlTypeInfo {
  method compatible (line 85) | fn compatible(ty: &MySqlTypeInfo) -> bool {
  method encode_by_ref (line 91) | fn encode_by_ref(&self, buf: &mut Vec<u8>) -> Result<IsNull, BoxDynError> {
  method decode (line 99) | fn decode(value: MySqlValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-mysql/src/value.rs
  type MySqlValueFormat (line 13) | pub enum MySqlValueFormat {
  type MySqlValue (line 20) | pub struct MySqlValue {
  type MySqlValueRef (line 28) | pub struct MySqlValueRef<'r> {
  function format (line 36) | pub(crate) fn format(&self) -> MySqlValueFormat {
  function as_bytes (line 40) | pub(crate) fn as_bytes(&self) -> Result<&'r [u8], BoxDynError> {
  function as_str (line 47) | pub(crate) fn as_str(&self) -> Result<&'r str, BoxDynError> {
  type Database (line 53) | type Database = MySql;
  method as_ref (line 55) | fn as_ref(&self) -> MySqlValueRef<'_> {
  method type_info (line 64) | fn type_info(&self) -> Cow<'_, MySqlTypeInfo> {
  method is_null (line 68) | fn is_null(&self) -> bool {
  type Database (line 74) | type Database = MySql;
  function to_owned (line 76) | fn to_owned(&self) -> MySqlValue {
  function type_info (line 92) | fn type_info(&self) -> Cow<'_, MySqlTypeInfo> {
  function is_null (line 97) | fn is_null(&self) -> bool {
  function is_null (line 102) | fn is_null(value: Option<&[u8]>, ty: &MySqlTypeInfo) -> bool {

FILE: sqlx-postgres/src/advisory_lock.rs
  type PgAdvisoryLock (line 38) | pub struct PgAdvisoryLock {
    method new (line 109) | pub fn new(key_string: impl AsRef<str>) -> Self {
    method with_key (line 164) | pub fn with_key(key: PgAdvisoryLockKey) -> Self {
    method key (line 172) | pub fn key(&self) -> &PgAdvisoryLockKey {
    method acquire (line 202) | pub async fn acquire<C: AsMut<PgConnection>>(
    method try_acquire (line 245) | pub async fn try_acquire<C: AsMut<PgConnection>>(
    method force_release (line 283) | pub async fn force_release<C: AsMut<PgConnection>>(&self, mut conn: C)...
    method get_release_query (line 303) | fn get_release_query(&self) -> &str {
  type PgAdvisoryLockKey (line 58) | pub enum PgAdvisoryLockKey {
    method as_bigint (line 315) | pub fn as_bigint(&self) -> Option<i64> {
  type PgAdvisoryLockGuard (line 81) | pub struct PgAdvisoryLockGuard<C: AsMut<PgConnection>> {
  constant NONE_ERR (line 324) | const NONE_ERR: &str = "BUG: PgAdvisoryLockGuard.conn taken";
  function new (line 327) | fn new(lock: PgAdvisoryLock, conn: C) -> Self {
  function release_now (line 342) | pub async fn release_now(mut self) -> Result<C> {
  function leak (line 361) | pub fn leak(mut self) -> C {
  type Target (line 367) | type Target = PgConnection;
  method deref (line 369) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 381) | fn deref_mut(&mut self) -> &mut Self::Target {
  function as_ref (line 387) | fn as_ref(&self) -> &PgConnection {
  function as_mut (line 399) | fn as_mut(&mut self) -> &mut PgConnection {
  method drop (line 408) | fn drop(&mut self) {

FILE: sqlx-postgres/src/any.rs
  method name (line 26) | fn name(&self) -> &str {
  method close (line 30) | fn close(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<()>> {
  method close_hard (line 34) | fn close_hard(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<(...
  method ping (line 38) | fn ping(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method begin (line 42) | fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, sqlx_cor...
  method commit (line 46) | fn commit(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method rollback (line 50) | fn rollback(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method start_rollback (line 54) | fn start_rollback(&mut self) {
  method get_transaction_depth (line 58) | fn get_transaction_depth(&self) -> usize {
  method shrink_buffers (line 62) | fn shrink_buffers(&mut self) {
  method flush (line 66) | fn flush(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method should_flush (line 70) | fn should_flush(&self) -> bool {
  method as_migrate (line 75) | fn as_migrate(
  method fetch_many (line 81) | fn fetch_many(
  method fetch_optional (line 107) | fn fetch_optional(
  method prepare_with (line 131) | fn prepare_with<'c, 'q: 'c>(
  method describe (line 144) | fn describe<'c>(
  type Error (line 188) | type Error = sqlx_core::Error;
  method try_from (line 190) | fn try_from(pg_type: &'a PgTypeInfo) -> Result<Self, Self::Error> {
  type Error (line 214) | type Error = sqlx_core::Error;
  method try_from (line 216) | fn try_from(col: &'a PgColumn) -> Result<Self, Self::Error> {
  type Error (line 232) | type Error = sqlx_core::Error;
  method try_from (line 234) | fn try_from(row: &'a PgRow) -> Result<Self, Self::Error> {
  type Error (line 240) | type Error = sqlx_core::Error;
  method try_from (line 242) | fn try_from(value: &'a AnyConnectOptions) -> Result<Self, Self::Error> {
  function map_result (line 249) | fn map_result(res: PgQueryResult) -> AnyQueryResult {

FILE: sqlx-postgres/src/arguments.rs
  type PgArgumentBuffer (line 26) | pub struct PgArgumentBuffer {
    method encode (line 167) | pub(crate) fn encode<'q, T>(&mut self, value: T) -> Result<(), BoxDynE...
    method patch (line 199) | pub(crate) fn patch<F>(&mut self, callback: F)
    method patch_type_by_name (line 215) | pub(crate) fn patch_type_by_name(&mut self, type_name: &UStr) {
    method patch_array_type (line 227) | pub(crate) fn patch_array_type(&mut self, array: Arc<PgArrayOf>) {
    method snapshot (line 234) | fn snapshot(&self) -> PgArgumentBufferSnapshot {
    method reset_to_snapshot (line 250) | fn reset_to_snapshot(
  type HoleKind (line 50) | enum HoleKind {
  type Patch (line 56) | struct Patch {
    method fmt (line 64) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type PgArguments (line 75) | pub struct PgArguments {
    method add (line 84) | pub(crate) fn add<'q, T>(&mut self, value: T) -> Result<(), BoxDynError>
    method apply_patches (line 110) | pub(crate) async fn apply_patches(
  type Database (line 142) | type Database = Postgres;
  method reserve (line 144) | fn reserve(&mut self, additional: usize, size: usize) {
  method add (line 149) | fn add<'t, T>(&mut self, value: T) -> Result<(), BoxDynError>
  method format_placeholder (line 156) | fn format_placeholder<W: Write>(&self, writer: &mut W) -> fmt::Result {
  method len (line 161) | fn len(&self) -> usize {
  type PgArgumentBufferSnapshot (line 266) | struct PgArgumentBufferSnapshot {
  type Target (line 274) | type Target = Vec<u8>;
  method deref (line 277) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 284) | fn deref_mut(&mut self) -> &mut Self::Target {
  function value_size_int4_checked (line 289) | pub(crate) fn value_size_int4_checked(size: usize) -> Result<i32, String> {

FILE: sqlx-postgres/src/bind_iter.rs
  type PgBindIter (line 11) | pub struct PgBindIter<I>(Cell<Option<I>>);
  type PgBindIterExt (line 55) | pub trait PgBindIterExt: Iterator + Sized {
    method bind_iter (line 56) | fn bind_iter(self) -> PgBindIter<Self>;
    method bind_iter (line 60) | fn bind_iter(self) -> PgBindIter<I> {
  function type_info (line 70) | fn type_info() -> <Postgres as Database>::TypeInfo {
  function compatible (line 73) | fn compatible(ty: &PgTypeInfo) -> bool {
  function encode_inner (line 83) | fn encode_inner(
  function encode_by_ref (line 142) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function encode (line 145) | fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError>

FILE: sqlx-postgres/src/column.rs
  type PgColumn (line 9) | pub struct PgColumn {
    method relation_id (line 30) | pub fn relation_id(&self) -> Option<crate::types::Oid> {
    method relation_attribute_no (line 40) | pub fn relation_attribute_no(&self) -> Option<i16> {
  type Database (line 46) | type Database = Postgres;
  method ordinal (line 48) | fn ordinal(&self) -> usize {
  method name (line 52) | fn name(&self) -> &str {
  method type_info (line 56) | fn type_info(&self) -> &PgTypeInfo {
  method origin (line 60) | fn origin(&self) -> ColumnOrigin {

FILE: sqlx-postgres/src/connection/describe.rs
  method is_explain_available (line 13) | fn is_explain_available(&self) -> bool {
  method get_nullable_for_columns (line 21) | pub(crate) async fn get_nullable_for_columns(
  method nullables_from_explain (line 114) | async fn nullables_from_explain(
  function visit_plan (line 163) | fn visit_plan(plan: &Plan, outputs: &[String], nullables: &mut Vec<Optio...
  type Explain (line 190) | enum Explain {
  type Plan (line 212) | struct Plan {
  function explain_parsing (line 224) | fn explain_parsing() {

FILE: sqlx-postgres/src/connection/establish.rs
  method establish (line 18) | pub(crate) async fn establish(options: &PgConnectOptions) -> Result<Self...

FILE: sqlx-postgres/src/connection/executor.rs
  function prepare (line 23) | async fn prepare(
  function recv_desc_params (line 107) | async fn recv_desc_params(conn: &mut PgConnection) -> Result<ParameterDe...
  function recv_desc_rows (line 111) | async fn recv_desc_rows(conn: &mut PgConnection) -> Result<Option<RowDes...
  method wait_for_close_complete (line 134) | pub(super) async fn wait_for_close_complete(&mut self, mut count: usize)...
  method write_sync (line 161) | pub(crate) fn write_sync(&mut self) {
  method get_or_prepare (line 171) | async fn get_or_prepare(
  method run (line 210) | pub(crate) async fn run<'e, 'c: 'e, 'q: 'e>(
  type Database (line 394) | type Database = Postgres;
  function fetch_many (line 396) | fn fetch_many<'e, 'q, E>(
  function fetch_optional (line 425) | fn fetch_optional<'e, 'q, E>(self, mut query: E) -> BoxFuture<'e, Result...
  function prepare_with (line 458) | fn prepare_with<'e>(
  function describe (line 478) | fn describe<'e>(

FILE: sqlx-postgres/src/connection/mod.rs
  type PgConnection (line 38) | pub struct PgConnection {
    method server_version_num (line 89) | pub fn server_version_num(&self) -> Option<u32> {
    method wait_until_ready (line 94) | pub(crate) async fn wait_until_ready(&mut self) -> Result<(), Error> {
    method recv_ready_for_query (line 110) | async fn recv_ready_for_query(&mut self) -> Result<(), Error> {
    method handle_ready_for_query (line 120) | fn handle_ready_for_query(&mut self, message: ReceivedMessage) -> Resu...
    method queue_simple_query (line 136) | pub(crate) fn queue_simple_query(&mut self, query: &str) -> Result<(),...
    method in_transaction (line 143) | pub(crate) fn in_transaction(&self) -> bool {
    method as_mut (line 253) | fn as_mut(&mut self) -> &mut PgConnection {
  type PgConnectionInner (line 42) | pub struct PgConnectionInner {
  type TableColumns (line 81) | pub(crate) struct TableColumns {
  method fmt (line 152) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Database (line 158) | type Database = Postgres;
  type Options (line 160) | type Options = PgConnectOptions;
  method close (line 162) | async fn close(mut self) -> Result<(), Error> {
  method close_hard (line 174) | async fn close_hard(mut self) -> Result<(), Error> {
  method ping (line 180) | async fn ping(&mut self) -> Result<(), Error> {
  method begin (line 190) | fn begin(
  method begin_with (line 196) | fn begin_with(
  method cached_statements_size (line 206) | fn cached_statements_size(&self) -> usize {
  method clear_cached_statements (line 210) | async fn clear_cached_statements(&mut self) -> Result<(), Error> {
  method shrink_buffers (line 233) | fn shrink_buffers(&mut self) {
  method flush (line 238) | fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + ...
  method should_flush (line 243) | fn should_flush(&self) -> bool {

FILE: sqlx-postgres/src/connection/resolve.rs
  type TypType (line 18) | enum TypType {
    type Error (line 28) | type Error = ();
    method try_from (line 30) | fn try_from(t: i8) -> Result<Self, Self::Error> {
  type TypCategory (line 50) | enum TypCategory {
    type Error (line 69) | type Error = ();
    method try_from (line 71) | fn try_from(c: i8) -> Result<Self, Self::Error> {
  method handle_row_description (line 97) | pub(super) async fn handle_row_description(
  method handle_parameter_description (line 148) | pub(super) async fn handle_parameter_description(
  method maybe_fetch_type_info_by_oid (line 161) | async fn maybe_fetch_type_info_by_oid(
  method maybe_fetch_column_origin (line 201) | async fn maybe_fetch_column_origin(
  method fetch_type_by_oid (line 264) | async fn fetch_type_by_oid(&mut self, oid: Oid) -> Result<PgTypeInfo, Er...
  method fetch_enum_by_oid 

[
  {
    "path": ".editorconfig",
    "chars": 140,
    "preview": "root = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ninsert_final_newline = true\nindent_style = space\nindent_size = 4\n\n[*.y"
  },
  {
    "path": ".gitattributes",
    "chars": 19,
    "preview": "* text=auto eol=lf\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.yml",
    "chars": 1693,
    "preview": "name: I think I found a bug in SQLx\ndescription: Create a bug-report issue\nlabels: [bug]\nbody:\n  - type: textarea\n    id"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 651,
    "preview": "blank_issues_enabled: false\ncontact_links:\n  - name: Enabling some optional features adds unexpected crates to Cargo.loc"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.yml",
    "chars": 1031,
    "preview": "name: I have a feature request for SQLx\ndescription: Create a feature-request issue\nlabels: [enhancement]\nbody:\n  - type"
  },
  {
    "path": ".github/pull_request_template.md",
    "chars": 2789,
    "preview": "<!-- \nPR AUTHOR INSTRUCTIONS; PLEASE READ.\n\nGive your pull request an accurate and descriptive title. It should mention "
  },
  {
    "path": ".github/workflows/examples.yml",
    "chars": 14272,
    "preview": "name: Examples\n\non:\n  pull_request:\n  push:\n    branches:\n      - main\n      - '*-dev'\n\njobs:\n  sqlx-cli:\n    name: Buil"
  },
  {
    "path": ".github/workflows/sqlx-cli.yml",
    "chars": 9533,
    "preview": "name: SQLx CLI\n\non:\n  pull_request:\n  push:\n    branches:\n      - main\n      - \"*-dev\"\n\njobs:\n  check:\n    name: Check\n "
  },
  {
    "path": ".github/workflows/sqlx.yml",
    "chars": 18385,
    "preview": "name: SQLx\n\non:\n  pull_request:\n  push:\n    branches:\n      - main\n      - \"*-dev\"\n\njobs:\n  format:\n    name: Format\n   "
  },
  {
    "path": ".gitignore",
    "chars": 326,
    "preview": "# Built artifacts\ntarget/\n\n# Project and editor files\n.vscode/\n.idea/\n*.vim\n*.vi\n\n# Environment\n.env\n\n# Shared-memory an"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 163894,
    "preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 1775,
    "preview": "# How to contribute\n\nSo, you've decided to contribute, that's great!\n\nYou can use this document to figure out how and wh"
  },
  {
    "path": "Cargo.toml",
    "chars": 13674,
    "preview": "[workspace]\nmembers = [\n    \".\",\n    \"sqlx-core\",\n    \"sqlx-macros\",\n    \"sqlx-macros-core\",\n    \"sqlx-test\",\n    \"sqlx-"
  },
  {
    "path": "FAQ.md",
    "chars": 29644,
    "preview": "SQLx Frequently Asked Questions\n===============================\n\n### What database versions does SQLx support?\n\nThis is "
  },
  {
    "path": "LICENSE-APACHE",
    "chars": 10243,
    "preview": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AN"
  },
  {
    "path": "LICENSE-MIT",
    "chars": 1060,
    "preview": "Copyright (c) 2020 LaunchBadge, LLC\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy of thi"
  },
  {
    "path": "README.md",
    "chars": 18374,
    "preview": "<h1 align=\"center\">SQLx</h1>\n<div align=\"center\">\n <strong>\n   🧰 The Rust SQL Toolkit\n </strong>\n</div>\n\n<br />\n\n<div al"
  },
  {
    "path": "benches/sqlite/describe.rs",
    "chars": 5087,
    "preview": "use criterion::BenchmarkId;\nuse criterion::Criterion;\nuse criterion::{criterion_group, criterion_main};\n\nuse sqlx::sqlit"
  },
  {
    "path": "clippy.toml",
    "chars": 427,
    "preview": "[[disallowed-methods]]\npath = \"core::cmp::Ord::min\"\nreason = '''\ntoo easy to misread `x.min(y)` as \"let the minimum valu"
  },
  {
    "path": "contrib/ide/vscode/settings.json",
    "chars": 60,
    "preview": "{\n    \"rust-analyzer.assist.importMergeBehaviour\": \"last\"\n}\n"
  },
  {
    "path": "examples/.gitignore",
    "chars": 22,
    "preview": "sqlite/todos/todos.db\n"
  },
  {
    "path": "examples/mysql/todos/Cargo.toml",
    "chars": 330,
    "preview": "[package]\nname = \"sqlx-example-mysql-todos\"\nversion = \"0.1.0\"\nedition = \"2021\"\nworkspace = \"../../../\"\n\n[dependencies]\na"
  },
  {
    "path": "examples/mysql/todos/README.md",
    "chars": 420,
    "preview": "# TODOs Example\n\n## Setup\n\n1. Declare the database URL\n\n    ```\n    export DATABASE_URL=\"mysql://root:password@localhost"
  },
  {
    "path": "examples/mysql/todos/migrations/20200718111257_todos.sql",
    "chars": 188,
    "preview": "CREATE TABLE IF NOT EXISTS todos\n(\n    id          BIGINT UNSIGNED PRIMARY KEY NOT NULL AUTO_INCREMENT,\n    description "
  },
  {
    "path": "examples/mysql/todos/src/main.rs",
    "chars": 2271,
    "preview": "use clap::{Parser, Subcommand};\nuse sqlx::mysql::MySqlPool;\nuse std::env;\n\n#[derive(Parser)]\nstruct Args {\n    #[command"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/Cargo.toml",
    "chars": 891,
    "preview": "[package]\nname = \"sqlx-example-postgres-axum-social\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their defin"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/README.md",
    "chars": 406,
    "preview": "This example demonstrates how to write integration tests for an API build with [Axum] and SQLx using `#[sqlx::test]`.\n\nS"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/migrations/1_user.sql",
    "chars": 166,
    "preview": "create table \"user\"\n(\n    user_id       uuid primary key default gen_random_uuid(),\n    username      text unique not nu"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/migrations/2_post.sql",
    "chars": 250,
    "preview": "create table post (\n    post_id uuid primary key default gen_random_uuid(),\n    user_id uuid not null references \"user\"("
  },
  {
    "path": "examples/postgres/axum-social-with-tests/migrations/3_comment.sql",
    "chars": 315,
    "preview": "create table comment (\n    comment_id uuid primary key default gen_random_uuid(),\n    post_id uuid not null references p"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/http/error.rs",
    "chars": 2110,
    "preview": "use axum::http::StatusCode;\nuse axum::response::{IntoResponse, Response};\nuse axum::Json;\n\nuse serde_with::DisplayFromSt"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/http/mod.rs",
    "chars": 556,
    "preview": "use anyhow::Context;\nuse axum::{Extension, Router};\nuse sqlx::PgPool;\n\nmod error;\n\nmod post;\nmod user;\n\npub use self::er"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/http/post/comment.rs",
    "chars": 2520,
    "preview": "use axum::extract::Path;\nuse axum::{Extension, Json, Router};\n\nuse axum::routing::get;\n\nuse serde::{Deserialize, Seriali"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/http/post/mod.rs",
    "chars": 2280,
    "preview": "use axum::{Extension, Json, Router};\n\nuse axum::routing::get;\n\nuse serde::{Deserialize, Serialize};\nuse time::OffsetDate"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/http/user.rs",
    "chars": 2761,
    "preview": "use axum::http::StatusCode;\nuse axum::{routing::post, Extension, Json, Router};\nuse rand::Rng;\nuse regex::Regex;\nuse std"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/lib.rs",
    "chars": 29,
    "preview": "pub mod http;\n\nmod password;\n"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/main.rs",
    "chars": 557,
    "preview": "use anyhow::Context;\nuse sqlx::postgres::PgPoolOptions;\n\n#[tokio::main]\nasync fn main() -> anyhow::Result<()> {\n    let "
  },
  {
    "path": "examples/postgres/axum-social-with-tests/src/password.rs",
    "chars": 1143,
    "preview": "use anyhow::{anyhow, Context};\nuse tokio::task;\n\nuse argon2::password_hash::SaltString;\nuse argon2::{password_hash, Argo"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/comment.rs",
    "chars": 4526,
    "preview": "use sqlx::PgPool;\n\nuse sqlx_example_postgres_axum_social::http;\n\nuse axum::http::{Request, StatusCode};\nuse tower::Servi"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/common.rs",
    "chars": 2042,
    "preview": "// This is imported by different tests that use different functions.\n#![allow(dead_code)]\n\nuse axum::body::{Body, BoxBod"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/fixtures/comments.sql",
    "chars": 708,
    "preview": "INSERT INTO public.comment (comment_id, post_id, user_id, content, created_at)\nVALUES\n    -- from: bob\n    ('3a86b8f8-82"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/fixtures/posts.sql",
    "chars": 409,
    "preview": "INSERT INTO public.post (post_id, user_id, content, created_at)\nVALUES\n    -- from: alice\n    ('d9ca2672-24c5-4442-b32f-"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/fixtures/users.sql",
    "chars": 498,
    "preview": "INSERT INTO public.\"user\" (user_id, username, password_hash)\nVALUES\n    -- username: \"alice\"; password: \"rustacean since"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/post.rs",
    "chars": 3424,
    "preview": "use sqlx::PgPool;\n\nuse sqlx_example_postgres_axum_social::http;\n\nuse axum::http::{Request, StatusCode};\nuse tower::Servi"
  },
  {
    "path": "examples/postgres/axum-social-with-tests/tests/user.rs",
    "chars": 2328,
    "preview": "use sqlx::PgPool;\n\nuse sqlx_example_postgres_axum_social::http;\n\nuse axum::http::{Request, StatusCode};\nuse tower::Servi"
  },
  {
    "path": "examples/postgres/chat/Cargo.toml",
    "chars": 350,
    "preview": "[package]\nname = \"sqlx-example-postgres-chat\"\nversion = \"0.1.0\"\nedition = \"2021\"\nworkspace = \"../../../\"\n\n[dependencies]"
  },
  {
    "path": "examples/postgres/chat/README.md",
    "chars": 482,
    "preview": "# Chat Example\n\nNote: this example has an interactive TUI which is not trivial to test automatically,\nso our CI currentl"
  },
  {
    "path": "examples/postgres/chat/src/main.rs",
    "chars": 5291,
    "preview": "use crossterm::{\n    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},\n    execute,\n    terminal::"
  },
  {
    "path": "examples/postgres/files/Cargo.toml",
    "chars": 381,
    "preview": "[package]\nname = \"sqlx-example-postgres-files\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions"
  },
  {
    "path": "examples/postgres/files/README.md",
    "chars": 516,
    "preview": "# Query files Example\n\n## Description\n\nThis example demonstrates storing external files to use for querying data.\nEncaps"
  },
  {
    "path": "examples/postgres/files/migrations/20220712221654_files.sql",
    "chars": 305,
    "preview": "CREATE TABLE IF NOT EXISTS users\n(\n    id       BIGSERIAL PRIMARY KEY,\n    username TEXT NOT NULL\n);\n\nCREATE TABLE IF NO"
  },
  {
    "path": "examples/postgres/files/queries/insert_seed_data.sql",
    "chars": 555,
    "preview": "-- seed some data to work with\nWITH inserted_users_cte AS (\n    INSERT INTO users (username)\n        VALUES ('user1'),\n "
  },
  {
    "path": "examples/postgres/files/queries/list_all_posts.sql",
    "chars": 179,
    "preview": "SELECT p.id as \"post_id\",\n       p.title,\n       p.body,\n       u.id as \"author_id\",\n       u.username as \"author_userna"
  },
  {
    "path": "examples/postgres/files/src/main.rs",
    "chars": 1331,
    "preview": "use sqlx::{query_file, query_file_as, FromRow, PgPool};\nuse std::fmt::{Display, Formatter};\n\n#[derive(FromRow)]\nstruct P"
  },
  {
    "path": "examples/postgres/json/Cargo.toml",
    "chars": 410,
    "preview": "[package]\nname = \"sqlx-example-postgres-json\"\nversion = \"0.1.0\"\nedition = \"2021\"\nworkspace = \"../../../\"\n\n[dependencies]"
  },
  {
    "path": "examples/postgres/json/README.md",
    "chars": 515,
    "preview": "# JSON Example\n\n## Setup\n\n1. Declare the database URL\n\n    ```\n    export DATABASE_URL=\"postgres://postgres:password@loc"
  },
  {
    "path": "examples/postgres/json/migrations/20200824190010_json.sql",
    "chars": 99,
    "preview": "CREATE TABLE IF NOT EXISTS people\n(\n    id     BIGSERIAL PRIMARY KEY,\n    person JSONB NOT NULL\n);\n"
  },
  {
    "path": "examples/postgres/json/src/main.rs",
    "chars": 2009,
    "preview": "use clap::{Parser, Subcommand};\nuse serde::{Deserialize, Serialize};\nuse serde_json::{Map, Value};\nuse sqlx::postgres::P"
  },
  {
    "path": "examples/postgres/listen/Cargo.toml",
    "chars": 340,
    "preview": "[package]\nname = \"sqlx-example-postgres-listen\"\nversion = \"0.1.0\"\nedition = \"2021\"\nworkspace = \"../../../\"\n\n[dependencie"
  },
  {
    "path": "examples/postgres/listen/README.md",
    "chars": 473,
    "preview": "Postgres LISTEN/NOTIFY\n======================\n\n## Usage\n\nDeclare the database URL. This example does not include any rea"
  },
  {
    "path": "examples/postgres/listen/src/main.rs",
    "chars": 3303,
    "preview": "use futures_util::TryStreamExt;\nuse sqlx::postgres::PgListener;\nuse sqlx::{Executor, PgPool};\nuse std::pin::pin;\nuse std"
  },
  {
    "path": "examples/postgres/mockable-todos/Cargo.toml",
    "chars": 404,
    "preview": "[package]\nname = \"sqlx-example-postgres-mockable-todos\"\nversion = \"0.1.0\"\nedition = \"2021\"\nworkspace = \"../../../\"\n\n[dep"
  },
  {
    "path": "examples/postgres/mockable-todos/README.md",
    "chars": 1006,
    "preview": "# Mockable TODOs Example\n\n## Description\n\nThis example is based on the ideas in [this blog post](https://medium.com/bett"
  },
  {
    "path": "examples/postgres/mockable-todos/docker-compose.yml",
    "chars": 322,
    "preview": "version: \"3\"\n\nservices:\n  database:\n    image: \"postgres\"\n    ports:\n      - \"5432:5432\"\n    restart: always\n    environ"
  },
  {
    "path": "examples/postgres/mockable-todos/migrations/20200718111257_todos.sql",
    "chars": 158,
    "preview": "CREATE TABLE IF NOT EXISTS todos\n(\n    id          BIGSERIAL PRIMARY KEY,\n    description TEXT    NOT NULL,\n    done    "
  },
  {
    "path": "examples/postgres/mockable-todos/src/main.rs",
    "chars": 4014,
    "preview": "use async_trait::async_trait;\nuse clap::{Parser, Subcommand};\nuse sqlx::postgres::PgPool;\nuse std::{env, io::Write, sync"
  },
  {
    "path": "examples/postgres/multi-database/Cargo.toml",
    "chars": 785,
    "preview": "[package]\nname = \"sqlx-example-postgres-multi-database\"\nversion.workspace = true\nlicense.workspace = true\nedition.worksp"
  },
  {
    "path": "examples/postgres/multi-database/README.md",
    "chars": 2509,
    "preview": "# Using Multiple Databases with `sqlx.toml`\n\nThis example project involves three crates, each owning a different schema "
  },
  {
    "path": "examples/postgres/multi-database/accounts/Cargo.toml",
    "chars": 643,
    "preview": "[package]\nname = \"sqlx-example-postgres-multi-database-accounts\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nsqlx"
  },
  {
    "path": "examples/postgres/multi-database/accounts/migrations/01_setup.sql",
    "chars": 900,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/multi-database/accounts/migrations/02_account.sql",
    "chars": 295,
    "preview": "create table account\n(\n    account_id    uuid primary key     default gen_random_uuid(),\n    email         text unique n"
  },
  {
    "path": "examples/postgres/multi-database/accounts/migrations/03_session.sql",
    "chars": 217,
    "preview": "create table session\n(\n    session_token text primary key, -- random alphanumeric string\n    account_id    uuid        n"
  },
  {
    "path": "examples/postgres/multi-database/accounts/sqlx.toml",
    "chars": 305,
    "preview": "[common]\ndatabase-url-var = \"ACCOUNTS_DATABASE_URL\"\n\n[macros.table-overrides.'account']\n'account_id' = \"crate::AccountId"
  },
  {
    "path": "examples/postgres/multi-database/accounts/src/lib.rs",
    "chars": 9450,
    "preview": "use argon2::{password_hash, Argon2, PasswordHasher, PasswordVerifier};\nuse password_hash::PasswordHashString;\nuse rand::"
  },
  {
    "path": "examples/postgres/multi-database/payments/Cargo.toml",
    "chars": 455,
    "preview": "[package]\nname = \"sqlx-example-postgres-multi-database-payments\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\n\nsql"
  },
  {
    "path": "examples/postgres/multi-database/payments/migrations/01_setup.sql",
    "chars": 892,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/multi-database/payments/migrations/02_payment.sql",
    "chars": 2946,
    "preview": "-- `payments::PaymentStatus`\n--\n-- Historically at LaunchBadge we preferred not to define enums on the database side bec"
  },
  {
    "path": "examples/postgres/multi-database/payments/sqlx.toml",
    "chars": 226,
    "preview": "[common]\ndatabase-url-var = \"PAYMENTS_DATABASE_URL\"\n\n[macros.table-overrides.'payment']\n'payment_id' = \"crate::PaymentId"
  },
  {
    "path": "examples/postgres/multi-database/payments/src/lib.rs",
    "chars": 4585,
    "preview": "use accounts::{AccountId, AccountsManager};\nuse sqlx::postgres::{PgConnectOptions, PgPoolOptions};\nuse sqlx::{Acquire, P"
  },
  {
    "path": "examples/postgres/multi-database/sqlx.toml",
    "chars": 111,
    "preview": "[migrate]\n# Move `migrations/` to under `src/` to separate it from subcrates.\nmigrations-dir = \"src/migrations\""
  },
  {
    "path": "examples/postgres/multi-database/src/main.rs",
    "chars": 4312,
    "preview": "use accounts::AccountsManager;\nuse color_eyre::eyre;\nuse color_eyre::eyre::{Context, OptionExt};\nuse payments::PaymentsM"
  },
  {
    "path": "examples/postgres/multi-database/src/migrations/01_setup.sql",
    "chars": 900,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/multi-database/src/migrations/02_purchase.sql",
    "chars": 325,
    "preview": "create table purchase\n(\n    purchase_id uuid primary key     default gen_random_uuid(),\n    account_id  uuid        not "
  },
  {
    "path": "examples/postgres/multi-tenant/Cargo.toml",
    "chars": 779,
    "preview": "[package]\nname = \"sqlx-example-postgres-multi-tenant\"\nversion.workspace = true\nlicense.workspace = true\nedition.workspac"
  },
  {
    "path": "examples/postgres/multi-tenant/README.md",
    "chars": 2322,
    "preview": "# Multi-tenant Databases with `sqlx.toml`\n\nThis example project involves three crates, each owning a different schema in"
  },
  {
    "path": "examples/postgres/multi-tenant/accounts/Cargo.toml",
    "chars": 681,
    "preview": "[package]\nname = \"sqlx-example-postgres-multi-tenant-accounts\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\ntokio "
  },
  {
    "path": "examples/postgres/multi-tenant/accounts/migrations/01_setup.sql",
    "chars": 936,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/multi-tenant/accounts/migrations/02_account.sql",
    "chars": 322,
    "preview": "create table accounts.account\n(\n    account_id    uuid primary key     default gen_random_uuid(),\n    email         text"
  },
  {
    "path": "examples/postgres/multi-tenant/accounts/migrations/03_session.sql",
    "chars": 235,
    "preview": "create table accounts.session\n(\n    session_token text primary key, -- random alphanumeric string\n    account_id    uuid"
  },
  {
    "path": "examples/postgres/multi-tenant/accounts/sqlx.toml",
    "chars": 352,
    "preview": "[migrate]\ncreate-schemas = [\"accounts\"]\ntable-name = \"accounts._sqlx_migrations\"\n\n[macros.table-overrides.'accounts.acco"
  },
  {
    "path": "examples/postgres/multi-tenant/accounts/src/lib.rs",
    "chars": 9267,
    "preview": "use argon2::{password_hash, Argon2, PasswordHasher, PasswordVerifier};\nuse password_hash::PasswordHashString;\nuse rand::"
  },
  {
    "path": "examples/postgres/multi-tenant/payments/Cargo.toml",
    "chars": 490,
    "preview": "[package]\nname = \"sqlx-example-postgres-multi-tenant-payments\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\n\nrust_"
  },
  {
    "path": "examples/postgres/multi-tenant/payments/migrations/01_setup.sql",
    "chars": 928,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/multi-tenant/payments/migrations/02_payment.sql",
    "chars": 3052,
    "preview": "-- `payments::PaymentStatus`\n--\n-- Historically at LaunchBadge we preferred not to define enums on the database side bec"
  },
  {
    "path": "examples/postgres/multi-tenant/payments/sqlx.toml",
    "chars": 273,
    "preview": "[migrate]\ncreate-schemas = [\"payments\"]\ntable-name = \"payments._sqlx_migrations\"\n\n[macros.table-overrides.'payments.paym"
  },
  {
    "path": "examples/postgres/multi-tenant/payments/src/lib.rs",
    "chars": 3978,
    "preview": "use accounts::AccountId;\nuse sqlx::{Acquire, PgConnection, Postgres};\nuse time::OffsetDateTime;\nuse uuid::Uuid;\n\n#[deriv"
  },
  {
    "path": "examples/postgres/multi-tenant/sqlx.toml",
    "chars": 111,
    "preview": "[migrate]\n# Move `migrations/` to under `src/` to separate it from subcrates.\nmigrations-dir = \"src/migrations\""
  },
  {
    "path": "examples/postgres/multi-tenant/src/main.rs",
    "chars": 3980,
    "preview": "use accounts::AccountsManager;\nuse color_eyre::eyre;\nuse color_eyre::eyre::{Context, OptionExt};\nuse rand::distributions"
  },
  {
    "path": "examples/postgres/multi-tenant/src/migrations/01_setup.sql",
    "chars": 900,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/multi-tenant/src/migrations/02_purchase.sql",
    "chars": 407,
    "preview": "create table purchase\n(\n    purchase_id uuid primary key     default gen_random_uuid(),\n    account_id  uuid        not "
  },
  {
    "path": "examples/postgres/preferred-crates/Cargo.toml",
    "chars": 915,
    "preview": "[package]\nname = \"sqlx-example-postgres-preferred-crates\"\nversion.workspace = true\nlicense.workspace = true\nedition.work"
  },
  {
    "path": "examples/postgres/preferred-crates/README.md",
    "chars": 3320,
    "preview": "# Usage of `macros.preferred-crates` in `sqlx.toml`\n\n## The Problem\n\nSQLx has many optional features that enable integra"
  },
  {
    "path": "examples/postgres/preferred-crates/sqlx.toml",
    "chars": 295,
    "preview": "[migrate]\n# Move `migrations/` to under `src/` to separate it from subcrates.\nmigrations-dir = \"src/migrations\"\n\n[macros"
  },
  {
    "path": "examples/postgres/preferred-crates/src/main.rs",
    "chars": 2089,
    "preview": "use anyhow::Context;\nuse chrono::{DateTime, Utc};\nuse sqlx::{Connection, PgConnection};\nuse std::time::Duration;\nuse uui"
  },
  {
    "path": "examples/postgres/preferred-crates/src/migrations/01_setup.sql",
    "chars": 900,
    "preview": "-- We try to ensure every table has `created_at` and `updated_at` columns, which can help immensely with debugging\n-- an"
  },
  {
    "path": "examples/postgres/preferred-crates/src/migrations/02_users.sql",
    "chars": 320,
    "preview": "create table users(\n    id uuid primary key default gen_random_uuid(),\n    username text not null,\n    password_hash tex"
  },
  {
    "path": "examples/postgres/preferred-crates/uses-rust-decimal/Cargo.toml",
    "chars": 458,
    "preview": "[package]\nname = \"sqlx-example-postgres-preferred-crates-uses-rust-decimal\"\nversion.workspace = true\nlicense.workspace ="
  },
  {
    "path": "examples/postgres/preferred-crates/uses-rust-decimal/src/lib.rs",
    "chars": 1394,
    "preview": "use chrono::{DateTime, Utc};\nuse sqlx::PgExecutor;\n\n#[derive(sqlx::FromRow, Debug)]\npub struct Purchase {\n    pub id: Uu"
  },
  {
    "path": "examples/postgres/preferred-crates/uses-time/Cargo.toml",
    "chars": 431,
    "preview": "[package]\nname = \"sqlx-example-postgres-preferred-crates-uses-time\"\nversion.workspace = true\nlicense.workspace = true\ned"
  },
  {
    "path": "examples/postgres/preferred-crates/uses-time/src/lib.rs",
    "chars": 1939,
    "preview": "use serde::de::DeserializeOwned;\nuse serde::Serialize;\nuse sqlx::PgExecutor;\nuse std::time::Duration;\nuse time::OffsetDa"
  },
  {
    "path": "examples/postgres/todos/Cargo.toml",
    "chars": 355,
    "preview": "[package]\nname = \"sqlx-example-postgres-todos\"\nversion = \"0.1.0\"\nedition = \"2018\"\nworkspace = \"../../../\"\n\n[dependencies"
  },
  {
    "path": "examples/postgres/todos/README.md",
    "chars": 427,
    "preview": "# TODOs Example\n\n## Setup\n\n1. Declare the database URL\n\n    ```\n    export DATABASE_URL=\"postgres://postgres:password@lo"
  },
  {
    "path": "examples/postgres/todos/migrations/20200718111257_todos.sql",
    "chars": 158,
    "preview": "CREATE TABLE IF NOT EXISTS todos\n(\n    id          BIGSERIAL PRIMARY KEY,\n    description TEXT    NOT NULL,\n    done    "
  },
  {
    "path": "examples/postgres/todos/src/main.rs",
    "chars": 2087,
    "preview": "use clap::{Parser, Subcommand};\nuse sqlx::postgres::PgPool;\nuse std::env;\n\n#[derive(Parser)]\nstruct Args {\n    #[command"
  },
  {
    "path": "examples/postgres/transaction/Cargo.toml",
    "chars": 292,
    "preview": "[package]\nname = \"sqlx-example-postgres-transaction\"\nversion = \"0.1.0\"\nedition = \"2021\"\nworkspace = \"../../../\"\n\n[depend"
  },
  {
    "path": "examples/postgres/transaction/README.md",
    "chars": 315,
    "preview": "# Postgres Transaction Example\n\nA simple example demonstrating how to obtain and roll back a transaction with postgres.\n"
  },
  {
    "path": "examples/postgres/transaction/migrations/20200718111257_todos.sql",
    "chars": 158,
    "preview": "CREATE TABLE IF NOT EXISTS todos\n(\n    id          BIGSERIAL PRIMARY KEY,\n    description TEXT    NOT NULL,\n    done    "
  },
  {
    "path": "examples/postgres/transaction/src/main.rs",
    "chars": 2998,
    "preview": "use sqlx::query;\n\nasync fn insert_and_verify(\n    transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,\n    test_id: "
  },
  {
    "path": "examples/sqlite/extension/Cargo.toml",
    "chars": 442,
    "preview": "[package]\nname = \"sqlx-example-sqlite-extension\"\nversion = \"0.1.0\"\nlicense.workspace = true\nedition.workspace = true\nrep"
  },
  {
    "path": "examples/sqlite/extension/download-extension.sh",
    "chars": 473,
    "preview": "#!/bin/bash\n\n# This grabs a pre-compiled version of the extension used in this\n# example, and stores it in a temporary d"
  },
  {
    "path": "examples/sqlite/extension/migrations/20250203094951_addresses.sql",
    "chars": 1158,
    "preview": "create table addresses (address text, family integer);\n\n-- The `ipfamily` function is provided by the\n-- [ipaddr](https:"
  },
  {
    "path": "examples/sqlite/extension/sqlx.toml",
    "chars": 665,
    "preview": "[common.drivers.sqlite]\n# Including the full path to the extension is somewhat unusual,\n# because normally an extension "
  },
  {
    "path": "examples/sqlite/extension/src/main.rs",
    "chars": 1795,
    "preview": "use std::str::FromStr;\n\nuse sqlx::{\n    query,\n    sqlite::{SqliteConnectOptions, SqlitePool},\n};\n\n#[tokio::main(flavor "
  },
  {
    "path": "examples/sqlite/todos/Cargo.toml",
    "chars": 332,
    "preview": "[package]\nname = \"sqlx-example-sqlite-todos\"\nversion = \"0.1.0\"\nedition = \"2018\"\nworkspace = \"../../../\"\n\n[dependencies]\n"
  },
  {
    "path": "examples/sqlite/todos/README.md",
    "chars": 398,
    "preview": "# TODOs Example\n\n## Setup\n\n1. Declare the database URL\n\n    ```\n    export DATABASE_URL=\"sqlite:todos.db\"\n    ```\n\n2. Cr"
  },
  {
    "path": "examples/sqlite/todos/migrations/20200718111257_todos.sql",
    "chars": 185,
    "preview": "CREATE TABLE IF NOT EXISTS todos\n(\n    id          INTEGER PRIMARY KEY NOT NULL,\n    description TEXT                NOT"
  },
  {
    "path": "examples/sqlite/todos/src/main.rs",
    "chars": 2214,
    "preview": "use clap::{Parser, Subcommand};\nuse sqlx::sqlite::SqlitePool;\nuse std::env;\n\n#[derive(Parser)]\nstruct Args {\n    #[comma"
  },
  {
    "path": "examples/x.py",
    "chars": 2135,
    "preview": "#!/usr/bin/env python3\n\nimport sys\nimport os\nfrom os import path\n\n# base dir of sqlx workspace\ndir_workspace = path.dirn"
  },
  {
    "path": "gen-changelog.sh",
    "chars": 3170,
    "preview": "# Requires Github CLI and `jq`\n# Usage: `./gen-changelog.sh YYYY-mm-dd`\n# Generates changelog entries for all PRs merged"
  },
  {
    "path": "rust-toolchain.toml",
    "chars": 112,
    "preview": "# Note: should NOT increase during a minor/patch release cycle\n[toolchain]\nchannel = \"1.86\"\nprofile = \"minimal\"\n"
  },
  {
    "path": "sqlx-cli/Cargo.toml",
    "chars": 2180,
    "preview": "[package]\nname = \"sqlx-cli\"\nversion.workspace = true\ndescription = \"Command-line utility for SQLx, the Rust SQL toolkit."
  },
  {
    "path": "sqlx-cli/README.md",
    "chars": 4399,
    "preview": "# SQLx CLI\n\nSQLx's associated command-line utility for managing databases, migrations, and enabling \"offline\"\nmode with "
  },
  {
    "path": "sqlx-cli/src/bin/cargo-sqlx.rs",
    "chars": 569,
    "preview": "use clap::Parser;\nuse console::style;\nuse sqlx_cli::Opt;\nuse std::process;\n\n// cargo invokes this binary as `cargo-sqlx "
  },
  {
    "path": "sqlx-cli/src/bin/sqlx.rs",
    "chars": 434,
    "preview": "use clap::Parser;\nuse console::style;\nuse sqlx_cli::Opt;\n\n#[tokio::main]\nasync fn main() {\n    // Checks for `--no-doten"
  },
  {
    "path": "sqlx-cli/src/completions.rs",
    "chars": 206,
    "preview": "use std::io;\n\nuse clap::CommandFactory;\nuse clap_complete::{generate, Shell};\n\nuse crate::opt::Command;\n\npub fn run(shel"
  },
  {
    "path": "sqlx-cli/src/database.rs",
    "chars": 3405,
    "preview": "use crate::opt::{ConnectOpts, MigrationSourceOpt};\nuse crate::{migrate, Config};\nuse console::{style, Term};\nuse dialogu"
  },
  {
    "path": "sqlx-cli/src/lib.rs",
    "chars": 8000,
    "preview": "//! # SQLx CLI\n//!\n//! Command-line utility for the [SQLx](https://github.com/launchbadge/sqlx) ecosystem.\n//!\n//! This "
  },
  {
    "path": "sqlx-cli/src/metadata.rs",
    "chars": 6156,
    "preview": "use std::{\n    collections::{btree_map, BTreeMap, BTreeSet},\n    ffi::OsStr,\n    path::{Path, PathBuf},\n    process::Com"
  },
  {
    "path": "sqlx-cli/src/migrate.rs",
    "chars": 13679,
    "preview": "use crate::config::Config;\nuse crate::opt::{AddMigrationOpts, ConnectOpts, MigrationSourceOpt};\nuse anyhow::{bail, Conte"
  },
  {
    "path": "sqlx-cli/src/opt.rs",
    "chars": 18397,
    "preview": "use crate::config::migrate::{DefaultMigrationType, DefaultVersioning};\nuse crate::config::Config;\nuse anyhow::Context;\nu"
  },
  {
    "path": "sqlx-cli/src/prepare.rs",
    "chars": 13302,
    "preview": "use std::collections::{BTreeSet, HashSet};\nuse std::env;\nuse std::ffi::{OsStr, OsString};\nuse std::fs;\nuse std::path::{P"
  },
  {
    "path": "sqlx-cli/tests/add.rs",
    "chars": 11992,
    "preview": "use anyhow::Context;\nuse assert_cmd::cargo_bin_cmd;\nuse std::cmp::Ordering;\nuse std::fs::read_dir;\nuse std::ops::Index;\n"
  },
  {
    "path": "sqlx-cli/tests/assets/config_default_type_reversible.toml",
    "chars": 48,
    "preview": "[migrate.defaults]\nmigration-type = \"reversible\""
  },
  {
    "path": "sqlx-cli/tests/assets/config_default_versioning_sequential.toml",
    "chars": 54,
    "preview": "[migrate.defaults]\nmigration-versioning = \"sequential\""
  },
  {
    "path": "sqlx-cli/tests/assets/config_default_versioning_timestamp.toml",
    "chars": 53,
    "preview": "[migrate.defaults]\nmigration-versioning = \"timestamp\""
  },
  {
    "path": "sqlx-cli/tests/assets/sample_metadata.json",
    "chars": 869147,
    "preview": "{\n  \"packages\": [\n    {\n      \"name\": \"ahash\",\n      \"version\": \"0.7.6\",\n      \"id\": \"ahash 0.7.6 (registry+https://gith"
  },
  {
    "path": "sqlx-cli/tests/common/mod.rs",
    "chars": 3782,
    "preview": "use assert_cmd::{assert::Assert, Command};\n\nuse sqlx::_unstable::config::Config;\nuse sqlx::{migrate::Migrate, Connection"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/BOM/.gitattributes",
    "chars": 18,
    "preview": "*.sql text eol=lf\n"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/BOM/1_user.sql",
    "chars": 153,
    "preview": "create table user\n(\n    -- integer primary keys are the most efficient in SQLite\n    user_id  integer primary key,\n    "
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/BOM/2_post.sql",
    "chars": 309,
    "preview": "create table post\n(\n    post_id    integer primary key,\n    user_id    integer not null references user (user_id),\n    "
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/BOM/3_comment.sql",
    "chars": 329,
    "preview": "create table comment\n(\n    comment_id integer primary key,\n    post_id    integer not null references post (post_id),\n "
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/CRLF/.gitattributes",
    "chars": 20,
    "preview": "*.sql text eol=crlf\n"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/CRLF/1_user.sql",
    "chars": 158,
    "preview": "create table user\r\n(\r\n    -- integer primary keys are the most efficient in SQLite\r\n    user_id  integer primary key,\r\n "
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/CRLF/2_post.sql",
    "chars": 318,
    "preview": "create table post\r\n(\r\n    post_id    integer primary key,\r\n    user_id    integer not null references user (user_id),\r\n "
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/CRLF/3_comment.sql",
    "chars": 338,
    "preview": "create table comment\r\n(\r\n    comment_id integer primary key,\r\n    post_id    integer not null references post (post_id),"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/LF/.gitattributes",
    "chars": 18,
    "preview": "*.sql text eol=lf\n"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/LF/1_user.sql",
    "chars": 152,
    "preview": "create table user\n(\n    -- integer primary keys are the most efficient in SQLite\n    user_id  integer primary key,\n    u"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/LF/2_post.sql",
    "chars": 308,
    "preview": "create table post\n(\n    post_id    integer primary key,\n    user_id    integer not null references user (user_id),\n    c"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/LF/3_comment.sql",
    "chars": 328,
    "preview": "create table comment\n(\n    comment_id integer primary key,\n    post_id    integer not null references post (post_id),\n  "
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/oops-all-tabs/.gitattributes",
    "chars": 18,
    "preview": "*.sql text eol=lf\n"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/oops-all-tabs/1_user.sql",
    "chars": 143,
    "preview": "create table user\n(\n\t-- integer primary keys are the most efficient in SQLite\n\tuser_id  integer primary key,\n\tusername t"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/oops-all-tabs/2_post.sql",
    "chars": 281,
    "preview": "create table post\n(\n\tpost_id\tinteger primary key,\n\tuser_id\tinteger not null references user (user_id),\n\tcontent\ttext\tnot"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/oops-all-tabs/3_comment.sql",
    "chars": 301,
    "preview": "create table comment\n(\n\tcomment_id integer primary key,\n\tpost_id\tinteger not null references post (post_id),\n\tuser_id\tin"
  },
  {
    "path": "sqlx-cli/tests/ignored-chars/sqlx.toml",
    "chars": 418,
    "preview": "[migrate]\n# Ignore common whitespace characters (beware syntactically significant whitespace!)\n# Space, tab, CR, LF, zer"
  },
  {
    "path": "sqlx-cli/tests/migrate.rs",
    "chars": 5891,
    "preview": "mod common;\n\nuse common::TestDatabase;\n\n#[tokio::test]\nasync fn run_reversible_migrations() {\n    let all_migrations: Ve"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230101000000_test1.down.sql",
    "chars": 18,
    "preview": "DROP TABLE test1;\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230101000000_test1.up.sql",
    "chars": 43,
    "preview": "CREATE TABLE test1(x INTEGER PRIMARY KEY);\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230201000000_test2.down.sql",
    "chars": 18,
    "preview": "DROP TABLE test2;\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230201000000_test2.up.sql",
    "chars": 43,
    "preview": "CREATE TABLE test2(x INTEGER PRIMARY KEY);\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230301000000_test3.down.sql",
    "chars": 18,
    "preview": "DROP TABLE test3;\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230301000000_test3.up.sql",
    "chars": 43,
    "preview": "CREATE TABLE test3(x INTEGER PRIMARY KEY);\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230401000000_test4.down.sql",
    "chars": 18,
    "preview": "DROP TABLE test4;\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230401000000_test4.up.sql",
    "chars": 43,
    "preview": "CREATE TABLE test4(x INTEGER PRIMARY KEY);\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230501000000_test5.down.sql",
    "chars": 18,
    "preview": "DROP TABLE test5;\n"
  },
  {
    "path": "sqlx-cli/tests/migrations_reversible/20230501000000_test5.up.sql",
    "chars": 43,
    "preview": "CREATE TABLE test5(x INTEGER PRIMARY KEY);\n"
  },
  {
    "path": "sqlx-core/Cargo.toml",
    "chars": 4328,
    "preview": "[package]\nname = \"sqlx-core\"\ndescription = \"Core of SQLx, the rust SQL toolkit. Not intended to be used directly.\"\nversi"
  },
  {
    "path": "sqlx-core/src/acquire.rs",
    "chars": 4133,
    "preview": "use crate::database::Database;\nuse crate::error::Error;\nuse crate::pool::{MaybePoolConnection, Pool, PoolConnection};\n\nu"
  },
  {
    "path": "sqlx-core/src/any/arguments.rs",
    "chars": 3625,
    "preview": "use crate::any::value::AnyValueKind;\nuse crate::any::{Any, AnyTypeInfoKind};\nuse crate::arguments::Arguments;\nuse crate:"
  },
  {
    "path": "sqlx-core/src/any/column.rs",
    "chars": 598,
    "preview": "use crate::any::{Any, AnyTypeInfo};\nuse crate::column::Column;\nuse crate::ext::ustr::UStr;\n\n#[derive(Debug, Clone)]\npub "
  },
  {
    "path": "sqlx-core/src/any/connection/backend.rs",
    "chars": 4510,
    "preview": "use crate::any::{AnyArguments, AnyQueryResult, AnyRow, AnyStatement, AnyTypeInfo};\nuse crate::sql_str::SqlStr;\nuse eithe"
  },
  {
    "path": "sqlx-core/src/any/connection/executor.rs",
    "chars": 1980,
    "preview": "use crate::any::{Any, AnyConnection, AnyQueryResult, AnyRow, AnyStatement, AnyTypeInfo};\nuse crate::error::Error;\nuse cr"
  },
  {
    "path": "sqlx-core/src/any/connection/mod.rs",
    "chars": 4226,
    "preview": "use futures_core::future::BoxFuture;\nuse std::future::Future;\n\nuse crate::any::{Any, AnyConnectOptions};\nuse crate::conn"
  },
  {
    "path": "sqlx-core/src/any/database.rs",
    "chars": 1059,
    "preview": "use crate::any::{\n    AnyArgumentBuffer, AnyArguments, AnyColumn, AnyConnection, AnyQueryResult, AnyRow,\n    AnyStatemen"
  },
  {
    "path": "sqlx-core/src/any/driver.rs",
    "chars": 5308,
    "preview": "use crate::any::connection::AnyConnectionBackend;\nuse crate::any::{AnyConnectOptions, AnyConnection};\nuse crate::common:"
  },
  {
    "path": "sqlx-core/src/any/error.rs",
    "chars": 413,
    "preview": "use std::any::type_name;\n\nuse crate::any::type_info::AnyTypeInfo;\nuse crate::any::Any;\nuse crate::error::BoxDynError;\nus"
  },
  {
    "path": "sqlx-core/src/any/kind.rs",
    "chars": 2585,
    "preview": "// Annoying how deprecation warnings trigger in the same module as the deprecated item.\n#![allow(deprecated)]\n// Cargo f"
  },
  {
    "path": "sqlx-core/src/any/migrate.rs",
    "chars": 2992,
    "preview": "use crate::any::driver;\nuse crate::any::{Any, AnyConnection};\nuse crate::error::Error;\nuse crate::migrate::{AppliedMigra"
  },
  {
    "path": "sqlx-core/src/any/mod.rs",
    "chars": 2461,
    "preview": "//! **SEE DOCUMENTATION BEFORE USE**. Generic database driver with the specific driver selected at runtime.\n//!\n//! The "
  },
  {
    "path": "sqlx-core/src/any/options.rs",
    "chars": 1823,
    "preview": "use crate::any::AnyConnection;\nuse crate::connection::{ConnectOptions, LogSettings};\nuse crate::error::Error;\nuse log::L"
  },
  {
    "path": "sqlx-core/src/any/query_result.rs",
    "chars": 663,
    "preview": "use std::iter::{Extend, IntoIterator};\n\n#[derive(Debug, Default)]\npub struct AnyQueryResult {\n    #[doc(hidden)]\n    pub"
  },
  {
    "path": "sqlx-core/src/any/row.rs",
    "chars": 5083,
    "preview": "use crate::any::error::mismatched_types;\nuse crate::any::{Any, AnyColumn, AnyTypeInfo, AnyTypeInfoKind, AnyValue, AnyVal"
  },
  {
    "path": "sqlx-core/src/any/statement.rs",
    "chars": 2541,
    "preview": "use crate::any::{Any, AnyArguments, AnyColumn, AnyTypeInfo};\nuse crate::column::ColumnIndex;\nuse crate::database::Databa"
  },
  {
    "path": "sqlx-core/src/any/transaction.rs",
    "chars": 1006,
    "preview": "use std::future::Future;\n\nuse crate::any::{Any, AnyConnection};\nuse crate::database::Database;\nuse crate::error::Error;\n"
  },
  {
    "path": "sqlx-core/src/any/type_info.rs",
    "chars": 1214,
    "preview": "use std::fmt::{self, Display, Formatter};\n\nuse crate::type_info::TypeInfo;\n\nuse AnyTypeInfoKind::*;\n\n#[derive(Debug, Clo"
  },
  {
    "path": "sqlx-core/src/any/types/blob.rs",
    "chars": 1573,
    "preview": "use crate::any::{Any, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind};\nuse crate::database::Database;\nuse crate::decode::Dec"
  },
  {
    "path": "sqlx-core/src/any/types/bool.rs",
    "chars": 854,
    "preview": "use crate::any::{Any, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind};\nuse crate::database::Database;\nuse crate::decode::Dec"
  },
  {
    "path": "sqlx-core/src/any/types/float.rs",
    "chars": 1552,
    "preview": "use crate::any::{Any, AnyArgumentBuffer, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind, AnyValueRef};\nuse crate::database::"
  },
  {
    "path": "sqlx-core/src/any/types/int.rs",
    "chars": 2119,
    "preview": "use crate::any::{Any, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind};\nuse crate::database::Database;\nuse crate::decode::Dec"
  },
  {
    "path": "sqlx-core/src/any/types/mod.rs",
    "chars": 1757,
    "preview": "//! Conversions between Rust and standard **SQL** types.\n//!\n//! # Types\n//!\n//! | Rust type                            "
  },
  {
    "path": "sqlx-core/src/any/types/str.rs",
    "chars": 1937,
    "preview": "use crate::any::types::str;\nuse crate::any::{Any, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind};\nuse crate::database::Data"
  }
]

// ... and 490 more files (download for full content)