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 (line 330) | async fn fetch_enum_by_oid(&mut self, oid: Oid, name: String) -> Result<...
  method fetch_composite_by_oid (line 350) | async fn fetch_composite_by_oid(
  method fetch_domain_by_oid (line 385) | async fn fetch_domain_by_oid(
  method fetch_range_by_oid (line 400) | async fn fetch_range_by_oid(&mut self, oid: Oid, name: String) -> Result...
  method resolve_type_id (line 421) | pub(crate) async fn resolve_type_id(&mut self, ty: &PgType) -> Result<Oi...
  method fetch_type_id_by_name (line 434) | pub(crate) async fn fetch_type_id_by_name(&mut self, name: &str) -> Resu...
  method fetch_array_type_id (line 454) | pub(crate) async fn fetch_array_type_id(&mut self, array: &PgArrayOf) ->...

FILE: sqlx-postgres/src/connection/sasl.rs
  constant GS2_HEADER (line 13) | const GS2_HEADER: &str = "n,,";
  constant CHANNEL_ATTR (line 14) | const CHANNEL_ATTR: &str = "c";
  constant USERNAME_ATTR (line 15) | const USERNAME_ATTR: &str = "n";
  constant CLIENT_PROOF_ATTR (line 16) | const CLIENT_PROOF_ATTR: &str = "p";
  constant NONCE_ATTR (line 17) | const NONCE_ATTR: &str = "r";
  function authenticate (line 19) | pub(crate) async fn authenticate(
  function gen_nonce (line 165) | fn gen_nonce() -> String {
  function hi (line 192) | async fn hi<'a>(s: &'a str, salt: &'a [u8], iter_count: u32) -> Result<[...

FILE: sqlx-postgres/src/connection/stream.rs
  type PgStream (line 28) | pub struct PgStream {
    method connect (line 44) | pub(super) async fn connect(options: &PgConnectOptions) -> Result<Self...
    method write_msg (line 61) | pub(crate) fn write_msg(&mut self, message: impl FrontendMessage) -> R...
    method send (line 65) | pub(crate) async fn send<T>(&mut self, message: T) -> Result<(), Error>
    method recv_expect (line 75) | pub(crate) async fn recv_expect<B: BackendMessage>(&mut self) -> Resul...
    method recv_unchecked (line 79) | pub(crate) async fn recv_unchecked(&mut self) -> Result<ReceivedMessag...
    method recv (line 123) | pub(crate) async fn recv(&mut self) -> Result<ReceivedMessage, Error> {
  type Target (line 204) | type Target = BufferedSocket<Box<dyn Socket>>;
  method deref (line 207) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 214) | fn deref_mut(&mut self) -> &mut Self::Target {
  function parse_server_version (line 221) | fn parse_server_version(s: &str) -> Option<u32> {
  function test_parse_server_version_num (line 269) | fn test_parse_server_version_num() {

FILE: sqlx-postgres/src/connection/tls.rs
  type MaybeUpgradeTls (line 8) | pub struct MaybeUpgradeTls<'a>(pub &'a PgConnectOptions);
  type Output (line 11) | type Output = crate::Result<Box<dyn Socket>>;
  method with_socket (line 13) | async fn with_socket<S: Socket>(self, socket: S) -> Self::Output {
  function maybe_upgrade (line 18) | async fn maybe_upgrade<S: Socket>(
  function request_upgrade (line 66) | async fn request_upgrade(

FILE: sqlx-postgres/src/copy.rs
  method copy_in_raw (line 34) | pub async fn copy_in_raw(&mut self, statement: &str) -> Result<PgCopyIn<...
  method copy_out_raw (line 58) | pub async fn copy_out_raw<'c>(
  type PgPoolCopyExt (line 70) | pub trait PgPoolCopyExt {
    method copy_in_raw (line 86) | fn copy_in_raw<'a>(
    method copy_out_raw (line 110) | fn copy_out_raw<'a>(
    method copy_in_raw (line 117) | async fn copy_in_raw<'a>(
    method copy_out_raw (line 124) | async fn copy_out_raw<'a>(
  constant PG_COPY_MAX_DATA_LEN (line 133) | pub const PG_COPY_MAX_DATA_LEN: usize = 0x3fffffff - 1 - 4;
  type PgCopyIn (line 143) | pub struct PgCopyIn<C: DerefMut<Target = PgConnection>> {
  function begin (line 149) | async fn begin(mut conn: C, statement: &str) -> Result<Self> {
  function is_textual (line 168) | pub fn is_textual(&self) -> bool {
  function num_columns (line 173) | pub fn num_columns(&self) -> usize {
  function column_is_textual (line 186) | pub fn column_is_textual(&self, column: usize) -> bool {
  function send (line 196) | pub async fn send(&mut self, data: impl Deref<Target = [u8]>) -> Result<...
  function read_from (line 224) | pub async fn read_from(&mut self, mut source: impl AsyncRead + Unpin) ->...
  function abort (line 257) | pub async fn abort(mut self, msg: impl Into<String>) -> Result<()> {
  function finish (line 287) | pub async fn finish(mut self) -> Result<u64> {
  method drop (line 309) | fn drop(&mut self) {
  function pg_begin_copy_out (line 321) | async fn pg_begin_copy_out<'c, C: DerefMut<Target = PgConnection> + Send...

FILE: sqlx-postgres/src/database.rs
  type Postgres (line 12) | pub struct Postgres;
  type Connection (line 15) | type Connection = PgConnection;
  type TransactionManager (line 17) | type TransactionManager = PgTransactionManager;
  type Row (line 19) | type Row = PgRow;
  type QueryResult (line 21) | type QueryResult = PgQueryResult;
  type Column (line 23) | type Column = PgColumn;
  type TypeInfo (line 25) | type TypeInfo = PgTypeInfo;
  type Value (line 27) | type Value = PgValue;
  type ValueRef (line 28) | type ValueRef<'r> = PgValueRef<'r>;
  type Arguments (line 30) | type Arguments = PgArguments;
  type ArgumentBuffer (line 31) | type ArgumentBuffer = PgArgumentBuffer;
  type Statement (line 33) | type Statement = PgStatement;
  constant NAME (line 35) | const NAME: &'static str = "PostgreSQL";
  constant URL_SCHEMES (line 37) | const URL_SCHEMES: &'static [&'static str] = &["postgres", "postgresql"];

FILE: sqlx-postgres/src/error.rs
  type PgDatabaseError (line 12) | pub struct PgDatabaseError(pub(crate) Notice);
    method severity (line 19) | pub fn severity(&self) -> PgSeverity {
    method code (line 26) | pub fn code(&self) -> &str {
    method message (line 33) | pub fn message(&self) -> &str {
    method detail (line 40) | pub fn detail(&self) -> Option<&str> {
    method hint (line 48) | pub fn hint(&self) -> Option<&str> {
    method position (line 55) | pub fn position(&self) -> Option<PgErrorPosition<'_>> {
    method r#where (line 71) | pub fn r#where(&self) -> Option<&str> {
    method schema (line 77) | pub fn schema(&self) -> Option<&str> {
    method table (line 82) | pub fn table(&self) -> Option<&str> {
    method column (line 87) | pub fn column(&self) -> Option<&str> {
    method data_type (line 92) | pub fn data_type(&self) -> Option<&str> {
    method constraint (line 99) | pub fn constraint(&self) -> Option<&str> {
    method file (line 104) | pub fn file(&self) -> Option<&str> {
    method line (line 109) | pub fn line(&self) -> Option<usize> {
    method routine (line 114) | pub fn routine(&self) -> Option<&str> {
  type PgErrorPosition (line 120) | pub enum PgErrorPosition<'a> {
  method fmt (line 136) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method fmt (line 158) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method message (line 166) | fn message(&self) -> &str {
  method code (line 170) | fn code(&self) -> Option<Cow<'_, str>> {
  method as_error (line 175) | fn as_error(&self) -> &(dyn StdError + Send + Sync + 'static) {
  method as_error_mut (line 180) | fn as_error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {
  method into_error (line 185) | fn into_error(self: Box<Self>) -> BoxDynError {
  method is_transient_in_connect_phase (line 189) | fn is_transient_in_connect_phase(&self) -> bool {
  method constraint (line 203) | fn constraint(&self) -> Option<&str> {
  method table (line 207) | fn table(&self) -> Option<&str> {
  method kind (line 211) | fn kind(&self) -> ErrorKind {
  constant FORMAT (line 225) | const FORMAT: BackendMessageFormat = BackendMessageFormat::ErrorResponse;
  method decode_body (line 228) | fn decode_body(buf: Bytes) -> std::result::Result<Self, Error> {
  constant UNIQUE_VIOLATION (line 236) | pub const UNIQUE_VIOLATION: &str = "23505";
  constant FOREIGN_KEY_VIOLATION (line 238) | pub const FOREIGN_KEY_VIOLATION: &str = "23503";
  constant NOT_NULL_VIOLATION (line 240) | pub const NOT_NULL_VIOLATION: &str = "23502";
  constant CHECK_VIOLATION (line 242) | pub const CHECK_VIOLATION: &str = "23514";
  constant EXCLUSION_VIOLATION (line 244) | pub const EXCLUSION_VIOLATION: &str = "23P01";

FILE: sqlx-postgres/src/io/buf_mut.rs
  type PgBufMutExt (line 3) | pub trait PgBufMutExt {
    method put_length_prefixed (line 4) | fn put_length_prefixed<F>(&mut self, f: F) -> Result<(), crate::Error>
    method put_statement_name (line 8) | fn put_statement_name(&mut self, id: StatementId);
    method put_portal_name (line 10) | fn put_portal_name(&mut self, id: PortalId);
    method put_length_prefixed (line 16) | fn put_length_prefixed<F>(&mut self, write_contents: F) -> Result<(), ...
    method put_statement_name (line 49) | fn put_statement_name(&mut self, id: StatementId) {
    method put_portal_name (line 55) | fn put_portal_name(&mut self, id: PortalId) {

FILE: sqlx-postgres/src/io/mod.rs
  type StatementId (line 11) | pub(crate) struct StatementId(IdInner);
    constant UNNAMED (line 27) | pub const UNNAMED: Self = Self(IdInner::UNNAMED);
    constant NAMED_START (line 29) | pub const NAMED_START: Self = Self(IdInner::NAMED_START);
    constant TEST_VAL (line 32) | pub const TEST_VAL: Self = Self(IdInner::TEST_VAL);
    constant NAME_PREFIX (line 34) | const NAME_PREFIX: &'static str = "sqlx_s_";
    method next (line 36) | pub fn next(&self) -> Self {
    method name_len (line 40) | pub fn name_len(&self) -> Saturating<usize> {
    method display (line 49) | pub fn display(&self) -> Option<DisplayId> {
    method put_name_with_nul (line 53) | pub fn put_name_with_nul(&self, buf: &mut Vec<u8>) {
  type PortalId (line 14) | pub(crate) struct PortalId(IdInner);
    constant UNNAMED (line 67) | pub const UNNAMED: Self = PortalId(IdInner::UNNAMED);
    constant NAMED_START (line 69) | pub const NAMED_START: Self = PortalId(IdInner::NAMED_START);
    constant TEST_VAL (line 72) | pub const TEST_VAL: Self = Self(IdInner::TEST_VAL);
    constant NAME_PREFIX (line 74) | const NAME_PREFIX: &'static str = "sqlx_p_";
    method next (line 79) | pub fn next(&self) -> Self {
    method name_len (line 84) | pub fn name_len(&self) -> Saturating<usize> {
    method put_name_with_nul (line 88) | pub fn put_name_with_nul(&self, buf: &mut Vec<u8>) {
  type IdInner (line 17) | struct IdInner(Option<NonZeroU32>);
    constant UNNAMED (line 94) | const UNNAMED: Self = Self(None);
    constant NAMED_START (line 96) | const NAMED_START: Self = Self(Some(NonZeroU32::MIN));
    constant TEST_VAL (line 99) | pub const TEST_VAL: Self = Self(NonZeroU32::new(1234567890));
    method next (line 102) | fn next(&self) -> Self {
    method display (line 111) | fn display(&self, prefix: &'static str) -> Option<DisplayId> {
    method name_len (line 116) | fn name_len(&self, name_prefix: &str) -> Saturating<usize> {
    method put_name_with_nul (line 135) | fn put_name_with_nul(&self, name_prefix: &str, buf: &mut Vec<u8>) {
  type DisplayId (line 20) | pub(crate) struct DisplayId {
  method fmt (line 59) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function statement_id_display_matches_encoding (line 146) | fn statement_id_display_matches_encoding() {

FILE: sqlx-postgres/src/lib.rs
  type PgPool (line 69) | pub type PgPool = crate::pool::Pool<Postgres>;
  type PgPoolOptions (line 72) | pub type PgPoolOptions = crate::pool::PoolOptions<Postgres>;
  type PgExecutor (line 75) | pub trait PgExecutor<'c>: Executor<'c, Database = Postgres> {}
  type PgTransaction (line 79) | pub type PgTransaction<'c> = crate::transaction::Transaction<'c, Postgres>;

FILE: sqlx-postgres/src/listener.rs
  type PgListener (line 28) | pub struct PgListener {
    method connect (line 42) | pub async fn connect(url: &str) -> Result<Self, Error> {
    method connect_with (line 59) | pub async fn connect_with(pool: &Pool<Postgres>) -> Result<Self, Error> {
    method ignore_pool_close_event (line 97) | pub fn ignore_pool_close_event(&mut self, val: bool) {
    method eager_reconnect (line 110) | pub fn eager_reconnect(&mut self, val: bool) {
    method listen (line 116) | pub async fn listen(&mut self, channel: &str) -> Result<(), Error> {
    method listen_all (line 128) | pub async fn listen_all(
    method unlisten (line 146) | pub async fn unlisten(&mut self, channel: &str) -> Result<(), Error> {
    method unlisten_all (line 163) | pub async fn unlisten_all(&mut self) -> Result<(), Error> {
    method connect_if_needed (line 176) | async fn connect_if_needed(&mut self) -> Result<(), Error> {
    method connection (line 192) | async fn connection(&mut self) -> Result<&mut PgConnection, Error> {
    method recv (line 225) | pub async fn recv(&mut self) -> Result<PgNotification, Error> {
    method try_recv (line 259) | pub async fn try_recv(&mut self) -> Result<Option<PgNotification>, Err...
    method next_buffered (line 337) | pub fn next_buffered(&mut self) -> Option<PgNotification> {
    method into_stream (line 351) | pub fn into_stream(mut self) -> impl Stream<Item = Result<PgNotificati...
  type PgNotification (line 39) | pub struct PgNotification(Notification);
    method process_id (line 456) | pub fn process_id(&self) -> u32 {
    method channel (line 463) | pub fn channel(&self) -> &str {
    method payload (line 470) | pub fn payload(&self) -> &str {
  method drop (line 361) | fn drop(&mut self) {
  type Database (line 379) | type Database = Postgres;
  type Connection (line 380) | type Connection = &'c mut PgConnection;
  function acquire (line 382) | fn acquire(self) -> BoxFuture<'c, Result<Self::Connection, Error>> {
  function begin (line 386) | fn begin(self) -> BoxFuture<'c, Result<Transaction<'c, Self::Database>, ...
  type Database (line 392) | type Database = Postgres;
  function fetch_many (line 394) | fn fetch_many<'e, 'q, E>(
  function fetch_optional (line 413) | fn fetch_optional<'e, 'q, E>(self, query: E) -> BoxFuture<'e, Result<Opt...
  function prepare_with (line 423) | fn prepare_with<'e>(
  function describe (line 442) | fn describe<'e>(
  method fmt (line 476) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 482) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function ident (line 491) | fn ident(mut name: &str) -> String {
  function build_listen_all_query (line 502) | fn build_listen_all_query(channels: impl IntoIterator<Item = impl AsRef<...
  function test_build_listen_all_query_with_single_channel (line 512) | fn test_build_listen_all_query_with_single_channel() {
  function test_build_listen_all_query_with_multiple_channels (line 518) | fn test_build_listen_all_query_with_multiple_channels() {

FILE: sqlx-postgres/src/message/authentication.rs
  type Authentication (line 26) | pub enum Authentication {
  constant FORMAT (line 64) | const FORMAT: BackendMessageFormat = BackendMessageFormat::Authentication;
  method decode_body (line 66) | fn decode_body(mut buf: Bytes) -> Result<Self, Error> {
  type AuthenticationMd5Password (line 92) | pub struct AuthenticationMd5Password {
  type AuthenticationSasl (line 98) | pub struct AuthenticationSasl(Bytes);
    method mechanisms (line 102) | pub fn mechanisms(&self) -> SaslMechanisms<'_> {
  type SaslMechanisms (line 108) | pub struct SaslMechanisms<'a>(&'a [u8]);
  type Item (line 111) | type Item = &'a str;
  method next (line 113) | fn next(&mut self) -> Option<Self::Item> {
  type AuthenticationSaslContinue (line 127) | pub struct AuthenticationSaslContinue {
    method decode_with (line 135) | fn decode_with(buf: Bytes, _: ()) -> Result<Self, Error> {
  type AuthenticationSaslFinal (line 174) | pub struct AuthenticationSaslFinal {
    method decode_with (line 179) | fn decode_with(buf: Bytes, _: ()) -> Result<Self, Error> {

FILE: sqlx-postgres/src/message/backend_key_data.rs
  type BackendKeyData (line 10) | pub struct BackendKeyData {
  constant FORMAT (line 19) | const FORMAT: BackendMessageFormat = BackendMessageFormat::BackendKeyData;
  method decode_body (line 21) | fn decode_body(buf: Bytes) -> Result<Self, Error> {
  function test_decode_backend_key_data (line 33) | fn test_decode_backend_key_data() {
  function bench_decode_backend_key_data (line 44) | fn bench_decode_backend_key_data(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/bind.rs
  type Bind (line 13) | pub struct Bind<'a> {
  constant FORMAT (line 46) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Bind;
  method body_size_hint (line 48) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 69) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), crate::Error> {

FILE: sqlx-postgres/src/message/close.rs
  constant CLOSE_PORTAL (line 5) | const CLOSE_PORTAL: u8 = b'P';
  constant CLOSE_STATEMENT (line 6) | const CLOSE_STATEMENT: u8 = b'S';
  type Close (line 10) | pub enum Close {
  constant FORMAT (line 16) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Close;
  method body_size_hint (line 18) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 30) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), crate::Error> {

FILE: sqlx-postgres/src/message/command_complete.rs
  type CommandComplete (line 9) | pub struct CommandComplete {
    method rows_affected (line 26) | pub fn rows_affected(&self) -> u64 {
  constant FORMAT (line 16) | const FORMAT: BackendMessageFormat = BackendMessageFormat::CommandComplete;
  method decode_body (line 18) | fn decode_body(bytes: Bytes) -> Result<Self, Error> {
  function test_decode_command_complete_for_insert (line 36) | fn test_decode_command_complete_for_insert() {
  function test_decode_command_complete_for_begin (line 45) | fn test_decode_command_complete_for_begin() {
  function test_decode_command_complete_for_update (line 54) | fn test_decode_command_complete_for_update() {
  function bench_decode_command_complete (line 64) | fn bench_decode_command_complete(b: &mut test::Bencher) {
  function bench_decode_command_complete_rows_affected (line 74) | fn bench_decode_command_complete_rows_affected(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/copy.rs
  type CopyResponseData (line 12) | pub struct CopyResponseData {
    method decode (line 33) | fn decode(mut buf: Bytes) -> Result<Self> {
  type CopyInResponse (line 18) | pub struct CopyInResponse(pub CopyResponseData);
  type CopyOutResponse (line 21) | pub struct CopyOutResponse(pub CopyResponseData);
  type CopyData (line 23) | pub struct CopyData<B>(pub B);
  type CopyFail (line 25) | pub struct CopyFail {
    method new (line 106) | pub fn new(msg: impl Into<String>) -> CopyFail {
  type CopyDone (line 29) | pub struct CopyDone;
  constant FORMAT (line 48) | const FORMAT: BackendMessageFormat = BackendMessageFormat::CopyInResponse;
  method decode_body (line 51) | fn decode_body(buf: Bytes) -> std::result::Result<Self, Error> {
  constant FORMAT (line 57) | const FORMAT: BackendMessageFormat = BackendMessageFormat::CopyOutResponse;
  method decode_body (line 60) | fn decode_body(buf: Bytes) -> std::result::Result<Self, Error> {
  constant FORMAT (line 66) | const FORMAT: BackendMessageFormat = BackendMessageFormat::CopyData;
  method decode_body (line 69) | fn decode_body(buf: Bytes) -> std::result::Result<Self, Error> {
  constant FORMAT (line 75) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::CopyData;
  method body_size_hint (line 78) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 83) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  constant FORMAT (line 90) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::CopyFail;
  method body_size_hint (line 93) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 98) | fn encode_body(&self, buf: &mut Vec<u8>) -> std::result::Result<(), Erro...
  constant FORMAT (line 114) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::CopyDone;
  method body_size_hint (line 116) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 121) | fn encode_body(&self, _buf: &mut Vec<u8>) -> std::result::Result<(), Err...
  constant FORMAT (line 127) | const FORMAT: BackendMessageFormat = BackendMessageFormat::CopyDone;
  method decode_body (line 130) | fn decode_body(bytes: Bytes) -> std::result::Result<Self, Error> {

FILE: sqlx-postgres/src/message/data_row.rs
  type DataRow (line 10) | pub struct DataRow {
    method get (line 21) | pub(crate) fn get(&self, index: usize) -> Option<&'_ [u8]> {
  constant FORMAT (line 29) | const FORMAT: BackendMessageFormat = BackendMessageFormat::DataRow;
  method decode_body (line 31) | fn decode_body(buf: Bytes) -> Result<Self, Error> {
  function test_decode_data_row (line 88) | fn test_decode_data_row() {
  function bench_data_row_get (line 120) | fn bench_data_row_get(b: &mut test::Bencher) {
  function bench_decode_data_row (line 132) | fn bench_decode_data_row(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/describe.rs
  constant DESCRIBE_PORTAL (line 6) | const DESCRIBE_PORTAL: u8 = b'P';
  constant DESCRIBE_STATEMENT (line 7) | const DESCRIBE_STATEMENT: u8 = b'S';
  type Describe (line 12) | pub enum Describe {
  constant FORMAT (line 18) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Describe;
  method body_size_hint (line 20) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 32) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  function test_encode_describe_portal (line 57) | fn test_encode_describe_portal() {
  function test_encode_describe_unnamed_portal (line 69) | fn test_encode_describe_unnamed_portal() {
  function test_encode_describe_statement (line 81) | fn test_encode_describe_statement() {
  function test_encode_describe_unnamed_statement (line 93) | fn test_encode_describe_unnamed_statement() {

FILE: sqlx-postgres/src/message/execute.rs
  type Execute (line 8) | pub struct Execute {
  constant FORMAT (line 18) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Execute;
  method body_size_hint (line 20) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 29) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  function test_encode_execute_named_portal (line 45) | fn test_encode_execute_named_portal() {
  function test_encode_execute_unnamed_portal (line 60) | fn test_encode_execute_unnamed_portal() {

FILE: sqlx-postgres/src/message/flush.rs
  type Flush (line 11) | pub struct Flush;
  constant FORMAT (line 14) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Flush;
  method body_size_hint (line 17) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 22) | fn encode_body(&self, _buf: &mut Vec<u8>) -> Result<(), Error> {

FILE: sqlx-postgres/src/message/mod.rs
  type FrontendMessageFormat (line 68) | pub enum FrontendMessageFormat {
  type BackendMessageFormat (line 92) | pub enum BackendMessageFormat {
    method try_from_u8 (line 146) | pub fn try_from_u8(v: u8) -> Result<Self, Error> {
  type ReceivedMessage (line 117) | pub struct ReceivedMessage {
    method decode (line 124) | pub fn decode<T>(self) -> Result<T, Error>
  type FrontendMessage (line 177) | pub(crate) trait FrontendMessage: Sized {
    constant FORMAT (line 179) | const FORMAT: FrontendMessageFormat;
    method body_size_hint (line 182) | fn body_size_hint(&self) -> Saturating<usize>;
    method encode_body (line 187) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error>;
    method encode_msg (line 191) | fn encode_msg(self, buf: &mut Vec<u8>) -> Result<(), Error> {
  type BackendMessage (line 196) | pub(crate) trait BackendMessage: Sized {
    constant FORMAT (line 200) | const FORMAT: BackendMessageFormat;
    method decode_body (line 205) | fn decode_body(buf: Bytes) -> Result<Self, Error>;
  type EncodeMessage (line 208) | pub struct EncodeMessage<F>(pub F);
  function encode_with (line 211) | fn encode_with(&self, buf: &mut Vec<u8>, _context: ()) -> Result<(), Err...

FILE: sqlx-postgres/src/message/notification.rs
  type Notification (line 8) | pub struct Notification {
  constant FORMAT (line 15) | const FORMAT: BackendMessageFormat = BackendMessageFormat::NotificationR...
  method decode_body (line 17) | fn decode_body(mut buf: Bytes) -> Result<Self, Error> {
  function test_decode_notification_response (line 31) | fn test_decode_notification_response() {

FILE: sqlx-postgres/src/message/parameter_description.rs
  type ParameterDescription (line 9) | pub struct ParameterDescription {
  constant FORMAT (line 14) | const FORMAT: BackendMessageFormat = BackendMessageFormat::ParameterDesc...
  method decode_body (line 16) | fn decode_body(mut buf: Bytes) -> Result<Self, Error> {
  function test_decode_parameter_description (line 31) | fn test_decode_parameter_description() {
  function test_decode_empty_parameter_description (line 42) | fn test_decode_empty_parameter_description() {
  function bench_decode_parameter_description (line 52) | fn bench_decode_parameter_description(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/parameter_status.rs
  type ParameterStatus (line 8) | pub struct ParameterStatus {
  constant FORMAT (line 14) | const FORMAT: BackendMessageFormat = BackendMessageFormat::ParameterStatus;
  method decode_body (line 16) | fn decode_body(mut buf: Bytes) -> Result<Self, Error> {
  function test_decode_parameter_status (line 25) | fn test_decode_parameter_status() {
  function test_decode_empty_parameter_status (line 35) | fn test_decode_empty_parameter_status() {
  function bench_decode_parameter_status (line 46) | fn bench_decode_parameter_status(b: &mut test::Bencher) {
  function test_decode_parameter_status_response (line 55) | fn test_decode_parameter_status_response() {

FILE: sqlx-postgres/src/message/parse.rs
  type Parse (line 9) | pub struct Parse<'a> {
  constant FORMAT (line 23) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Parse;
  method body_size_hint (line 25) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 41) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  function test_encode_parse (line 66) | fn test_encode_parse() {
  function test_encode_parse_unnamed_statement (line 82) | fn test_encode_parse_unnamed_statement() {

FILE: sqlx-postgres/src/message/parse_complete.rs
  type ParseComplete (line 5) | pub struct ParseComplete;
  constant FORMAT (line 8) | const FORMAT: BackendMessageFormat = BackendMessageFormat::ParseComplete;
  method decode_body (line 10) | fn decode_body(_bytes: Bytes) -> Result<Self, Error> {

FILE: sqlx-postgres/src/message/password.rs
  type Password (line 9) | pub enum Password<'a> {
  constant FORMAT (line 20) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::PasswordPol...
  method body_size_hint (line 23) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 47) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  function test_encode_clear_password (line 94) | fn test_encode_clear_password() {
  function test_encode_md5_password (line 106) | fn test_encode_md5_password() {
  function bench_encode_clear_password (line 123) | fn bench_encode_clear_password(b: &mut test::Bencher) {
  function bench_encode_md5_password (line 137) | fn bench_encode_md5_password(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/query.rs
  type Query (line 7) | pub struct Query<'a>(pub &'a str);
  constant FORMAT (line 10) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Query;
  method body_size_hint (line 12) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 21) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  function test_encode_query (line 28) | fn test_encode_query() {

FILE: sqlx-postgres/src/message/ready_for_query.rs
  type TransactionStatus (line 8) | pub enum TransactionStatus {
  type ReadyForQuery (line 20) | pub struct ReadyForQuery {
  constant FORMAT (line 25) | const FORMAT: BackendMessageFormat = BackendMessageFormat::ReadyForQuery;
  method decode_body (line 27) | fn decode_body(buf: Bytes) -> Result<Self, Error> {
  function test_decode_ready_for_query (line 48) | fn test_decode_ready_for_query() -> Result<(), Error> {

FILE: sqlx-postgres/src/message/response.rs
  type PgSeverity (line 14) | pub enum PgSeverity {
    method is_error (line 27) | pub fn is_error(self) -> bool {
    type Error (line 33) | type Error = Error;
    method try_from (line 35) | fn try_from(s: &str) -> Result<PgSeverity, Error> {
  type Notice (line 56) | pub struct Notice {
    method severity (line 65) | pub fn severity(&self) -> PgSeverity {
    method code (line 70) | pub fn code(&self) -> &str {
    method message (line 75) | pub fn message(&self) -> &str {
    method get (line 83) | pub fn get(&self, ty: u8) -> Option<&str> {
    method get_raw (line 87) | pub fn get_raw(&self, ty: u8) -> Option<&[u8]> {
    method fields (line 97) | fn fields(&self) -> Fields<'_> {
    method get_cached_str (line 105) | fn get_cached_str(&self, cache: Range<usize>) -> &str {
    method decode_with (line 112) | fn decode_with(buf: Bytes, _: ()) -> Result<Self, Error> {
  constant FORMAT (line 184) | const FORMAT: BackendMessageFormat = BackendMessageFormat::NoticeResponse;
  method decode_body (line 186) | fn decode_body(buf: Bytes) -> Result<Self, Error> {
  type Fields (line 193) | struct Fields<'a> {
  type Item (line 199) | type Item = (u8, Range<usize>);
  method next (line 201) | fn next(&mut self) -> Option<Self::Item> {
  function notice_protocol_err (line 226) | fn notice_protocol_err() -> Error {
  function test_decode_error_response (line 238) | fn test_decode_error_response() {
  function bench_error_response_get_message (line 254) | fn bench_error_response_get_message(b: &mut test::Bencher) {
  function bench_decode_error_response (line 266) | fn bench_decode_error_response(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/row_description.rs
  type RowDescription (line 9) | pub struct RowDescription {
  type Field (line 14) | pub struct Field {
  constant FORMAT (line 45) | const FORMAT: BackendMessageFormat = BackendMessageFormat::RowDescription;
  method decode_body (line 47) | fn decode_body(mut buf: Bytes) -> Result<Self, Error> {

FILE: sqlx-postgres/src/message/sasl.rs
  type SaslInitialResponse (line 6) | pub struct SaslInitialResponse<'a> {
  function selected_mechanism (line 13) | fn selected_mechanism(&self) -> &'static str {
  constant FORMAT (line 23) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::PasswordPol...
  method body_size_hint (line 26) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 38) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {
  type SaslResponse (line 56) | pub struct SaslResponse<'a>(pub &'a str);
  constant FORMAT (line 59) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::PasswordPol...
  method body_size_hint (line 61) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 65) | fn encode_body(&self, buf: &mut Vec<u8>) -> Result<(), Error> {

FILE: sqlx-postgres/src/message/ssl_request.rs
  type SslRequest (line 3) | pub struct SslRequest;
    constant BYTES (line 7) | pub const BYTES: &'static [u8] = b"\x00\x00\x00\x08\x04\xd2\x16\x2f";
    method encode_with (line 13) | fn encode_with(&self, buf: &mut Vec<u8>, _context: ()) -> Result<(), c...
  function test_encode_ssl_request (line 20) | fn test_encode_ssl_request() {

FILE: sqlx-postgres/src/message/startup.rs
  type Startup (line 10) | pub struct Startup<'a> {
  function encode_with (line 24) | fn encode_with(&self, buf: &mut Vec<u8>, _context: ()) -> Result<(), cra...
  function encode_startup_param (line 58) | fn encode_startup_param(buf: &mut Vec<u8>, name: &str, value: &str) {
  function test_encode_startup (line 64) | fn test_encode_startup() {
  function bench_encode_startup (line 81) | fn bench_encode_startup(b: &mut test::Bencher) {

FILE: sqlx-postgres/src/message/sync.rs
  type Sync (line 6) | pub struct Sync;
  constant FORMAT (line 9) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Sync;
  method body_size_hint (line 12) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 17) | fn encode_body(&self, _buf: &mut Vec<u8>) -> Result<(), Error> {

FILE: sqlx-postgres/src/message/terminate.rs
  type Terminate (line 5) | pub struct Terminate;
  constant FORMAT (line 8) | const FORMAT: FrontendMessageFormat = FrontendMessageFormat::Terminate;
  method body_size_hint (line 11) | fn body_size_hint(&self) -> Saturating<usize> {
  method encode_body (line 16) | fn encode_body(&self, _buf: &mut Vec<u8>) -> Result<(), Error> {

FILE: sqlx-postgres/src/migrate.rs
  function parse_for_maintenance (line 20) | fn parse_for_maintenance(url: &str) -> Result<(PgConnectOptions, String)...
  method create_database (line 43) | async fn create_database(url: &str) -> Result<(), Error> {
  method database_exists (line 57) | async fn database_exists(url: &str) -> Result<bool, Error> {
  method drop_database (line 70) | async fn drop_database(url: &str) -> Result<(), Error> {
  method force_drop_database (line 84) | async fn force_drop_database(url: &str) -> Result<(), Error> {
  method create_schema_if_not_exists (line 107) | fn create_schema_if_not_exists<'e>(
  method ensure_migrations_table (line 122) | fn ensure_migrations_table<'e>(
  method dirty_version (line 146) | fn dirty_version<'e>(
  method list_applied_migrations (line 162) | fn list_applied_migrations<'e>(
  method lock (line 186) | fn lock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method unlock (line 207) | fn unlock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method apply (line 222) | fn apply<'e>(
  method revert (line 267) | fn revert<'e>(
  function execute_migration (line 293) | async fn execute_migration(
  function revert_migration (line 319) | async fn revert_migration(
  function current_database (line 340) | async fn current_database(conn: &mut PgConnection) -> Result<String, Mig...
  function generate_lock_id (line 348) | fn generate_lock_id(database_name: &str) -> i64 {

FILE: sqlx-postgres/src/options/connect.rs
  type Connection (line 10) | type Connection = PgConnection;
  method from_url (line 12) | fn from_url(url: &Url) -> Result<Self, Error> {
  method to_url_lossy (line 16) | fn to_url_lossy(&self) -> Url {
  method connect (line 20) | fn connect(&self) -> impl Future<Output = Result<Self::Connection, Error...
  method log_statements (line 27) | fn log_statements(mut self, level: LevelFilter) -> Self {
  method log_slow_statements (line 32) | fn log_slow_statements(mut self, level: LevelFilter, duration: Duration)...

FILE: sqlx-postgres/src/options/mod.rs
  type PgConnectOptions (line 17) | pub struct PgConnectOptions {
    method new (line 47) | pub fn new() -> Self {
    method new_without_pgpass (line 56) | pub fn new_without_pgpass() -> Self {
    method apply_pgpass (line 103) | pub(crate) fn apply_pgpass(mut self) -> Self {
    method host (line 132) | pub fn host(mut self, host: &str) -> Self {
    method port (line 148) | pub fn port(mut self, port: u16) -> Self {
    method socket (line 157) | pub fn socket(mut self, path: impl AsRef<Path>) -> Self {
    method username (line 174) | pub fn username(mut self, username: &str) -> Self {
    method password (line 189) | pub fn password(mut self, password: &str) -> Self {
    method database (line 203) | pub fn database(mut self, database: &str) -> Self {
    method ssl_mode (line 223) | pub fn ssl_mode(mut self, mode: PgSslMode) -> Self {
    method ssl_root_cert (line 241) | pub fn ssl_root_cert(mut self, cert: impl AsRef<Path>) -> Self {
    method ssl_client_cert (line 257) | pub fn ssl_client_cert(mut self, cert: impl AsRef<Path>) -> Self {
    method ssl_client_cert_from_pem (line 283) | pub fn ssl_client_cert_from_pem(mut self, cert: impl AsRef<[u8]>) -> S...
    method ssl_client_key (line 299) | pub fn ssl_client_key(mut self, key: impl AsRef<Path>) -> Self {
    method ssl_client_key_from_pem (line 325) | pub fn ssl_client_key_from_pem(mut self, key: impl AsRef<[u8]>) -> Self {
    method ssl_root_cert_from_pem (line 341) | pub fn ssl_root_cert_from_pem(mut self, pem_certificate: Vec<u8>) -> S...
    method statement_cache_capacity (line 352) | pub fn statement_cache_capacity(mut self, capacity: usize) -> Self {
    method application_name (line 366) | pub fn application_name(mut self, application_name: &str) -> Self {
    method extra_float_digits (line 419) | pub fn extra_float_digits(mut self, extra_float_digits: impl Into<Opti...
    method options (line 436) | pub fn options<K, V, I>(mut self, options: I) -> Self
    method fetch_socket (line 457) | pub(crate) fn fetch_socket(&self) -> Option<String> {
    method get_host (line 483) | pub fn get_host(&self) -> &str {
    method get_port (line 497) | pub fn get_port(&self) -> u16 {
    method get_socket (line 511) | pub fn get_socket(&self) -> Option<&PathBuf> {
    method get_username (line 525) | pub fn get_username(&self) -> &str {
    method get_database (line 539) | pub fn get_database(&self) -> Option<&str> {
    method get_ssl_mode (line 552) | pub fn get_ssl_mode(&self) -> PgSslMode {
    method get_application_name (line 566) | pub fn get_application_name(&self) -> Option<&str> {
    method get_options (line 580) | pub fn get_options(&self) -> Option<&str> {
  method default (line 36) | fn default() -> Self {
  function default_host (line 585) | fn default_host(port: u16) -> String {
  type PgOptionsWriteEscaped (line 609) | struct PgOptionsWriteEscaped<'a>(&'a mut String);
  method write_str (line 612) | fn write_str(&mut self, s: &str) -> fmt::Result {
  method write_char (line 626) | fn write_char(&mut self, ch: char) -> fmt::Result {
  function test_options_formatting (line 638) | fn test_options_formatting() {
  function test_pg_write_escaped (line 663) | fn test_pg_write_escaped() {

FILE: sqlx-postgres/src/options/parse.rs
  method parse_from_url (line 9) | pub(crate) fn parse_from_url(url: &Url) -> Result<Self, Error> {
  method build_url (line 116) | pub(crate) fn build_url(&self) -> Url {
  type Err (line 174) | type Err = Error;
  method from_str (line 176) | fn from_str(s: &str) -> Result<Self, Error> {
  function it_parses_socket_correctly_from_parameter (line 184) | fn it_parses_socket_correctly_from_parameter() {
  function it_parses_host_correctly_from_parameter (line 192) | fn it_parses_host_correctly_from_parameter() {
  function it_parses_hostaddr_correctly_from_parameter (line 201) | fn it_parses_hostaddr_correctly_from_parameter() {
  function it_parses_port_correctly_from_parameter (line 210) | fn it_parses_port_correctly_from_parameter() {
  function it_parses_dbname_correctly_from_parameter (line 219) | fn it_parses_dbname_correctly_from_parameter() {
  function it_parses_user_correctly_from_parameter (line 228) | fn it_parses_user_correctly_from_parameter() {
  function it_parses_password_correctly_from_parameter (line 237) | fn it_parses_password_correctly_from_parameter() {
  function it_parses_application_name_correctly_from_parameter (line 246) | fn it_parses_application_name_correctly_from_parameter() {
  function it_parses_username_with_at_sign_correctly (line 254) | fn it_parses_username_with_at_sign_correctly() {
  function it_parses_password_with_non_ascii_chars_correctly (line 262) | fn it_parses_password_with_non_ascii_chars_correctly() {
  function it_parses_socket_correctly_percent_encoded (line 270) | fn it_parses_socket_correctly_percent_encoded() {
  function it_parses_socket_correctly_with_username_percent_encoded (line 277) | fn it_parses_socket_correctly_with_username_percent_encoded() {
  function it_parses_libpq_options_correctly (line 286) | fn it_parses_libpq_options_correctly() {
  function it_parses_sqlx_options_correctly (line 296) | fn it_parses_sqlx_options_correctly() {
  function it_returns_the_parsed_url_when_socket (line 307) | fn it_returns_the_parsed_url_when_socket() {
  function it_returns_the_parsed_url_when_host (line 322) | fn it_returns_the_parsed_url_when_host() {
  function built_url_can_be_parsed (line 335) | fn built_url_can_be_parsed() {

FILE: sqlx-postgres/src/options/pgpass.rs
  function load_password (line 8) | pub fn load_password(
  function load_password_from_file (line 39) | fn load_password_from_file(
  function load_password_from_reader (line 88) | fn load_password_from_reader(
  function load_password_from_line (line 129) | fn load_password_from_line(
  function matches_next_field (line 153) | fn matches_next_field(whole_line: &str, line: &mut &str, value: &str) ->...
  function find_next_field (line 173) | fn find_next_field<'a>(line: &mut &'a str) -> Option<Cow<'a, str>> {
  function test_find_next_field (line 215) | fn test_find_next_field() {
  function test_load_password_from_line (line 265) | fn test_load_password_from_line() {
  function test_load_password_from_reader (line 313) | fn test_load_password_from_reader() {

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

FILE: sqlx-postgres/src/query_result.rs
  type PgQueryResult (line 4) | pub struct PgQueryResult {
    method rows_affected (line 9) | pub fn rows_affected(&self) -> u64 {
    method extend (line 15) | fn extend<T: IntoIterator<Item = PgQueryResult>>(&mut self, iter: T) {
  function from (line 24) | fn from(done: PgQueryResult) -> Self {

FILE: sqlx-postgres/src/row.rs
  type PgRow (line 12) | pub struct PgRow {
    method fmt (line 53) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Database (line 19) | type Database = Postgres;
  method columns (line 21) | fn columns(&self) -> &[PgColumn] {
  method try_get_raw (line 25) | fn try_get_raw<I>(&self, index: I) -> Result<PgValueRef<'_>, Error>
  function index (line 43) | fn index(&self, row: &PgRow) -> Result<usize, Error> {

FILE: sqlx-postgres/src/statement.rs
  type PgStatement (line 13) | pub struct PgStatement {
  type PgStatementMetadata (line 19) | pub(crate) struct PgStatementMetadata {
  type Database (line 28) | type Database = Postgres;
  method into_sql (line 30) | fn into_sql(self) -> SqlStr {
  method sql (line 34) | fn sql(&self) -> &SqlStr {
  method parameters (line 38) | fn parameters(&self) -> Option<Either<&[PgTypeInfo], usize>> {
  method columns (line 42) | fn columns(&self) -> &[PgColumn] {
  function index (line 50) | fn index(&self, statement: &PgStatement) -> Result<usize, Error> {

FILE: sqlx-postgres/src/testing/mod.rs
  method test_context (line 25) | fn test_context(
  method cleanup_test (line 31) | async fn cleanup_test(db_name: &str) -> Result<(), Error> {
  method cleanup_test_dbs (line 41) | async fn cleanup_test_dbs() -> Result<Option<usize>, Error> {
  method snapshot (line 85) | async fn snapshot(_conn: &mut Self::Connection) -> Result<FixtureSnapsho...
  function test_context (line 92) | async fn test_context(args: &TestArgs) -> Result<TestContext<Postgres>, ...
  function do_cleanup (line 189) | async fn do_cleanup(conn: &mut PgConnection, db_name: &str) -> Result<()...
  function once_lock_try_insert_polyfill (line 200) | fn once_lock_try_insert_polyfill<T>(this: &OnceLock<T>, value: T) -> Res...

FILE: sqlx-postgres/src/transaction.rs
  type PgTransactionManager (line 12) | pub struct PgTransactionManager;
  type Database (line 15) | type Database = Postgres;
  method begin (line 17) | async fn begin(conn: &mut PgConnection, statement: Option<SqlStr>) -> Re...
  method commit (line 40) | async fn commit(conn: &mut PgConnection) -> Result<(), Error> {
  method rollback (line 51) | async fn rollback(conn: &mut PgConnection) -> Result<(), Error> {
  method start_rollback (line 62) | fn start_rollback(conn: &mut PgConnection) {
  method get_transaction_depth (line 73) | fn get_transaction_depth(conn: &<Self::Database as Database>::Connection...
  type Rollback (line 78) | struct Rollback<'c> {
  method drop (line 84) | fn drop(&mut self) {
  function new (line 92) | fn new(conn: &'c mut PgConnection) -> Self {
  function defuse (line 98) | fn defuse(mut self) {

FILE: sqlx-postgres/src/type_info.rs
  type PgTypeInfo (line 44) | pub struct PgTypeInfo(pub(crate) PgType);
    method try_from_oid (line 197) | pub(crate) fn try_from_oid(oid: Oid) -> Option<Self> {
    method kind (line 202) | pub fn kind(&self) -> &PgTypeKind {
    method oid (line 221) | pub fn oid(&self) -> Option<Oid> {
    method __type_feature_gate (line 226) | pub fn __type_feature_gate(&self) -> Option<&'static str> {
    method with_name (line 310) | pub const fn with_name(name: &'static str) -> Self {
    method array_of (line 318) | pub fn array_of(elem_name: &'static str) -> Self {
    method with_oid (line 336) | pub const fn with_oid(oid: Oid) -> Self {
    method type_eq (line 343) | pub fn type_eq(&self, other: &Self) -> bool {
    constant BOOL (line 1081) | pub(crate) const BOOL: Self = Self(PgType::Bool);
    constant BOOL_ARRAY (line 1082) | pub(crate) const BOOL_ARRAY: Self = Self(PgType::BoolArray);
    constant BYTEA (line 1085) | pub(crate) const BYTEA: Self = Self(PgType::Bytea);
    constant BYTEA_ARRAY (line 1086) | pub(crate) const BYTEA_ARRAY: Self = Self(PgType::ByteaArray);
    constant UUID (line 1089) | pub(crate) const UUID: Self = Self(PgType::Uuid);
    constant UUID_ARRAY (line 1090) | pub(crate) const UUID_ARRAY: Self = Self(PgType::UuidArray);
    constant RECORD (line 1093) | pub(crate) const RECORD: Self = Self(PgType::Record);
    constant RECORD_ARRAY (line 1094) | pub(crate) const RECORD_ARRAY: Self = Self(PgType::RecordArray);
    constant JSON (line 1101) | pub(crate) const JSON: Self = Self(PgType::Json);
    constant JSON_ARRAY (line 1102) | pub(crate) const JSON_ARRAY: Self = Self(PgType::JsonArray);
    constant JSONB (line 1104) | pub(crate) const JSONB: Self = Self(PgType::Jsonb);
    constant JSONB_ARRAY (line 1105) | pub(crate) const JSONB_ARRAY: Self = Self(PgType::JsonbArray);
    constant JSONPATH (line 1107) | pub(crate) const JSONPATH: Self = Self(PgType::Jsonpath);
    constant JSONPATH_ARRAY (line 1108) | pub(crate) const JSONPATH_ARRAY: Self = Self(PgType::JsonpathArray);
    constant CIDR (line 1115) | pub(crate) const CIDR: Self = Self(PgType::Cidr);
    constant CIDR_ARRAY (line 1116) | pub(crate) const CIDR_ARRAY: Self = Self(PgType::CidrArray);
    constant INET (line 1118) | pub(crate) const INET: Self = Self(PgType::Inet);
    constant INET_ARRAY (line 1119) | pub(crate) const INET_ARRAY: Self = Self(PgType::InetArray);
    constant MACADDR (line 1121) | pub(crate) const MACADDR: Self = Self(PgType::Macaddr);
    constant MACADDR_ARRAY (line 1122) | pub(crate) const MACADDR_ARRAY: Self = Self(PgType::MacaddrArray);
    constant MACADDR8 (line 1124) | pub(crate) const MACADDR8: Self = Self(PgType::Macaddr8);
    constant MACADDR8_ARRAY (line 1125) | pub(crate) const MACADDR8_ARRAY: Self = Self(PgType::Macaddr8Array);
    constant NAME (line 1133) | pub(crate) const NAME: Self = Self(PgType::Name);
    constant NAME_ARRAY (line 1134) | pub(crate) const NAME_ARRAY: Self = Self(PgType::NameArray);
    constant BPCHAR (line 1137) | pub(crate) const BPCHAR: Self = Self(PgType::Bpchar);
    constant BPCHAR_ARRAY (line 1138) | pub(crate) const BPCHAR_ARRAY: Self = Self(PgType::BpcharArray);
    constant VARCHAR (line 1141) | pub(crate) const VARCHAR: Self = Self(PgType::Varchar);
    constant VARCHAR_ARRAY (line 1142) | pub(crate) const VARCHAR_ARRAY: Self = Self(PgType::VarcharArray);
    constant TEXT (line 1145) | pub(crate) const TEXT: Self = Self(PgType::Text);
    constant TEXT_ARRAY (line 1146) | pub(crate) const TEXT_ARRAY: Self = Self(PgType::TextArray);
    constant UNKNOWN (line 1149) | pub(crate) const UNKNOWN: Self = Self(PgType::Unknown);
    constant CHAR (line 1157) | pub(crate) const CHAR: Self = Self(PgType::Char);
    constant CHAR_ARRAY (line 1158) | pub(crate) const CHAR_ARRAY: Self = Self(PgType::CharArray);
    constant OID (line 1161) | pub(crate) const OID: Self = Self(PgType::Oid);
    constant OID_ARRAY (line 1162) | pub(crate) const OID_ARRAY: Self = Self(PgType::OidArray);
    constant INT2 (line 1165) | pub(crate) const INT2: Self = Self(PgType::Int2);
    constant INT2_ARRAY (line 1166) | pub(crate) const INT2_ARRAY: Self = Self(PgType::Int2Array);
    constant INT4 (line 1169) | pub(crate) const INT4: Self = Self(PgType::Int4);
    constant INT4_ARRAY (line 1170) | pub(crate) const INT4_ARRAY: Self = Self(PgType::Int4Array);
    constant INT8 (line 1173) | pub(crate) const INT8: Self = Self(PgType::Int8);
    constant INT8_ARRAY (line 1174) | pub(crate) const INT8_ARRAY: Self = Self(PgType::Int8Array);
    constant FLOAT4 (line 1177) | pub(crate) const FLOAT4: Self = Self(PgType::Float4);
    constant FLOAT4_ARRAY (line 1178) | pub(crate) const FLOAT4_ARRAY: Self = Self(PgType::Float4Array);
    constant FLOAT8 (line 1181) | pub(crate) const FLOAT8: Self = Self(PgType::Float8);
    constant FLOAT8_ARRAY (line 1182) | pub(crate) const FLOAT8_ARRAY: Self = Self(PgType::Float8Array);
    constant NUMERIC (line 1185) | pub(crate) const NUMERIC: Self = Self(PgType::Numeric);
    constant NUMERIC_ARRAY (line 1186) | pub(crate) const NUMERIC_ARRAY: Self = Self(PgType::NumericArray);
    constant MONEY (line 1189) | pub(crate) const MONEY: Self = Self(PgType::Money);
    constant MONEY_ARRAY (line 1190) | pub(crate) const MONEY_ARRAY: Self = Self(PgType::MoneyArray);
    constant TIMESTAMP (line 1198) | pub(crate) const TIMESTAMP: Self = Self(PgType::Timestamp);
    constant TIMESTAMP_ARRAY (line 1199) | pub(crate) const TIMESTAMP_ARRAY: Self = Self(PgType::TimestampArray);
    constant TIMESTAMPTZ (line 1202) | pub(crate) const TIMESTAMPTZ: Self = Self(PgType::Timestamptz);
    constant TIMESTAMPTZ_ARRAY (line 1203) | pub(crate) const TIMESTAMPTZ_ARRAY: Self = Self(PgType::TimestamptzArr...
    constant DATE (line 1206) | pub(crate) const DATE: Self = Self(PgType::Date);
    constant DATE_ARRAY (line 1207) | pub(crate) const DATE_ARRAY: Self = Self(PgType::DateArray);
    constant TIME (line 1210) | pub(crate) const TIME: Self = Self(PgType::Time);
    constant TIME_ARRAY (line 1211) | pub(crate) const TIME_ARRAY: Self = Self(PgType::TimeArray);
    constant TIMETZ (line 1214) | pub(crate) const TIMETZ: Self = Self(PgType::Timetz);
    constant TIMETZ_ARRAY (line 1215) | pub(crate) const TIMETZ_ARRAY: Self = Self(PgType::TimetzArray);
    constant INTERVAL (line 1218) | pub(crate) const INTERVAL: Self = Self(PgType::Interval);
    constant INTERVAL_ARRAY (line 1219) | pub(crate) const INTERVAL_ARRAY: Self = Self(PgType::IntervalArray);
    constant POINT (line 1227) | pub(crate) const POINT: Self = Self(PgType::Point);
    constant POINT_ARRAY (line 1228) | pub(crate) const POINT_ARRAY: Self = Self(PgType::PointArray);
    constant LINE (line 1231) | pub(crate) const LINE: Self = Self(PgType::Line);
    constant LINE_ARRAY (line 1232) | pub(crate) const LINE_ARRAY: Self = Self(PgType::LineArray);
    constant LSEG (line 1235) | pub(crate) const LSEG: Self = Self(PgType::Lseg);
    constant LSEG_ARRAY (line 1236) | pub(crate) const LSEG_ARRAY: Self = Self(PgType::LsegArray);
    constant BOX (line 1239) | pub(crate) const BOX: Self = Self(PgType::Box);
    constant BOX_ARRAY (line 1240) | pub(crate) const BOX_ARRAY: Self = Self(PgType::BoxArray);
    constant PATH (line 1243) | pub(crate) const PATH: Self = Self(PgType::Path);
    constant PATH_ARRAY (line 1244) | pub(crate) const PATH_ARRAY: Self = Self(PgType::PathArray);
    constant POLYGON (line 1247) | pub(crate) const POLYGON: Self = Self(PgType::Polygon);
    constant POLYGON_ARRAY (line 1248) | pub(crate) const POLYGON_ARRAY: Self = Self(PgType::PolygonArray);
    constant CIRCLE (line 1251) | pub(crate) const CIRCLE: Self = Self(PgType::Circle);
    constant CIRCLE_ARRAY (line 1252) | pub(crate) const CIRCLE_ARRAY: Self = Self(PgType::CircleArray);
    constant BIT (line 1259) | pub(crate) const BIT: Self = Self(PgType::Bit);
    constant BIT_ARRAY (line 1260) | pub(crate) const BIT_ARRAY: Self = Self(PgType::BitArray);
    constant VARBIT (line 1262) | pub(crate) const VARBIT: Self = Self(PgType::Varbit);
    constant VARBIT_ARRAY (line 1263) | pub(crate) const VARBIT_ARRAY: Self = Self(PgType::VarbitArray);
    constant INT4_RANGE (line 1270) | pub(crate) const INT4_RANGE: Self = Self(PgType::Int4Range);
    constant INT4_RANGE_ARRAY (line 1271) | pub(crate) const INT4_RANGE_ARRAY: Self = Self(PgType::Int4RangeArray);
    constant NUM_RANGE (line 1273) | pub(crate) const NUM_RANGE: Self = Self(PgType::NumRange);
    constant NUM_RANGE_ARRAY (line 1274) | pub(crate) const NUM_RANGE_ARRAY: Self = Self(PgType::NumRangeArray);
    constant TS_RANGE (line 1276) | pub(crate) const TS_RANGE: Self = Self(PgType::TsRange);
    constant TS_RANGE_ARRAY (line 1277) | pub(crate) const TS_RANGE_ARRAY: Self = Self(PgType::TsRangeArray);
    constant TSTZ_RANGE (line 1279) | pub(crate) const TSTZ_RANGE: Self = Self(PgType::TstzRange);
    constant TSTZ_RANGE_ARRAY (line 1280) | pub(crate) const TSTZ_RANGE_ARRAY: Self = Self(PgType::TstzRangeArray);
    constant DATE_RANGE (line 1282) | pub(crate) const DATE_RANGE: Self = Self(PgType::DateRange);
    constant DATE_RANGE_ARRAY (line 1283) | pub(crate) const DATE_RANGE_ARRAY: Self = Self(PgType::DateRangeArray);
    constant INT8_RANGE (line 1285) | pub(crate) const INT8_RANGE: Self = Self(PgType::Int8Range);
    constant INT8_RANGE_ARRAY (line 1286) | pub(crate) const INT8_RANGE_ARRAY: Self = Self(PgType::Int8RangeArray);
    constant VOID (line 1293) | pub(crate) const VOID: Self = Self(PgType::Void);
  type Target (line 47) | type Target = PgType;
  method deref (line 49) | fn deref(&self) -> &Self::Target {
  type PgType (line 57) | pub enum PgType {
    method try_from_oid (line 356) | pub(crate) fn try_from_oid(oid: Oid) -> Option<Self> {
    method oid (line 457) | pub(crate) fn oid(&self) -> Oid {
    method try_oid (line 464) | pub(crate) fn try_oid(&self) -> Option<Oid> {
    method display_name (line 571) | pub(crate) fn display_name(&self) -> &str {
    method name (line 672) | pub(crate) fn name(&self) -> &str {
    method kind (line 773) | pub(crate) fn kind(&self) -> &PgTypeKind {
    method try_array_element (line 887) | pub(crate) fn try_array_element(&self) -> Option<Cow<'_, PgTypeInfo>> {
    method is_declare_with_oid (line 1007) | fn is_declare_with_oid(&self) -> bool {
    method eq_impl (line 1015) | fn eq_impl(&self, other: &Self, soft_eq: bool) -> bool {
    method try_base_oid (line 1041) | fn try_base_oid(&self) -> Option<Oid> {
    method eq (line 1303) | fn eq(&self, other: &PgType) -> bool {
  type PgCustomType (line 169) | pub struct PgCustomType {
    method eq (line 1074) | fn eq(&self, other: &PgCustomType) -> bool {
  type PgTypeKind (line 178) | pub enum PgTypeKind {
  type PgArrayOf (line 190) | pub struct PgArrayOf {
  method name (line 1053) | fn name(&self) -> &str {
  method is_null (line 1057) | fn is_null(&self) -> bool {
  method is_void (line 1061) | fn is_void(&self) -> bool {
  method type_compatible (line 1065) | fn type_compatible(&self, other: &Self) -> bool
  method fmt (line 1297) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function name_eq (line 1311) | fn name_eq(name1: &str, name2: &str) -> bool {
  type IdentifierChar (line 1330) | struct IdentifierChar {
    method eq (line 1336) | fn eq(&self, other: &Self) -> bool {
  function identifier_chars (line 1348) | fn identifier_chars(ident: &str) -> impl Iterator<Item = IdentifierChar>...
  function test_name_eq (line 1370) | fn test_name_eq() {

FILE: sqlx-postgres/src/types/array.rs
  type PgHasArrayType (line 50) | pub trait PgHasArrayType {
    method array_type_info (line 51) | fn array_type_info() -> PgTypeInfo;
    method array_compatible (line 52) | fn array_compatible(ty: &PgTypeInfo) -> bool {
    method array_type_info (line 61) | fn array_type_info() -> PgTypeInfo {
    method array_compatible (line 65) | fn array_compatible(ty: &PgTypeInfo) -> bool {
    method array_type_info (line 74) | fn array_type_info() -> PgTypeInfo {
    method array_compatible (line 78) | fn array_compatible(ty: &PgTypeInfo) -> bool {
    method array_type_info (line 84) | fn array_type_info() -> PgTypeInfo {
    method array_compatible (line 88) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 97) | fn type_info() -> PgTypeInfo {
  function compatible (line 101) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 110) | fn type_info() -> PgTypeInfo {
  function compatible (line 114) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 123) | fn type_info() -> PgTypeInfo {
  function compatible (line 127) | fn compatible(ty: &PgTypeInfo) -> bool {
  function encode_by_ref (line 138) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function encode_by_ref (line 148) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function encode_by_ref (line 157) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 173) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode (line 186) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/bigdecimal.rs
  method type_info (line 13) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 19) | fn array_type_info() -> PgTypeInfo {
  type Error (line 25) | type Error = BoxDynError;
  method try_from (line 27) | fn try_from(numeric: PgNumeric) -> Result<Self, BoxDynError> {
  type Error (line 33) | type Error = BoxDynError;
  method try_from (line 35) | fn try_from(numeric: &'_ PgNumeric) -> Result<Self, Self::Error> {
  type Error (line 93) | type Error = BoxDynError;
  method try_from (line 95) | fn try_from(decimal: &BigDecimal) -> Result<Self, BoxDynError> {
  method encode_by_ref (line 185) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 191) | fn size_hint(&self) -> usize {
  method decode (line 200) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function sign_to_pg (line 208) | fn sign_to_pg(sign: Sign) -> PgNumericSign {
  function zero (line 222) | fn zero() {
  function one (line 237) | fn one() {
  function ten (line 251) | fn ten() {
  function one_hundred (line 265) | fn one_hundred() {
  function ten_thousand (line 279) | fn ten_thousand() {
  function two_digits (line 294) | fn two_digits() {
  function one_tenth (line 308) | fn one_tenth() {
  function one_hundredth (line 322) | fn one_hundredth() {
  function twelve_thousandths (line 336) | fn twelve_thousandths() {
  function decimal_1 (line 350) | fn decimal_1() {
  function decimal_2 (line 364) | fn decimal_2() {
  function decimal_3 (line 378) | fn decimal_3() {
  function decimal_4 (line 392) | fn decimal_4() {
  function one_digit_decimal (line 406) | fn one_digit_decimal() {
  function issue_423_four_digit (line 420) | fn issue_423_four_digit() {
  function issue_423_negative_four_digit (line 435) | fn issue_423_negative_four_digit() {
  function issue_423_eight_digit (line 450) | fn issue_423_eight_digit() {
  function issue_423_negative_eight_digit (line 465) | fn issue_423_negative_eight_digit() {

FILE: sqlx-postgres/src/types/bit_vec.rs
  method type_info (line 14) | fn type_info() -> PgTypeInfo {
  method compatible (line 18) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 24) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 28) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method encode_by_ref (line 34) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 43) | fn size_hint(&self) -> usize {
  method decode (line 49) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/bool.rs
  function type_info (line 8) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 14) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 20) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 28) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/bytes.rs
  method array_type_info (line 12) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 18) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 24) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 30) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 36) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 42) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function encode_by_ref (line 50) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function encode_by_ref (line 56) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 62) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function text_hex_decode_input (line 72) | fn text_hex_decode_input(value: PgValueRef<'_>) -> Result<&[u8], BoxDynE...
  function decode (line 82) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function decode (line 91) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/chrono/date.rs
  method type_info (line 12) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 18) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 24) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 36) | fn size_hint(&self) -> usize {
  method decode (line 42) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function postgres_epoch_date (line 62) | fn postgres_epoch_date() -> NaiveDate {

FILE: sqlx-postgres/src/types/chrono/datetime.rs
  method type_info (line 12) | fn type_info() -> PgTypeInfo {
  function type_info (line 18) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 24) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 30) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 36) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 45) | fn size_hint(&self) -> usize {
  method decode (line 51) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode_by_ref (line 78) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function size_hint (line 82) | fn size_hint(&self) -> usize {
  function decode (line 88) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode (line 95) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode (line 102) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function postgres_epoch_datetime (line 128) | fn postgres_epoch_datetime() -> NaiveDateTime {

FILE: sqlx-postgres/src/types/chrono/time.rs
  method type_info (line 10) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 16) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 22) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 31) | fn size_hint(&self) -> usize {
  method decode (line 37) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function check_naive_time_default_is_midnight (line 51) | fn check_naive_time_default_is_midnight() {

FILE: sqlx-postgres/src/types/citext.rs
  type PgCiText (line 39) | pub struct PgCiText(pub String);
    method type_info (line 42) | fn type_info() -> PgTypeInfo {
    method compatible (line 47) | fn compatible(ty: &PgTypeInfo) -> bool {
    method from (line 61) | fn from(value: String) -> Self {
    method encode_by_ref (line 97) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method decode (line 103) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  type Target (line 53) | type Target = str;
  method deref (line 55) | fn deref(&self) -> &Self::Target {
  method from (line 67) | fn from(value: PgCiText) -> Self {
  type Err (line 73) | type Err = core::convert::Infallible;
  method from_str (line 75) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 81) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method array_type_info (line 87) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 91) | fn array_compatible(ty: &PgTypeInfo) -> bool {

FILE: sqlx-postgres/src/types/cube.rs
  constant BYTE_WIDTH (line 11) | const BYTE_WIDTH: usize = 8;
  constant MAX_DIMENSIONS (line 14) | const MAX_DIMENSIONS: usize = 100;
  constant IS_POINT_FLAG (line 16) | const IS_POINT_FLAG: u32 = 1 << 31;
  type PgCube (line 21) | pub enum PgCube {
    method type_info (line 54) | fn type_info() -> PgTypeInfo {
    method decode (line 66) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 75) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 79) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method size_hint (line 84) | fn size_hint(&self) -> usize {
    method header (line 118) | fn header(&self) -> Header {
    method from_bytes (line 139) | fn from_bytes(mut bytes: &[u8]) -> Result<Self, BoxDynError> {
    method serialize (line 167) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), String> {
    method serialize_to_vec (line 201) | fn serialize_to_vec(&self) -> Vec<u8> {
  type Header (line 40) | struct Header {
    constant PACKED_WIDTH (line 308) | const PACKED_WIDTH: usize = mem::size_of::<u32>();
    method encoded_size (line 310) | fn encoded_size(&self) -> usize {
    method data_size (line 314) | fn data_size(&self) -> usize {
    method try_write (line 322) | fn try_write(&self, buff: &mut PgArgumentBuffer) -> Result<(), String> {
    method try_read (line 344) | fn try_read(buf: &mut &[u8]) -> Result<Self, String> {
  type DecodeError (line 47) | struct DecodeError {
    method new (line 372) | fn new(header: &Header, message: String) -> Self {
  method array_type_info (line 60) | fn array_type_info() -> PgTypeInfo {
  type Err (line 90) | type Err = Error;
  method from_str (line 92) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function read_vec (line 208) | fn read_vec(bytes: &mut &[u8]) -> Result<Vec<f64>, String> {
  function read_cube (line 225) | fn read_cube(header: &Header, mut bytes: &[u8]) -> Result<Vec<Vec<f64>>,...
  function parse_float_from_str (line 250) | fn parse_float_from_str(s: &str, error_msg: &str) -> Result<f64, Error> {
  function parse_point (line 254) | fn parse_point(str: &str) -> Result<PgCube, Error> {
  function parse_zero_volume (line 261) | fn parse_zero_volume(content: &str) -> Result<PgCube, Error> {
  function parse_one_dimensional_interval (line 269) | fn parse_one_dimensional_interval(point_vecs: Vec<&str>) -> Result<PgCub...
  function parse_multidimensional_interval (line 285) | fn parse_multidimensional_interval(point_vecs: Vec<&str>) -> Result<PgCu...
  function remove_parentheses (line 303) | fn remove_parentheses(s: &str) -> String {
  constant POINT_BYTES (line 388) | const POINT_BYTES: &[u8] = &[128, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 0];
  constant ZERO_VOLUME_BYTES (line 389) | const ZERO_VOLUME_BYTES: &[u8] = &[
  constant ONE_DIMENSIONAL_INTERVAL_BYTES (line 392) | const ONE_DIMENSIONAL_INTERVAL_BYTES: &[u8] = &[
  constant MULTI_DIMENSION_2_DIM_BYTES (line 395) | const MULTI_DIMENSION_2_DIM_BYTES: &[u8] = &[
  constant MULTI_DIMENSION_3_DIM_BYTES (line 399) | const MULTI_DIMENSION_3_DIM_BYTES: &[u8] = &[
  function can_deserialise_point_type_byes (line 405) | fn can_deserialise_point_type_byes() {
  function can_deserialise_point_type_str (line 411) | fn can_deserialise_point_type_str() {
  function can_serialise_point_type (line 419) | fn can_serialise_point_type() {
  function can_deserialise_zero_volume_bytes (line 423) | fn can_deserialise_zero_volume_bytes() {
  function can_deserialise_zero_volume_string (line 429) | fn can_deserialise_zero_volume_string() {
  function can_serialise_zero_volume (line 437) | fn can_serialise_zero_volume() {
  function can_deserialise_one_dimension_interval_bytes (line 445) | fn can_deserialise_one_dimension_interval_bytes() {
  function can_deserialise_one_dimension_interval_string (line 451) | fn can_deserialise_one_dimension_interval_string() {
  function can_serialise_one_dimension_interval (line 459) | fn can_serialise_one_dimension_interval() {
  function can_deserialise_multi_dimension_2_dimension_byte (line 467) | fn can_deserialise_multi_dimension_2_dimension_byte() {
  function can_deserialise_multi_dimension_2_dimension_string (line 476) | fn can_deserialise_multi_dimension_2_dimension_string() {
  function can_serialise_multi_dimension_2_dimension (line 500) | fn can_serialise_multi_dimension_2_dimension() {
  function can_deserialise_multi_dimension_3_dimension_bytes (line 508) | fn can_deserialise_multi_dimension_3_dimension_bytes() {
  function can_deserialise_multi_dimension_3_dimension_string (line 517) | fn can_deserialise_multi_dimension_3_dimension_string() {
  function can_serialise_multi_dimension_3_dimension (line 531) | fn can_serialise_multi_dimension_3_dimension() {

FILE: sqlx-postgres/src/types/float.rs
  function type_info (line 10) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 16) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 22) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 30) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function type_info (line 39) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 45) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 51) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 59) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/geometry/box.rs
  constant ERROR (line 9) | const ERROR: &str = "error decoding BOX";
  type PgBox (line 31) | pub struct PgBox {
    method type_info (line 39) | fn type_info() -> PgTypeInfo {
    method decode (line 51) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 60) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 64) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method from_bytes (line 111) | fn from_bytes(mut bytes: &[u8]) -> Result<PgBox, BoxDynError> {
    method serialize (line 125) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), String> {
    method serialize_to_vec (line 140) | fn serialize_to_vec(&self) -> Vec<u8> {
  method array_type_info (line 45) | fn array_type_info() -> PgTypeInfo {
  type Err (line 71) | type Err = BoxDynError;
  method from_str (line 73) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  constant BOX_BYTES (line 154) | const BOX_BYTES: &[u8] = &[
  function can_deserialise_box_type_bytes_in_order (line 160) | fn can_deserialise_box_type_bytes_in_order() {
  function can_deserialise_box_type_str_first_syntax (line 174) | fn can_deserialise_box_type_str_first_syntax() {
  function can_deserialise_box_type_str_second_syntax (line 187) | fn can_deserialise_box_type_str_second_syntax() {
  function can_deserialise_box_type_str_third_syntax (line 201) | fn can_deserialise_box_type_str_third_syntax() {
  function can_deserialise_box_type_str_fourth_syntax (line 215) | fn can_deserialise_box_type_str_fourth_syntax() {
  function cannot_deserialise_too_many_numbers (line 229) | fn cannot_deserialise_too_many_numbers() {
  function cannot_deserialise_too_few_numbers (line 242) | fn cannot_deserialise_too_few_numbers() {
  function cannot_deserialise_invalid_numbers (line 255) | fn cannot_deserialise_invalid_numbers() {
  function can_deserialise_box_type_str_float (line 268) | fn can_deserialise_box_type_str_float() {
  function can_serialise_box_type_in_order (line 282) | fn can_serialise_box_type_in_order() {
  function can_serialise_box_type_out_of_order (line 293) | fn can_serialise_box_type_out_of_order() {
  function can_order_box (line 304) | fn can_order_box() {

FILE: sqlx-postgres/src/types/geometry/circle.rs
  constant ERROR (line 10) | const ERROR: &str = "error decoding CIRCLE";
  type PgCircle (line 30) | pub struct PgCircle {
    method type_info (line 37) | fn type_info() -> PgTypeInfo {
    method decode (line 49) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 58) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 62) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method from_bytes (line 103) | fn from_bytes(mut bytes: &[u8]) -> Result<PgCircle, Error> {
    method serialize (line 110) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), Error> {
    method serialize_to_vec (line 118) | fn serialize_to_vec(&self) -> Vec<u8> {
  method array_type_info (line 43) | fn array_type_info() -> PgTypeInfo {
  type Err (line 69) | type Err = BoxDynError;
  method from_str (line 71) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  constant CIRCLE_BYTES (line 132) | const CIRCLE_BYTES: &[u8] = &[
  function can_deserialise_circle_type_bytes (line 138) | fn can_deserialise_circle_type_bytes() {
  function can_deserialise_circle_type_str (line 151) | fn can_deserialise_circle_type_str() {
  function can_deserialise_circle_type_str_second_syntax (line 164) | fn can_deserialise_circle_type_str_second_syntax() {
  function can_deserialise_circle_type_str_third_syntax (line 177) | fn can_deserialise_circle_type_str_third_syntax() {
  function can_deserialise_circle_type_str_fourth_syntax (line 190) | fn can_deserialise_circle_type_str_fourth_syntax() {
  function cannot_deserialise_circle_invalid_numbers (line 203) | fn cannot_deserialise_circle_invalid_numbers() {
  function cannot_deserialise_circle_negative_radius (line 216) | fn cannot_deserialise_circle_negative_radius() {
  function can_deserialise_circle_type_str_float (line 229) | fn can_deserialise_circle_type_str_float() {
  function can_serialise_circle_type (line 242) | fn can_serialise_circle_type() {

FILE: sqlx-postgres/src/types/geometry/line.rs
  constant ERROR (line 9) | const ERROR: &str = "error decoding LINE";
  type PgLine (line 23) | pub struct PgLine {
    method type_info (line 30) | fn type_info() -> PgTypeInfo {
    method decode (line 42) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 51) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 55) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method from_bytes (line 93) | fn from_bytes(mut bytes: &[u8]) -> Result<PgLine, BoxDynError> {
    method serialize (line 100) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), BoxDynE...
    method serialize_to_vec (line 108) | fn serialize_to_vec(&self) -> Vec<u8> {
  method array_type_info (line 36) | fn array_type_info() -> PgTypeInfo {
  type Err (line 62) | type Err = BoxDynError;
  method from_str (line 64) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  constant LINE_BYTES (line 122) | const LINE_BYTES: &[u8] = &[
  function can_deserialise_line_type_bytes (line 128) | fn can_deserialise_line_type_bytes() {
  function can_deserialise_line_type_str (line 141) | fn can_deserialise_line_type_str() {
  function cannot_deserialise_line_too_few_numbers (line 154) | fn cannot_deserialise_line_too_few_numbers() {
  function cannot_deserialise_line_too_many_numbers (line 167) | fn cannot_deserialise_line_too_many_numbers() {
  function cannot_deserialise_line_invalid_numbers (line 180) | fn cannot_deserialise_line_invalid_numbers() {
  function can_deserialise_line_type_str_float (line 193) | fn can_deserialise_line_type_str_float() {
  function can_serialise_line_type (line 206) | fn can_serialise_line_type() {

FILE: sqlx-postgres/src/types/geometry/line_segment.rs
  constant ERROR (line 9) | const ERROR: &str = "error decoding LSEG";
  type PgLSeg (line 32) | pub struct PgLSeg {
    method type_info (line 40) | fn type_info() -> PgTypeInfo {
    method decode (line 52) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 61) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 65) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method from_bytes (line 112) | fn from_bytes(mut bytes: &[u8]) -> Result<PgLSeg, BoxDynError> {
    method serialize (line 126) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), BoxDynE...
    method serialize_to_vec (line 135) | fn serialize_to_vec(&self) -> Vec<u8> {
  method array_type_info (line 46) | fn array_type_info() -> PgTypeInfo {
  type Err (line 72) | type Err = BoxDynError;
  method from_str (line 74) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  constant LINE_SEGMENT_BYTES (line 149) | const LINE_SEGMENT_BYTES: &[u8] = &[
  function can_deserialise_lseg_type_bytes (line 155) | fn can_deserialise_lseg_type_bytes() {
  function can_deserialise_lseg_type_str_first_syntax (line 169) | fn can_deserialise_lseg_type_str_first_syntax() {
  function can_deserialise_lseg_type_str_second_syntax (line 182) | fn can_deserialise_lseg_type_str_second_syntax() {
  function can_deserialise_lseg_type_str_third_syntax (line 196) | fn can_deserialise_lseg_type_str_third_syntax() {
  function can_deserialise_lseg_type_str_fourth_syntax (line 210) | fn can_deserialise_lseg_type_str_fourth_syntax() {
  function can_deserialise_too_many_numbers (line 224) | fn can_deserialise_too_many_numbers() {
  function can_deserialise_too_few_numbers (line 237) | fn can_deserialise_too_few_numbers() {
  function can_deserialise_invalid_numbers (line 250) | fn can_deserialise_invalid_numbers() {
  function can_deserialise_lseg_type_str_float (line 263) | fn can_deserialise_lseg_type_str_float() {
  function can_serialise_lseg_type (line 277) | fn can_serialise_lseg_type() {

FILE: sqlx-postgres/src/types/geometry/path.rs
  constant BYTE_WIDTH (line 11) | const BYTE_WIDTH: usize = mem::size_of::<f64>();
  type PgPath (line 35) | pub struct PgPath {
    method type_info (line 47) | fn type_info() -> PgTypeInfo {
    method decode (line 59) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 68) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 72) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method header (line 115) | fn header(&self) -> Header {
    method from_bytes (line 122) | fn from_bytes(mut bytes: &[u8]) -> Result<Self, BoxDynError> {
    method serialize (line 157) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), BoxDynE...
    method serialize_to_vec (line 170) | fn serialize_to_vec(&self) -> Vec<u8> {
  type Header (line 41) | struct Header {
    constant HEADER_WIDTH (line 178) | const HEADER_WIDTH: usize = mem::size_of::<i8>() + mem::size_of::<i32>();
    method data_size (line 180) | fn data_size(&self) -> usize {
    method try_read (line 184) | fn try_read(buf: &mut &[u8]) -> Result<Self, String> {
    method try_write (line 209) | fn try_write(&self, buff: &mut PgArgumentBuffer) -> Result<(), String> {
  method array_type_info (line 53) | fn array_type_info() -> PgTypeInfo {
  type Err (line 79) | type Err = Error;
  method from_str (line 81) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function parse_float_from_str (line 227) | fn parse_float_from_str(s: &str, error_msg: &str) -> Result<f64, Error> {
  constant PATH_CLOSED_BYTES (line 240) | const PATH_CLOSED_BYTES: &[u8] = &[
  constant PATH_OPEN_BYTES (line 245) | const PATH_OPEN_BYTES: &[u8] = &[
  constant PATH_UNEVEN_POINTS (line 250) | const PATH_UNEVEN_POINTS: &[u8] = &[
  function can_deserialise_path_type_bytes_closed (line 256) | fn can_deserialise_path_type_bytes_closed() {
  function cannot_deserialise_path_type_uneven_point_bytes (line 268) | fn cannot_deserialise_path_type_uneven_point_bytes() {
  function can_deserialise_path_type_bytes_open (line 281) | fn can_deserialise_path_type_bytes_open() {
  function can_deserialise_path_type_str_first_syntax (line 293) | fn can_deserialise_path_type_str_first_syntax() {
  function cannot_deserialise_path_type_str_uneven_points_first_syntax (line 305) | fn cannot_deserialise_path_type_str_uneven_points_first_syntax() {
  function can_deserialise_path_type_str_second_syntax (line 320) | fn can_deserialise_path_type_str_second_syntax() {
  function can_deserialise_path_type_str_third_syntax (line 332) | fn can_deserialise_path_type_str_third_syntax() {
  function can_deserialise_path_type_str_fourth_syntax (line 344) | fn can_deserialise_path_type_str_fourth_syntax() {
  function can_deserialise_path_type_str_float (line 356) | fn can_deserialise_path_type_str_float() {
  function can_serialise_path_type (line 368) | fn can_serialise_path_type() {

FILE: sqlx-postgres/src/types/geometry/point.rs
  type PgPoint (line 27) | pub struct PgPoint {
    method type_info (line 33) | fn type_info() -> PgTypeInfo {
    method decode (line 45) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 54) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 58) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method from_bytes (line 87) | fn from_bytes(mut bytes: &[u8]) -> Result<PgPoint, BoxDynError> {
    method serialize (line 93) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), BoxDynE...
    method serialize_to_vec (line 100) | fn serialize_to_vec(&self) -> Vec<u8> {
  method array_type_info (line 39) | fn array_type_info() -> PgTypeInfo {
  function parse_float_from_str (line 64) | fn parse_float_from_str(s: &str, error_msg: &str) -> Result<f64, Error> {
  type Err (line 71) | type Err = BoxDynError;
  method from_str (line 73) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  constant POINT_BYTES (line 114) | const POINT_BYTES: &[u8] = &[
  function can_deserialise_point_type_bytes (line 119) | fn can_deserialise_point_type_bytes() {
  function can_deserialise_point_type_str (line 125) | fn can_deserialise_point_type_str() {
  function can_deserialise_point_type_str_float (line 131) | fn can_deserialise_point_type_str_float() {
  function can_serialise_point_type (line 137) | fn can_serialise_point_type() {

FILE: sqlx-postgres/src/types/geometry/polygon.rs
  constant BYTE_WIDTH (line 11) | const BYTE_WIDTH: usize = mem::size_of::<f64>();
  type PgPolygon (line 36) | pub struct PgPolygon {
    method type_info (line 46) | fn type_info() -> PgTypeInfo {
    method decode (line 58) | fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::E...
    method produces (line 67) | fn produces(&self) -> Option<PgTypeInfo> {
    method encode_by_ref (line 71) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method header (line 113) | fn header(&self) -> Header {
    method from_bytes (line 119) | fn from_bytes(mut bytes: &[u8]) -> Result<Self, BoxDynError> {
    method serialize (line 150) | fn serialize(&self, buff: &mut PgArgumentBuffer) -> Result<(), BoxDynE...
    method serialize_to_vec (line 163) | fn serialize_to_vec(&self) -> Vec<u8> {
  type Header (line 41) | struct Header {
    constant HEADER_WIDTH (line 171) | const HEADER_WIDTH: usize = mem::size_of::<i8>() + mem::size_of::<i32>();
    method data_size (line 173) | fn data_size(&self) -> usize {
    method try_read (line 177) | fn try_read(buf: &mut &[u8]) -> Result<Self, String> {
    method try_write (line 198) | fn try_write(&self, buff: &mut PgArgumentBuffer) -> Result<(), String> {
  method array_type_info (line 52) | fn array_type_info() -> PgTypeInfo {
  type Err (line 78) | type Err = Error;
  method from_str (line 80) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function parse_float_from_str (line 213) | fn parse_float_from_str(s: &str, error_msg: &str) -> Result<f64, Error> {
  constant POLYGON_BYTES (line 226) | const POLYGON_BYTES: &[u8] = &[
  function can_deserialise_polygon_type_bytes (line 238) | fn can_deserialise_polygon_type_bytes() {
  function can_deserialise_polygon_type_str_first_syntax (line 262) | fn can_deserialise_polygon_type_str_first_syntax() {
  function can_deserialise_polygon_type_str_second_syntax (line 273) | fn can_deserialise_polygon_type_str_second_syntax() {
  function cannot_deserialise_polygon_type_str_uneven_points_first_syntax (line 284) | fn cannot_deserialise_polygon_type_str_uneven_points_first_syntax() {
  function cannot_deserialise_polygon_type_str_invalid_numbers (line 299) | fn cannot_deserialise_polygon_type_str_invalid_numbers() {
  function can_deserialise_polygon_type_str_third_syntax (line 314) | fn can_deserialise_polygon_type_str_third_syntax() {
  function can_deserialise_polygon_type_str_fourth_syntax (line 325) | fn can_deserialise_polygon_type_str_fourth_syntax() {
  function can_deserialise_polygon_type_str_float (line 336) | fn can_deserialise_polygon_type_str_float() {
  function can_serialise_polygon_type (line 347) | fn can_serialise_polygon_type() {

FILE: sqlx-postgres/src/types/hstore.rs
  type PgHstore (line 92) | pub struct PgHstore(pub BTreeMap<String, Option<String>>);
    method from_iter (line 109) | fn from_iter<T: IntoIterator<Item = (String, String)>>(iter: T) -> Self {
    method from_iter (line 115) | fn from_iter<T: IntoIterator<Item = (String, Option<String>)>>(iter: T...
    method type_info (line 136) | fn type_info() -> PgTypeInfo {
    method decode (line 148) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
    method encode_by_ref (line 177) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
  type Target (line 95) | type Target = BTreeMap<String, Option<String>>;
  method deref (line 97) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 103) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Item (line 127) | type Item = (String, Option<String>);
  type IntoIter (line 128) | type IntoIter = btree_map::IntoIter<String, Option<String>>;
  method into_iter (line 130) | fn into_iter(self) -> Self::IntoIter {
  method array_type_info (line 142) | fn array_type_info() -> PgTypeInfo {
  function read_length (line 222) | fn read_length(buf: &mut &[u8]) -> Result<i32, String> {
  function read_string (line 234) | fn read_string(buf: &mut &[u8]) -> Result<Option<String>, String> {
  constant EMPTY (line 262) | const EMPTY: &str = "00000000";
  constant NAME_SURNAME_AGE (line 264) | const NAME_SURNAME_AGE: &str =
  function hstore_deserialize_ok (line 268) | fn hstore_deserialize_ok() {
  function hstore_deserialize_buffer_length_error (line 297) | fn hstore_deserialize_buffer_length_error() {
  function hstore_serialize_ok (line 309) | fn hstore_serialize_ok() {

FILE: sqlx-postgres/src/types/int.rs
  function int_decode (line 10) | fn int_decode(value: PgValueRef<'_>) -> Result<i64, BoxDynError> {
  function type_info (line 36) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 42) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 48) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 56) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function type_info (line 83) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 89) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 95) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 103) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function type_info (line 109) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 115) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 121) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 129) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function type_info (line 135) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 141) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 147) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 155) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  method array_type_info (line 161) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 167) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 173) | fn array_type_info() -> PgTypeInfo {

FILE: sqlx-postgres/src/types/interval.rs
  type PgInterval (line 14) | pub struct PgInterval {
    method type_info (line 21) | fn type_info() -> PgTypeInfo {
    method decode (line 33) | fn decode(value: PgValueRef<'de>) -> Result<Self, BoxDynError> {
    method encode_by_ref (line 57) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method size_hint (line 65) | fn size_hint(&self) -> usize {
    type Error (line 96) | type Error = BoxDynError;
    method try_from (line 102) | fn try_from(value: std::time::Duration) -> Result<Self, BoxDynError> {
    type Error (line 143) | type Error = BoxDynError;
    method try_from (line 149) | fn try_from(value: chrono::Duration) -> Result<Self, BoxDynError> {
    type Error (line 205) | type Error = BoxDynError;
    method try_from (line 211) | fn try_from(value: time::Duration) -> Result<Self, BoxDynError> {
  method array_type_info (line 27) | fn array_type_info() -> PgTypeInfo {
  function type_info (line 74) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 80) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 86) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function size_hint (line 90) | fn size_hint(&self) -> usize {
  function type_info (line 117) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 124) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 131) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function size_hint (line 136) | fn size_hint(&self) -> usize {
  function type_info (line 179) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 186) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 193) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function size_hint (line 198) | fn size_hint(&self) -> usize {
  function test_encode_interval (line 225) | fn test_encode_interval() {
  function test_pginterval_std (line 314) | fn test_pginterval_std() {
  function test_pginterval_chrono (line 335) | fn test_pginterval_chrono() {
  function test_pginterval_time (line 369) | fn test_pginterval_time() {

FILE: sqlx-postgres/src/types/ipnet/ipaddr.rs
  method type_info (line 15) | fn type_info() -> PgTypeInfo {
  method compatible (line 19) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 25) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 29) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method encode_by_ref (line 38) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 42) | fn size_hint(&self) -> usize {
  method decode (line 51) | fn decode(value: PgValueRef<'db>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/ipnet/ipnet.rs
  constant PGSQL_AF_INET (line 16) | const PGSQL_AF_INET: u8 = 2;
  constant PGSQL_AF_INET6 (line 17) | const PGSQL_AF_INET6: u8 = PGSQL_AF_INET + 1;
  method type_info (line 20) | fn type_info() -> PgTypeInfo {
  method compatible (line 24) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 30) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 34) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method encode_by_ref (line 40) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 65) | fn size_hint(&self) -> usize {
  method decode (line 74) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/ipnetwork/ipaddr.rs
  method type_info (line 15) | fn type_info() -> PgTypeInfo {
  method compatible (line 19) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 25) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 29) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method encode_by_ref (line 38) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 42) | fn size_hint(&self) -> usize {
  method decode (line 51) | fn decode(value: PgValueRef<'db>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/ipnetwork/ipnetwork.rs
  constant PGSQL_AF_INET (line 15) | const PGSQL_AF_INET: u8 = 2;
  constant PGSQL_AF_INET6 (line 16) | const PGSQL_AF_INET6: u8 = PGSQL_AF_INET + 1;
  method type_info (line 19) | fn type_info() -> PgTypeInfo {
  method compatible (line 23) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 29) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 33) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method encode_by_ref (line 39) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 64) | fn size_hint(&self) -> usize {
  method decode (line 73) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/json.rs
  function type_info (line 18) | fn type_info() -> PgTypeInfo {
  function compatible (line 22) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 28) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 32) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 38) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 42) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 48) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 52) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  function encode_by_ref (line 61) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 84) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/lquery.rs
  type PgLQueryParseError (line 17) | pub enum PgLQueryParseError {
  type PgLQuery (line 52) | pub struct PgLQuery {
    method new (line 59) | pub fn new() -> Self {
    method from (line 63) | pub fn from(levels: Vec<PgLQueryLevel>) -> Self {
    method push (line 68) | pub fn push(&mut self, level: PgLQueryLevel) {
    method pop (line 73) | pub fn pop(&mut self) -> Option<PgLQueryLevel> {
    method from_iter (line 81) | pub fn from_iter<I, S>(levels: I) -> Result<Self, PgLQueryParseError>
    method try_from_iter (line 96) | pub fn try_from_iter<I, S>(levels: I) -> Result<Self, PgLQueryParseError>
    method from_iter (line 109) | fn from_iter<T: IntoIterator<Item = PgLQueryLevel>>(iter: T) -> Self {
    method type_info (line 158) | fn type_info() -> PgTypeInfo {
    method encode_by_ref (line 171) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method decode (line 180) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  type Item (line 115) | type Item = PgLQueryLevel;
  type IntoIter (line 116) | type IntoIter = std::vec::IntoIter<Self::Item>;
  method into_iter (line 118) | fn into_iter(self) -> Self::IntoIter {
  type Err (line 124) | type Err = PgLQueryParseError;
  method from_str (line 126) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 137) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Target (line 150) | type Target = [PgLQueryLevel];
  method deref (line 152) | fn deref(&self) -> &Self::Target {
  method array_type_info (line 165) | fn array_type_info() -> PgTypeInfo {
  method fmt (line 209) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type PgLQueryVariant (line 225) | pub struct PgLQueryVariant {
  method fmt (line 231) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type PgLQueryLevel (line 237) | pub enum PgLQueryLevel {
  type Err (line 247) | type Err = PgLQueryParseError;
  method from_str (line 249) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type Err (line 290) | type Err = PgLQueryParseError;
  method from_str (line 292) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function write_variants (line 313) | fn write_variants(f: &mut Formatter<'_>, variants: &[PgLQueryVariant], n...
  method fmt (line 325) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: sqlx-postgres/src/types/ltree.rs
  type PgLTreeParseError (line 14) | pub enum PgLTreeParseError {
  type PgLTreeLabel (line 25) | pub struct PgLTreeLabel(String);
    method new (line 28) | pub fn new<S>(label: S) -> Result<Self, PgLTreeParseError>
  type Target (line 46) | type Target = str;
  method deref (line 48) | fn deref(&self) -> &Self::Target {
  type Err (line 54) | type Err = PgLTreeParseError;
  method from_str (line 56) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 62) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type PgLTree (line 88) | pub struct PgLTree {
    method new (line 94) | pub fn new() -> Self {
    method from_labels (line 99) | pub fn from_labels(labels: Vec<PgLTreeLabel>) -> Self {
    method from_iter (line 107) | pub fn from_iter<I, S>(labels: I) -> Result<Self, PgLTreeParseError>
    method try_from_iter (line 122) | pub fn try_from_iter<I, S>(labels: I) -> Result<Self, PgLTreeParseError>
    method push (line 131) | pub fn push(&mut self, label: PgLTreeLabel) {
    method pop (line 136) | pub fn pop(&mut self) -> Option<PgLTreeLabel> {
    method from (line 142) | fn from(labels: Vec<PgLTreeLabel>) -> Self {
    method from_iter (line 148) | fn from_iter<T: IntoIterator<Item = PgLTreeLabel>>(iter: T) -> Self {
    method type_info (line 199) | fn type_info() -> PgTypeInfo {
    method encode_by_ref (line 212) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method decode (line 221) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  type Item (line 156) | type Item = PgLTreeLabel;
  type IntoIter (line 157) | type IntoIter = std::vec::IntoIter<Self::Item>;
  method into_iter (line 159) | fn into_iter(self) -> Self::IntoIter {
  type Err (line 165) | type Err = PgLTreeParseError;
  method from_str (line 167) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 178) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Target (line 191) | type Target = [PgLTreeLabel];
  method deref (line 193) | fn deref(&self) -> &Self::Target {
  method array_type_info (line 206) | fn array_type_info() -> PgTypeInfo {

FILE: sqlx-postgres/src/types/mac_address.rs
  method type_info (line 10) | fn type_info() -> PgTypeInfo {
  method compatible (line 14) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 20) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 26) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 31) | fn size_hint(&self) -> usize {
  method decode (line 37) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/mod.rs
  function array_compatible (line 308) | fn array_compatible<E: Type<Postgres> + ?Sized>(ty: &PgTypeInfo) -> bool {

FILE: sqlx-postgres/src/types/money.rs
  type PgMoney (line 52) | pub struct PgMoney(
    method to_bigdecimal (line 73) | pub fn to_bigdecimal(self, locale_frac_digits: i64) -> bigdecimal::Big...
    method to_decimal (line 85) | pub fn to_decimal(self, locale_frac_digits: u32) -> rust_decimal::Deci...
    method from_decimal (line 98) | pub fn from_decimal(mut decimal: rust_decimal::Decimal, locale_frac_di...
    method from_bigdecimal (line 122) | pub fn from_bigdecimal(
    method type_info (line 147) | fn type_info() -> PgTypeInfo {
    method from (line 162) | fn from(num: T) -> Self {
    method encode_by_ref (line 168) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method decode (line 176) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
    type Output (line 196) | type Output = PgMoney;
    method add (line 202) | fn add(self, rhs: PgMoney) -> Self::Output {
    method add_assign (line 215) | fn add_assign(&mut self, rhs: PgMoney) {
    type Output (line 224) | type Output = PgMoney;
    method sub (line 230) | fn sub(self, rhs: PgMoney) -> Self::Output {
    method sub_assign (line 243) | fn sub_assign(&mut self, rhs: PgMoney) {
  method array_type_info (line 153) | fn array_type_info() -> PgTypeInfo {
  function adding_works (line 256) | fn adding_works() {
  function add_assign_works (line 261) | fn add_assign_works() {
  function subtracting_works (line 269) | fn subtracting_works() {
  function sub_assign_works (line 274) | fn sub_assign_works() {
  function default_value (line 282) | fn default_value() {
  function add_overflow_panics (line 290) | fn add_overflow_panics() {
  function add_assign_overflow_panics (line 296) | fn add_assign_overflow_panics() {
  function sub_overflow_panics (line 303) | fn sub_overflow_panics() {
  function sub_assign_overflow_panics (line 309) | fn sub_assign_overflow_panics() {
  function conversion_to_bigdecimal_works (line 316) | fn conversion_to_bigdecimal_works() {
  function conversion_to_decimal_works (line 327) | fn conversion_to_decimal_works() {
  function conversion_from_decimal_works (line 336) | fn conversion_from_decimal_works() {
  function conversion_from_bigdecimal_works (line 360) | fn conversion_from_bigdecimal_works() {

FILE: sqlx-postgres/src/types/numeric.rs
  type PgNumeric (line 9) | pub(crate) enum PgNumeric {
    constant ZERO (line 80) | pub const ZERO: Self = PgNumeric::Number {
    method is_valid_digit (line 87) | pub(crate) fn is_valid_digit(digit: i16) -> bool {
    method size_hint (line 91) | pub(crate) fn size_hint(decimal_digits: u64) -> usize {
    method decode (line 108) | pub(crate) fn decode(mut buf: &[u8]) -> Result<Self, BoxDynError> {
    method encode (line 133) | pub(crate) fn encode(&self, buf: &mut PgArgumentBuffer) -> Result<(), ...
  constant SIGN_POS (line 53) | const SIGN_POS: u16 = 0x0000;
  constant SIGN_NEG (line 54) | const SIGN_NEG: u16 = 0x4000;
  constant SIGN_NAN (line 55) | const SIGN_NAN: u16 = 0xC000;
  type PgNumericSign (line 60) | pub(crate) enum PgNumericSign {
    method try_from_u16 (line 66) | fn try_from_u16(val: u16) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/oid.rs
  type Oid (line 14) | pub struct Oid(
    method type_info (line 20) | fn type_info() -> PgTypeInfo {
    method encode_by_ref (line 32) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, ...
    method decode (line 40) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
    method serialize (line 50) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    method deserialize (line 60) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method array_type_info (line 26) | fn array_type_info() -> PgTypeInfo {

FILE: sqlx-postgres/src/types/range.rs
  type PgRange (line 30) | pub struct PgRange<T> {
  function from (line 36) | fn from(v: [Bound<T>; 2]) -> Self {
  function from (line 43) | fn from(v: (Bound<T>, Bound<T>)) -> Self {
  function from (line 52) | fn from(v: Range<T>) -> Self {
  function from (line 61) | fn from(v: RangeFrom<T>) -> Self {
  function from (line 70) | fn from(v: RangeInclusive<T>) -> Self {
  function from (line 80) | fn from(v: RangeTo<T>) -> Self {
  function from (line 89) | fn from(v: RangeToInclusive<T>) -> Self {
  function start_bound (line 98) | fn start_bound(&self) -> Bound<&T> {
  function end_bound (line 106) | fn end_bound(&self) -> Bound<&T> {
  function type_info (line 116) | fn type_info() -> PgTypeInfo {
  function compatible (line 120) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 126) | fn type_info() -> PgTypeInfo {
  function compatible (line 130) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 137) | fn type_info() -> PgTypeInfo {
  function compatible (line 141) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 148) | fn type_info() -> PgTypeInfo {
  function compatible (line 152) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 159) | fn type_info() -> PgTypeInfo {
  function compatible (line 163) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 170) | fn type_info() -> PgTypeInfo {
  function compatible (line 174) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 181) | fn type_info() -> PgTypeInfo {
  function compatible (line 185) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 192) | fn type_info() -> PgTypeInfo {
  function compatible (line 196) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 203) | fn type_info() -> PgTypeInfo {
  function compatible (line 207) | fn compatible(ty: &PgTypeInfo) -> bool {
  function type_info (line 214) | fn type_info() -> PgTypeInfo {
  function compatible (line 218) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 224) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 230) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 237) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 244) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 251) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 258) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 265) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 272) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 279) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 286) | fn array_type_info() -> PgTypeInfo {
  function encode_by_ref (line 295) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 331) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function parse_bound (line 475) | fn parse_bound<T>(ch: char, value: Option<T>) -> Result<Bound<T>, BoxDyn...
  method fmt (line 497) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function range_compatible (line 514) | fn range_compatible<E: Type<Postgres>>(ty: &PgTypeInfo) -> bool {

FILE: sqlx-postgres/src/types/record.rs
  type PgRecordEncoder (line 13) | pub struct PgRecordEncoder<'a> {
  function new (line 21) | pub fn new(buf: &'a mut PgArgumentBuffer) -> Self {
  function finish (line 31) | pub fn finish(&mut self) {
  function encode (line 37) | pub fn encode<'q, T>(&mut self, value: T) -> Result<&mut Self, BoxDynError>
  type PgRecordDecoder (line 61) | pub struct PgRecordDecoder<'r> {
  function new (line 70) | pub fn new(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function try_decode (line 95) | pub fn try_decode<T>(&mut self) -> Result<T, BoxDynError>
  function find_type_info (line 186) | fn find_type_info(

FILE: sqlx-postgres/src/types/rust_decimal.rs
  method type_info (line 13) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 19) | fn array_type_info() -> PgTypeInfo {
  type Error (line 25) | type Error = BoxDynError;
  method try_from (line 27) | fn try_from(numeric: PgNumeric) -> Result<Self, BoxDynError> {
  type Error (line 33) | type Error = BoxDynError;
  method try_from (line 35) | fn try_from(numeric: &'_ PgNumeric) -> Result<Self, BoxDynError> {
  method from (line 88) | fn from(value: Decimal) -> Self {
  method from (line 97) | fn from(decimal: &Decimal) -> Self {
  method encode_by_ref (line 175) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method decode (line 184) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {
  function zero (line 199) | fn zero() {
  function one (line 208) | fn one() {
  function ten (line 222) | fn ten() {
  function one_hundred (line 236) | fn one_hundred() {
  function ten_thousand (line 250) | fn ten_thousand() {
  function two_digits (line 265) | fn two_digits() {
  function one_tenth (line 279) | fn one_tenth() {
  function decimal_1 (line 293) | fn decimal_1() {
  function decimal_2 (line 307) | fn decimal_2() {
  function decimal_3 (line 321) | fn decimal_3() {
  function decimal_4 (line 335) | fn decimal_4() {
  function one_digit_decimal (line 352) | fn one_digit_decimal() {
  function max_value (line 369) | fn max_value() {
  function mult_overflow (line 389) | fn mult_overflow() {
  function max_value_max_scale (line 402) | fn max_value_max_scale() {
  function issue_423_four_digit (line 424) | fn issue_423_four_digit() {
  function issue_423_negative_four_digit (line 439) | fn issue_423_negative_four_digit() {
  function issue_423_eight_digit (line 454) | fn issue_423_eight_digit() {
  function issue_423_negative_eight_digit (line 469) | fn issue_423_negative_eight_digit() {
  function issue_2247_trailing_zeros (line 484) | fn issue_2247_trailing_zeros() {

FILE: sqlx-postgres/src/types/str.rs
  function type_info (line 12) | fn type_info() -> PgTypeInfo {
  function compatible (line 16) | fn compatible(ty: &PgTypeInfo) -> bool {
  method type_info (line 30) | fn type_info() -> PgTypeInfo {
  method compatible (line 34) | fn compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 40) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 44) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 50) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 54) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 60) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 64) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  method array_type_info (line 70) | fn array_type_info() -> PgTypeInfo {
  method array_compatible (line 74) | fn array_compatible(ty: &PgTypeInfo) -> bool {
  function encode_by_ref (line 80) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 88) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  method decode (line 94) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/text.rs
  function type_info (line 12) | fn type_info() -> PgTypeInfo {
  function compatible (line 16) | fn compatible(ty: &PgTypeInfo) -> bool {
  function encode_by_ref (line 25) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function decode (line 36) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/time/date.rs
  method type_info (line 12) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 18) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 24) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 32) | fn size_hint(&self) -> usize {
  method decode (line 38) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/time/datetime.rs
  method type_info (line 14) | fn type_info() -> PgTypeInfo {
  method type_info (line 20) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 26) | fn array_type_info() -> PgTypeInfo {
  method array_type_info (line 32) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 38) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 49) | fn size_hint(&self) -> usize {
  method decode (line 55) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  method encode_by_ref (line 92) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 99) | fn size_hint(&self) -> usize {
  method decode (line 105) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/time/mod.rs
  constant PG_EPOCH (line 9) | const PG_EPOCH: ::time::Date = ::time::macros::date!(2000-1-1);

FILE: sqlx-postgres/src/types/time/time.rs
  method type_info (line 11) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 17) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 23) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method size_hint (line 32) | fn size_hint(&self) -> usize {
  method decode (line 38) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/time_tz.rs
  type DefaultTime (line 11) | type DefaultTime = ::time::Time;
  type DefaultTime (line 14) | type DefaultTime = ::chrono::NaiveTime;
  type DefaultOffset (line 17) | type DefaultOffset = ::time::UtcOffset;
  type DefaultOffset (line 20) | type DefaultOffset = ::chrono::FixedOffset;
  type PgTimeTz (line 31) | pub struct PgTimeTz<Time = DefaultTime, Offset = DefaultOffset> {
  method array_type_info (line 37) | fn array_type_info() -> PgTypeInfo {
  function type_info (line 48) | fn type_info() -> PgTypeInfo {
  function encode_by_ref (line 54) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function size_hint (line 62) | fn size_hint(&self) -> usize {
  function decode (line 68) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
  function try_parse_timetz (line 96) | fn try_parse_timetz(s: &str) -> Result<PgTimeTz<NaiveTime, FixedOffset>,...
  function type_info (line 130) | fn type_info() -> PgTypeInfo {
  function encode_by_ref (line 136) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  function size_hint (line 144) | fn size_hint(&self) -> usize {
  function decode (line 150) | fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/uuid.rs
  method type_info (line 10) | fn type_info() -> PgTypeInfo {
  method array_type_info (line 16) | fn array_type_info() -> PgTypeInfo {
  method encode_by_ref (line 22) | fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Bo...
  method decode (line 30) | fn decode(value: PgValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/types/void.rs
  function type_info (line 7) | fn type_info() -> PgTypeInfo {
  function compatible (line 11) | fn compatible(ty: &PgTypeInfo) -> bool {
  function decode (line 18) | fn decode(_value: PgValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-postgres/src/value.rs
  type PgValueFormat (line 10) | pub enum PgValueFormat {
  type PgValueRef (line 17) | pub struct PgValueRef<'r> {
  type PgValue (line 26) | pub struct PgValue {
  function get (line 33) | pub(crate) fn get(
  function format (line 60) | pub fn format(&self) -> PgValueFormat {
  function as_bytes (line 64) | pub fn as_bytes(&self) -> Result<&'r [u8], BoxDynError> {
  function as_str (line 71) | pub fn as_str(&self) -> Result<&'r str, BoxDynError> {
  type Database (line 77) | type Database = Postgres;
  method as_ref (line 80) | fn as_ref(&self) -> PgValueRef<'_> {
  method type_info (line 89) | fn type_info(&self) -> Cow<'_, PgTypeInfo> {
  method is_null (line 93) | fn is_null(&self) -> bool {
  type Database (line 99) | type Database = Postgres;
  function to_owned (line 101) | fn to_owned(&self) -> PgValue {
  function type_info (line 117) | fn type_info(&self) -> Cow<'_, PgTypeInfo> {
  function is_null (line 121) | fn is_null(&self) -> bool {

FILE: sqlx-sqlite/src/any.rs
  method name (line 27) | fn name(&self) -> &str {
  method close (line 31) | fn close(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<()>> {
  method close_hard (line 35) | fn close_hard(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<(...
  method ping (line 39) | fn ping(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method begin (line 43) | fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, sqlx_cor...
  method commit (line 47) | fn commit(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method rollback (line 51) | fn rollback(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method start_rollback (line 55) | fn start_rollback(&mut self) {
  method get_transaction_depth (line 59) | fn get_transaction_depth(&self) -> usize {
  method shrink_buffers (line 63) | fn shrink_buffers(&mut self) {
  method flush (line 67) | fn flush(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
  method should_flush (line 71) | fn should_flush(&self) -> bool {
  method as_migrate (line 76) | fn as_migrate(
  method fetch_many (line 82) | fn fetch_many(
  method fetch_optional (line 105) | fn fetch_optional(
  method prepare_with (line 130) | fn prepare_with<'c, 'q: 'c>(
  method describe (line 143) | fn describe(
  type Error (line 152) | type Error = sqlx_core::Error;
  method try_from (line 154) | fn try_from(sqlite_type: &'a SqliteTypeInfo) -> Result<Self, Self::Error> {
  type Error (line 175) | type Error = sqlx_core::Error;
  method try_from (line 177) | fn try_from(col: &'a SqliteColumn) -> Result<Self, Self::Error> {
  type Error (line 193) | type Error = sqlx_core::Error;
  method try_from (line 195) | fn try_from(row: &'a SqliteRow) -> Result<Self, Self::Error> {
  type Error (line 201) | type Error = sqlx_core::Error;
  method try_from (line 203) | fn try_from(opts: &'a AnyConnectOptions) -> Result<Self, Self::Error> {
  function map_arguments (line 212) | fn map_arguments(args: AnyArguments) -> SqliteArguments {
  function map_result (line 237) | fn map_result(res: SqliteQueryResult) -> AnyQueryResult {

FILE: sqlx-sqlite/src/arguments.rs
  type SqliteArgumentValue (line 13) | pub enum SqliteArgumentValue {
    method bind (line 129) | fn bind(&self, handle: &mut StatementHandle, i: usize) -> Result<(), E...
  type SqliteArguments (line 24) | pub struct SqliteArguments {
    method add (line 32) | pub(crate) fn add<'t, T>(&mut self, value: T) -> Result<(), BoxDynError>
    method bind (line 72) | pub(super) fn bind(&self, handle: &mut StatementHandle, offset: usize)...
  type SqliteArgumentsBuffer (line 29) | pub struct SqliteArgumentsBuffer(Vec<SqliteArgumentValue>);
    method new (line 119) | pub(crate) fn new(values: Vec<SqliteArgumentValue>) -> SqliteArguments...
    method push (line 123) | pub(crate) fn push(&mut self, value: SqliteArgumentValue) {
  type Database (line 53) | type Database = Sqlite;
  method reserve (line 55) | fn reserve(&mut self, len: usize, _size_hint: usize) {
  method add (line 59) | fn add<'t, T>(&mut self, value: T) -> Result<(), BoxDynError>
  method len (line 66) | fn len(&self) -> usize {

FILE: sqlx-sqlite/src/column.rs
  type SqliteColumn (line 8) | pub struct SqliteColumn {
  type Database (line 18) | type Database = Sqlite;
  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) -> &SqliteTypeInfo {
  method origin (line 32) | fn origin(&self) -> ColumnOrigin {

FILE: sqlx-sqlite/src/connection/collation.rs
  type Collation (line 15) | pub struct Collation {
    method new (line 31) | pub fn new<N, F>(name: N, collate: F) -> Self
    method create (line 48) | pub(crate) fn create(&self, handle: &mut ConnectionHandle) -> Result<(...
  method fmt (line 75) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function create_collation (line 82) | pub(crate) fn create_collation<F>(
  function call_boxed_closure (line 118) | unsafe extern "C" fn call_boxed_closure<C>(

FILE: sqlx-sqlite/src/connection/describe.rs
  function describe (line 12) | pub(crate) fn describe(

FILE: sqlx-sqlite/src/connection/deserialize.rs
  method serialize (line 30) | pub async fn serialize(&mut self, schema: Option<&str>) -> Result<Sqlite...
  method deserialize (line 64) | pub async fn deserialize(
  function serialize (line 76) | pub(crate) fn serialize(
  function deserialize (line 121) | pub(crate) fn deserialize(
  type SqliteOwnedBuf (line 162) | pub struct SqliteOwnedBuf {
    method with_capacity (line 183) | unsafe fn with_capacity(size: usize) -> Option<SqliteOwnedBuf> {
    method from_raw (line 192) | unsafe fn from_raw(ptr: *mut u8, size: usize) -> Option<Self> {
    method into_raw (line 199) | fn into_raw(self) -> (*mut u8, usize) {
    type Error (line 211) | type Error = Error;
    method try_from (line 213) | fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
    method as_ref (line 240) | fn as_ref(&self) -> &[u8] {
    method as_mut (line 246) | fn as_mut(&mut self) -> &mut [u8] {
  method drop (line 171) | fn drop(&mut self) {
  type Target (line 226) | type Target = [u8];
  method deref (line 228) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 234) | fn deref_mut(&mut self) -> &mut Self::Target {
  type SchemaName (line 258) | pub(crate) struct SchemaName(Box<str>);
    method as_str (line 262) | pub fn as_str(&self) -> &str {
    method as_ptr (line 270) | pub fn as_ptr(&self) -> *const c_char {
    type Error (line 276) | type Error = Error;
    method try_from (line 278) | fn try_from(name: &'a str) -> Result<Self, Self::Error> {

FILE: sqlx-sqlite/src/connection/establish.rs
  type EstablishParams (line 26) | pub struct EstablishParams {
    method from_options (line 41) | pub fn from_options(options: &SqliteConnectOptions) -> Result<Self, Er...
    method establish (line 159) | pub(crate) fn establish(&self) -> Result<ConnectionState, Error> {
    method apply_extensions (line 200) | unsafe fn apply_extensions(&self, handle: &mut ConnectionHandle) -> Re...

FILE: sqlx-sqlite/src/connection/execute.rs
  type ExecuteIter (line 9) | pub struct ExecuteIter<'a> {
  function iter (line 22) | pub(crate) fn iter(
  function bind (line 44) | fn bind(
  function finish (line 59) | pub fn finish(self) -> Result<(), Error> {
  type Item (line 69) | type Item = Result<Either<SqliteQueryResult, SqliteRow>, Error>;
  method next (line 71) | fn next(&mut self) -> Option<Self::Item> {
  method drop (line 129) | fn drop(&mut self) {

FILE: sqlx-sqlite/src/connection/executor.rs
  type Database (line 14) | type Database = Sqlite;
  function fetch_many (line 16) | fn fetch_many<'e, 'q, E>(
  function fetch_optional (line 41) | fn fetch_optional<'e, 'q, E>(
  function prepare_with (line 75) | fn prepare_with<'e>(
  function describe (line 92) | fn describe<'e>(

FILE: sqlx-sqlite/src/connection/explain.rs
  constant SQLITE_AFF_NONE (line 21) | const SQLITE_AFF_NONE: u8 = 0x40;
  constant SQLITE_AFF_BLOB (line 22) | const SQLITE_AFF_BLOB: u8 = 0x41;
  constant SQLITE_AFF_TEXT (line 23) | const SQLITE_AFF_TEXT: u8 = 0x42;
  constant SQLITE_AFF_NUMERIC (line 24) | const SQLITE_AFF_NUMERIC: u8 = 0x43;
  constant SQLITE_AFF_INTEGER (line 25) | const SQLITE_AFF_INTEGER: u8 = 0x44;
  constant SQLITE_AFF_REAL (line 26) | const SQLITE_AFF_REAL: u8 = 0x45;
  constant OP_INIT (line 29) | const OP_INIT: &str = "Init";
  constant OP_GOTO (line 30) | const OP_GOTO: &str = "Goto";
  constant OP_DECR_JUMP_ZERO (line 31) | const OP_DECR_JUMP_ZERO: &str = "DecrJumpZero";
  constant OP_DELETE (line 32) | const OP_DELETE: &str = "Delete";
  constant OP_ELSE_EQ (line 33) | const OP_ELSE_EQ: &str = "ElseEq";
  constant OP_EQ (line 34) | const OP_EQ: &str = "Eq";
  constant OP_END_COROUTINE (line 35) | const OP_END_COROUTINE: &str = "EndCoroutine";
  constant OP_FILTER (line 36) | const OP_FILTER: &str = "Filter";
  constant OP_FK_IF_ZERO (line 37) | const OP_FK_IF_ZERO: &str = "FkIfZero";
  constant OP_FOUND (line 38) | const OP_FOUND: &str = "Found";
  constant OP_GE (line 39) | const OP_GE: &str = "Ge";
  constant OP_GO_SUB (line 40) | const OP_GO_SUB: &str = "Gosub";
  constant OP_GT (line 41) | const OP_GT: &str = "Gt";
  constant OP_IDX_GE (line 42) | const OP_IDX_GE: &str = "IdxGE";
  constant OP_IDX_GT (line 43) | const OP_IDX_GT: &str = "IdxGT";
  constant OP_IDX_LE (line 44) | const OP_IDX_LE: &str = "IdxLE";
  constant OP_IDX_LT (line 45) | const OP_IDX_LT: &str = "IdxLT";
  constant OP_IF (line 46) | const OP_IF: &str = "If";
  constant OP_IF_NO_HOPE (line 47) | const OP_IF_NO_HOPE: &str = "IfNoHope";
  constant OP_IF_NOT (line 48) | const OP_IF_NOT: &str = "IfNot";
  constant OP_IF_NOT_OPEN (line 49) | const OP_IF_NOT_OPEN: &str = "IfNotOpen";
  constant OP_IF_NOT_ZERO (line 50) | const OP_IF_NOT_ZERO: &str = "IfNotZero";
  constant OP_IF_NULL_ROW (line 51) | const OP_IF_NULL_ROW: &str = "IfNullRow";
  constant OP_IF_POS (line 52) | const OP_IF_POS: &str = "IfPos";
  constant OP_IF_SMALLER (line 53) | const OP_IF_SMALLER: &str = "IfSmaller";
  constant OP_INCR_VACUUM (line 54) | const OP_INCR_VACUUM: &str = "IncrVacuum";
  constant OP_INIT_COROUTINE (line 55) | const OP_INIT_COROUTINE: &str = "InitCoroutine";
  constant OP_IS_NULL (line 56) | const OP_IS_NULL: &str = "IsNull";
  constant OP_IS_NULL_OR_TYPE (line 57) | const OP_IS_NULL_OR_TYPE: &str = "IsNullOrType";
  constant OP_LAST (line 58) | const OP_LAST: &str = "Last";
  constant OP_LE (line 59) | const OP_LE: &str = "Le";
  constant OP_LT (line 60) | const OP_LT: &str = "Lt";
  constant OP_MUST_BE_INT (line 61) | const OP_MUST_BE_INT: &str = "MustBeInt";
  constant OP_NE (line 62) | const OP_NE: &str = "Ne";
  constant OP_NEXT (line 63) | const OP_NEXT: &str = "Next";
  constant OP_NO_CONFLICT (line 64) | const OP_NO_CONFLICT: &str = "NoConflict";
  constant OP_NOT_EXISTS (line 65) | const OP_NOT_EXISTS: &str = "NotExists";
  constant OP_NOT_NULL (line 66) | const OP_NOT_NULL: &str = "NotNull";
  constant OP_ONCE (line 67) | const OP_ONCE: &str = "Once";
  constant OP_PREV (line 68) | const OP_PREV: &str = "Prev";
  constant OP_PROGRAM (line 69) | const OP_PROGRAM: &str = "Program";
  constant OP_RETURN (line 70) | const OP_RETURN: &str = "Return";
  constant OP_REWIND (line 71) | const OP_REWIND: &str = "Rewind";
  constant OP_ROW_DATA (line 72) | const OP_ROW_DATA: &str = "RowData";
  constant OP_ROW_SET_READ (line 73) | const OP_ROW_SET_READ: &str = "RowSetRead";
  constant OP_ROW_SET_TEST (line 74) | const OP_ROW_SET_TEST: &str = "RowSetTest";
  constant OP_SEEK_GE (line 75) | const OP_SEEK_GE: &str = "SeekGE";
  constant OP_SEEK_GT (line 76) | const OP_SEEK_GT: &str = "SeekGT";
  constant OP_SEEK_LE (line 77) | const OP_SEEK_LE: &str = "SeekLE";
  constant OP_SEEK_LT (line 78) | const OP_SEEK_LT: &str = "SeekLT";
  constant OP_SEEK_ROW_ID (line 79) | const OP_SEEK_ROW_ID: &str = "SeekRowid";
  constant OP_SEEK_SCAN (line 80) | const OP_SEEK_SCAN: &str = "SeekScan";
  constant OP_SEQUENCE (line 81) | const OP_SEQUENCE: &str = "Sequence";
  constant OP_SEQUENCE_TEST (line 82) | const OP_SEQUENCE_TEST: &str = "SequenceTest";
  constant OP_SORT (line 83) | const OP_SORT: &str = "Sort";
  constant OP_SORTER_DATA (line 84) | const OP_SORTER_DATA: &str = "SorterData";
  constant OP_SORTER_INSERT (line 85) | const OP_SORTER_INSERT: &str = "SorterInsert";
  constant OP_SORTER_NEXT (line 86) | const OP_SORTER_NEXT: &str = "SorterNext";
  constant OP_SORTER_OPEN (line 87) | const OP_SORTER_OPEN: &str = "SorterOpen";
  constant OP_SORTER_SORT (line 88) | const OP_SORTER_SORT: &str = "SorterSort";
  constant OP_V_FILTER (line 89) | const OP_V_FILTER: &str = "VFilter";
  constant OP_V_NEXT (line 90) | const OP_V_NEXT: &str = "VNext";
  constant OP_YIELD (line 91) | const OP_YIELD: &str = "Yield";
  constant OP_JUMP (line 92) | const OP_JUMP: &str = "Jump";
  constant OP_COLUMN (line 93) | const OP_COLUMN: &str = "Column";
  constant OP_MAKE_RECORD (line 94) | const OP_MAKE_RECORD: &str = "MakeRecord";
  constant OP_INSERT (line 95) | const OP_INSERT: &str = "Insert";
  constant OP_IDX_INSERT (line 96) | const OP_IDX_INSERT: &str = "IdxInsert";
  constant OP_OPEN_DUP (line 97) | const OP_OPEN_DUP: &str = "OpenDup";
  constant OP_OPEN_PSEUDO (line 98) | const OP_OPEN_PSEUDO: &str = "OpenPseudo";
  constant OP_OPEN_READ (line 99) | const OP_OPEN_READ: &str = "OpenRead";
  constant OP_OPEN_WRITE (line 100) | const OP_OPEN_WRITE: &str = "OpenWrite";
  constant OP_OPEN_EPHEMERAL (line 101) | const OP_OPEN_EPHEMERAL: &str = "OpenEphemeral";
  constant OP_OPEN_AUTOINDEX (line 102) | const OP_OPEN_AUTOINDEX: &str = "OpenAutoindex";
  constant OP_AGG_FINAL (line 103) | const OP_AGG_FINAL: &str = "AggFinal";
  constant OP_AGG_VALUE (line 104) | const OP_AGG_VALUE: &str = "AggValue";
  constant OP_AGG_STEP (line 105) | const OP_AGG_STEP: &str = "AggStep";
  constant OP_FUNCTION (line 106) | const OP_FUNCTION: &str = "Function";
  constant OP_MOVE (line 107) | const OP_MOVE: &str = "Move";
  constant OP_COPY (line 108) | const OP_COPY: &str = "Copy";
  constant OP_SCOPY (line 109) | const OP_SCOPY: &str = "SCopy";
  constant OP_NULL (line 110) | const OP_NULL: &str = "Null";
  constant OP_NULL_ROW (line 111) | const OP_NULL_ROW: &str = "NullRow";
  constant OP_INT_COPY (line 112) | const OP_INT_COPY: &str = "IntCopy";
  constant OP_CAST (line 113) | const OP_CAST: &str = "Cast";
  constant OP_STRING8 (line 114) | const OP_STRING8: &str = "String8";
  constant OP_INT64 (line 115) | const OP_INT64: &str = "Int64";
  constant OP_INTEGER (line 116) | const OP_INTEGER: &str = "Integer";
  constant OP_REAL (line 117) | const OP_REAL: &str = "Real";
  constant OP_NOT (line 118) | const OP_NOT: &str = "Not";
  constant OP_BLOB (line 119) | const OP_BLOB: &str = "Blob";
  constant OP_VARIABLE (line 120) | const OP_VARIABLE: &str = "Variable";
  constant OP_COUNT (line 121) | const OP_COUNT: &str = "Count";
  constant OP_ROWID (line 122) | const OP_ROWID: &str = "Rowid";
  constant OP_NEWROWID (line 123) | const OP_NEWROWID: &str = "NewRowid";
  constant OP_OR (line 124) | const OP_OR: &str = "Or";
  constant OP_AND (line 125) | const OP_AND: &str = "And";
  constant OP_BIT_AND (line 126) | const OP_BIT_AND: &str = "BitAnd";
  constant OP_BIT_OR (line 127) | const OP_BIT_OR: &str = "BitOr";
  constant OP_SHIFT_LEFT (line 128) | const OP_SHIFT_LEFT: &str = "ShiftLeft";
  constant OP_SHIFT_RIGHT (line 129) | const OP_SHIFT_RIGHT: &str = "ShiftRight";
  constant OP_ADD (line 130) | const OP_ADD: &str = "Add";
  constant OP_SUBTRACT (line 131) | const OP_SUBTRACT: &str = "Subtract";
  constant OP_MULTIPLY (line 132) | const OP_MULTIPLY: &str = "Multiply";
  constant OP_DIVIDE (line 133) | const OP_DIVIDE: &str = "Divide";
  constant OP_REMAINDER (line 134) | const OP_REMAINDER: &str = "Remainder";
  constant OP_CONCAT (line 135) | const OP_CONCAT: &str = "Concat";
  constant OP_OFFSET_LIMIT (line 136) | const OP_OFFSET_LIMIT: &str = "OffsetLimit";
  constant OP_RESULT_ROW (line 137) | const OP_RESULT_ROW: &str = "ResultRow";
  constant OP_HALT (line 138) | const OP_HALT: &str = "Halt";
  constant OP_HALT_IF_NULL (line 139) | const OP_HALT_IF_NULL: &str = "HaltIfNull";
  constant MAX_LOOP_COUNT (line 141) | const MAX_LOOP_COUNT: u8 = 2;
  constant MAX_TOTAL_INSTRUCTION_COUNT (line 142) | const MAX_TOTAL_INSTRUCTION_COUNT: u32 = 100_000;
  type ColumnType (line 145) | enum ColumnType {
    method null (line 163) | fn null() -> Self {
    method map_to_datatype (line 169) | fn map_to_datatype(&self) -> DataType {
    method map_to_nullable (line 175) | fn map_to_nullable(&self) -> Option<bool> {
    method fmt (line 184) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method default (line 154) | fn default() -> Self {
  type RegDataType (line 210) | enum RegDataType {
    method map_to_datatype (line 216) | fn map_to_datatype(&self) -> DataType {
    method map_to_nullable (line 222) | fn map_to_nullable(&self) -> Option<bool> {
    method map_to_columntype (line 228) | fn map_to_columntype(&self) -> ColumnType {
  method default (line 240) | fn default() -> Self {
  type TableDataType (line 246) | struct TableDataType {
  type CursorDataType (line 252) | enum CursorDataType {
    method columns (line 258) | fn columns(
    method columns_ref (line 275) | fn columns_ref<'s, 'r, 'o>(
    method columns_mut (line 296) | fn columns_mut<'s, 'r, 'o>(
    method table_mut (line 317) | fn table_mut<'s, 'r, 'o>(
    method is_empty (line 334) | fn is_empty(&self, tables: &IntMap<TableDataType>) -> Option<bool> {
  function affinity_to_type (line 346) | fn affinity_to_type(affinity: u8) -> DataType {
  function opcode_to_type (line 359) | fn opcode_to_type(op: &str) -> DataType {
  function root_block_columns (line 370) | fn root_block_columns(
  type Sequence (line 414) | struct Sequence(i64);
    method new (line 417) | pub fn new() -> Self {
    method next (line 420) | pub fn next(&mut self) -> i64 {
  type QueryState (line 428) | struct QueryState {
    method get_reference (line 465) | fn get_reference(&self) -> BranchParent {
    method new_branch (line 471) | fn new_branch(&self, branch_seq: &mut Sequence) -> Self {
  method from (line 456) | fn from(val: &QueryState) -> Self {
  type MemoryState (line 487) | struct MemoryState {
    method from (line 444) | fn from(val: &QueryState) -> Self {
    method from (line 450) | fn from(val: QueryState) -> Self {
  method diff (line 499) | fn diff(&self, prev: &Self) -> String {
  type BranchList (line 527) | struct BranchList {
    method new (line 533) | pub fn new(state: QueryState) -> Self {
    method push (line 539) | pub fn push<R: Debug, P: Debug>(
    method pop (line 559) | pub fn pop(&mut self) -> Option<QueryState> {
  function explain (line 565) | pub(super) fn explain(
  function test_root_block_columns_has_types (line 1535) | fn test_root_block_columns_has_types() {

FILE: sqlx-sqlite/src/connection/handle.rs
  type ConnectionHandle (line 16) | pub(crate) struct ConnectionHandle(NonNull<sqlite3>);
    method open (line 29) | pub(crate) fn open(filename: &CStr, flags: c_int) -> Result<Self, Erro...
    method as_ptr (line 62) | pub(crate) fn as_ptr(&self) -> *mut sqlite3 {
    method as_non_null_ptr (line 66) | pub(crate) fn as_non_null_ptr(&self) -> NonNull<sqlite3> {
    method call_with_result (line 70) | pub(crate) fn call_with_result(
    method in_transaction (line 81) | pub(crate) fn in_transaction(&mut self) -> bool {
    method last_insert_rowid (line 87) | pub(crate) fn last_insert_rowid(&mut self) -> i64 {
    method last_error (line 92) | pub(crate) fn last_error(&mut self) -> Option<SqliteError> {
    method expect_error (line 98) | pub(crate) fn expect_error(&mut self) -> SqliteError {
    method exec (line 103) | pub(crate) fn exec(&mut self, query: impl Into<String>) -> Result<(), ...
  method drop (line 136) | fn drop(&mut self) {

FILE: sqlx-sqlite/src/connection/intmap.rs
  type IntMap (line 13) | pub(crate) struct IntMap<V>(Vec<Option<V>>);
  method default (line 16) | fn default() -> Self {
  function new (line 22) | pub(crate) fn new() -> Self {
  function expand (line 26) | pub(crate) fn expand(&mut self, size: i64) -> usize {
  function values_mut (line 36) | pub(crate) fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
  function values (line 40) | pub(crate) fn values(&self) -> impl Iterator<Item = &V> {
  function get (line 44) | pub(crate) fn get(&self, idx: &i64) -> Option<&V> {
  function get_mut (line 55) | pub(crate) fn get_mut(&mut self, idx: &i64) -> Option<&mut V> {
  function insert (line 65) | pub(crate) fn insert(&mut self, idx: i64, value: V) -> Option<V> {
  function remove (line 71) | pub(crate) fn remove(&mut self, idx: &i64) -> Option<V> {
  function iter (line 83) | pub(crate) fn iter(&self) -> impl Iterator<Item = Option<&V>> {
  function iter_entries (line 87) | pub(crate) fn iter_entries(&self) -> impl Iterator<Item = (i64, &V)> {
  function last_index (line 94) | pub(crate) fn last_index(&self) -> Option<i64> {
  function get_mut_or_default (line 100) | pub(crate) fn get_mut_or_default(&mut self, idx: &i64) -> &mut V {
  function from_elem (line 107) | pub(crate) fn from_elem(elem: V, len: usize) -> Self {
  function from_dense_record (line 110) | pub(crate) fn from_dense_record(record: &[V]) -> Self {
  function diff (line 117) | pub(crate) fn diff<'a, 'b, 'c>(
  method hash (line 140) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method eq (line 148) | fn eq(&self, other: &Self) -> bool {
  function from_iter (line 164) | fn from_iter<I>(iter: I) -> Self

FILE: sqlx-sqlite/src/connection/mod.rs
  type SqliteConnection (line 59) | pub struct SqliteConnection {
    method establish (line 185) | pub(crate) async fn establish(options: &SqliteConnectOptions) -> Resul...
    method lock_handle (line 199) | pub async fn lock_handle(&mut self) -> Result<LockedSqliteHandle<'_>, ...
  type LockedSqliteHandle (line 65) | pub struct LockedSqliteHandle<'a> {
  type Handler (line 70) | pub(crate) struct Handler(NonNull<dyn FnMut() -> bool + Send + 'static>);
  type SqliteOperation (line 74) | pub enum SqliteOperation {
    method from (line 82) | fn from(value: i32) -> Self {
  type UpdateHookResult (line 92) | pub struct UpdateHookResult<'a> {
  type UpdateHookHandler (line 99) | pub(crate) struct UpdateHookHandler(NonNull<dyn FnMut(UpdateHookResult) ...
  type CommitHookHandler (line 102) | pub(crate) struct CommitHookHandler(NonNull<dyn FnMut() -> bool + Send +...
  type RollbackHookHandler (line 105) | pub(crate) struct RollbackHookHandler(NonNull<dyn FnMut() + Send + 'stat...
  type ConnectionState (line 108) | pub(crate) struct ConnectionState {
    method remove_progress_handler (line 130) | pub(crate) fn remove_progress_handler(&mut self) {
    method remove_update_hook (line 139) | pub(crate) fn remove_update_hook(&mut self) {
    method remove_preupdate_hook (line 149) | pub(crate) fn remove_preupdate_hook(&mut self) {
    method remove_commit_hook (line 158) | pub(crate) fn remove_commit_hook(&mut self) {
    method remove_rollback_hook (line 167) | pub(crate) fn remove_rollback_hook(&mut self) {
  type Statements (line 177) | pub(crate) struct Statements {
    method new (line 562) | fn new(capacity: usize) -> Self {
    method get (line 569) | fn get(&mut self, query: &str, persistent: bool) -> Result<&mut Virtua...
    method len (line 591) | fn len(&self) -> usize {
    method clear (line 595) | fn clear(&mut self) {
  method fmt (line 207) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Database (line 216) | type Database = Sqlite;
  type Options (line 218) | type Options = SqliteConnectOptions;
  method close (line 220) | async fn close(mut self) -> Result<(), Error> {
  method close_hard (line 237) | async fn close_hard(self) -> Result<(), Error> {
  method ping (line 243) | fn ping(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_ {
  method begin (line 247) | fn begin(
  method begin_with (line 253) | fn begin_with(
  method cached_statements_size (line 263) | fn cached_statements_size(&self) -> usize {
  method clear_cached_statements (line 267) | fn clear_cached_statements(&mut self) -> impl Future<Output = Result<(),...
  method shrink_buffers (line 272) | fn shrink_buffers(&mut self) {
  method flush (line 277) | async fn flush(&mut self) -> Result<(), Error> {
  method should_flush (line 286) | fn should_flush(&self) -> bool {
  function progress_callback (line 293) | extern "C" fn progress_callback<F>(callback: *mut c_void) -> c_int
  function update_hook (line 306) | extern "C" fn update_hook<F>(
  function commit_hook (line 331) | extern "C" fn commit_hook<F>(callback: *mut c_void) -> c_int
  function rollback_hook (line 344) | extern "C" fn rollback_hook<F>(callback: *mut c_void)
  function as_raw_handle (line 371) | pub fn as_raw_handle(&mut self) -> NonNull<sqlite3> {
  function create_collation (line 378) | pub fn create_collation(
  function set_progress_handler (line 399) | pub fn set_progress_handler<F>(&mut self, num_ops: i32, callback: F)
  function set_update_hook (line 420) | pub fn set_update_hook<F>(&mut self, callback: F)
  function set_preupdate_hook (line 448) | pub fn set_preupdate_hook<F>(&mut self, callback: F)
  function set_commit_hook (line 479) | pub fn set_commit_hook<F>(&mut self, callback: F)
  function set_rollback_hook (line 503) | pub fn set_rollback_hook<F>(&mut self, callback: F)
  function remove_progress_handler (line 524) | pub fn remove_progress_handler(&mut self) {
  function remove_update_hook (line 528) | pub fn remove_update_hook(&mut self) {
  function remove_preupdate_hook (line 533) | pub fn remove_preupdate_hook(&mut self) {
  function remove_commit_hook (line 537) | pub fn remove_commit_hook(&mut self) {
  function remove_rollback_hook (line 541) | pub fn remove_rollback_hook(&mut self) {
  function last_error (line 545) | pub fn last_error(&mut self) -> Option<SqliteError> {
  method drop (line 551) | fn drop(&mut self) {

FILE: sqlx-sqlite/src/connection/preupdate_hook.rs
  type PreupdateError (line 16) | pub enum PreupdateError {
  type PreupdateHookHandler (line 28) | pub(crate) struct PreupdateHookHandler(
  type PreupdateHookResult (line 34) | pub struct PreupdateHookResult<'a> {
  function get_column_count (line 48) | pub fn get_column_count(&self) -> i32 {
  function get_query_depth (line 57) | pub fn get_query_depth(&self) -> i32 {
  function get_old_row_id (line 63) | pub fn get_old_row_id(&self) -> Result<i64, PreupdateError> {
  function get_new_row_id (line 72) | pub fn get_new_row_id(&self) -> Result<i64, PreupdateError> {
  function get_old_column_value (line 81) | pub fn get_old_column_value(&self, i: i32) -> Result<SqliteValueRef<'a>,...
  function get_new_column_value (line 96) | pub fn get_new_column_value(&self, i: i32) -> Result<SqliteValueRef<'a>,...
  function validate_column_index (line 109) | fn validate_column_index(&self, i: i32) -> Result<(), PreupdateError> {
  function get_value (line 116) | unsafe fn get_value(
  function preupdate_hook (line 128) | pub(super) extern "C" fn preupdate_hook<F>(

FILE: sqlx-sqlite/src/connection/worker.rs
  type ConnectionWorker (line 31) | pub(crate) struct ConnectionWorker {
    method establish (line 105) | pub(crate) async fn establish(params: EstablishParams) -> Result<Self,...
    method prepare (line 350) | pub(crate) async fn prepare(&mut self, query: SqlStr) -> Result<Sqlite...
    method describe (line 356) | pub(crate) async fn describe(
    method execute (line 364) | pub(crate) async fn execute(
    method begin (line 391) | pub(crate) async fn begin(&mut self, statement: Option<SqlStr>) -> Res...
    method commit (line 396) | pub(crate) async fn commit(&mut self) -> Result<(), Error> {
    method rollback (line 401) | pub(crate) async fn rollback(&mut self) -> Result<(), Error> {
    method start_rollback (line 406) | pub(crate) fn start_rollback(&mut self) -> Result<(), Error> {
    method ping (line 412) | pub(crate) async fn ping(&mut self) -> Result<(), Error> {
    method deserialize (line 417) | pub(crate) async fn deserialize(
    method serialize (line 433) | pub(crate) async fn serialize(
    method oneshot_cmd (line 441) | async fn oneshot_cmd<F, T>(&mut self, command: F) -> Result<T, Error>
    method oneshot_cmd_with_ack (line 455) | async fn oneshot_cmd_with_ack<F, T>(&mut self, command: F) -> Result<T...
    method clear_cache (line 469) | pub(crate) async fn clear_cache(&mut self) -> Result<(), Error> {
    method unlock_db (line 473) | pub(crate) async fn unlock_db(&mut self) -> Result<MutexGuard<'_, Conn...
    method shutdown (line 490) | pub(crate) fn shutdown(&mut self) -> impl Future<Output = Result<(), E...
  type WorkerSharedState (line 37) | pub(crate) struct WorkerSharedState {
    method get_transaction_depth (line 44) | pub(crate) fn get_transaction_depth(&self) -> usize {
    method get_cached_statements_size (line 48) | pub(crate) fn get_cached_statements_size(&self) -> usize {
  type Command (line 53) | enum Command {
  function prepare (line 507) | fn prepare(conn: &mut ConnectionState, query: SqlStr) -> Result<SqliteSt...
  function update_cached_statements_size (line 533) | fn update_cached_statements_size(conn: &ConnectionState, size: &AtomicUs...
  function channel (line 541) | pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
  type Sender (line 546) | pub struct Sender<T> {
  function send (line 551) | pub async fn send(self, value: T) -> Result<(), Canceled> {
  function blocking_send (line 557) | pub fn blocking_send(self, value: T) -> Result<(), Canceled> {
  type Receiver (line 562) | pub struct Receiver<T> {
  function recv (line 567) | pub async fn recv(self) -> Result<T, Canceled> {

FILE: sqlx-sqlite/src/database.rs
  type Sqlite (line 11) | pub struct Sqlite;
  type Connection (line 14) | type Connection = SqliteConnection;
  type TransactionManager (line 16) | type TransactionManager = SqliteTransactionManager;
  type Row (line 18) | type Row = SqliteRow;
  type QueryResult (line 20) | type QueryResult = SqliteQueryResult;
  type Column (line 22) | type Column = SqliteColumn;
  type TypeInfo (line 24) | type TypeInfo = SqliteTypeInfo;
  type Value (line 26) | type Value = SqliteValue;
  type ValueRef (line 27) | type ValueRef<'r> = SqliteValueRef<'r>;
  type Arguments (line 29) | type Arguments = SqliteArguments;
  type ArgumentBuffer (line 30) | type ArgumentBuffer = SqliteArgumentsBuffer;
  type Statement (line 32) | type Statement = SqliteStatement;
  constant NAME (line 34) | const NAME: &'static str = "SQLite";
  constant URL_SCHEMES (line 36) | const URL_SCHEMES: &'static [&'static str] = &["sqlite"];

FILE: sqlx-sqlite/src/error.rs
  type SqliteError (line 19) | pub struct SqliteError {
    method new (line 25) | pub(crate) unsafe fn new(handle: *mut sqlite3) -> Self {
    method try_new (line 29) | pub(crate) unsafe fn try_new(handle: *mut sqlite3) -> Option<Self> {
    method with_message (line 53) | pub(crate) fn with_message(mut self, error_msg: String) -> Self {
    method from_code (line 59) | pub(crate) fn from_code(code: c_int) -> Self {
    method generic (line 78) | pub(crate) fn generic(message: impl Into<Cow<'static, str>>) -> Self {
    method nomem (line 86) | pub(crate) fn nomem() -> Self {
  method fmt (line 92) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method message (line 105) | fn message(&self) -> &str {
  method code (line 111) | fn code(&self) -> Option<Cow<'_, str>> {
  method as_error (line 116) | fn as_error(&self) -> &(dyn StdError + Send + Sync + 'static) {
  method as_error_mut (line 121) | fn as_error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {
  method into_error (line 126) | fn into_error(self: Box<Self>) -> Box<dyn StdError + Send + Sync + 'stat...
  method kind (line 130) | fn kind(&self) -> ErrorKind {

FILE: sqlx-sqlite/src/lib.rs
  type SqlitePool (line 137) | pub type SqlitePool = crate::pool::Pool<Sqlite>;
  type SqlitePoolOptions (line 140) | pub type SqlitePoolOptions = crate::pool::PoolOptions<Sqlite>;
  type SqliteExecutor (line 143) | pub trait SqliteExecutor<'c>: Executor<'c, Database = Sqlite> {}
  type SqliteTransaction (line 147) | pub type SqliteTransaction<'c> = sqlx_core::transaction::Transaction<'c,...
  function describe_blocking (line 164) | pub fn describe_blocking(

FILE: sqlx-sqlite/src/logger.rs
  type BranchResult (line 17) | pub(crate) enum BranchResult<R: Debug + 'static> {
  type BranchParent (line 28) | pub(crate) struct BranchParent {
  type InstructionHistory (line 34) | pub(crate) struct InstructionHistory<S: Debug + DebugDiff> {
  type DebugDiff (line 39) | pub(crate) trait DebugDiff {
    method diff (line 40) | fn diff(&self, prev: &Self) -> String;
  type QueryPlanLogger (line 43) | pub struct QueryPlanLogger<'q, R: Debug + 'static, S: Debug + DebugDiff ...
  function dot_escape_string (line 53) | fn dot_escape_string(value: impl AsRef<str>) -> String {
  function fmt (line 63) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function new (line 347) | pub fn new(sql: &'q str, program: &'q [P]) -> Self {
  function log_enabled (line 358) | pub fn log_enabled(&self) -> bool {
  function add_branch (line 363) | pub fn add_branch<I: Copy>(&mut self, state: I, parent: &BranchParent)
  function add_operation (line 374) | pub fn add_operation<I: Copy>(&mut self, program_i: usize, state: I)
  function add_result (line 389) | pub fn add_result<I>(&mut self, state: I, result: BranchResult<R>)
  function add_unknown_operation (line 401) | pub fn add_unknown_operation(&mut self, operation: usize) {
  function finish (line 408) | pub fn finish(&self) {
  method drop (line 440) | fn drop(&mut self) {

FILE: sqlx-sqlite/src/migrate.rs
  method create_database (line 22) | async fn create_database(url: &str) -> Result<(), Error> {
  method database_exists (line 41) | async fn database_exists(url: &str) -> Result<bool, Error> {
  method drop_database (line 51) | async fn drop_database(url: &str) -> Result<(), Error> {
  method create_schema_if_not_exists (line 63) | fn create_schema_if_not_exists<'e>(
  method ensure_migrations_table (line 85) | fn ensure_migrations_table<'e>(
  method dirty_version (line 109) | fn dirty_version<'e>(
  method list_applied_migrations (line 125) | fn list_applied_migrations<'e>(
  method lock (line 149) | fn lock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method unlock (line 153) | fn unlock(&mut self) -> BoxFuture<'_, Result<(), MigrateError>> {
  method apply (line 157) | fn apply<'e>(
  method revert (line 201) | fn revert<'e>(
  function execute_migration (line 226) | async fn execute_migration(
  function revert_migration (line 252) | async fn revert_migration(

FILE: sqlx-sqlite/src/options/auto_vacuum.rs
  type SqliteAutoVacuum (line 5) | pub enum SqliteAutoVacuum {
    method as_str (line 13) | pub(crate) fn as_str(&self) -> &'static str {
  type Err (line 23) | type Err = Error;
  method from_str (line 25) | fn from_str(s: &str) -> Result<Self, Error> {

FILE: sqlx-sqlite/src/options/connect.rs
  type Connection (line 14) | type Connection = SqliteConnection;
  method from_url (line 16) | fn from_url(url: &Url) -> Result<Self, Error> {
  method to_url_lossy (line 28) | fn to_url_lossy(&self) -> Url {
  method connect (line 32) | async fn connect(&self) -> Result<Self::Connection, Error>
  method log_statements (line 52) | fn log_statements(mut self, level: LevelFilter) -> Self {
  method log_slow_statements (line 57) | fn log_slow_statements(mut self, level: LevelFilter, duration: Duration)...
  method __unstable_apply_driver_config (line 62) | fn __unstable_apply_driver_config(
  method pragma_string (line 72) | pub(crate) fn pragma_string(&self) -> String {

FILE: sqlx-sqlite/src/options/journal_mode.rs
  type SqliteJournalMode (line 8) | pub enum SqliteJournalMode {
    method as_str (line 19) | pub(crate) fn as_str(&self) -> &'static str {
  type Err (line 32) | type Err = Error;
  method from_str (line 34) | fn from_str(s: &str) -> Result<Self, Error> {

FILE: sqlx-sqlite/src/options/locking_mode.rs
  type SqliteLockingMode (line 8) | pub enum SqliteLockingMode {
    method as_str (line 15) | pub(crate) fn as_str(&self) -> &'static str {
  type Err (line 24) | type Err = Error;
  method from_str (line 26) | fn from_str(s: &str) -> Result<Self, Error> {

FILE: sqlx-sqlite/src/options/mod.rs
  type SqliteConnectOptions (line 62) | pub struct SqliteConnectOptions {
    method new (line 113) | pub fn new() -> Self {
    method filename (line 226) | pub fn filename(mut self, filename: impl AsRef<Path>) -> Self {
    method get_filename (line 232) | pub fn get_filename(&self) -> &Path {
    method foreign_keys (line 240) | pub fn foreign_keys(self, on: bool) -> Self {
    method in_memory (line 247) | pub fn in_memory(mut self, in_memory: bool) -> Self {
    method shared_cache (line 255) | pub fn shared_cache(mut self, on: bool) -> Self {
    method journal_mode (line 281) | pub fn journal_mode(self, mode: SqliteJournalMode) -> Self {
    method locking_mode (line 288) | pub fn locking_mode(self, mode: SqliteLockingMode) -> Self {
    method read_only (line 294) | pub fn read_only(mut self, read_only: bool) -> Self {
    method create_if_missing (line 303) | pub fn create_if_missing(mut self, create: bool) -> Self {
    method statement_cache_capacity (line 314) | pub fn statement_cache_capacity(mut self, capacity: usize) -> Self {
    method busy_timeout (line 323) | pub fn busy_timeout(mut self, timeout: Duration) -> Self {
    method synchronous (line 332) | pub fn synchronous(self, synchronous: SqliteSynchronous) -> Self {
    method auto_vacuum (line 342) | pub fn auto_vacuum(self, auto_vacuum: SqliteAutoVacuum) -> Self {
    method page_size (line 353) | pub fn page_size(self, page_size: u32) -> Self {
    method pragma (line 358) | pub fn pragma<K, V>(mut self, key: K, value: V) -> Self
    method collation (line 383) | pub fn collation<N, F>(mut self, name: N, collate: F) -> Self
    method immutable (line 405) | pub fn immutable(mut self, immutable: bool) -> Self {
    method serialized (line 426) | pub fn serialized(mut self, serialized: bool) -> Self {
    method thread_name (line 434) | pub fn thread_name(
    method command_buffer_size (line 448) | pub fn command_buffer_size(mut self, size: usize) -> Self {
    method row_buffer_size (line 457) | pub fn row_buffer_size(mut self, size: usize) -> Self {
    method vfs (line 466) | pub fn vfs(mut self, vfs_name: impl Into<Cow<'static, str>>) -> Self {
    method extension (line 520) | pub unsafe fn extension(mut self, extension_name: impl Into<Cow<'stati...
    method extension_with_entrypoint (line 558) | pub unsafe fn extension_with_entrypoint(
    method optimize_on_close (line 586) | pub fn optimize_on_close(
    method analysis_limit (line 608) | pub fn analysis_limit(mut self, limit: impl Into<Option<u32>>) -> Self {
    method with_regexp (line 636) | pub fn with_regexp(mut self) -> Self {
    method apply_driver_config (line 642) | pub(crate) fn apply_driver_config(
  type OptimizeOnClose (line 98) | pub enum OptimizeOnClose {
  method default (line 104) | fn default() -> Self {

FILE: sqlx-sqlite/src/options/parse.rs
  method from_db_and_params (line 17) | pub(crate) fn from_db_and_params(database: &str, params: Option<&str>) -...
  method build_url (line 118) | pub(crate) fn build_url(&self) -> Url {
  type Err (line 166) | type Err = Error;
  method from_str (line 168) | fn from_str(mut url: &str) -> Result<Self, Self::Err> {
  function test_parse_in_memory (line 184) | fn test_parse_in_memory() -> Result<(), Error> {
  function test_parse_read_only (line 205) | fn test_parse_read_only() -> Result<(), Error> {
  function test_parse_shared_in_memory (line 214) | fn test_parse_shared_in_memory() -> Result<(), Error> {
  function it_returns_the_parsed_url (line 223) | fn it_returns_the_parsed_url() -> Result<(), Error> {

FILE: sqlx-sqlite/src/options/synchronous.rs
  type SqliteSynchronous (line 8) | pub enum SqliteSynchronous {
    method as_str (line 17) | pub(crate) fn as_str(&self) -> &'static str {
  type Err (line 28) | type Err = Error;
  method from_str (line 30) | fn from_str(s: &str) -> Result<Self, Error> {

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

FILE: sqlx-sqlite/src/regexp.rs
  function register (line 28) | pub fn register(sqlite3: *mut ffi::sqlite3) -> i32 {
  function sqlite3_regexp_func (line 58) | unsafe extern "C" fn sqlite3_regexp_func(
  function get_regex_from_arg (line 100) | unsafe fn get_regex_from_arg(
  function get_text_from_arg (line 144) | unsafe fn get_text_from_arg<'a>(
  function cleanup_arc_regex_pointer (line 167) | unsafe extern "C" fn cleanup_arc_regex_pointer(ptr: *mut std::ffi::c_voi...
  function test_db (line 176) | async fn test_db() -> crate::SqliteConnection {
  function test_regexp_does_not_fail (line 198) | async fn test_regexp_does_not_fail() {
  function test_regexp_filters_correctly (line 208) | async fn test_regexp_filters_correctly() {
  function test_invalid_regexp_should_fail (line 226) | async fn test_invalid_regexp_should_fail() {

FILE: sqlx-sqlite/src/row.rs
  type SqliteRow (line 15) | pub struct SqliteRow {
    method current (line 31) | pub(crate) fn current(
    method fmt (line 81) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Database (line 56) | type Database = Sqlite;
  method columns (line 58) | fn columns(&self) -> &[SqliteColumn] {
  method try_get_raw (line 62) | fn try_get_raw<I>(&self, index: I) -> Result<SqliteValueRef<'_>, Error>
  function index (line 72) | fn index(&self, row: &SqliteRow) -> Result<usize, Error> {

FILE: sqlx-sqlite/src/statement/handle.rs
  type StatementHandle (line 28) | pub(crate) struct StatementHandle(NonNull<sqlite3_stmt>);
    method new (line 58) | pub(super) fn new(ptr: NonNull<sqlite3_stmt>) -> Self {
    method db_handle (line 63) | pub(super) unsafe fn db_handle(&self) -> *mut sqlite3 {
    method read_only (line 69) | pub(crate) fn read_only(&self) -> bool {
    method sql (line 74) | pub(crate) fn sql(&self) -> &str {
    method last_error (line 85) | pub(crate) fn last_error(&mut self) -> SqliteError {
    method column_count (line 90) | pub(crate) fn column_count(&self) -> usize {
    method changes (line 96) | pub(crate) fn changes(&self) -> u64 {
    method column_name (line 104) | pub(crate) fn column_name(&self, index: usize) -> &str {
    method column_origin (line 114) | pub(crate) fn column_origin(&self, index: usize) -> ColumnOrigin {
    method column_db_name (line 137) | fn column_db_name(&self, index: usize) -> Option<&str> {
    method column_table_name (line 149) | fn column_table_name(&self, index: usize) -> Option<&str> {
    method column_origin_name (line 161) | fn column_origin_name(&self, index: usize) -> Option<&str> {
    method column_type_info (line 173) | pub(crate) fn column_type_info(&self, index: usize) -> SqliteTypeInfo {
    method column_type_info_opt (line 177) | pub(crate) fn column_type_info_opt(&self, index: usize) -> Option<Sqli...
    method column_decltype (line 185) | pub(crate) fn column_decltype(&self, index: usize) -> Option<SqliteTyp...
    method column_nullable (line 201) | pub(crate) fn column_nullable(&self, index: usize) -> Result<Option<bo...
    method bind_parameter_count (line 254) | pub(crate) fn bind_parameter_count(&self) -> usize {
    method bind_parameter_name (line 262) | pub(crate) fn bind_parameter_name(&self, index: usize) -> Option<&str> {
    method bind_blob (line 278) | pub(crate) fn bind_blob(&self, index: usize, v: &[u8]) -> c_int {
    method bind_text (line 291) | pub(crate) fn bind_text(&self, index: usize, v: &str) -> c_int {
    method bind_int (line 308) | pub(crate) fn bind_int(&self, index: usize, v: i32) -> c_int {
    method bind_int64 (line 313) | pub(crate) fn bind_int64(&self, index: usize, v: i64) -> c_int {
    method bind_double (line 318) | pub(crate) fn bind_double(&self, index: usize, v: f64) -> c_int {
    method bind_null (line 323) | pub(crate) fn bind_null(&self, index: usize) -> c_int {
    method column_type (line 331) | pub(crate) fn column_type(&self, index: usize) -> c_int {
    method column_int (line 336) | pub(crate) fn column_int(&self, index: usize) -> i32 {
    method column_int64 (line 341) | pub(crate) fn column_int64(&self, index: usize) -> i64 {
    method column_double (line 346) | pub(crate) fn column_double(&self, index: usize) -> f64 {
    method column_value (line 351) | pub(crate) fn column_value(&self, index: usize) -> *mut sqlite3_value {
    method column_blob (line 355) | pub(crate) fn column_blob(&self, index: usize) -> &[u8] {
    method column_text (line 372) | pub(crate) fn column_text(&self, index: usize) -> Result<&str, BoxDynE...
    method clear_bindings (line 376) | pub(crate) fn clear_bindings(&self) {
    method reset (line 380) | pub(crate) fn reset(&mut self) -> Result<(), SqliteError> {
    method step (line 391) | pub(crate) fn step(&mut self) -> Result<bool, SqliteError> {
  method drop (line 417) | fn drop(&mut self) {

FILE: sqlx-sqlite/src/statement/mod.rs
  type SqliteStatement (line 22) | pub struct SqliteStatement {
  type Database (line 30) | type Database = Sqlite;
  method into_sql (line 32) | fn into_sql(self) -> SqlStr {
  method sql (line 36) | fn sql(&self) -> &SqlStr {
  method parameters (line 40) | fn parameters(&self) -> Option<Either<&[SqliteTypeInfo], usize>> {
  method columns (line 44) | fn columns(&self) -> &[SqliteColumn] {
  function index (line 52) | fn index(&self, statement: &SqliteStatement) -> Result<usize, Error> {

FILE: sqlx-sqlite/src/statement/unlock_notify.rs
  function wait (line 11) | pub unsafe fn wait(conn: *mut sqlite3) -> Result<(), SqliteError> {
  function unlock_notify_cb (line 28) | unsafe extern "C" fn unlock_notify_cb(ptr: *mut *mut c_void, len: c_int) {
  type Notify (line 38) | struct Notify {
    method new (line 44) | fn new() -> Self {
    method wait (line 51) | fn wait(&self) {
    method fire (line 60) | fn fire(&self) {

FILE: sqlx-sqlite/src/statement/virtual.rs
  type VirtualStatement (line 25) | pub struct VirtualStatement {
    method new (line 56) | pub(crate) fn new(mut query: &str, persistent: bool) -> Result<Self, E...
    method prepare_next (line 76) | pub(crate) fn prepare_next(
    method current (line 122) | pub fn current(&mut self) -> Option<PreparedStatement<'_>> {
    method reset (line 132) | pub fn reset(&mut self) -> Result<(), Error> {
  type PreparedStatement (line 49) | pub struct PreparedStatement<'a> {
  function prepare (line 144) | fn prepare(

FILE: sqlx-sqlite/src/testing/mod.rs
  constant BASE_PATH (line 10) | const BASE_PATH: &str = "target/sqlx/test-dbs";
  method test_context (line 13) | fn test_context(
  method cleanup_test (line 19) | async fn cleanup_test(db_name: &str) -> Result<(), Error> {
  method cleanup_test_dbs (line 24) | async fn cleanup_test_dbs() -> Result<Option<usize>, Error> {
  method snapshot (line 29) | async fn snapshot(_conn: &mut Self::Connection) -> Result<FixtureSnapsho...
  method db_name (line 33) | fn db_name(args: &TestArgs) -> String {
  function test_context (line 38) | async fn test_context(args: &TestArgs) -> Result<TestContext<Sqlite>, Er...
  function convert_path (line 64) | fn convert_path(test_path: &str) -> String {
  function test_convert_path (line 79) | fn test_convert_path() {

FILE: sqlx-sqlite/src/transaction.rs
  type SqliteTransactionManager (line 9) | pub struct SqliteTransactionManager;
  type Database (line 12) | type Database = Sqlite;
  method begin (line 14) | async fn begin(conn: &mut SqliteConnection, statement: Option<SqlStr>) -...
  method commit (line 18) | fn commit(conn: &mut SqliteConnection) -> impl Future<Output = Result<()...
  method rollback (line 22) | fn rollback(
  method start_rollback (line 28) | fn start_rollback(conn: &mut SqliteConnection) {
  method get_transaction_depth (line 32) | fn get_transaction_depth(conn: &SqliteConnection) -> usize {

FILE: sqlx-sqlite/src/type_info.rs
  type DataType (line 13) | pub(crate) enum DataType {
    method from_code (line 75) | pub(crate) fn from_code(code: c_int) -> Self {
  type SqliteTypeInfo (line 43) | pub struct SqliteTypeInfo(pub(crate) DataType);
  method fmt (line 46) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method is_null (line 52) | fn is_null(&self) -> bool {
  method name (line 56) | fn name(&self) -> &str {
  type Err (line 93) | type Err = BoxDynError;
  method from_str (line 95) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function test_data_type_from_str (line 130) | fn test_data_type_from_str() -> Result<(), BoxDynError> {

FILE: sqlx-sqlite/src/types/bool.rs
  function type_info (line 10) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 14) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 20) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 28) | fn decode(value: SqliteValueRef<'r>) -> Result<bool, BoxDynError> {

FILE: sqlx-sqlite/src/types/bytes.rs
  function type_info (line 14) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 18) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 24) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 32) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode (line 38) | fn encode(self, args: &mut SqliteArgumentsBuffer) -> Result<IsNull, BoxD...
  function encode_by_ref (line 44) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function type_info (line 52) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 56) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode (line 62) | fn encode(self, args: &mut SqliteArgumentsBuffer) -> Result<IsNull, BoxD...
  function encode_by_ref (line 68) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 76) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode (line 82) | fn encode(self, args: &mut SqliteArgumentsBuffer) -> Result<IsNull, BoxD...
  function encode_by_ref (line 88) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function encode_by_ref (line 96) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function encode_by_ref (line 102) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...

FILE: sqlx-sqlite/src/types/chrono.rs
  function type_info (line 18) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 22) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method type_info (line 28) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 32) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method type_info (line 45) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 49) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method type_info (line 55) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 59) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 68) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method encode_by_ref (line 74) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method encode_by_ref (line 80) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method encode_by_ref (line 86) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  function decode (line 92) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode (line 98) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode (line 104) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode_datetime (line 109) | fn decode_datetime(value: SqliteValueRef<'_>) -> Result<DateTime<FixedOf...
  function decode_datetime_from_text (line 125) | fn decode_datetime_from_text(value: &str) -> Option<DateTime<FixedOffset...
  function decode_datetime_from_int (line 162) | fn decode_datetime_from_int(value: i64) -> Option<DateTime<FixedOffset>> {
  function decode_datetime_from_float (line 166) | fn decode_datetime_from_float(value: f64) -> Option<DateTime<FixedOffset...
  method decode (line 187) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  method decode (line 193) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  method decode (line 199) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-sqlite/src/types/float.rs
  function type_info (line 10) | fn type_info() -> SqliteTypeInfo {
  function encode_by_ref (line 16) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 24) | fn decode(value: SqliteValueRef<'r>) -> Result<f32, BoxDynError> {
  function type_info (line 32) | fn type_info() -> SqliteTypeInfo {
  function encode_by_ref (line 38) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 46) | fn decode(value: SqliteValueRef<'r>) -> Result<f64, BoxDynError> {

FILE: sqlx-sqlite/src/types/int.rs
  function type_info (line 10) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 14) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 20) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 28) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 38) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 42) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 48) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 56) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 62) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 66) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 72) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 80) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 86) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 90) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 96) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 104) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-sqlite/src/types/json.rs
  function type_info (line 11) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 15) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 24) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  function decode (line 33) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-sqlite/src/types/str.rs
  function type_info (line 14) | fn type_info() -> SqliteTypeInfo {
  function encode_by_ref (line 20) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 28) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode (line 34) | fn encode(self, args: &mut SqliteArgumentsBuffer) -> Result<IsNull, BoxD...
  function encode_by_ref (line 40) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  method type_info (line 48) | fn type_info() -> SqliteTypeInfo {
  method encode (line 54) | fn encode(self, args: &mut SqliteArgumentsBuffer) -> Result<IsNull, BoxD...
  method encode_by_ref (line 60) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  method decode (line 68) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function encode (line 74) | fn encode(self, args: &mut SqliteArgumentsBuffer) -> Result<IsNull, BoxD...
  function encode_by_ref (line 80) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function encode (line 88) | fn encode(self, args: &mut <Sqlite as Database>::ArgumentBuffer) -> Resu...
  function encode_by_ref (line 97) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function encode_by_ref (line 103) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...

FILE: sqlx-sqlite/src/types/text.rs
  function type_info (line 11) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 15) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 24) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  function decode (line 34) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-sqlite/src/types/time.rs
  method type_info (line 16) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 20) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method type_info (line 26) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 30) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method type_info (line 39) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 43) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method type_info (line 49) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 53) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method encode_by_ref (line 59) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method encode_by_ref (line 65) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method encode_by_ref (line 72) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method encode_by_ref (line 79) | fn encode_by_ref(&self, buf: &mut SqliteArgumentsBuffer) -> Result<IsNul...
  method decode (line 86) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  method decode (line 92) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  method decode (line 98) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  method decode (line 107) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function decode_offset_datetime (line 126) | fn decode_offset_datetime(value: SqliteValueRef<'_>) -> Result<OffsetDat...
  function decode_offset_datetime_from_text (line 143) | fn decode_offset_datetime_from_text(value: &str) -> Option<OffsetDateTim...
  function decode_datetime (line 159) | fn decode_datetime(value: SqliteValueRef<'_>) -> Result<PrimitiveDateTim...
  function decode_datetime_from_text (line 177) | fn decode_datetime_from_text(value: &str) -> Option<PrimitiveDateTime> {
  constant YEAR (line 199) | const YEAR: BorrowedFormatItem<'_> = Component(Year({
  constant MONTH (line 208) | const MONTH: BorrowedFormatItem<'_> = Component(Month({
  constant DAY (line 216) | const DAY: BorrowedFormatItem<'_> = Component(Day({
  constant HOUR (line 222) | const HOUR: BorrowedFormatItem<'_> = Component(Hour({
  constant MINUTE (line 229) | const MINUTE: BorrowedFormatItem<'_> = Component(Minute({
  constant SECOND (line 235) | const SECOND: BorrowedFormatItem<'_> = Component(Second({
  constant SUBSECOND (line 241) | const SUBSECOND: BorrowedFormatItem<'_> = Component(Subsecond({
  constant OFFSET_HOUR (line 247) | const OFFSET_HOUR: BorrowedFormatItem<'_> = Component(OffsetHour({
  constant OFFSET_MINUTE (line 254) | const OFFSET_MINUTE: BorrowedFormatItem<'_> = Component(OffsetMinute({
  constant OFFSET_DATE_TIME (line 260) | pub(super) const OFFSET_DATE_TIME: &[BorrowedFormatItem<'_>] = {
  constant PRIMITIVE_DATE_TIME_SPACE_SEPARATED (line 282) | pub(super) const PRIMITIVE_DATE_TIME_SPACE_SEPARATED: &[BorrowedFormatIt...
  constant PRIMITIVE_DATE_TIME_T_SEPARATED (line 301) | pub(super) const PRIMITIVE_DATE_TIME_T_SEPARATED: &[BorrowedFormatItem<'...

FILE: sqlx-sqlite/src/types/uint.rs
  function type_info (line 10) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 14) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 20) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 28) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 38) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 42) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 48) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 56) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 62) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 66) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function encode_by_ref (line 72) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  function decode (line 80) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
  function type_info (line 86) | fn type_info() -> SqliteTypeInfo {
  function compatible (line 90) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  function decode (line 96) | fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {

FILE: sqlx-sqlite/src/types/uuid.rs
  method type_info (line 15) | fn type_info() -> SqliteTypeInfo {
  method compatible (line 19) | fn compatible(ty: &SqliteTypeInfo) -> bool {
  method encode_by_ref (line 25) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  method decode (line 35) | fn decode(value: SqliteValueRef<'_>) -> Result<Self, BoxDynError> {
  method type_info (line 42) | fn type_info() -> SqliteTypeInfo {
  method encode_by_ref (line 48) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  method decode (line 56) | fn decode(value: SqliteValueRef<'_>) -> Result<Self, BoxDynError> {
  method type_info (line 65) | fn type_info() -> SqliteTypeInfo {
  method encode_by_ref (line 71) | fn encode_by_ref(&self, args: &mut SqliteArgumentsBuffer) -> Result<IsNu...
  method decode (line 79) | fn decode(value: SqliteValueRef<'_>) -> Result<Self, BoxDynError> {

FILE: sqlx-sqlite/src/value.rs
  type SqliteValue (line 52) | pub struct SqliteValue(ValueHandle);
    method dup (line 64) | pub(crate) unsafe fn dup(
    method reset_borrow (line 78) | pub fn reset_borrow(&mut self) {
    method try_clone (line 90) | pub fn try_clone(&self) -> Result<Self, SqliteError> {
  type SqliteValueRef (line 60) | pub struct SqliteValueRef<'r>(Cow<'r, ValueHandle>);
  method clone (line 104) | fn clone(&self) -> Self {
  type Database (line 110) | type Database = Sqlite;
  method as_ref (line 112) | fn as_ref(&self) -> SqliteValueRef<'_> {
  method type_info (line 116) | fn type_info(&self) -> Cow<'_, SqliteTypeInfo> {
  method is_null (line 120) | fn is_null(&self) -> bool {
  function try_to_owned (line 134) | pub fn try_to_owned(&self) -> Result<SqliteValue, SqliteError> {
  function value (line 138) | pub(crate) fn value(value: &'r SqliteValue) -> Self {
  function borrowed (line 147) | pub(crate) unsafe fn borrowed(value: *mut sqlite3_value) -> Self {
  function int64 (line 157) | pub(super) fn int64(&self) -> Result<i64, BorrowedBlobError> {
  function double (line 161) | pub(super) fn double(&self) -> Result<f64, BorrowedBlobError> {
  function blob_borrowed (line 165) | pub(super) fn blob_borrowed(&self) -> &'r [u8] {
  function with_temp_blob (line 170) | pub(super) fn with_temp_blob<R>(&self, op: impl FnOnce(&[u8]) -> R) -> R {
  function blob_owned (line 174) | pub(super) fn blob_owned(&self) -> Vec<u8> {
  function text_borrowed (line 178) | pub(super) fn text_borrowed(&self) -> Result<&'r str, str::Utf8Error> {
  function with_temp_text (line 183) | pub(super) fn with_temp_text<R>(
  function text_owned (line 190) | pub(super) fn text_owned(&self) -> Result<String, str::Utf8Error> {
  type Database (line 196) | type Database = Sqlite;
  function to_owned (line 206) | fn to_owned(&self) -> SqliteValue {
  function type_info (line 214) | fn type_info(&self) -> Cow<'_, SqliteTypeInfo> {
  function is_null (line 218) | fn is_null(&self) -> bool {
  type ValueHandle (line 223) | pub(crate) struct ValueHandle {
    method try_dup_of (line 251) | unsafe fn try_dup_of(
    method temporary (line 267) | fn temporary(value: NonNull<sqlite3_value>) -> Self {
    method try_dup (line 276) | fn try_dup(&self) -> Result<Self, SqliteError> {
    method value_type_info (line 281) | fn value_type_info(&self) -> SqliteTypeInfo {
    method type_info (line 287) | fn type_info(&self) -> SqliteTypeInfo {
    method int64 (line 297) | fn int64(&self) -> Result<i64, BorrowedBlobError> {
    method double (line 304) | fn double(&self) -> Result<f64, BorrowedBlobError> {
    method is_null (line 311) | fn is_null(&self) -> bool {
    method assert_blob_not_borrowed (line 333) | fn assert_blob_not_borrowed(&self) -> Result<(), BorrowedBlobError> {
    method reset_blob_borrow (line 341) | fn reset_blob_borrow(&mut self) {
    method get_blob (line 345) | fn get_blob(&self) -> Option<Blob> {
    method with_blob (line 370) | fn with_blob<R>(&self, with_blob: impl FnOnce(&[u8]) -> R) -> R {
    method blob_borrowed (line 381) | unsafe fn blob_borrowed<'a>(&self) -> &'a [u8] {
    method text_borrowed (line 395) | unsafe fn text_borrowed<'b>(&self) -> Result<&'b str, str::Utf8Error> {
  type Blob (line 231) | struct Blob {
    method as_slice (line 413) | unsafe fn as_slice<'a>(&self) -> &'a [u8] {
  type BorrowedBlobError (line 238) | pub(crate) struct BorrowedBlobError;
  method clone (line 317) | fn clone(&self) -> Self {
  method drop (line 323) | fn drop(&mut self) {

FILE: sqlx-test/src/lib.rs
  function setup_if_needed (line 5) | pub fn setup_if_needed() {
  function new (line 12) | pub async fn new<DB>() -> sqlx::Result<DB::Connection>
  function pool (line 25) | pub async fn pool<DB>() -> anyhow::Result<Pool<DB>>

FILE: src/any/mod.rs
  function install_default_drivers (line 35) | pub fn install_default_drivers() {

FILE: src/lib.rs
  function warn_on_ambiguous_inferred_date_time_crate (line 197) | pub fn warn_on_ambiguous_inferred_date_time_crate() {}
  function warn_on_ambiguous_inferred_numeric_crate (line 209) | pub fn warn_on_ambiguous_inferred_numeric_crate() {}

FILE: src/spec_error.rs
  type SpecErrorWrapper (line 6) | pub struct SpecErrorWrapper<E>(pub E);
  type SpecError (line 8) | pub trait SpecError<E>: Sized {
    method __sqlx_spec_error (line 9) | fn __sqlx_spec_error(
  function __sqlx_spec_error (line 18) | fn __sqlx_spec_error(
  function __sqlx_spec_error (line 29) | fn __sqlx_spec_error(
  function __sqlx_spec_error (line 40) | fn __sqlx_spec_error(
  function __sqlx_spec_error (line 51) | fn __sqlx_spec_error(
  function __sqlx_spec_error (line 59) | fn __sqlx_spec_error(
  function test_spec_error (line 79) | fn test_spec_error() {

FILE: src/ty_match.rs
  function same_type (line 19) | pub fn same_type<T>(_1: &T, _2: &T) {}
  type WrapSame (line 21) | pub struct WrapSame<T, U>(PhantomData<T>, PhantomData<U>);
  function new (line 24) | pub fn new(_arg: &U) -> Self {
  type WrapSameExt (line 29) | pub trait WrapSameExt: Sized {
    method wrap_same (line 32) | fn wrap_same(self) -> Self::Wrapped {
    type Wrapped (line 38) | type Wrapped = Option<T>;
    type Wrapped (line 42) | type Wrapped = T;
  type MatchBorrow (line 45) | pub struct MatchBorrow<T, U>(PhantomData<T>, PhantomData<U>);
  function new (line 48) | pub fn new(t: T, _u: &U) -> (T, Self) {
  type MatchBorrowExt (line 53) | pub trait MatchBorrowExt: Sized {
    method match_borrow (line 56) | fn match_borrow(self) -> Self::Matched {
    type Matched (line 62) | type Matched = Option<&'a str>;
    type Matched (line 66) | type Matched = Option<&'a [u8]>;
    type Matched (line 70) | type Matched = Option<&'a str>;
    type Matched (line 74) | type Matched = Option<&'a [u8]>;
    type Matched (line 78) | type Matched = &'a str;
    type Matched (line 82) | type Matched = &'a [u8];
    type Matched (line 86) | type Matched = T;
    type Matched (line 90) | type Matched = T;
    type Matched (line 94) | type Matched = T;
    type Matched (line 98) | type Matched = T;
    type Matched (line 102) | type Matched = Option<T>;
    type Matched (line 106) | type Matched = Option<T>;
    type Matched (line 110) | type Matched = Option<T>;
    type Matched (line 114) | type Matched = Option<T>;
    type Matched (line 118) | type Matched = U;
  function conjure_value (line 121) | pub fn conjure_value<T>() -> T {
  function dupe_value (line 125) | pub fn dupe_value<T>(_t: &T) -> T {
  function test_dupe_value (line 130) | fn test_dupe_value() {
  function test_wrap_same (line 141) | fn test_wrap_same() {
  function test_match_borrow (line 150) | fn test_match_borrow() {

FILE: tests/any/any.rs
  function it_connects (line 9) | async fn it_connects() -> anyhow::Result<()> {
  function it_pings (line 27) | async fn it_pings() -> anyhow::Result<()> {
  function it_executes_with_pool (line 38) | async fn it_executes_with_pool() -> anyhow::Result<()> {
  function it_does_not_stop_stream_after_decoding_error (line 51) | async fn it_does_not_stop_stream_after_decoding_error() -> anyhow::Resul...
  function it_gets_by_name (line 83) | async fn it_gets_by_name() -> anyhow::Result<()> {
  function it_can_fail_and_recover (line 97) | async fn it_can_fail_and_recover() -> anyhow::Result<()> {
  function it_can_fail_and_recover_with_pool (line 123) | async fn it_can_fail_and_recover_with_pool() -> anyhow::Result<()> {
  function it_can_query_by_string_args (line 149) | async fn it_can_query_by_string_args() -> sqlx::Result<()> {

FILE: tests/any/pool.rs
  function pool_should_invoke_after_connect (line 11) | async fn pool_should_invoke_after_connect() -> anyhow::Result<()> {
  function pool_should_be_returned_failed_transactions (line 45) | async fn pool_should_be_returned_failed_transactions() -> anyhow::Result...
  function test_pool_callbacks (line 75) | async fn test_pool_callbacks() -> anyhow::Result<()> {
  function test_connection_maintenance (line 210) | async fn test_connection_maintenance() -> anyhow::Result<()> {

FILE: tests/docker.py
  function start_database (line 15) | def start_database(driver, database, cwd):

FILE: tests/migrate/macro.rs
  function same_output (line 10) | async fn same_output() -> anyhow::Result<()> {
  function assert_same (line 23) | fn assert_same(embedded: &Migrator, runtime: &Migrator) {

FILE: tests/migrate/migrations_reversible/20220721124650_add_table.up.sql
  type migrations_reversible_test (line 1) | CREATE TABLE migrations_reversible_test (

FILE: tests/migrate/migrations_simple/20220721115250_add_test_table.sql
  type migrations_simple_test (line 1) | CREATE TABLE migrations_simple_test (

FILE: tests/mssql/describe.rs
  function it_describes_simple (line 6) | async fn it_describes_simple() -> anyhow::Result<()> {
  function it_describes_with_params (line 30) | async fn it_describes_with_params() -> anyhow::Result<()> {

FILE: tests/mssql/macros.rs
  function test_query_simple (line 5) | async fn test_query_simple() -> anyhow::Result<()> {

FILE: tests/mssql/mssql.rs
  function it_connects (line 10) | async fn it_connects() -> anyhow::Result<()> {
  function it_can_select_expression (line 21) | async fn it_can_select_expression() -> anyhow::Result<()> {
  function it_can_select_expression_by_name (line 33) | async fn it_can_select_expression_by_name() -> anyhow::Result<()> {
  function it_can_fail_to_connect (line 45) | async fn it_can_fail_to_connect() -> anyhow::Result<()> {
  function it_can_inspect_errors (line 59) | async fn it_can_inspect_errors() -> anyhow::Result<()> {
  function it_maths (line 74) | async fn it_maths() -> anyhow::Result<()> {
  function it_executes (line 89) | async fn it_executes() -> anyhow::Result<()> {
  function it_can_return_1000_rows (line 121) | async fn it_can_return_1000_rows() -> anyhow::Result<()> {
  function it_selects_null (line 153) | async fn it_selects_null() -> anyhow::Result<()> {
  function it_binds_empty_string_and_null (line 170) | async fn it_binds_empty_string_and_null() -> anyhow::Result<()> {
  function it_can_work_with_transactions (line 186) | async fn it_can_work_with_transactions() -> anyhow::Result<()> {
  function it_can_work_with_nested_transactions (line 251) | async fn it_can_work_with_nested_transactions() -> anyhow::Result<()> {
  function it_can_prepare_then_execute (line 301) | async fn it_can_prepare_then_execute() -> anyhow::Result<()> {
  function test_pool_callbacks (line 334) | async fn test_pool_callbacks() -> anyhow::Result<()> {

FILE: tests/mssql/setup.sql
  type tweet (line 12) | CREATE TABLE tweet

FILE: tests/mysql/derives.rs
  function test_derive_strong_enum (line 5) | async fn test_derive_strong_enum() -> anyhow::Result<()> {
  function test_derive_weak_enum (line 147) | async fn test_derive_weak_enum() -> anyhow::Result<()> {
  type TransparentTuple (line 306) | struct TransparentTuple(i64);
  type TransparentNamed (line 310) | struct TransparentNamed {

FILE: tests/mysql/describe.rs
  function it_describes_simple (line 6) | async fn it_describes_simple() -> anyhow::Result<()> {
  function test_boolean (line 30) | async fn test_boolean() -> anyhow::Result<()> {
  function uses_alias_name (line 63) | async fn uses_alias_name() -> anyhow::Result<()> {

FILE: tests/mysql/error.rs
  function it_fails_with_unique_violation (line 5) | async fn it_fails_with_unique_violation() -> anyhow::Result<()> {
  function it_fails_with_foreign_key_violation (line 26) | async fn it_fails_with_foreign_key_violation() -> anyhow::Result<()> {
  function it_fails_with_not_null_violation (line 44) | async fn it_fails_with_not_null_violation() -> anyhow::Result<()> {
  function it_fails_with_check_violation (line 61) | async fn it_fails_with_check_violation() -> anyhow::Result<()> {
  function it_fails_with_begin_failed (line 79) | async fn it_fails_with_begin_failed() -> anyhow::Result<()> {
  function it_fails_with_invalid_save_point_statement (line 91) | async fn it_fails_with_invalid_save_point_statement() -> anyhow::Result<...
  function it_fails_with_parameter_count_mismatch_too_few (line 105) | async fn it_fails_with_parameter_count_mismatch_too_few() -> anyhow::Res...
  function it_fails_with_parameter_count_mismatch_too_many (line 121) | async fn it_fails_with_parameter_count_mismatch_too_many() -> anyhow::Re...
  function it_fails_with_parameter_count_mismatch_zero_expected (line 137) | async fn it_fails_with_parameter_count_mismatch_zero_expected() -> anyho...

FILE: tests/mysql/macros.rs
  function macro_select_from_cte (line 5) | async fn macro_select_from_cte() -> anyhow::Result<()> {
  function macro_select_from_cte_bind (line 21) | async fn macro_select_from_cte_bind() -> anyhow::Result<()> {
  type RawAccount (line 37) | struct RawAccount {
  function test_query_as_raw (line 43) | async fn test_query_as_raw() -> anyhow::Result<()> {
  function test_query_scalar (line 62) | async fn test_query_scalar() -> anyhow::Result<()> {
  function test_query_as_bool (line 128) | async fn test_query_as_bool() -> anyhow::Result<()> {
  function test_query_bytes (line 150) | async fn test_query_bytes() -> anyhow::Result<()> {
  function test_column_override_not_null (line 163) | async fn test_column_override_not_null() -> anyhow::Result<()> {
  function test_column_override_nullable (line 176) | async fn test_column_override_nullable() -> anyhow::Result<()> {
  function with_test_row (line 189) | async fn with_test_row<'a>(
  type MyInt (line 202) | struct MyInt(i64);
  type Record (line 204) | struct Record {
  type OptionalRecord (line 208) | struct OptionalRecord {
  function test_column_override_wildcard (line 213) | async fn test_column_override_wildcard() -> anyhow::Result<()> {
  function test_column_override_wildcard_not_null (line 240) | async fn test_column_override_wildcard_not_null() -> anyhow::Result<()> {
  function test_column_override_wildcard_nullable (line 254) | async fn test_column_override_wildcard_nullable() -> anyhow::Result<()> {
  function test_column_override_exact (line 268) | async fn test_column_override_exact() -> anyhow::Result<()> {
  function test_column_override_exact_not_null (line 295) | async fn test_column_override_exact_not_null() -> anyhow::Result<()> {
  function test_column_override_exact_nullable (line 309) | async fn test_column_override_exact_nullable() -> anyhow::Result<()> {
  type MyEnum (line 324) | enum MyEnum {
  type MyCEnum (line 332) | enum MyCEnum {
  function test_column_override_exact_enum (line 339) | async fn test_column_override_exact_enum() -> anyhow::Result<()> {
  function test_try_from_attr_for_native_type (line 358) | async fn test_try_from_attr_for_native_type() -> anyhow::Result<()> {
  function test_try_from_attr_for_custom_type (line 378) | async fn test_try_from_attr_for_custom_type() -> anyhow::Result<()> {
  function test_try_from_attr_with_flatten (line 407) | async fn test_try_from_attr_with_flatten() -> anyhow::Result<()> {
  function test_try_from_attr_with_complex_type (line 439) | async fn test_try_from_attr_with_complex_type() -> anyhow::Result<()> {
  function test_from_row_json_attr (line 472) | async fn test_from_row_json_attr() -> anyhow::Result<()> {
  function test_from_row_json_attr_nullable (line 498) | async fn test_from_row_json_attr_nullable() -> anyhow::Result<()> {
  function test_from_row_json_try_from_attr (line 523) | async fn test_from_row_json_try_from_attr() -> anyhow::Result<()> {
  function test_uuid_is_compatible_mariadb (line 560) | async fn test_uuid_is_compatible_mariadb() -> anyhow::Result<()> {

FILE: tests/mysql/migrate.rs
  function simple (line 9) | async fn simple(mut conn: PoolConnection<MySql>) -> anyhow::Result<()> {
  function reversible (line 31) | async fn reversible(mut conn: PoolConnection<MySql>) -> anyhow::Result<(...
  function clean_up (line 70) | async fn clean_up(conn: &mut MySqlConnection) -> anyhow::Result<()> {

FILE: tests/mysql/migrations/1_user.sql
  type user (line 1) | create table user

FILE: tests/mysql/migrations/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: tests/mysql/migrations/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: tests/mysql/migrations_reversible/20220721124650_add_table.up.sql
  type migrations_reversible_test (line 1) | CREATE TABLE migrations_reversible_test (

FILE: tests/mysql/migrations_simple/20220721115250_add_test_table.sql
  type migrations_simple_test (line 1) | CREATE TABLE migrations_simple_test (

FILE: tests/mysql/mysql.rs
  function it_connects (line 12) | async fn it_connects() -> anyhow::Result<()> {
  function it_connects_without_password (line 22) | async fn it_connects_without_password() -> anyhow::Result<()> {
  function it_maths (line 43) | async fn it_maths() -> anyhow::Result<()> {
  function it_can_fail_at_querying (line 58) | async fn it_can_fail_at_querying() -> anyhow::Result<()> {
  function it_executes (line 72) | async fn it_executes() -> anyhow::Result<()> {
  function it_executes_with_pool (line 104) | async fn it_executes_with_pool() -> anyhow::Result<()> {
  function it_works_with_cache_disabled (line 127) | async fn it_works_with_cache_disabled() -> anyhow::Result<()> {
  function it_drops_results_in_affected_rows (line 147) | async fn it_drops_results_in_affected_rows() -> anyhow::Result<()> {
  function it_selects_null (line 162) | async fn it_selects_null() -> anyhow::Result<()> {
  function it_can_fetch_one_and_ping (line 177) | async fn it_can_fetch_one_and_ping() -> anyhow::Result<()> {
  function it_interleaves_reads_and_writes (line 195) | async fn it_interleaves_reads_and_writes() -> anyhow::Result<()> {
  function it_caches_statements (line 229) | async fn it_caches_statements() -> anyhow::Result<()> {
  function it_closes_statements_with_persistent_disabled (line 266) | async fn it_closes_statements_with_persistent_disabled() -> anyhow::Resu...
  function it_closes_statements_with_cache_disabled (line 291) | async fn it_closes_statements_with_cache_disabled() -> anyhow::Result<()> {
  function it_can_bind_null_and_non_null_issue_540 (line 317) | async fn it_can_bind_null_and_non_null_issue_540() -> anyhow::Result<()> {
  function it_can_bind_only_null_issue_540 (line 336) | async fn it_can_bind_only_null_issue_540() -> anyhow::Result<()> {
  function it_can_bind_and_return_years (line 352) | async fn it_can_bind_and_return_years() -> anyhow::Result<()> {
  function it_can_prepare_then_execute (line 385) | async fn it_can_prepare_then_execute() -> anyhow::Result<()> {
  function test_issue_622 (line 419) | async fn test_issue_622() -> anyhow::Result<()> {
  function it_can_work_with_transactions (line 471) | async fn it_can_work_with_transactions() -> anyhow::Result<()> {
  function it_can_handle_split_packets (line 531) | async fn it_can_handle_split_packets() -> anyhow::Result<()> {
  function test_shrink_buffers (line 564) | async fn test_shrink_buffers() -> anyhow::Result<()> {
  function select_statement_count (line 594) | async fn select_statement_count(conn: &mut MySqlConnection) -> Result<i6...
  function issue_3200 (line 610) | async fn issue_3200() -> anyhow::Result<()> {

FILE: tests/mysql/rustsec.rs
  function rustsec_2024_0363 (line 11) | async fn rustsec_2024_0363() -> anyhow::Result<()> {

FILE: tests/mysql/setup-mariadb.sql
  type tweet_with_uuid (line 3) | CREATE TABLE tweet_with_uuid

FILE: tests/mysql/setup.sql
  type tweet (line 2) | CREATE TABLE tweet
  type tweet_reply (line 10) | CREATE TABLE tweet_reply
  type products (line 20) | CREATE TABLE products (

FILE: tests/mysql/test-attr.rs
  constant MIGRATOR (line 5) | const MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("tests/mysql/mi...
  function it_gets_a_pool (line 8) | async fn it_gets_a_pool(pool: MySqlPool) -> sqlx::Result<()> {
  function it_gets_users (line 22) | async fn it_gets_users(pool: MySqlPool) -> sqlx::Result<()> {
  function it_gets_posts (line 46) | async fn it_gets_posts(pool: MySqlPool) -> sqlx::Result<()> {
  function it_gets_posts_explicit_fixtures_path (line 73) | async fn it_gets_posts_explicit_fixtures_path(pool: MySqlPool) -> sqlx::...
  function it_gets_posts_mixed_fixtures_path (line 101) | async fn it_gets_posts_mixed_fixtures_path(pool: MySqlPool) -> sqlx::Res...
  function it_gets_posts_custom_relative_fixtures_path (line 128) | async fn it_gets_posts_custom_relative_fixtures_path(pool: MySqlPool) ->...
  function it_gets_comments (line 153) | async fn it_gets_comments(pool: MySqlPool) -> sqlx::Result<()> {

FILE: tests/mysql/types.rs
  function test_type_chrono_zero_date (line 121) | async fn test_type_chrono_zero_date() -> anyhow::Result<()> {
  function test_type_time_zero_date (line 199) | async fn test_type_time_zero_date() -> anyhow::Result<()> {
  type Friend (line 280) | struct Friend {
  type Customer (line 296) | struct Customer {
  function test_bits (line 322) | async fn test_bits() -> anyhow::Result<()> {
  function test_text_adapter (line 364) | async fn test_text_adapter() -> anyhow::Result<()> {

FILE: tests/postgres/derives.rs
  type Transparent (line 13) | struct Transparent(i32);
  type TransparentNamed (line 18) | struct TransparentNamed {
  type TransparentArray (line 27) | struct TransparentArray(Vec<i64>);
  function test_transparent_slice_to_array (line 30) | async fn test_transparent_slice_to_array() -> anyhow::Result<()> {
  type Weak (line 46) | enum Weak {
  type Strong (line 56) | enum Strong {
  type ColorLower (line 68) | enum ColorLower {
  type ColorSnake (line 77) | enum ColorSnake {
  type ColorUpper (line 85) | enum ColorUpper {
  type ColorScreamingSnake (line 94) | enum ColorScreamingSnake {
  type ColorKebabCase (line 102) | enum ColorKebabCase {
  type ColorCamelCase (line 110) | enum ColorCamelCase {
  type ColorPascalCase (line 118) | enum ColorPascalCase {
  type Mood (line 127) | enum Mood {
  type InventoryItem (line 137) | struct InventoryItem {
  type FloatRange (line 146) | struct FloatRange(PgRange<f64>);
  type RangeInclusive (line 151) | struct RangeInclusive(PgRange<i32>);
  function test_enum_type (line 193) | async fn test_enum_type() -> anyhow::Result<()> {
  function test_record_type (line 387) | async fn test_record_type() -> anyhow::Result<()> {
  function test_new_type (line 413) | async fn test_new_type() {
  function test_from_row (line 448) | async fn test_from_row() -> anyhow::Result<()> {
  function test_from_row_with_keyword (line 492) | async fn test_from_row_with_keyword() -> anyhow::Result<()> {
  function test_from_row_with_rename (line 522) | async fn test_from_row_with_rename() -> anyhow::Result<()> {
  function test_from_row_with_rename_all (line 560) | async fn test_from_row_with_rename_all() -> anyhow::Result<()> {
  function test_from_row_tuple (line 587) | async fn test_from_row_tuple() -> anyhow::Result<()> {
  function test_default (line 625) | async fn test_default() -> anyhow::Result<()> {
  function test_struct_default (line 648) | async fn test_struct_default() -> anyhow::Result<()> {
  function test_flatten (line 683) | async fn test_flatten() -> anyhow::Result<()> {
  function test_skip (line 724) | async fn test_skip() -> anyhow::Result<()> {
  function test_enum_with_schema (line 752) | async fn test_enum_with_schema() -> anyhow::Result<()> {
  function test_from_row_hygiene (line 789) | async fn test_from_row_hygiene() -> anyhow::Result<()> {
  function test_custom_pg_array (line 811) | async fn test_custom_pg_array() -> anyhow::Result<()> {
  function test_record_array_type (line 828) | async fn test_record_array_type() -> anyhow::Result<()> {

FILE: tests/postgres/describe.rs
  function it_describes_simple (line 5) | async fn it_describes_simple() -> anyhow::Result<()> {
  function it_describes_expression (line 29) | async fn it_describes_expression() -> anyhow::Result<()> {
  function it_describes_enum (line 46) | async fn it_describes_enum() -> anyhow::Result<()> {
  function it_describes_record (line 68) | async fn it_describes_record() -> anyhow::Result<()> {
  function it_describes_composite (line 82) | async fn it_describes_composite() -> anyhow::Result<()> {

FILE: tests/postgres/error.rs
  function it_fails_with_unique_violation (line 5) | async fn it_fails_with_unique_violation() -> anyhow::Result<()> {
  function it_fails_with_foreign_key_violation (line 26) | async fn it_fails_with_foreign_key_violation() -> anyhow::Result<()> {
  function it_fails_with_not_null_violation (line 44) | async fn it_fails_with_not_null_violation() -> anyhow::Result<()> {
  function it_fails_with_check_violation (line 61) | async fn it_fails_with_check_violation() -> anyhow::Result<()> {
  function it_fails_with_exclude_violation (line 79) | async fn it_fails_with_exclude_violation() -> anyhow::Result<()> {
  function it_fails_with_begin_failed (line 101) | async fn it_fails_with_begin_failed() -> anyhow::Result<()> {
  function it_fails_with_invalid_save_point_statement (line 113) | async fn it_fails_with_invalid_save_point_statement() -> anyhow::Result<...

FILE: tests/postgres/fixtures/rustsec/2024_0363.sql
  type injection_target (line 3) | CREATE TABLE injection_target(id BIGSERIAL PRIMARY KEY, message TEXT)

FILE: tests/postgres/macros.rs
  function test_query (line 8) | async fn test_query() -> anyhow::Result<()> {
  function test_non_null (line 25) | async fn test_non_null() -> anyhow::Result<()> {
  function test_no_result (line 47) | async fn test_no_result() -> anyhow::Result<()> {
  function test_text_var_char_char_n (line 59) | async fn test_text_var_char_char_n() -> anyhow::Result<()> {
  function test_void (line 90) | async fn test_void() -> anyhow::Result<()> {
  function test_call_procedure (line 101) | async fn test_call_procedure() -> anyhow::Result<()> {
  function test_query_file (line 114) | async fn test_query_file() -> anyhow::Result<()> {
  type Account (line 129) | struct Account {
  function test_query_as (line 135) | async fn test_query_as() -> anyhow::Result<()> {
  type RawAccount (line 156) | struct RawAccount {
  function test_query_as_raw (line 162) | async fn test_query_as_raw() -> anyhow::Result<()> {
  function test_query_file_as (line 181) | async fn test_query_file_as() -> anyhow::Result<()> {
  function test_query_scalar (line 194) | async fn test_query_scalar() -> anyhow::Result<()> {
  function query_by_string (line 262) | async fn query_by_string() -> anyhow::Result<()> {
  function query_by_bigdecimal (line 289) | async fn query_by_bigdecimal() -> anyhow::Result<()> {
  function test_nullable_err (line 319) | async fn test_nullable_err() -> anyhow::Result<()> {
  function test_many_args (line 347) | async fn test_many_args() -> anyhow::Result<()> {
  function test_array_from_slice (line 367) | async fn test_array_from_slice() -> anyhow::Result<()> {
  function fetch_is_usable_issue_224 (line 392) | async fn fetch_is_usable_issue_224() -> anyhow::Result<()> {
  function test_column_override_not_null (line 409) | async fn test_column_override_not_null() -> anyhow::Result<()> {
  function test_column_override_nullable (line 422) | async fn test_column_override_nullable() -> anyhow::Result<()> {
  function with_test_row (line 438) | async fn with_test_row<'a>(
  type MyInt (line 450) | struct MyInt(i64);
  type MyInt4 (line 454) | struct MyInt4(i32);
  type Record (line 456) | struct Record {
  type OptionalRecord (line 460) | struct OptionalRecord {
  function test_column_override_wildcard (line 465) | async fn test_column_override_wildcard() -> anyhow::Result<()> {
  function test_column_override_wildcard_not_null (line 485) | async fn test_column_override_wildcard_not_null() -> anyhow::Result<()> {
  function test_column_override_wildcard_nullable (line 499) | async fn test_column_override_wildcard_nullable() -> anyhow::Result<()> {
  function test_column_override_exact (line 513) | async fn test_column_override_exact() -> anyhow::Result<()> {
  function test_column_override_exact_not_null (line 533) | async fn test_column_override_exact_not_null() -> anyhow::Result<()> {
  function test_column_override_exact_nullable (line 547) | async fn test_column_override_exact_nullable() -> anyhow::Result<()> {
  function test_bind_arg_override_exact (line 561) | async fn test_bind_arg_override_exact() -> anyhow::Result<()> {
  function test_bind_arg_override_wildcard (line 600) | async fn test_bind_arg_override_wildcard() -> anyhow::Result<()> {
  function test_to_from_citext (line 618) | async fn test_to_from_citext() -> anyhow::Result<()> {
  function pghstore_tests (line 643) | async fn pghstore_tests() -> anyhow::Result<()> {

FILE: tests/postgres/migrate.rs
  function simple (line 9) | async fn simple(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
  function reversible (line 31) | async fn reversible(mut conn: PoolConnection<Postgres>) -> anyhow::Resul...
  function no_tx (line 70) | async fn no_tx(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
  function clean_up (line 89) | async fn clean_up(conn: &mut PgConnection) -> anyhow::Result<()> {

FILE: tests/postgres/migrations/1_user.sql
  type "user" (line 1) | create table "user"

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

FILE: tests/postgres/migrations/3_comment.sql
  type comment (line 1) | create table comment (
  type comment (line 9) | create index on comment(created_at desc)

FILE: tests/postgres/migrations_reversible/20220721124650_add_table.up.sql
  type migrations_reversible_test (line 1) | CREATE TABLE migrations_reversible_test (

FILE: tests/postgres/migrations_simple/20220721115250_add_test_table.sql
  type migrations_simple_test (line 1) | CREATE TABLE migrations_simple_test (

FILE: tests/postgres/postgres.rs
  function it_connects (line 18) | async fn it_connects() -> anyhow::Result<()> {
  function it_can_select_void (line 32) | async fn it_can_select_void() -> anyhow::Result<()> {
  function it_pings (line 44) | async fn it_pings() -> anyhow::Result<()> {
  function it_pings_after_suspended_query (line 53) | async fn it_pings_after_suspended_query() -> anyhow::Result<()> {
  function it_maths (line 87) | async fn it_maths() -> anyhow::Result<()> {
  function it_can_inspect_errors (line 102) | async fn it_can_inspect_errors() -> anyhow::Result<()> {
  function it_can_inspect_constraint_errors (line 128) | async fn it_can_inspect_constraint_errors() -> anyhow::Result<()> {
  function it_executes (line 163) | async fn it_executes() -> anyhow::Result<()> {
  function it_can_nest_map (line 195) | async fn it_can_nest_map() -> anyhow::Result<()> {
  function it_describes_and_inserts_json_and_jsonb (line 211) | async fn it_describes_and_inserts_json_and_jsonb() -> anyhow::Result<()> {
  function it_works_with_cache_disabled (line 237) | async fn it_works_with_cache_disabled() -> anyhow::Result<()> {
  function it_executes_with_pool (line 257) | async fn it_executes_with_pool() -> anyhow::Result<()> {
  function it_can_return_interleaved_nulls_issue_104 (line 269) | async fn it_can_return_interleaved_nulls_issue_104() -> anyhow::Result<(...
  function it_can_fail_and_recover (line 301) | async fn it_can_fail_and_recover() -> anyhow::Result<()> {
  function it_can_fail_and_recover_with_pool (line 325) | async fn it_can_fail_and_recover_with_pool() -> anyhow::Result<()> {
  function it_can_query_scalar (line 349) | async fn it_can_query_scalar() -> anyhow::Result<()> {
  function it_can_query_all_scalar (line 377) | async fn it_can_query_all_scalar() -> anyhow::Result<()> {
  function copy_can_work_with_failed_transactions (line 397) | async fn copy_can_work_with_failed_transactions() -> anyhow::Result<()> {
  function it_can_work_with_failed_transactions (line 430) | async fn it_can_work_with_failed_transactions() -> anyhow::Result<()> {
  function it_can_work_with_transactions (line 458) | async fn it_can_work_with_transactions() -> anyhow::Result<()> {
  function it_can_work_with_nested_transactions (line 523) | async fn it_can_work_with_nested_transactions() -> anyhow::Result<()> {
  function it_can_drop_multiple_transactions (line 578) | async fn it_can_drop_multiple_transactions() -> anyhow::Result<()> {
  function pool_smoke_test (line 613) | async fn pool_smoke_test() -> anyhow::Result<()> {
  function test_invalid_query (line 684) | async fn test_invalid_query() -> anyhow::Result<()> {
  function test_empty_query (line 704) | async fn test_empty_query() -> anyhow::Result<()> {
  function test_select_expression (line 715) | async fn test_select_expression() -> anyhow::Result<()> {
  function test_multi_read_write (line 730) | async fn test_multi_read_write() -> anyhow::Result<()> {
  function it_caches_statements (line 764) | async fn it_caches_statements() -> anyhow::Result<()> {
  function it_closes_statement_from_cache_issue_470 (line 801) | async fn it_closes_statement_from_cache_issue_470() -> anyhow::Result<()> {
  function it_closes_statements_when_not_persistent_issue_3850 (line 828) | async fn it_closes_statements_when_not_persistent_issue_3850() -> anyhow...
  function it_sets_application_name (line 849) | async fn it_sets_application_name() -> anyhow::Result<()> {
  function it_can_handle_parameter_status_message_issue_484 (line 869) | async fn it_can_handle_parameter_status_message_issue_484() -> anyhow::R...
  function it_can_prepare_then_execute (line 875) | async fn it_can_prepare_then_execute() -> anyhow::Result<()> {
  function test_issue_622 (line 909) | async fn test_issue_622() -> anyhow::Result<()> {
  function test_describe_outer_join_nullable (line 961) | async fn test_describe_outer_join_nullable() -> anyhow::Result<()> {
  function test_listener_cleanup (line 1039) | async fn test_listener_cleanup() -> anyhow::Result<()> {
  function test_listener_try_recv_buffered (line 1100) | async fn test_listener_try_recv_buffered() -> anyhow::Result<()> {
  function test_pg_listener_allows_pool_to_close (line 1171) | async fn test_pg_listener_allows_pool_to_close() -> anyhow::Result<()> {
  function test_pg_listener_implements_acquire (line 1188) | async fn test_pg_listener_implements_acquire() -> anyhow::Result<()> {
  function it_supports_domain_types_in_composite_domain_types (line 1227) | async fn it_supports_domain_types_in_composite_domain_types() -> anyhow:...
  function it_resolves_custom_type_in_array (line 1355) | async fn it_resolves_custom_type_in_array() -> anyhow::Result<()> {
  function it_resolves_custom_types_in_anonymous_records (line 1442) | async fn it_resolves_custom_types_in_anonymous_records() -> anyhow::Resu...
  function custom_type_resolution_respects_search_path (line 1597) | async fn custom_type_resolution_respects_search_path() -> anyhow::Result...
  function test_pg_server_num (line 1660) | async fn test_pg_server_num() -> anyhow::Result<()> {
  function it_can_copy_in (line 1669) | async fn it_can_copy_in() -> anyhow::Result<()> {
  function it_can_abort_copy_in (line 1702) | async fn it_can_abort_copy_in() -> anyhow::Result<()> {
  function it_can_copy_out (line 1733) | async fn it_can_copy_out() -> anyhow::Result<()> {
  function it_encodes_custom_array_issue_1504 (line 1765) | async fn it_encodes_custom_array_issue_1504() -> anyhow::Result<()> {
  function test_issue_1254 (line 1887) | async fn test_issue_1254() -> anyhow::Result<()> {
  function test_advisory_locks (line 1923) | async fn test_advisory_locks() -> anyhow::Result<()> {
  function test_postgres_bytea_hex_deserialization_errors (line 1986) | async fn test_postgres_bytea_hex_deserialization_errors() -> anyhow::Res...
  function test_shrink_buffers (line 2000) | async fn test_shrink_buffers() -> anyhow::Result<()> {
  function test_error_handling_with_deferred_constraints (line 2030) | async fn test_error_handling_with_deferred_constraints() -> anyhow::Resu...
  function test_issue_3052 (line 2055) | async fn test_issue_3052() {
  function test_bind_iter (line 2089) | async fn test_bind_iter() -> anyhow::Result<()> {
  function test_pg_copy_chunked (line 2147) | async fn test_pg_copy_chunked() -> anyhow::Result<()> {
  function test_copy_in_error_case (line 2166) | async fn test_copy_in_error_case(query: &str, expected_error: &str) -> a...
  function it_can_recover_from_copy_in_to_missing_table (line 2187) | async fn it_can_recover_from_copy_in_to_missing_table() -> anyhow::Resul...
  function it_can_recover_from_copy_in_empty_query (line 2197) | async fn it_can_recover_from_copy_in_empty_query() -> anyhow::Result<()> {
  function it_can_recover_from_copy_in_syntax_error (line 2201) | async fn it_can_recover_from_copy_in_syntax_error() -> anyhow::Result<()> {
  function it_can_recover_from_copy_in_invalid_params (line 2211) | async fn it_can_recover_from_copy_in_invalid_params() -> anyhow::Result<...

FILE: tests/postgres/query_builder.rs
  function test_new (line 9) | fn test_new() {
  function test_push (line 15) | fn test_push() {
  function test_push_panics_after_build_without_reset (line 28) | fn test_push_panics_after_build_without_reset() {
  function test_push_bind (line 37) | fn test_push_bind() {
  function test_build (line 51) | fn test_build() {
  function test_reset (line 62) | fn test_reset() {
  function test_query_builder_reuse (line 78) | fn test_query_builder_reuse() {
  function test_query_builder_with_args (line 94) | fn test_query_builder_with_args() {
  function test_max_number_of_binds (line 114) | async fn test_max_number_of_binds() -> anyhow::Result<()> {

FILE: tests/postgres/rustsec.rs
  function rustsec_2024_0363 (line 8) | async fn rustsec_2024_0363(pool: PgPool) -> anyhow::Result<()> {

FILE: tests/postgres/setup.sql
  type tweet (line 25) | CREATE TABLE tweet
  type tweet_reply (line 33) | CREATE TABLE tweet_reply
  type products (line 48) | CREATE TABLE products (
  type test_citext (line 57) | CREATE TABLE test_citext (
  type mytable (line 65) | CREATE TABLE mytable(f HSTORE)
  type circles (line 67) | CREATE TABLE circles (

FILE: tests/postgres/test-attr.rs
  constant MIGRATOR (line 5) | const MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("tests/postgres...
  function it_gets_a_pool (line 8) | async fn it_gets_a_pool(pool: PgPool) -> sqlx::Result<()> {
  function it_gets_users (line 22) | async fn it_gets_users(pool: PgPool) -> sqlx::Result<()> {
  function it_gets_posts (line 47) | async fn it_gets_posts(pool: PgPool) -> sqlx::Result<()> {
  function it_gets_posts_explicit_fixtures_path (line 75) | async fn it_gets_posts_explicit_fixtures_path(pool: PgPool) -> sqlx::Res...
  function it_gets_posts_mixed_fixtures_path (line 104) | async fn it_gets_posts_mixed_fixtures_path(pool: PgPool) -> sqlx::Result...
  function it_gets_posts_custom_relative_fixtures_path (line 132) | async fn it_gets_posts_custom_relative_fixtures_path(pool: PgPool) -> sq...
  function it_gets_comments (line 157) | async fn it_gets_comments(pool: PgPool) -> sqlx::Result<()> {
  function this_should_compile (line 186) | async fn this_should_compile(_pool: PgPool) -> sqlx::Result<()> {

FILE: tests/postgres/types.rs
  type PgTimeTz (line 304) | type PgTimeTz = sqlx::postgres::types::PgTimeTz<NaiveTime, FixedOffset>;
  type PgTimeTz (line 367) | type PgTimeTz = sqlx::postgres::types::PgTimeTz<Time, UtcOffset>;
  type Friend (line 452) | struct Friend {
  function test_json_raw_value (line 470) | async fn test_json_raw_value() -> anyhow::Result<()> {
  constant EXC2 (line 618) | const EXC2: Bound<i32> = Bound::Excluded(2);
  constant EXC3 (line 619) | const EXC3: Bound<i32> = Bound::Excluded(3);
  constant INC1 (line 620) | const INC1: Bound<i32> = Bound::Included(1);
  constant INC2 (line 621) | const INC2: Bound<i32> = Bound::Included(2);
  constant UNB (line 622) | const UNB: Bound<i32> = Bound::Unbounded;
  type PositiveInt (line 699) | struct PositiveInt(i32);
  type Percentage (line 703) | struct Percentage(PositiveInt);
  type Person (line 706) | struct Person {
  type LeafComposite (line 734) | struct LeafComposite {
  type Domain (line 740) | struct Domain(LeafComposite);
  type RootComposite (line 744) | struct RootComposite {
  function test_text_adapter (line 776) | async fn test_text_adapter() -> anyhow::Result<()> {

FILE: tests/sqlite/any.rs
  function it_encodes_bool_with_any (line 5) | async fn it_encodes_bool_with_any() -> anyhow::Result<()> {
  function issue_3179 (line 21) | async fn issue_3179() -> anyhow::Result<()> {

FILE: tests/sqlite/derives.rs
  type Origin (line 6) | enum Origin {
  type TransparentTuple (line 18) | struct TransparentTuple(i64);
  type TransparentNamed (line 22) | struct TransparentNamed {

FILE: tests/sqlite/describe.rs
  function it_describes_simple (line 10) | async fn it_describes_simple() -> anyhow::Result<()> {
  function it_describes_variables (line 40) | async fn it_describes_variables() -> anyhow::Result<()> {
  function it_describes_expression (line 61) | async fn it_describes_expression() -> anyhow::Result<()> {
  function it_describes_temporary_table (line 94) | async fn it_describes_temporary_table() -> anyhow::Result<()> {
  function it_describes_expression_from_empty_table (line 144) | async fn it_describes_expression_from_empty_table() -> anyhow::Result<()> {
  function it_describes_expression_from_empty_table_with_star (line 173) | async fn it_describes_expression_from_empty_table_with_star() -> anyhow:...
  function it_describes_insert (line 192) | async fn it_describes_insert() -> anyhow::Result<()> {
  function it_describes_insert_with_read_only (line 216) | async fn it_describes_insert_with_read_only() -> anyhow::Result<()> {
  function it_describes_insert_with_returning (line 234) | async fn it_describes_insert_with_returning() -> anyhow::Result<()> {
  function it_describes_bound_columns_non_null (line 261) | async fn it_describes_bound_columns_non_null() -> anyhow::Result<()> {
  function it_describes_update_with_returning (line 277) | async fn it_describes_update_with_returning() -> anyhow::Result<()> {
  function it_describes_delete_with_returning (line 312) | async fn it_describes_delete_with_returning() -> anyhow::Result<()> {
  function it_describes_bad_statement (line 327) | async fn it_describes_bad_statement() -> anyhow::Result<()> {
  function it_describes_left_join (line 346) | async fn it_describes_left_join() -> anyhow::Result<()> {
  function it_describes_group_by (line 409) | async fn it_describes_group_by() -> anyhow::Result<()> {
  function it_describes_ungrouped_aggregate (line 436) | async fn it_describes_ungrouped_aggregate() -> anyhow::Result<()> {
  function it_describes_literal_subquery (line 461) | async fn it_describes_literal_subquery() -> anyhow::Result<()> {
  function assert_tweet_described (line 498) | async fn assert_tweet_described(
  function it_describes_table_subquery (line 529) | async fn it_describes_table_subquery() -> anyhow::Result<()> {
  function it_describes_table_order_by (line 548) | async fn it_describes_table_order_by() -> anyhow::Result<()> {
  function it_describes_union (line 595) | async fn it_describes_union() -> anyhow::Result<()> {
  function it_describes_having_group_by (line 640) | async fn it_describes_having_group_by() -> anyhow::Result<()> {
  function it_describes_strange_queries (line 678) | async fn it_describes_strange_queries() -> anyhow::Result<()> {
  function it_describes_func_date (line 783) | async fn it_describes_func_date() -> anyhow::Result<()> {
  function it_describes_func_time (line 809) | async fn it_describes_func_time() -> anyhow::Result<()> {
  function it_describes_func_datetime (line 835) | async fn it_describes_func_datetime() -> anyhow::Result<()> {
  function it_describes_func_julianday (line 861) | async fn it_describes_func_julianday() -> anyhow::Result<()> {
  function it_describes_func_strftime (line 887) | async fn it_describes_func_strftime() -> anyhow::Result<()> {
  function it_describes_with_recursive (line 908) | async fn it_describes_with_recursive() -> anyhow::Result<()> {
  function it_describes_analytical_function (line 951) | async fn it_describes_analytical_function() -> anyhow::Result<()> {

FILE: tests/sqlite/error.rs
  function it_fails_with_unique_violation (line 5) | async fn it_fails_with_unique_violation() -> anyhow::Result<()> {
  function it_fails_with_foreign_key_violation (line 22) | async fn it_fails_with_foreign_key_violation() -> anyhow::Result<()> {
  function it_fails_with_not_null_violation (line 40) | async fn it_fails_with_not_null_violation() -> anyhow::Result<()> {
  function it_fails_with_check_violation (line 57) | async fn it_fails_with_check_violation() -> anyhow::Result<()> {
  function it_fails_with_begin_failed (line 75) | async fn it_fails_with_begin_failed() -> anyhow::Result<()> {
  function it_fails_with_invalid_save_point_statement (line 87) | async fn it_fails_with_invalid_save_point_statement() -> anyhow::Result<...

FILE: tests/sqlite/macros.rs
  function macro_select (line 5) | async fn macro_select() -> anyhow::Result<()> {
  function macro_select_expression (line 41) | async fn macro_select_expression() -> anyhow::Result<()> {
  function macro_select_partial_expression (line 55) | async fn macro_select_partial_expression() -> anyhow::Result<()> {
  function macro_select_bind (line 74) | async fn macro_select_bind() -> anyhow::Result<()> {
  type RawAccount (line 92) | struct RawAccount {
  function test_query_as_raw (line 99) | async fn test_query_as_raw() -> anyhow::Result<()> {
  function test_query_scalar (line 114) | async fn test_query_scalar() -> anyhow::Result<()> {
  function query_by_string (line 179) | async fn query_by_string() -> anyhow::Result<()> {
  function macro_select_from_view (line 204) | async fn macro_select_from_view() -> anyhow::Result<()> {
  function test_column_override_not_null (line 220) | async fn test_column_override_not_null() -> anyhow::Result<()> {
  function test_column_override_nullable (line 233) | async fn test_column_override_nullable() -> anyhow::Result<()> {
  type MyInt (line 247) | struct MyInt(i64);
  type Record (line 249) | struct Record {
  type OptionalRecord (line 253) | struct OptionalRecord {
  function test_column_override_wildcard (line 258) | async fn test_column_override_wildcard() -> anyhow::Result<()> {
  function test_column_override_wildcard_not_null (line 284) | async fn test_column_override_wildcard_not_null() -> anyhow::Result<()> {
  function test_column_override_wildcard_nullable (line 297) | async fn test_column_override_wildcard_nullable() -> anyhow::Result<()> {
  function test_column_override_exact (line 310) | async fn test_column_override_exact() -> anyhow::Result<()> {
  function test_column_override_exact_not_null (line 336) | async fn test_column_override_exact_not_null() -> anyhow::Result<()> {
  function test_column_override_exact_nullable (line 349) | async fn test_column_override_exact_nullable() -> anyhow::Result<()> {

FILE: tests/sqlite/migrate.rs
  function simple (line 9) | async fn simple(mut conn: PoolConnection<Sqlite>) -> anyhow::Result<()> {
  function reversible (line 31) | async fn reversible(mut conn: PoolConnection<Sqlite>) -> anyhow::Result<...
  function no_tx (line 70) | async fn no_tx(mut conn: PoolConnection<Sqlite>) -> anyhow::Result<()> {
  function no_tx_reversible (line 81) | async fn no_tx_reversible(mut conn: PoolConnection<Sqlite>) -> anyhow::R...
  function clean_up (line 104) | async fn clean_up(conn: &mut SqliteConnection) -> anyhow::Result<()> {

FILE: tests/sqlite/migrations/1_user.sql
  type user (line 1) | create table user

FILE: tests/sqlite/migrations/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: tests/sqlite/migrations/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: tests/sqlite/migrations_reversible/20220721124650_add_table.up.sql
  type migrations_reversible_test (line 1) | CREATE TABLE migrations_reversible_test (

FILE: tests/sqlite/migrations_simple/20220721115250_add_test_table.sql
  type migrations_simple_test (line 1) | CREATE TABLE migrations_simple_test (

FILE: tests/sqlite/rustsec.rs
  function rustsec_2024_0363 (line 8) | async fn rustsec_2024_0363() -> anyhow::Result<()> {

FILE: tests/sqlite/setup.sql
  type tweet (line 2) | CREATE TABLE tweet (
  type tweet_reply (line 11) | CREATE TABLE tweet_reply (
  type accounts (line 21) | CREATE TABLE accounts (
  type accounts_view (line 28) | CREATE VIEW accounts_view as
  type products (line 32) | CREATE TABLE products (

FILE: tests/sqlite/sqlcipher.rs
  function new_db_url (line 10) | async fn new_db_url() -> anyhow::Result<(String, TempDir)> {
  function fill_db (line 17) | async fn fill_db(conn: &mut SqliteConnection) -> anyhow::Result<SqliteQu...
  function it_encrypts (line 49) | async fn it_encrypts() -> anyhow::Result<()> {
  function it_can_store_and_read_encrypted_data (line 74) | async fn it_can_store_and_read_encrypted_data() -> anyhow::Result<()> {
  function it_fails_if_password_is_incorrect (line 103) | async fn it_fails_if_password_is_incorrect() -> anyhow::Result<()> {
  function it_honors_order_of_encryption_pragmas (line 131) | async fn it_honors_order_of_encryption_pragmas() -> anyhow::Result<()> {
  function it_allows_to_rekey_the_db (line 174) | async fn it_allows_to_rekey_the_db() -> anyhow::Result<()> {

FILE: tests/sqlite/sqlite.rs
  function it_connects (line 17) | async fn it_connects() -> anyhow::Result<()> {
  function it_fetches_and_inflates_row (line 22) | async fn it_fetches_and_inflates_row() -> anyhow::Result<()> {
  function it_maths (line 88) | async fn it_maths() -> anyhow::Result<()> {
  function test_bind_multiple_statements_multiple_values (line 103) | async fn test_bind_multiple_statements_multiple_values() -> anyhow::Resu...
  function test_bind_multiple_statements_same_value (line 120) | async fn test_bind_multiple_statements_same_value() -> anyhow::Result<()> {
  function it_can_describe_with_pragma (line 136) | async fn it_can_describe_with_pragma() -> anyhow::Result<()> {
  function it_binds_positional_parameters_issue_467 (line 164) | async fn it_binds_positional_parameters_issue_467() -> anyhow::Result<()> {
  function it_fetches_in_loop (line 183) | async fn it_fetches_in_loop() -> anyhow::Result<()> {
  function it_executes_with_pool (line 197) | async fn it_executes_with_pool() -> anyhow::Result<()> {
  function it_opens_with_extension (line 214) | async fn it_opens_with_extension() -> anyhow::Result<()> {
  function it_opens_in_memory (line 233) | async fn it_opens_in_memory() -> anyhow::Result<()> {
  function it_opens_temp_on_disk (line 243) | async fn it_opens_temp_on_disk() -> anyhow::Result<()> {
  function it_fails_to_parse (line 253) | async fn it_fails_to_parse() -> anyhow::Result<()> {
  function it_handles_empty_queries (line 270) | async fn it_handles_empty_queries() -> anyhow::Result<()> {
  function it_binds_parameters (line 280) | async fn it_binds_parameters() -> anyhow::Result<()> {
  function it_binds_dollar_parameters (line 302) | async fn it_binds_dollar_parameters() -> anyhow::Result<()> {
  function it_executes_queries (line 318) | async fn it_executes_queries() -> anyhow::Result<()> {
  function it_can_execute_multiple_statements (line 349) | async fn it_can_execute_multiple_statements() -> anyhow::Result<()> {
  function it_interleaves_reads_and_writes (line 382) | async fn it_interleaves_reads_and_writes() -> anyhow::Result<()> {
  function it_supports_collations (line 416) | async fn it_supports_collations() -> anyhow::Result<()> {
  function it_caches_statements (line 452) | async fn it_caches_statements() -> anyhow::Result<()> {
  function it_can_prepare_then_execute (line 503) | async fn it_can_prepare_then_execute() -> anyhow::Result<()> {
  function it_resets_prepared_statement_after_fetch_one (line 536) | async fn it_resets_prepared_statement_after_fetch_one() -> anyhow::Resul...
  function it_resets_prepared_statement_after_fetch_many (line 555) | async fn it_resets_prepared_statement_after_fetch_many() -> anyhow::Resu...
  function concurrent_resets_dont_segfault (line 576) | async fn concurrent_resets_dont_segfault() {
  function row_dropped_after_connection_doesnt_panic (line 609) | async fn row_dropped_after_connection_doesnt_panic() {
  function issue_1467 (line 634) | async fn issue_1467() -> anyhow::Result<()> {
  function concurrent_read_and_write (line 694) | async fn concurrent_read_and_write() {
  function test_query_with_progress_handler (line 742) | async fn test_query_with_progress_handler() -> anyhow::Result<()> {
  function test_multiple_set_progress_handler_calls_drop_old_handler (line 764) | async fn test_multiple_set_progress_handler_calls_drop_old_handler() -> ...
  function test_query_with_update_hook (line 810) | async fn test_query_with_update_hook() -> anyhow::Result<()> {
  function test_multiple_set_update_hook_calls_drop_old_handler (line 833) | async fn test_multiple_set_update_hook_calls_drop_old_handler() -> anyho...
  function test_query_with_commit_hook (line 866) | async fn test_query_with_commit_hook() -> anyhow::Result<()> {
  function test_multiple_set_commit_hook_calls_drop_old_handler (line 892) | async fn test_multiple_set_commit_hook_calls_drop_old_handler() -> anyho...
  function test_query_with_rollback_hook (line 928) | async fn test_query_with_rollback_hook() -> anyhow::Result<()> {
  function test_multiple_set_rollback_hook_calls_drop_old_handler (line 949) | async fn test_multiple_set_rollback_hook_calls_drop_old_handler() -> any...
  function issue_3150 (line 982) | async fn issue_3150() {
  function test_query_with_preupdate_hook_insert (line 1001) | async fn test_query_with_preupdate_hook_insert() -> anyhow::Result<()> {
  function test_query_with_preupdate_hook_delete (line 1051) | async fn test_query_with_preupdate_hook_delete() -> anyhow::Result<()> {
  function test_query_with_preupdate_hook_update (line 1096) | async fn test_query_with_preupdate_hook_update() -> anyhow::Result<()> {
  function test_multiple_set_preupdate_hook_calls_drop_old_handler (line 1177) | async fn test_multiple_set_preupdate_hook_calls_drop_old_handler() -> an...
  function test_get_last_error (line 1210) | async fn test_get_last_error() -> anyhow::Result<()> {
  function test_serialize_deserialize (line 1231) | async fn test_serialize_deserialize() -> anyhow::Result<()> {
  function test_serialize_deserialize_with_schema (line 1265) | async fn test_serialize_deserialize_with_schema() -> anyhow::Result<()> {
  function test_serialize_nonexistent_schema (line 1309) | async fn test_serialize_nonexistent_schema() -> anyhow::Result<()> {
  function test_serialize_invalid_schema (line 1328) | async fn test_serialize_invalid_schema() -> anyhow::Result<()> {
  function it_can_use_transaction_options (line 1349) | async fn it_can_use_transaction_options() -> anyhow::Result<()> {
  function it_can_recover_from_bad_transaction_begin (line 1379) | async fn it_can_recover_from_bad_transaction_begin() -> anyhow::Result<(...
  function transaction_state (line 1400) | fn transaction_state(handle: &mut LockedSqliteHandle) -> SqliteTransacti...
  type SqliteTransactionState (line 1414) | enum SqliteTransactionState {
  function issue_3982 (line 1421) | async fn issue_3982() -> anyhow::Result<()> {

FILE: tests/sqlite/test-attr.rs
  constant MIGRATOR (line 5) | const MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("tests/sqlite/m...
  function it_gets_a_pool (line 8) | async fn it_gets_a_pool(pool: SqlitePool) -> sqlx::Result<()> {
  function it_gets_users (line 29) | async fn it_gets_users(pool: SqlitePool) -> sqlx::Result<()> {
  function it_gets_posts (line 53) | async fn it_gets_posts(pool: SqlitePool) -> sqlx::Result<()> {
  function it_gets_comments (line 78) | async fn it_gets_comments(pool: SqlitePool) -> sqlx::Result<()> {
  function this_should_compile (line 105) | async fn this_should_compile(_pool: SqlitePool) -> sqlx::Result<()> {

FILE: tests/sqlite/types.rs
  type Friend (line 66) | struct Friend {
  type Customer (line 80) | struct Customer {
  function it_json_extracts (line 90) | async fn it_json_extracts() -> anyhow::Result<()> {
  function test_text_adapter (line 222) | async fn test_text_adapter() -> anyhow::Result<()> {
  function it_binds_with_borrowed_data (line 265) | async fn it_binds_with_borrowed_data() -> anyhow::Result<()> {

FILE: tests/ui-tests.rs
  function ui_tests (line 5) | fn ui_tests() {

FILE: tests/ui/mysql/gated/chrono.rs
  function main (line 1) | fn main() {

FILE: tests/ui/postgres/deprecated_rename.rs
  type Foo (line 3) | enum Foo {
  function main (line 9) | fn main() {

FILE: tests/ui/postgres/gated/chrono.rs
  function main (line 1) | fn main() {

FILE: tests/ui/postgres/gated/ipnetwork.rs
  function main (line 1) | fn main() {

FILE: tests/ui/postgres/gated/uuid.rs
  function main (line 1) | fn main() {

FILE: tests/ui/postgres/issue_30.rs
  function main (line 1) | fn main() {

FILE: tests/ui/postgres/unsupported-type.rs
  function main (line 1) | fn main() {

FILE: tests/ui/postgres/wrong_param_type.rs
  function main (line 1) | fn main() {

FILE: tests/ui/sqlite/expression-column-type.rs
  function main (line 1) | fn main() {

FILE: tests/x.py
  function maybe_fetch_sqlite_extension (line 28) | def maybe_fetch_sqlite_extension():
  function run (line 58) | def run(command, comment=None, env=None, service=None, tag=None, args=No...