Vendor dependencies

notes-service/vendor/sqlx/tests/.dockerignore

@@ -0,0 +1,7 @@
+*
+!certs/*
+!certs/keys/*
+!mysql/my.cnf
+!mssql/*.sh
+!postgres/pg_hba.conf
+!*/*.sql

notes-service/vendor/sqlx/tests/.env

@@ -0,0 +1,2 @@
+# environment values for docker-compose
+COMPOSE_PROJECT_NAME=sqlx

notes-service/vendor/sqlx/tests/README.md

@@ -0,0 +1,59 @@
+
+
+### Running Tests
+SQLx uses docker to run many compatible database systems for integration testing. You'll need to [install docker](https://docs.docker.com/engine/) to run the full suite. You can validate your docker installation with:
+    
+    $ docker run hello-world
+
+Start the databases with `docker compose` (or `docker-compose`) before running tests:
+
+    $ docker compose up -d
+
+Run clippy for the check matrix:
+
+    $ ./x.py --clippy
+
+This runs only the check/clippy matrix and skips unit and integration tests.
+
+For the full test matrix, run all tests against all supported databases using:
+
+    $ ./x.py
+
+### Limiting the Matrix
+
+The full matrix (runtimes, TLS backends, and DB versions) is large. Use the filters in `x.py` to keep runs small.
+
+List all targets (tags):
+
+    $ ./x.py --list-targets
+
+Run by prefix (uses `tag.startswith`):
+
+    $ ./x.py --target sqlite_tokio
+    $ ./x.py --target postgres_17_tokio
+    $ ./x.py --target mysql_8
+    $ ./x.py --target mariadb_10_11
+
+Note: integration tags do not include TLS, so a target like `postgres_17_tokio`
+still runs all `TLS_VARIANTS`. To limit TLS locally, edit `TLS_VARIANTS` (and
+`CHECK_TLS` for the check phase).
+
+Run exactly one target:
+
+    $ ./x.py --target-exact mysql_8_client_ssl_no_password_tokio
+
+Run only one integration test binary:
+
+    $ ./x.py --test sqlite
+    $ ./x.py --test any
+
+Pass extra args to cargo:
+
+    $ ./x.py -- --nocapture
+
+To shrink the matrix globally, edit the lists at the top of `tests/x.py`:
+`CHECK_TLS`, `TLS_VARIANTS`, `POSTGRES_VERSIONS`, `MYSQL_VERSIONS`, `MARIADB_VERSIONS`.
+
+If you see test failures, or want to run a more specific set of tests against a specific database, you can specify both the features to be tests and the DATABASE_URL. e.g.
+
+    $ DATABASE_URL=mysql://root:password@127.0.0.1:49183/sqlx cargo test --no-default-features --features macros,offline,any,all-types,mysql,runtime-async-std-native-tls

notes-service/vendor/sqlx/tests/any/any.rs

@@ -0,0 +1,210 @@
+use sqlx::any::{install_default_drivers, AnyRow};
+use sqlx::{Any, Connection, Executor, Row};
+use sqlx_core::error::BoxDynError;
+use sqlx_core::sql_str::AssertSqlSafe;
+use sqlx_core::Error;
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_connects() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    let value = sqlx::query("select 1 + 5")
+        .try_map(|row: AnyRow| row.try_get::<i32, _>(0))
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(6i32, value);
+
+    conn.close().await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_pings() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    conn.ping().await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_executes_with_pool() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let pool = sqlx_test::pool::<Any>().await?;
+
+    let rows = pool.fetch_all("SELECT 1; SElECT 2").await?;
+
+    assert_eq!(rows.len(), 2);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_does_not_stop_stream_after_decoding_error() -> anyhow::Result<()> {
+    use futures_util::stream::StreamExt;
+
+    sqlx::any::install_default_drivers();
+
+    // see https://github.com/launchbadge/sqlx/issues/1884
+    let pool = sqlx_test::pool::<Any>().await?;
+
+    #[derive(Debug, PartialEq)]
+    struct MyType;
+    impl<'a> sqlx::FromRow<'a, AnyRow> for MyType {
+        fn from_row(row: &'a AnyRow) -> sqlx::Result<Self> {
+            let n = row.try_get::<i32, _>(0)?;
+            if n == 1 {
+                Err(sqlx::Error::RowNotFound)
+            } else {
+                Ok(MyType)
+            }
+        }
+    }
+
+    let rows = sqlx::query_as("SELECT 0 UNION ALL SELECT 1 UNION ALL SELECT 2")
+        .fetch(&pool)
+        .map(|r| r.ok())
+        .collect::<Vec<_>>()
+        .await;
+
+    assert_eq!(rows, vec![Some(MyType), None, Some(MyType)]);
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_gets_by_name() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    let row = conn.fetch_one("SELECT 1 as _1").await?;
+    let val: i32 = row.get("_1");
+
+    assert_eq!(val, 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_fail_and_recover() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    for i in 0..10 {
+        // make a query that will fail
+        let res = conn
+            .execute("INSERT INTO not_found (column) VALUES (10)")
+            .await;
+
+        assert!(res.is_err());
+
+        // now try and use the connection
+        let val: i32 = conn
+            .fetch_one(AssertSqlSafe(format!("SELECT {i}")))
+            .await?
+            .get_unchecked(0);
+
+        assert_eq!(val, i);
+    }
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_fail_and_recover_with_pool() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let pool = sqlx_test::pool::<Any>().await?;
+
+    for i in 0..10 {
+        // make a query that will fail
+        let res = pool
+            .execute("INSERT INTO not_found (column) VALUES (10)")
+            .await;
+
+        assert!(res.is_err());
+
+        // now try and use the connection
+        let val: i32 = pool
+            .fetch_one(AssertSqlSafe(format!("SELECT {i}")))
+            .await?
+            .get_unchecked(0);
+
+        assert_eq!(val, i);
+    }
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_query_by_string_args() -> sqlx::Result<()> {
+    install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    let string = "Hello, world!".to_string();
+    let ref tuple = ("Hello, world!".to_string(),);
+
+    #[cfg(feature = "postgres")]
+    const SQL: &str = "SELECT 'Hello, world!' \
+        FROM (SELECT 1) AS t \
+        WHERE 'Hello, world!' IN ($1, $2, $3, $4, $5, $6, $7)";
+
+    #[cfg(not(feature = "postgres"))]
+    const SQL: &str = "SELECT 'Hello, world!' \
+        FROM (SELECT 1) AS t \
+        WHERE 'Hello, world!' IN (?, ?, ?, ?, ?, ?, ?)";
+
+    {
+        let query = sqlx::query(SQL)
+            // validate flexibility of lifetimes
+            .bind(&string)
+            .bind(&string[..])
+            .bind(Some(&string))
+            .bind(Some(&string[..]))
+            .bind(&Option::<String>::None)
+            .bind(&string.clone())
+            .bind(&tuple.0); // should not get "temporary value is freed at the end of this statement" here
+
+        let result = query.fetch_one(&mut conn).await?;
+
+        let column_0: String = result.try_get(0)?;
+
+        assert_eq!(column_0, string);
+    }
+
+    {
+        let mut query = sqlx::query(SQL);
+
+        let query = || -> Result<_, BoxDynError> {
+            // validate flexibility of lifetimes
+            query.try_bind(&string)?;
+            query.try_bind(&string[..])?;
+            query.try_bind(Some(&string))?;
+            query.try_bind(Some(&string[..]))?;
+            query.try_bind(&Option::<String>::None)?;
+            query.try_bind(&string.clone())?;
+            query.try_bind(&tuple.0)?;
+
+            Ok(query)
+        }()
+        .map_err(Error::Encode)?;
+
+        let result = query.fetch_one(&mut conn).await?;
+
+        let column_0: String = result.try_get(0)?;
+
+        assert_eq!(column_0, string);
+    }
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/any/pool.rs

@@ -0,0 +1,270 @@
+use sqlx::any::{AnyConnectOptions, AnyPoolOptions};
+use sqlx::Executor;
+use sqlx_core::sql_str::AssertSqlSafe;
+use std::sync::{
+    atomic::{AtomicI32, AtomicUsize, Ordering},
+    Arc, Mutex,
+};
+use std::time::Duration;
+
+#[sqlx_macros::test]
+async fn pool_should_invoke_after_connect() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let counter = Arc::new(AtomicUsize::new(0));
+
+    let pool = AnyPoolOptions::new()
+        .after_connect({
+            let counter = counter.clone();
+            move |_conn, _meta| {
+                let counter = counter.clone();
+                Box::pin(async move {
+                    counter.fetch_add(1, Ordering::SeqCst);
+
+                    Ok(())
+                })
+            }
+        })
+        .connect(&dotenvy::var("DATABASE_URL")?)
+        .await?;
+
+    let _ = pool.acquire().await?;
+    let _ = pool.acquire().await?;
+    let _ = pool.acquire().await?;
+    let _ = pool.acquire().await?;
+
+    // since connections are released asynchronously,
+    // `.after_connect()` may be called more than once
+    assert!(counter.load(Ordering::SeqCst) >= 1);
+
+    Ok(())
+}
+
+// https://github.com/launchbadge/sqlx/issues/527
+#[sqlx_macros::test]
+async fn pool_should_be_returned_failed_transactions() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let pool = AnyPoolOptions::new()
+        .max_connections(2)
+        .acquire_timeout(Duration::from_secs(3))
+        .connect(&dotenvy::var("DATABASE_URL")?)
+        .await?;
+
+    let query = "blah blah";
+
+    let mut tx = pool.begin().await?;
+    let res = sqlx::query(query).execute(&mut *tx).await;
+    assert!(res.is_err());
+    drop(tx);
+
+    let mut tx = pool.begin().await?;
+    let res = sqlx::query(query).execute(&mut *tx).await;
+    assert!(res.is_err());
+    drop(tx);
+
+    let mut tx = pool.begin().await?;
+    let res = sqlx::query(query).execute(&mut *tx).await;
+    assert!(res.is_err());
+    drop(tx);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_pool_callbacks() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
+    struct ConnStats {
+        id: i32,
+        before_acquire_calls: i32,
+        after_release_calls: i32,
+    }
+
+    sqlx_test::setup_if_needed();
+
+    let conn_options: AnyConnectOptions = std::env::var("DATABASE_URL")?.parse()?;
+
+    let current_id = AtomicI32::new(0);
+
+    let pool = AnyPoolOptions::new()
+        .max_connections(1)
+        .acquire_timeout(Duration::from_secs(5))
+        .after_connect(move |conn, meta| {
+            assert_eq!(meta.age, Duration::ZERO);
+            assert_eq!(meta.idle_for, Duration::ZERO);
+
+            let id = current_id.fetch_add(1, Ordering::AcqRel);
+
+            Box::pin(async move {
+                let statement = format!(
+                    // language=SQL
+                    r#"
+                    CREATE TEMPORARY TABLE conn_stats(
+                        id int primary key,
+                        before_acquire_calls int default 0,
+                        after_release_calls int default 0
+                    );
+                    INSERT INTO conn_stats(id) VALUES ({});
+                    "#,
+                    // Until we have generalized bind parameters
+                    id
+                );
+
+                conn.execute(AssertSqlSafe(statement)).await?;
+                Ok(())
+            })
+        })
+        .before_acquire(|conn, meta| {
+            // `age` and `idle_for` should both be nonzero
+            assert_ne!(meta.age, Duration::ZERO);
+            assert_ne!(meta.idle_for, Duration::ZERO);
+
+            Box::pin(async move {
+                // MySQL and MariaDB don't support UPDATE ... RETURNING
+                sqlx::query(
+                    r#"
+                        UPDATE conn_stats
+                        SET before_acquire_calls = before_acquire_calls + 1
+                    "#,
+                )
+                .execute(&mut *conn)
+                .await?;
+
+                let stats: ConnStats = sqlx::query_as("SELECT * FROM conn_stats")
+                    .fetch_one(conn)
+                    .await?;
+
+                // For even IDs, cap by the number of before_acquire calls.
+                // Ignore the check for odd IDs.
+                Ok((stats.id & 1) == 1 || stats.before_acquire_calls < 3)
+            })
+        })
+        .after_release(|conn, meta| {
+            // `age` should be nonzero but `idle_for` should be zero.
+            assert_ne!(meta.age, Duration::ZERO);
+            assert_eq!(meta.idle_for, Duration::ZERO);
+
+            Box::pin(async move {
+                sqlx::query(
+                    r#"
+                        UPDATE conn_stats
+                        SET after_release_calls = after_release_calls + 1
+                    "#,
+                )
+                .execute(&mut *conn)
+                .await?;
+
+                let stats: ConnStats = sqlx::query_as("SELECT * FROM conn_stats")
+                    .fetch_one(conn)
+                    .await?;
+
+                // For odd IDs, cap by the number of before_release calls.
+                // Ignore the check for even IDs.
+                Ok((stats.id & 1) == 0 || stats.after_release_calls < 4)
+            })
+        })
+        // Don't establish a connection yet.
+        .connect_lazy_with(conn_options);
+
+    // Expected pattern of (id, before_acquire_calls, after_release_calls)
+    let pattern = [
+        // The connection pool starts empty.
+        (0, 0, 0),
+        (0, 1, 1),
+        (0, 2, 2),
+        (1, 0, 0),
+        (1, 1, 1),
+        (1, 2, 2),
+        // We should expect one more `acquire` because the ID is odd
+        (1, 3, 3),
+        (2, 0, 0),
+        (2, 1, 1),
+        (2, 2, 2),
+        (3, 0, 0),
+    ];
+
+    for (id, before_acquire_calls, after_release_calls) in pattern {
+        let conn_stats: ConnStats = sqlx::query_as("SELECT * FROM conn_stats")
+            .fetch_one(&pool)
+            .await?;
+
+        assert_eq!(
+            conn_stats,
+            ConnStats {
+                id,
+                before_acquire_calls,
+                after_release_calls
+            }
+        );
+    }
+
+    pool.close().await;
+
+    Ok(())
+}
+
+#[ignore]
+#[sqlx_macros::test]
+async fn test_connection_maintenance() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+    sqlx_test::setup_if_needed();
+    let conn_options: AnyConnectOptions = std::env::var("DATABASE_URL")?.parse()?;
+
+    let last_meta = Arc::new(Mutex::new(None));
+    let last_meta_ = last_meta.clone();
+    let pool = AnyPoolOptions::new()
+        .max_lifetime(Duration::from_millis(400))
+        .min_connections(3)
+        .before_acquire(move |_conn, _meta| {
+            *last_meta_.lock().unwrap() = Some(_meta);
+            Box::pin(async { Ok(true) })
+        })
+        .connect_lazy_with(conn_options);
+
+    // Open and release 5 connections
+    let conns = vec![
+        pool.acquire().await?,
+        pool.acquire().await?,
+        pool.acquire().await?,
+        pool.acquire().await?,
+        pool.acquire().await?,
+    ];
+    assert_eq!(pool.size(), 5);
+    assert_eq!(pool.num_idle(), 0);
+    for mut conn in conns {
+        conn.return_to_pool().await;
+    }
+
+    assert_eq!(pool.size(), 5);
+    assert_eq!(pool.num_idle(), 5);
+
+    // Wait for at least two iterations of maintenance task
+    sqlx_core::rt::sleep(Duration::from_secs(1)).await;
+
+    // Existing connections should have been closed due to max lifetime
+    // and the pool should have reopened min_connections new ones.
+    // One connection might be in the process of being replaced so we assert 2-3.
+    assert!(
+        pool.size() >= 2 && pool.size() <= 3,
+        "pool.size() = {}",
+        pool.size()
+    );
+    for _ in 0..2 {
+        // Check that the connections was both acquired from the pool AND it's new
+        let _ = pool.acquire().await.expect("failed to acquire connection");
+        let meta = last_meta
+            .lock()
+            .unwrap()
+            .take()
+            .expect("expected a connection from the pool");
+        assert!(
+            meta.age < Duration::from_secs(2),
+            "expected a fresh connection (age {:?})",
+            meta.age
+        );
+    }
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/certs/README.md

@@ -0,0 +1,93 @@
+# SQLx Test TLS Certificates
+
+This directory contains the following files for testing TLS connections.
+
+* `ca.crt`: Self-signed Certificate Authority for `client.crt`
+* `client.crt`: Client certificate signed by `ca.crt`
+* `server.crt`: Server certificate signed by `ca.crt`
+
+These certificates are **not** to be used outside of testing with SQLx.
+The private keys are publicly available in the `keys` directory.
+
+These certificates should be valid until the year 2035.
+
+RusTLS requires TLS certificates to be x509v3. 
+OpenSSL 3.2 and up create v3 certificates by default.
+
+### MySQL 5.7 (RSA)
+
+The default test certificates in this directory use Ed25519, which MySQL 5.7
+cannot load. We keep a separate RSA CA/client/server set under
+`tests/certs/rsa` and use it only for the MySQL 5.7 client-SSL targets.
+
+## (Re)generating
+
+When generating certificates, OpenSSL prompts for a number of fields:
+
+```
+You are about to be asked to enter information that will be incorporated
+into your certificate request.
+What you are about to enter is what is called a Distinguished Name or a DN.
+There are quite a few fields but you can leave some blank
+For some fields there will be a default value,
+If you enter '.', the field will be left blank.
+-----
+Country Name (2 letter code) [AU]:
+State or Province Name (full name) [Some-State]:
+Locality Name (eg, city) []:
+Organization Name (eg, company) [Internet Widgits Pty Ltd]:
+Organizational Unit Name (eg, section) []:
+Common Name (e.g. server FQDN or YOUR name) []:
+Email Address []:
+```
+
+These are purely informational and can _generally_ be left blank or filled with arbitrary values 
+(except for `Common Name` with client certificates; see below for details).
+
+### CA Certificate
+
+Create a self-signed root certificate:
+
+```shell
+openssl req -x509 -sha256 -days 3650 -key keys/ca.key -out ca.crt
+```
+
+This is passed as a trust root when testing certificate authentication.
+
+### Client Certificate
+
+**Note**: Postgres expects the Common Name (`CN`) field of the certificate to match the database username: 
+<https://www.postgresql.org/docs/current/auth-cert.html>
+
+At the prompt `Common Name (e.g. server FQDN or YOUR name) []:`, enter `postgres`.
+
+Create a certificate signing request (CSR) to "submit" to our fake certificate authority:
+
+```
+openssl req -key keys/client.key -new -out client.csr
+```
+
+Create a signed certificate using our CA key and the CSR:
+
+```
+openssl x509 -req -CA ca.crt -CAkey keys/ca.key -in client.csr -out client.crt -days 3650 -CAcreateserial
+```
+
+### Server Certificate
+
+
+Create a certificate signing request (CSR) to "submit" to our fake certificate authority:
+
+```
+openssl req -key keys/server.key -new -out server.csr -addext subjectAltName=DNS:sqlx.rs
+```
+
+This adds a required x509 v3 extension:
+* `subjectAltName=DNS:sqlx.rs` supplies the Subject Alternative Name that RusTLS uses to verify the hostname.
+  * Only checked if using SSL mode `ssl_mode=verify_identity` (MySQL/MariaDB) or `sslmode=verify-full` (Postgres).
+
+Create a signed certificate using our CA key and the CSR:
+
+```
+openssl x509 -req -CA ca.crt -CAkey keys/ca.key -in server.csr -out server.crt -days 3650 -CAcreateserial
+```

notes-service/vendor/sqlx/tests/certs/ca.crt

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIB0zCCAYWgAwIBAgIUEFN5G3AUb5d/ZC+q+YtFuMeoWvowBQYDK2VwMF8xCzAJ
+BgNVBAYTAnVzMRMwEQYDVQQIDApjYWxpZm9ybmlhMSEwHwYDVQQKDBhJbnRlcm5l
+dCBXaWRnaXRzIFB0eSBMdGQxGDAWBgNVBAMMD0F1c3RpbiBCb25hbmRlcjAeFw0y
+NTA3MDEwMzA4MTVaFw0zNTA2MjkwMzA4MTVaMF8xCzAJBgNVBAYTAnVzMRMwEQYD
+VQQIDApjYWxpZm9ybmlhMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBM
+dGQxGDAWBgNVBAMMD0F1c3RpbiBCb25hbmRlcjAqMAUGAytlcAMhAHfjdF5QJ4OW
+k/3XLlsxDcP8cwBVmB+ySWKq2JanRS8uo1MwUTAdBgNVHQ4EFgQUCw2pVpGKz2xk
+IjbVHYh0LnzdkW4wHwYDVR0jBBgwFoAUCw2pVpGKz2xkIjbVHYh0LnzdkW4wDwYD
+VR0TAQH/BAUwAwEB/zAFBgMrZXADQQBA6VMDBPz9x0b5Wvw4D+2UrLdyhzzjqtrX
+UQOjCTqcKdEwWvgS6ftiQlQJPDfkVDEMOAJgqRmEGvsKjvwMCPIC
+-----END CERTIFICATE-----

notes-service/vendor/sqlx/tests/certs/client.crt

@@ -0,0 +1,11 @@
+-----BEGIN CERTIFICATE-----
+MIIBqjCCAVygAwIBAgIURmjYOsv10CRGeCFUY35KOsBmD8IwBQYDK2VwMF8xCzAJ
+BgNVBAYTAnVzMRMwEQYDVQQIDApjYWxpZm9ybmlhMSEwHwYDVQQKDBhJbnRlcm5l
+dCBXaWRnaXRzIFB0eSBMdGQxGDAWBgNVBAMMD0F1c3RpbiBCb25hbmRlcjAeFw0y
+NTA3MDEwNjQ2NDdaFw0zNTA2MjkwNjQ2NDdaMEcxCzAJBgNVBAYTAnVzMRMwEQYD
+VQQIDApjYWxpZm9ybmlhMRAwDgYDVQQKDAdTUUx4LnJzMREwDwYDVQQDDAhwb3N0
+Z3JlczAqMAUGAytlcAMhAKlX7AIHulcVhkBeSN2WtjZbjzde5tlUKwVWyWEhP7sE
+o0IwQDAdBgNVHQ4EFgQUf2VV1eVj09YOwgKa1ZX1kq7VAd4wHwYDVR0jBBgwFoAU
+Cw2pVpGKz2xkIjbVHYh0LnzdkW4wBQYDK2VwA0EA5WMQjRBwEI/QtLzSAQTy5fSM
+FGorJMxGtUpBjFzCEbYku4EHvbJoN707Kf9vYpgxjAIyP2cowxj/Wdd4paegBg==
+-----END CERTIFICATE-----

notes-service/vendor/sqlx/tests/certs/keys/ca.key

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEILnh8afwKgHjlFlCqooToMmzrI3DAifXtxhUtnCElFtn
+-----END PRIVATE KEY-----

notes-service/vendor/sqlx/tests/certs/keys/client.key

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEICauTALD/rWma9h+oROYjcxDrzI9KZlaVzwmhiTpSItd
+-----END PRIVATE KEY-----

notes-service/vendor/sqlx/tests/certs/keys/server.key

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEIAbYyLPV13NEkja/UUn+MB00kdTMivtC9DFysTjtZOXb
+-----END PRIVATE KEY-----

notes-service/vendor/sqlx/tests/certs/rsa/ca.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDizCCAnOgAwIBAgIUYWAIZEOv172fTkUC1LZvQbdmUcYwDQYJKoZIhvcNAQEL
+BQAwVTELMAkGA1UEBhMCdXMxEzARBgNVBAgMCmNhbGlmb3JuaWExEDAOBgNVBAoM
+B1NRTHgucnMxHzAdBgNVBAMMFlNRTHggTXlTUUwgNS43IFRlc3QgQ0EwHhcNMjYw
+MTE3MjA0OTQzWhcNMzYwMTE1MjA0OTQzWjBVMQswCQYDVQQGEwJ1czETMBEGA1UE
+CAwKY2FsaWZvcm5pYTEQMA4GA1UECgwHU1FMeC5yczEfMB0GA1UEAwwWU1FMeCBN
+eVNRTCA1LjcgVGVzdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AJlTKGk0hm+kuaX7AXFPt7z3EgkAakqEF7zpz6oyKohgQ/favYUgFW36A27VCpLs
+eUhzRvlYUaLjdbMiSZMcDLyFMPQysFR6XFmB/loUppEhWGUCY/2qbUlnCd3jj9vB
+qSuJ4KkVHo9HMeivLhAxEiFQ60iYgQ1dC+cOXxXckDUAqr1ZRVCwpkqo5VKyi5Ft
+2jo2I8q20pAbnPteQJcWwF4zdKD989WoToZyFEsHGSNJvx7qsXnbbQV9ZfVD2gQO
+3ac8rO746lq/Mv4hvX7UmRE3N/wrJvsE6wkHLOGwqs79AlWfUR/7PDxf2Qolaujf
+e7ZSWVmvsG4YsHLYbFgt0rECAwEAAaNTMFEwHQYDVR0OBBYEFOJi5+EmSMZYTpnK
+IEdk7FyA6RsUMB8GA1UdIwQYMBaAFOJi5+EmSMZYTpnKIEdk7FyA6RsUMA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBABiC7AG9C8HmMEHEFgK0Vu96
+JKnWrObjINR07VfxLNpQ8lCSTdxVj6f4gNA4rfWuoai5+9us/nVQEHWwul7OZM5s
+nrrh6G4xF6gWETpCj7Psro33tA3P9gjYanf9pBA8cEnjSN9mZdR+EToNkWwqYa25
+KnNUSV8dAmOGWkFinqQh1buR5BL55muffKL91rDtsbjVuS+FKfXUF6RR7+MwHuGz
+KSuK5jN2lXuXryyuCLqKdEP5Hzi453M1EbSnbFPNnNihVsO7IEbyrvsrdDoo2KwQ
+kZsWZxdT7CnVkVVUDrgJTql4suDYdcJkY/wAm8lPDf+oHyEBEXoNCmW31pKu6o8=
+-----END CERTIFICATE-----

notes-service/vendor/sqlx/tests/certs/rsa/client.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDJzCCAg8CFAxjCSTLziRQ3tsnEl9kRYWx+mDmMA0GCSqGSIb3DQEBCwUAMFUx
+CzAJBgNVBAYTAnVzMRMwEQYDVQQIDApjYWxpZm9ybmlhMRAwDgYDVQQKDAdTUUx4
+LnJzMR8wHQYDVQQDDBZTUUx4IE15U1FMIDUuNyBUZXN0IENBMB4XDTI2MDExNzIw
+NTAxMFoXDTM2MDExNTIwNTAxMFowSzELMAkGA1UEBhMCdXMxEzARBgNVBAgMCmNh
+bGlmb3JuaWExEDAOBgNVBAoMB1NRTHgucnMxFTATBgNVBAMMDG15c3FsLWNsaWVu
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALMvA+vqxPuTVtX/9uFH
+Up7Wkx5iaFBiC2x3wTLZX1WavknU/aw8jYQabgwVbiCaCvjoncPtQt1abtzBvPbL
+HpXC6h91D0hpMabzr8HyRutPQ09MK2OkIQvIJZPFu8CKbDdSsD2uqgSEjvAeFxKv
+v1JdL24ha+hoojTnG+Of5qzPgIKeuQrUa5lvB0RVpxxs86tjENZXsqgYVtCD3i9u
+ne6DGcTn0sMZTjQiHll0HGbTPEOY0CzIp+xoAOrTfVXeAVhi+B90U31q371X70+H
+qa6R8KmsJ4f+qWn26yJoZacLEcO97IPZLxo+zEegDSDIWfiCDb8o+JGdjpMDmsvS
+XIECAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAOBdK+gBtdy8hAF313FCBCNAhe5eF
+jSVUt0B+sknqXh5W2cx8J0cfyiL2/HgID5t4d1JaNOUt+3Pv2XDWgp8zQ7Tqob+j
+Rp0M//IuBAJgyBkN6E+Xok+4sIX8pRJ0fYPzHPU7LbnCcKb6tc5MnY6wjtLM1I8F
+ayCwXIEdXcsvPey98kWnmwJu4QHpjBkvAs6NEGWbW2ZLdm0URdAUdBlgv/sSNnV9
+4UTHVvjk1/aZOC2BTtcNvLO+8qXRkeWy/YMEFKMWtcF19uXOS39jTtjeRnyNhosy
+g6yFsDbcEU+TnVtRA0lji+DsRJ3JBLT6UKmIY45tMYMDqlDm77MwLcH1sw==
+-----END CERTIFICATE-----

notes-service/vendor/sqlx/tests/certs/rsa/keys/ca.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCZUyhpNIZvpLml
++wFxT7e89xIJAGpKhBe86c+qMiqIYEP32r2FIBVt+gNu1QqS7HlIc0b5WFGi43Wz
+IkmTHAy8hTD0MrBUelxZgf5aFKaRIVhlAmP9qm1JZwnd44/bwakrieCpFR6PRzHo
+ry4QMRIhUOtImIENXQvnDl8V3JA1AKq9WUVQsKZKqOVSsouRbdo6NiPKttKQG5z7
+XkCXFsBeM3Sg/fPVqE6GchRLBxkjSb8e6rF5220FfWX1Q9oEDt2nPKzu+OpavzL+
+Ib1+1JkRNzf8Kyb7BOsJByzhsKrO/QJVn1Ef+zw8X9kKJWro33u2UllZr7BuGLBy
+2GxYLdKxAgMBAAECggEAHNJYfNpOUStOaKiT/1hkaiWpor6MvIAzNCRhkJVIkIVE
+EZHxYVaEIL3IKmvqxm6kZ92foFydT/jhFbDi0sAJluCUsLrckazEsmCwzv8lxo9V
+nftCj5sbWxp+7NKLptwzMEeFT1N0gKt58ssHZizLQy8CY42jaL8ubxsw/ZuOEiBI
+4bz+tr17UWxA08K4jmxM+un+wUSAa1X6+j8DqqdvAyGXoHRoyweQQ8gC87c7pIal
+GMIk+Bk1izILR2SdgoOdLiTASpYQEr6x3/+A/ZGixlD6tlM2twuKWD3LuGhDCZ/V
+I0+3MQxO8PPKdb3DaB5ReRyVyuNTpaH7SxKnbV9vzwKBgQDQzWTxnsEDf2zCfsO+
+yDntH9tTigI+WMt6nVX4lV3jy6fnqa+6zPuYxes6RLRMkJZMud1S3b35FNW9lQHd
+CYxS4eRO1DnrRWFgj8VGJQ97d4wqSg5YLoB/de/h6JN7C2SctsmCXm9qL0L5wXrx
+DS5ZWLe//gKIDPU8m8yMEvbkjwKBgQC7+31p/Lgu39DqhiRCrbwMShOgu9JqTlmN
+LroJJ2eZA931gnK3wysWlHpJBu6+/ObippEW9IJ+NRecYHe/jMyL1fCCm6iCUu6o
+E8s2u8lzltOQSskC6PBn9p/kM3mmC+mhlA2qFYoInT+2OMZhbFup96fb1Yc5FmPR
+/k0QKE/0vwKBgQDP97OSANgn3rP56H6YuB8R8gfm5e+kH5bTkn/9bvAsIj0jPVx9
+RwtVN9Q5nhKiq+Q3mWw6zAcaXskg4ZgQiyELsFhQt4rUra72mVwYqHMKO6EMweQV
+qoNr8JCzxo2WIVvdxyVfxyVbcqVX04DbNJC0huvFu37T+WwNKPSLk5v7OwKBgCis
+TYJ1L9TUkHtt8sKKnLl7/as1eF2P/khR5+a7I+szrv7D7tZb4CLOlXbfjSC9z6cS
+qynwVZvBGQ64wLAtYsSO0a8wxtEL6J9tSPbawsfDxprd04hRplKYRhg2GwgWY8KW
+Ki624lriyzo+Jo5Fx7+K2kLyfIOZmJeDEmGAl2w5AoGALtFWXrHFNuHqFAk7oRBk
+m6IgHrWf4SAH13fbReROk3nAhZwRBUIoFBSBJA8i0z3kjg01lm3rk64h5SwB7WIg
+As+x0QYVlQifR7Lv0kQbtN55GsQYYyj4DUPTqVvZXSm88yzJ0TqFWLd5RdhFZviC
+ZPF8adFIzEAnRXoEH6d98Og=
+-----END PRIVATE KEY-----

notes-service/vendor/sqlx/tests/certs/rsa/keys/client.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCzLwPr6sT7k1bV
+//bhR1Ke1pMeYmhQYgtsd8Ey2V9Vmr5J1P2sPI2EGm4MFW4gmgr46J3D7ULdWm7c
+wbz2yx6VwuofdQ9IaTGm86/B8kbrT0NPTCtjpCELyCWTxbvAimw3UrA9rqoEhI7w
+HhcSr79SXS9uIWvoaKI05xvjn+asz4CCnrkK1GuZbwdEVaccbPOrYxDWV7KoGFbQ
+g94vbp3ugxnE59LDGU40Ih5ZdBxm0zxDmNAsyKfsaADq031V3gFYYvgfdFN9at+9
+V+9Ph6mukfCprCeH/qlp9usiaGWnCxHDveyD2S8aPsxHoA0gyFn4gg2/KPiRnY6T
+A5rL0lyBAgMBAAECggEABX/ZnvZMgyMCh0XBlyh0qdkQqt4RMPiszswCtEOuhM2E
+Li2kdu33IM2u3B3MQ30JIlFvGG/CC1JNgnkCCpEMzPmcNe09QbKLHLk5YpXocr4g
+m+C6mMIDHRBQqThoZjdHGv3cauOoVDIGejOWytd1dX9mrB81535zMuNSrqnL/O94
+0lmIn3iIwqGY0Hcc1Oed4GnOp0mSbjQfJ9SrBNTYS0BrbnYeO0B+E0W6nc/AfTRw
+JLri5zWl+iQpiKjtvu9ABmLMeI5NrFzsZaUOPnTaJ3XKAr5tUWfB/pnjWf07JhRZ
+5z97qjx1UTcjNiy/xCS0BzHm11FlOviBtNLF9NFEAQKBgQDnl4Pxg4Fmo/aCDL4E
+so/YMfXJEH1qaGmtaI8pwsWtvlTQeflFYvNNZqSihe+YzkdrOWdIqBQS5vyjS/pl
+yDhUU9ZUNWrtJBgo7bPHLKXP5t2asfvvHEp7YPZH6WWsJW2P8cslWmyu9lHIO9S5
+rdcTHfd+pKTK5fVZGCBsxWEXfwKBgQDGEX7pADH4xjBfbWt4KCJH1Yoy+p+8ftkt
+/nN4KS+0P6dTne9Dmekt/wrX4n0qrJLYTzCO0LU7KDOgD7K/3JMwqgIYSYnFSEPt
+LNaSKXhRhazgOhr55YfR4WGNfixApgrkICwB2iKqnkSZCu0wIqogr1BWE1vj84I7
+WNzcxKaL/wKBgQDEeEeZJkUq/EJuRb0WYx2g/ZFUB8c99GJimGeLuA7XvLZbPn74
+HF/n9AILVrDS43y3PDWg7+ZHuuns5tIAcwFGmPEk80RI9ewBHNb9S6VHYMXzLLdc
+PJX7YWDN1PVKO15dVXVPtQyqyZDL2+Y1t4LUVwHV0Ht1He0srkkjvbcGpQKBgQCS
+c5lNGzHX6mMWDEfsfnBqgQBAlYPK0lgvY/dpH7sAIhjNAPhLGeCKfAw+eF9oUFX7
+zwHud2+poB4b+b+Hkcbbsrj90FIoJzjig8bcKAGo9ZhP62bK4+a7T1TcVDDQVHW1
+G/yuGeaMFZ5PMv8SGm+E31wdaQ8Gy6S90QTt0BH9bQKBgFuOaNc+ByJl6zLpxoXI
+Xtdd0jtzIwMHz6XOi+fn1BaCaadB+WWKbp8Si6WnkHXAckFIRLt6n86Pb4v79kVB
+GKY/saNvtv8FWx9IfKCc/utrTm27J+OhAQhvChrrb4kGpbm8iBqX1mNstDcaKS5x
+I6RrWqv3aLoo0Gxvy01sRaC0
+-----END PRIVATE KEY-----

notes-service/vendor/sqlx/tests/certs/rsa/keys/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDQMXlx6SQejGgE
+viUQMUb40KkFixRo0FlHb4mONLPbMZ+TCNGt1OziLe2pPJnnfJPdq3miKza2iuxX
+sB8e9wL2XVra3HtD1qlbl12vkPx8DHO2NNh3BYFgDij9CNZNAaD2O0IjDtBkhcv+
+yOYUoEnehtu4KyoiYcZbD1iASxJtiyK6fNWIWFRxYR+AF6t0BKEQKSivbiXtkawc
+asXxelC8nupIwijgEms3CRabyDnMkJnWJ3wPuTDzQr7g3xW9NQ/rkKfqnw96rQJV
+K1OxLr3c4D7/7T5Dt6glJijghCqgUrc2I8Z1cEdDWEJ2rED4a9CztW5nTenfc9pb
+hw/yTue5AgMBAAECggEABa4/PZxSdy/BKVWiXNfJXiyRsL7ny0iEZ8fLdC5sNL2H
+g1YCOaOQZJyt9M2Rt1B4V5Fa7TxlCWlO6QFwsfIPD2ztQmucb0Bjfdt/wQn8LQAp
+JUY5x1Kb7M8/b1BkdN9dNobCp4Kl7UOTf76DJ6TW1dFucURNPvkAa2zmucEX+JY+
+ug4ZvKY7EH7vV5Hr96tfCz2oCcbtJn3NBODE0Nq6FYxzZsEMsMmAFDDutncBZVQl
+3K77te2v2UussYuFqae0t2+VUADJ6Jc3oNHWKAvGG0zSa/W4yAFVc5feJzD4I/qD
+vEVZOQRkUmjcDZwI5mGgwFdSf/I8c/HFh71W1H/1MQKBgQDzoWntgSU8TNfhj2s1
+bq+hCxOs9ytuH7TALd4DoqGTr7y79d0PCYUCOHHY7cXdVUTIRgyshAKHkiqsmE1w
+M3CsyU1uPvp0zIqIHeddjdwy8rNrrvlQ0KaUE/KElSfXhjPtE5TdFm1xkrCJBW9W
+TLbcwklXzyWLt778QMOyeSXWEQKBgQDaw3cKcjpxQdqrZzbU71B+69E7yNMU2Jnb
+B/9A2xPlb4omkFdqi0naEENySClPCeXR0E9v6+hq87pzx6JlfYu22CJk5f78lUpS
+dbZQYaSQPKO5Unik5oPJHY6oA5iYYAaZxxEj9GsAMHWNV27FVHPoz5J9Z40Hm12X
+YDt7/UqvKQKBgFqUUrvY3i0zLLhSCDwPcQDhC2mtY9pHs34YD4kueABewD7pxEyI
+74jJz5olnQETaMVFNgUV95LMB02wOmpS1buIBF/OznOKcJ7270RbL9lJXufUYCFp
+0eUQHYSpp+x7muaz9w7T/dDSBwyKlsBxOTOOkJIzE/SEVl+W/KtoW2bhAoGBAKUx
+72WbBpjZ4teGNHitUrrVNoYPy521RtGIg28lQCwEg21FmE1ja1xY5aWZ6l++GKbM
+x/+7RCHndMfTW8WJ/YQQSECrEVcJITuNmiOu6EbnE7dxGJtlWuT3Be/H72Y5NSLQ
+mRfujRJyhYI7IPGwKWsHvBYoqO2ynAUgbSrfBZOpAoGAPUTE0jjRchngnR9hdfQZ
+ztwXq2vpfaQd8vyYiNkihNGu3h4MVGvm86zw7288AMwd2ArEYVccqcqM9KdPulee
+WcPxKHV3dQirldwlk2ZErUhFRDO3BORwChm4uIkjN9yfOOaX4kOixllTMTVb19WX
+SE6T72rWH84Kev/aPsHFMao=
+-----END PRIVATE KEY-----

notes-service/vendor/sqlx/tests/certs/rsa/server.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDfzCCAmegAwIBAgIUDGMJJMvOJFDe2ycSX2RFhbH6YOUwDQYJKoZIhvcNAQEL
+BQAwVTELMAkGA1UEBhMCdXMxEzARBgNVBAgMCmNhbGlmb3JuaWExEDAOBgNVBAoM
+B1NRTHgucnMxHzAdBgNVBAMMFlNRTHggTXlTUUwgNS43IFRlc3QgQ0EwHhcNMjYw
+MTE3MjA0OTU2WhcNMzYwMTE1MjA0OTU2WjBGMQswCQYDVQQGEwJ1czETMBEGA1UE
+CAwKY2FsaWZvcm5pYTEQMA4GA1UECgwHU1FMeC5yczEQMA4GA1UEAwwHc3FseC5y
+czCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAxeXHpJB6MaAS+JRAx
+RvjQqQWLFGjQWUdviY40s9sxn5MI0a3U7OIt7ak8med8k92reaIrNraK7FewHx73
+AvZdWtrce0PWqVuXXa+Q/HwMc7Y02HcFgWAOKP0I1k0BoPY7QiMO0GSFy/7I5hSg
+Sd6G27grKiJhxlsPWIBLEm2LIrp81YhYVHFhH4AXq3QEoRApKK9uJe2RrBxqxfF6
+ULye6kjCKOASazcJFpvIOcyQmdYnfA+5MPNCvuDfFb01D+uQp+qfD3qtAlUrU7Eu
+vdzgPv/tPkO3qCUmKOCEKqBStzYjxnVwR0NYQnasQPhr0LO1bmdN6d9z2luHD/JO
+57kCAwEAAaNWMFQwEgYDVR0RBAswCYIHc3FseC5yczAdBgNVHQ4EFgQU+AloROBZ
+cbZ3TX5lZGxB6E8IF+EwHwYDVR0jBBgwFoAU4mLn4SZIxlhOmcogR2TsXIDpGxQw
+DQYJKoZIhvcNAQELBQADggEBADS2doCZzWhSaqHjycgs4KkmCd3rORNL+U6QbPTk
+5fjPvO0Ni6kXOYfCnyhocelyhc3dKt8Kvkusqg/fNmeRAj3BNo4cKlsnycdCezvg
+vZBxVB9DnV2NcCmFRN4uKSqGszJ5mtCHbgWxJWnP+48qpWVUNi0dZSL7SYRr/eou
+3WancEOJ3OkUAZssUNSNloXkhpyzvFkLd1btLCSnyGpE2pACfpX5JiRrX/qkRKaM
+IP2l5s/5QDRhRde85PvKqWCQkzIh5wR5qwZfKx/n0ZjtEWDvu0fzdpFdgag03Q2L
+vZZ8+9RqwQ1E8KB6dLQjZSbi71UbUqVN97535w9oYPOLY8k=
+-----END CERTIFICATE-----

notes-service/vendor/sqlx/tests/certs/server.crt

@@ -0,0 +1,11 @@
+-----BEGIN CERTIFICATE-----
+MIIBnjCCAVCgAwIBAgIJALbHH0sRwKGPMAUGAytlcDBfMQswCQYDVQQGEwJ1czET
+MBEGA1UECAwKY2FsaWZvcm5pYTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQ
+dHkgTHRkMRgwFgYDVQQDDA9BdXN0aW4gQm9uYW5kZXIwHhcNMjUwNzAxMDUyMTU2
+WhcNMzUwNjI5MDUyMTU2WjBGMQswCQYDVQQGEwJ1czETMBEGA1UECAwKY2FsaWZv
+cm5pYTEQMA4GA1UECgwHU1FMeC5yczEQMA4GA1UEAwwHc3FseC5yczAqMAUGAytl
+cAMhAA33S2qsqpZssUcYrpleMXDj5/mhb56HPaO3CIIgY5c8o0IwQDAdBgNVHQ4E
+FgQUPUpn95GHFuMe7+2pG5rbmJS55/wwHwYDVR0jBBgwFoAUCw2pVpGKz2xkIjbV
+HYh0LnzdkW4wBQYDK2VwA0EAExEOza9IrSchoQs1NwPxfCdfXMHiXpsgMThDuig+
+9hauW+b1KlBR3ZeW8AOIwazMhdstBFOhumaWPQ/wZNUkCg==
+-----END CERTIFICATE-----

notes-service/vendor/sqlx/tests/docker-compose.yml

@@ -0,0 +1,387 @@
+services:
+    #
+    # MySQL 8.x, 5.7.x
+    # https://www.mysql.com/support/supportedplatforms/database.html
+    #
+
+    mysql_8:
+        image: mysql:8.0
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        ports:
+            - 3306
+        environment:
+            MYSQL_ROOT_HOST: '%'
+            MYSQL_ROOT_PASSWORD: password
+            MYSQL_DATABASE: sqlx
+
+    mysql_8_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: mysql:8.0
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        ports:
+            - 3306
+        environment:
+            MYSQL_ROOT_HOST: '%'
+            MYSQL_DATABASE: sqlx
+            MYSQL_ALLOW_EMPTY_PASSWORD: 1
+
+    mysql_5_7:
+        image: mysql:5.7
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        ports:
+            - 3306
+        environment:
+            MYSQL_ROOT_HOST: '%'
+            MYSQL_ROOT_PASSWORD: password
+            MYSQL_DATABASE: sqlx
+
+    mysql_5_7_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: mysql:5.7
+                SSL_CERT_DIR: certs/rsa
+                SSL_KEY_DIR: certs/rsa/keys
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        ports:
+            - 3306
+        environment:
+            MYSQL_ROOT_HOST: '%'
+            MYSQL_DATABASE: sqlx
+            MYSQL_ALLOW_EMPTY_PASSWORD: 1
+
+    # MariaDB
+    # Testing will be dropped when Community Support ends.
+    # https://mariadb.org/about/#maintenance-policy
+
+    # EOL: 2028/06/04 (sooner than 11.4 for some reason)
+    mariadb_11_8:
+        image: mariadb:11.8
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_ROOT_PASSWORD: password
+            MARIADB_DATABASE: sqlx
+
+    mariadb_11_8_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: mariadb:11.8
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_DATABASE: sqlx
+            MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: 1
+
+    # EOL: 2029/05/29
+    mariadb_11_4:
+        image: mariadb:11.4
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_ROOT_PASSWORD: password
+            MARIADB_DATABASE: sqlx
+
+    mariadb_11_4_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: mariadb:11.4
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_DATABASE: sqlx
+            MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: 1
+
+    # EOL: 2028/02/16
+    mariadb_10_11:
+        image: mariadb:10.11
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_ROOT_PASSWORD: password
+            MARIADB_DATABASE: sqlx
+
+    mariadb_10_11_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: mariadb:10.11
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_DATABASE: sqlx
+            MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: 1
+
+    # EOL: 2026/07/06
+    mariadb_10_6:
+        image: mariadb:10.6
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            # UUID support was not added until 10.10
+            # - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_ROOT_PASSWORD: password
+            MARIADB_DATABASE: sqlx
+
+    mariadb_10_6_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: mariadb:10.6
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            # UUID support was not added until 10.10
+            # - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_DATABASE: sqlx
+            MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: 1
+
+    # Ensure MariaDB upstream isn't regressing before release
+    # https://mariadb.org/new-service-quay-io-mariadb-foundation-mariadb-devel/
+    mariadb_verylatest:
+        image: quay.io/mariadb-foundation/mariadb-devel:verylatest
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_ROOT_PASSWORD: password
+            MARIADB_DATABASE: sqlx
+
+    mariadb_verylatest_client_ssl:
+        build:
+            context: .
+            dockerfile: mysql/Dockerfile
+            args:
+                IMAGE: quay.io/mariadb-foundation/mariadb-devel:verylatest
+        volumes:
+            - "./mysql/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+            - "./mysql/setup-mariadb.sql:/docker-entrypoint-initdb.d/setup-mariadb.sql:z"
+        ports:
+            - 3306
+        environment:
+            MARIADB_DATABASE: sqlx
+            MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: 1
+    #
+    # PostgreSQL 17.x, 16.x, 15.x, 14.x, 13.x
+    # https://www.postgresql.org/support/versioning/
+    #
+
+    postgres_17:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 17
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: password
+            POSTGRES_HOST_AUTH_METHOD: scram-sha-256
+            POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        # Loading `pg_stat_statements` should serve as a regression test for:
+        # https://github.com/launchbadge/sqlx/issues/2622
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key -c shared_preload_libraries=pg_stat_statements
+
+    postgres_17_client_ssl:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 17
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_HOST_AUTH_METHOD: trust
+            POSTGRES_INITDB_ARGS: --auth-host=trust
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key -c ssl_ca_file=/var/lib/postgresql/ca.crt -c hba_file=/var/lib/postgresql/pg_hba.conf
+
+    postgres_16:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 16
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: password
+            POSTGRES_HOST_AUTH_METHOD: scram-sha-256
+            POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key
+
+    postgres_16_client_ssl:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 16
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_HOST_AUTH_METHOD: trust
+            POSTGRES_INITDB_ARGS: --auth-host=trust
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key -c ssl_ca_file=/var/lib/postgresql/ca.crt -c hba_file=/var/lib/postgresql/pg_hba.conf
+
+    postgres_15:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 15
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: password
+            POSTGRES_HOST_AUTH_METHOD: scram-sha-256
+            POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key
+
+    postgres_15_client_ssl:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 15
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_HOST_AUTH_METHOD: trust
+            POSTGRES_INITDB_ARGS: --auth-host=trust
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key -c ssl_ca_file=/var/lib/postgresql/ca.crt -c hba_file=/var/lib/postgresql/pg_hba.conf
+
+    postgres_14:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 14
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: password
+            POSTGRES_HOST_AUTH_METHOD: scram-sha-256
+            POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key
+
+    postgres_14_client_ssl:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 14
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_HOST_AUTH_METHOD: trust
+            POSTGRES_INITDB_ARGS: --auth-host=trust
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key -c ssl_ca_file=/var/lib/postgresql/ca.crt -c hba_file=/var/lib/postgresql/pg_hba.conf
+
+    postgres_13:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 13
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: password
+            POSTGRES_HOST_AUTH_METHOD: scram-sha-256
+            POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key
+
+    postgres_13_client_ssl:
+        build:
+            context: .
+            dockerfile: postgres/Dockerfile
+            args:
+                VERSION: 13
+        ports:
+            - 5432
+        environment:
+            POSTGRES_DB: sqlx
+            POSTGRES_HOST_AUTH_METHOD: trust
+            POSTGRES_INITDB_ARGS: --auth-host=trust
+        volumes:
+            - "./postgres/setup.sql:/docker-entrypoint-initdb.d/setup.sql:z"
+        command: >
+            -c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key -c ssl_ca_file=/var/lib/postgresql/ca.crt -c hba_file=/var/lib/postgresql/pg_hba.conf

notes-service/vendor/sqlx/tests/docker.py

@@ -0,0 +1,120 @@
+import subprocess
+import sys
+import time
+from os import path
+import shutil
+
+# base dir of sqlx workspace
+dir_workspace = path.dirname(path.dirname(path.realpath(__file__)))
+
+# dir of tests
+dir_tests = path.join(dir_workspace, "tests")
+
+
+# start database server and return a URL to use to connect
+def docker_compose_command():
+    if shutil.which("docker-compose"):
+        return ["docker-compose"]
+    if shutil.which("docker"):
+        return ["docker", "compose"]
+    return None
+
+
+def start_database(driver, database, cwd):
+    if driver == "sqlite":
+        database = path.join(cwd, database)
+        (base_path, ext) = path.splitext(database)
+        new_database = f"{base_path}.test{ext}"
+        if path.exists(database):
+            shutil.copy(database, new_database)
+        # short-circuit for sqlite
+        return f"sqlite://{path.join(cwd, new_database)}?mode=rwc"
+
+    compose_cmd = docker_compose_command()
+    if compose_cmd is None:
+        raise FileNotFoundError("docker-compose or docker compose not found")
+
+    compose_args = [*compose_cmd, "-p", "sqlx"]
+    res = subprocess.run(
+        [*compose_args, "up", "-d", driver],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=dir_tests,
+    )
+
+    if res.returncode != 0:
+        print(res.stderr, file=sys.stderr)
+
+    if b"done" in res.stderr:
+        time.sleep(30)
+
+    res = subprocess.run(
+        [*compose_args, "ps", "-q", driver],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=dir_tests,
+    )
+
+    if res.returncode != 0:
+        print(res.stderr, file=sys.stderr)
+        raise RuntimeError(f"failed to resolve container for {driver}")
+
+    container_id = res.stdout.strip().decode()
+    if not container_id:
+        raise RuntimeError(f"no container found for {driver}")
+
+    # determine appropriate port for driver
+    if driver.startswith("mysql") or driver.startswith("mariadb"):
+        port = 3306
+
+    elif driver.startswith("postgres"):
+        port = 5432
+
+    else:
+        raise NotImplementedError
+
+    # find port
+    format_arg = f"{{{{(index (index .NetworkSettings.Ports \"{port}/tcp\") 0).HostPort}}}}"
+    res = subprocess.run(
+        ["docker", "inspect", "-f", format_arg, container_id],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=dir_tests,
+    )
+
+    if res.returncode != 0:
+        print(res.stderr, file=sys.stderr)
+
+    port = int(res.stdout.decode().strip())
+
+    # need additional permissions to connect to MySQL when using SSL
+    if driver.startswith("mysql") or driver.startswith("mariadb"):
+        mysql_args = ["docker", "exec", container_id, "mysql", "-u", "root"]
+        if not driver.endswith("client_ssl"):
+            mysql_args.append("-ppassword")
+        mysql_args.extend(["-e", "GRANT ALL PRIVILEGES ON *.* TO 'root' WITH GRANT OPTION;"])
+        res = subprocess.run(
+            mysql_args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=dir_tests,
+        )
+
+        if res.returncode != 0:
+            print(res.stderr, file=sys.stderr)
+
+    # do not set password in URL if authenticating using SSL key file
+    if driver.endswith("client_ssl"):
+        password = ""
+    else:
+        password = ":password"
+
+    # construct appropriate database URL
+    if driver.startswith("mysql") or driver.startswith("mariadb"):
+        return f"mysql://root{password}@localhost:{port}/{database}"
+
+    elif driver.startswith("postgres"):
+        return f"postgres://postgres{password}@localhost:{port}/{database}"
+
+    else:
+        raise NotImplementedError

notes-service/vendor/sqlx/tests/fixtures/mysql/posts.sql

@@ -0,0 +1,9 @@
+insert into post(post_id, user_id, content, created_at)
+values (1,
+        1,
+        'This new computer is lightning-fast!',
+        timestamp(now(), '-1:00:00')),
+       (2,
+        2,
+        '@alice is a haxxor :(',
+        timestamp(now(), '-0:30:00'));

notes-service/vendor/sqlx/tests/fixtures/mysql/users.sql

@@ -0,0 +1,2 @@
+insert into user(user_id, username)
+values (1, 'alice'), (2, 'bob');

notes-service/vendor/sqlx/tests/fixtures/postgres/posts.sql

@@ -0,0 +1,14 @@
+insert into post(post_id, user_id, content, created_at)
+values
+       (
+        '252c1d98-a9b0-4f18-8298-e59058bdfe16',
+        '6592b7c0-b531-4613-ace5-94246b7ce0c3',
+        'This new computer is lightning-fast!',
+        now() + '1 hour ago'::interval
+        ),
+       (
+        '844265f7-2472-4689-9a2e-b21f40dbf401',
+        '6592b7c0-b531-4613-ace5-94246b7ce0c3',
+        '@alice is a haxxor :(',
+        now() + '30 minutes ago'::interval
+        );

notes-service/vendor/sqlx/tests/fixtures/postgres/users.sql

@@ -0,0 +1,2 @@
+insert into "user"(user_id, username)
+values ('6592b7c0-b531-4613-ace5-94246b7ce0c3', 'alice'), ('297923c5-a83c-4052-bab0-030887154e52', 'bob');

notes-service/vendor/sqlx/tests/migrate/macro.rs

@@ -0,0 +1,33 @@
+#![cfg(unix)]
+use sqlx::migrate::Migrator;
+use std::path::Path;
+
+static EMBEDDED_SIMPLE: Migrator = sqlx::migrate!("tests/migrate/migrations_simple");
+static EMBEDDED_REVERSIBLE: Migrator = sqlx::migrate!("tests/migrate/migrations_reversible");
+static EMBEDDED_SYMLINK: Migrator = sqlx::migrate!("tests/migrate/migrations_symlink");
+
+#[sqlx_macros::test]
+async fn same_output() -> anyhow::Result<()> {
+    let runtime_simple = Migrator::new(Path::new("tests/migrate/migrations_simple")).await?;
+    let runtime_reversible =
+        Migrator::new(Path::new("tests/migrate/migrations_reversible")).await?;
+    let runtime_symlink = Migrator::new(Path::new("tests/migrate/migrations_symlink")).await?;
+
+    assert_same(&EMBEDDED_SIMPLE, &runtime_simple);
+    assert_same(&EMBEDDED_REVERSIBLE, &runtime_reversible);
+    assert_same(&EMBEDDED_SYMLINK, &runtime_symlink);
+
+    Ok(())
+}
+
+fn assert_same(embedded: &Migrator, runtime: &Migrator) {
+    assert_eq!(runtime.migrations.len(), embedded.migrations.len());
+
+    for (e, r) in embedded.iter().zip(runtime.iter()) {
+        assert_eq!(e.version, r.version);
+        assert_eq!(e.description, r.description);
+        assert_eq!(e.migration_type, r.migration_type);
+        assert_eq!(e.sql, r.sql);
+        assert_eq!(e.checksum, r.checksum);
+    }
+}

notes-service/vendor/sqlx/tests/migrate/migrations_reversible/20220721124650_add_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE migrations_reversible_test;

notes-service/vendor/sqlx/tests/migrate/migrations_reversible/20220721124650_add_table.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_reversible_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_reversible_test (some_id, some_payload)
+VALUES (1, 100);

notes-service/vendor/sqlx/tests/migrate/migrations_reversible/20220721125033_modify_column.down.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload - 1;

notes-service/vendor/sqlx/tests/migrate/migrations_reversible/20220721125033_modify_column.up.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload + 1;

notes-service/vendor/sqlx/tests/migrate/migrations_simple/20220721115250_add_test_table.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_simple_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_simple_test (some_id, some_payload)
+VALUES (1, 100);

notes-service/vendor/sqlx/tests/migrate/migrations_simple/20220721115524_convert_type.sql

@@ -0,0 +1,34 @@
+-- Perform a tricky conversion of the payload.
+--
+-- This script will only succeed once and will fail if executed twice.
+
+-- set up temporary target column
+ALTER TABLE migrations_simple_test
+ADD some_payload_tmp TEXT;
+
+-- perform conversion
+-- This will fail if `some_payload` is already a string column due to the addition.
+-- We add a suffix after the addition to ensure that the SQL database does not silently cast the string back to an 
+-- integer.
+UPDATE migrations_simple_test
+SET some_payload_tmp = CONCAT(CAST((some_payload + 10) AS TEXT), '_suffix');
+
+-- remove original column including the content
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload;
+
+-- prepare new payload column (nullable, so we can copy over the data)
+ALTER TABLE migrations_simple_test
+ADD some_payload TEXT;
+
+-- copy new values
+UPDATE migrations_simple_test
+SET some_payload = some_payload_tmp;
+
+-- "freeze" column
+ALTER TABLE migrations_simple_test
+ALTER COLUMN some_payload SET NOT NULL;
+
+-- clean up
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload_tmp;

notes-service/vendor/sqlx/tests/migrate/migrations_symlink

@@ -0,0 +1 @@
+migrations_simple

notes-service/vendor/sqlx/tests/mssql/Dockerfile

@@ -0,0 +1,21 @@
+ARG VERSION
+FROM mcr.microsoft.com/mssql/server:${VERSION}
+
+# Create a config directory
+RUN mkdir -p /usr/config
+WORKDIR /usr/config
+
+# Bundle config source
+COPY mssql/entrypoint.sh /usr/config/entrypoint.sh
+COPY mssql/configure-db.sh /usr/config/configure-db.sh
+COPY mssql/setup.sql /usr/config/setup.sql
+
+# Grant permissions for to our scripts to be executable
+USER root
+RUN chmod +x /usr/config/entrypoint.sh
+RUN chmod +x /usr/config/configure-db.sh
+RUN chown 10001 /usr/config/entrypoint.sh
+RUN chown 10001 /usr/config/configure-db.sh
+USER 10001
+
+ENTRYPOINT ["/usr/config/entrypoint.sh"]

notes-service/vendor/sqlx/tests/mssql/configure-db.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# Wait 60 seconds for SQL Server to start up
+sleep 60
+
+# Run the setup script to create the DB and the schema in the DB
+/opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P $SA_PASSWORD -d master -i setup.sql

notes-service/vendor/sqlx/tests/mssql/describe.rs

@@ -0,0 +1,41 @@
+use sqlx::mssql::Mssql;
+use sqlx::{Column, Executor, TypeInfo};
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_describes_simple() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let d = conn.describe("SELECT * FROM tweet").await?;
+
+    assert_eq!(d.columns()[0].name(), "id");
+    assert_eq!(d.columns()[1].name(), "text");
+    assert_eq!(d.columns()[2].name(), "is_sent");
+    assert_eq!(d.columns()[3].name(), "owner_id");
+
+    assert_eq!(d.nullable(0), Some(false));
+    assert_eq!(d.nullable(1), Some(false));
+    assert_eq!(d.nullable(2), Some(false));
+    assert_eq!(d.nullable(3), Some(true));
+
+    assert_eq!(d.columns()[0].type_info().name(), "BIGINT");
+    assert_eq!(d.columns()[1].type_info().name(), "NVARCHAR");
+    assert_eq!(d.columns()[2].type_info().name(), "TINYINT");
+    assert_eq!(d.columns()[3].type_info().name(), "BIGINT");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_describes_with_params() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let d = conn
+        .describe("SELECT text FROM tweet WHERE id = @p1")
+        .await?;
+
+    assert_eq!(d.columns()[0].name(), "text");
+    assert_eq!(d.nullable(0), Some(false));
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mssql/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# Start the script to create the DB and user
+/usr/config/configure-db.sh &
+
+# Start SQL Server
+/opt/mssql/bin/sqlservr

notes-service/vendor/sqlx/tests/mssql/macros.rs

@@ -0,0 +1,19 @@
+use sqlx::Mssql;
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn test_query_simple() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let account =
+        sqlx::query!("select * from (select (1) as id, 'Herp Derpinson' as name, cast(null as char) as email, CAST(1 as bit) as deleted) accounts")
+            .fetch_one(&mut conn)
+            .await?;
+
+    assert_eq!(account.id, 1);
+    assert_eq!(account.name, "Herp Derpinson");
+    assert_eq!(account.email, None);
+    assert_eq!(account.deleted, Some(true));
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mssql/mssql-2017.dockerfile

@@ -0,0 +1,19 @@
+# vim: set ft=dockerfile:
+ARG VERSION
+FROM mcr.microsoft.com/mssql/server:${VERSION}
+
+# Create a config directory
+RUN mkdir -p /usr/config
+WORKDIR /usr/config
+
+# Bundle config source
+COPY mssql/entrypoint.sh /usr/config/entrypoint.sh
+COPY mssql/configure-db.sh /usr/config/configure-db.sh
+COPY mssql/setup.sql /usr/config/setup.sql
+
+# Grant permissions for to our scripts to be executable
+USER root
+RUN chmod +x /usr/config/entrypoint.sh
+RUN chmod +x /usr/config/configure-db.sh
+
+ENTRYPOINT ["/usr/config/entrypoint.sh"]

notes-service/vendor/sqlx/tests/mssql/mssql.rs

@@ -0,0 +1,461 @@
+use futures_util::TryStreamExt;
+use sqlx::mssql::{Mssql, MssqlPoolOptions};
+use sqlx::{Column, Connection, Executor, MssqlConnection, Row, Statement, TypeInfo};
+use sqlx_core::mssql::MssqlRow;
+use sqlx_test::new;
+use std::sync::atomic::{AtomicI32, Ordering};
+use std::time::Duration;
+
+#[sqlx_macros::test]
+async fn it_connects() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    conn.ping().await?;
+
+    conn.close().await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_select_expression() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let row: MssqlRow = conn.fetch_one("SELECT 4").await?;
+    let v: i32 = row.try_get(0)?;
+
+    assert_eq!(v, 4);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_select_expression_by_name() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let row: MssqlRow = conn.fetch_one("SELECT 4 as _3").await?;
+    let v: i32 = row.try_get("_3")?;
+
+    assert_eq!(v, 4);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_fail_to_connect() -> anyhow::Result<()> {
+    let mut url = dotenvy::var("DATABASE_URL")?;
+    url = url.replace("Password", "NotPassword");
+
+    let res = MssqlConnection::connect(&url).await;
+    let err = res.unwrap_err();
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.message(), "Login failed for user \'sa\'.");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_inspect_errors() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("select f").execute(&mut conn).await;
+    let err = res.unwrap_err();
+
+    // can also do [as_database_error] or use `match ..`
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.message(), "Invalid column name 'f'.");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_maths() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let value = sqlx::query("SELECT 1 + @p1")
+        .bind(5_i32)
+        .try_map(|row: MssqlRow| row.try_get::<i32, _>(0))
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(6_i32, value);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_executes() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let _ = conn
+        .execute(
+            r#"
+CREATE TABLE #users (id INTEGER PRIMARY KEY);
+            "#,
+        )
+        .await?;
+
+    for index in 1..=10_i32 {
+        let done = sqlx::query("INSERT INTO #users (id) VALUES (@p1)")
+            .bind(index * 2)
+            .execute(&mut conn)
+            .await?;
+
+        assert_eq!(done.rows_affected(), 1);
+    }
+
+    let sum: i32 = sqlx::query("SELECT id FROM #users")
+        .try_map(|row: MssqlRow| row.try_get::<i32, _>(0))
+        .fetch(&mut conn)
+        .try_fold(0_i32, |acc, x| async move { Ok(acc + x) })
+        .await?;
+
+    assert_eq!(sum, 110);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_return_1000_rows() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let _ = conn
+        .execute(
+            r#"
+CREATE TABLE #users (id INTEGER PRIMARY KEY);
+            "#,
+        )
+        .await?;
+
+    for index in 1..=1000_i32 {
+        let done = sqlx::query("INSERT INTO #users (id) VALUES (@p1)")
+            .bind(index * 2)
+            .execute(&mut conn)
+            .await?;
+
+        assert_eq!(done.rows_affected(), 1);
+    }
+
+    let sum: i32 = sqlx::query("SELECT id FROM #users")
+        .try_map(|row: MssqlRow| row.try_get::<i32, _>(0))
+        .fetch(&mut conn)
+        .try_fold(0_i32, |acc, x| async move { Ok(acc + x) })
+        .await?;
+
+    assert_eq!(sum, 1001000);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_selects_null() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let (_, val): (i32, Option<i32>) = sqlx::query_as("SELECT 5, NULL")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(val.is_none());
+
+    let val: Option<i32> = conn.fetch_one("SELECT 10, NULL").await?.try_get(1)?;
+
+    assert!(val.is_none());
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_binds_empty_string_and_null() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    let (val, val2): (String, Option<String>) = sqlx::query_as("SELECT @p1, @p2")
+        .bind("")
+        .bind(None::<String>)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(val.is_empty());
+    assert!(val2.is_none());
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_work_with_transactions() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    conn.execute("IF OBJECT_ID('_sqlx_users_1922', 'U') IS NULL CREATE TABLE _sqlx_users_1922 (id INTEGER PRIMARY KEY)")
+        .await?;
+
+    conn.execute("DELETE FROM _sqlx_users_1922").await?;
+
+    // begin .. rollback
+
+    let mut tx = conn.begin().await?;
+
+    sqlx::query("INSERT INTO _sqlx_users_1922 (id) VALUES ($1)")
+        .bind(10_i32)
+        .execute(&mut tx)
+        .await?;
+
+    tx.rollback().await?;
+
+    let (count,): (i32,) = sqlx::query_as("SELECT COUNT(*) FROM _sqlx_users_1922")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(count, 0);
+
+    // begin .. commit
+
+    let mut tx = conn.begin().await?;
+
+    sqlx::query("INSERT INTO _sqlx_users_1922 (id) VALUES (@p1)")
+        .bind(10_i32)
+        .execute(&mut tx)
+        .await?;
+
+    tx.commit().await?;
+
+    let (count,): (i32,) = sqlx::query_as("SELECT COUNT(*) FROM _sqlx_users_1922")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(count, 1);
+
+    // begin .. (drop)
+
+    {
+        let mut tx = conn.begin().await?;
+
+        sqlx::query("INSERT INTO _sqlx_users_1922 (id) VALUES (@p1)")
+            .bind(20_i32)
+            .execute(&mut tx)
+            .await?;
+    }
+
+    conn = new::<Mssql>().await?;
+
+    let (count,): (i32,) = sqlx::query_as("SELECT COUNT(*) FROM _sqlx_users_1922")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(count, 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_work_with_nested_transactions() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+
+    conn.execute("IF OBJECT_ID('_sqlx_users_2523', 'U') IS NULL CREATE TABLE _sqlx_users_2523 (id INTEGER PRIMARY KEY)")
+        .await?;
+
+    conn.execute("DELETE FROM _sqlx_users_2523").await?;
+
+    // begin
+    let mut tx = conn.begin().await?;
+
+    // insert a user
+    sqlx::query("INSERT INTO _sqlx_users_2523 (id) VALUES (@p1)")
+        .bind(50_i32)
+        .execute(&mut tx)
+        .await?;
+
+    // begin once more
+    let mut tx2 = tx.begin().await?;
+
+    // insert another user
+    sqlx::query("INSERT INTO _sqlx_users_2523 (id) VALUES (@p1)")
+        .bind(10_i32)
+        .execute(&mut tx2)
+        .await?;
+
+    // never mind, rollback
+    tx2.rollback().await?;
+
+    // did we really?
+    let (count,): (i32,) = sqlx::query_as("SELECT COUNT(*) FROM _sqlx_users_2523")
+        .fetch_one(&mut tx)
+        .await?;
+
+    assert_eq!(count, 1);
+
+    // actually, commit
+    tx.commit().await?;
+
+    // did we really?
+    let (count,): (i32,) = sqlx::query_as("SELECT COUNT(*) FROM _sqlx_users_2523")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(count, 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_prepare_then_execute() -> anyhow::Result<()> {
+    let mut conn = new::<Mssql>().await?;
+    let mut tx = conn.begin().await?;
+
+    let tweet_id: i64 = sqlx::query_scalar(
+        "INSERT INTO tweet ( id, text ) OUTPUT INSERTED.id VALUES ( 50, 'Hello, World' )",
+    )
+    .fetch_one(&mut tx)
+    .await?;
+
+    let statement = tx.prepare("SELECT * FROM tweet WHERE id = @p1").await?;
+
+    assert_eq!(statement.column(0).name(), "id");
+    assert_eq!(statement.column(1).name(), "text");
+    assert_eq!(statement.column(2).name(), "is_sent");
+    assert_eq!(statement.column(3).name(), "owner_id");
+
+    assert_eq!(statement.column(0).type_info().name(), "BIGINT");
+    assert_eq!(statement.column(1).type_info().name(), "NVARCHAR");
+    assert_eq!(statement.column(2).type_info().name(), "TINYINT");
+    assert_eq!(statement.column(3).type_info().name(), "BIGINT");
+
+    let row = statement.query().bind(tweet_id).fetch_one(&mut tx).await?;
+    let tweet_text: String = row.try_get("text")?;
+
+    assert_eq!(tweet_text, "Hello, World");
+
+    Ok(())
+}
+
+// MSSQL-specific copy of the test case in `tests/any/pool.rs`
+// because MSSQL has its own bespoke syntax for temporary tables.
+#[sqlx_macros::test]
+async fn test_pool_callbacks() -> anyhow::Result<()> {
+    #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
+    struct ConnStats {
+        id: i32,
+        before_acquire_calls: i32,
+        after_release_calls: i32,
+    }
+
+    sqlx_test::setup_if_needed();
+
+    let current_id = AtomicI32::new(0);
+
+    let pool = MssqlPoolOptions::new()
+        .max_connections(1)
+        .acquire_timeout(Duration::from_secs(5))
+        .after_connect(move |conn, meta| {
+            assert_eq!(meta.age, Duration::ZERO);
+            assert_eq!(meta.idle_for, Duration::ZERO);
+
+            let id = current_id.fetch_add(1, Ordering::AcqRel);
+
+            Box::pin(async move {
+                let statement = format!(
+                    // language=MSSQL
+                    r#"
+                    CREATE TABLE #conn_stats(
+                        id int primary key,
+                        before_acquire_calls int default 0,
+                        after_release_calls int default 0 
+                    );
+                    INSERT INTO #conn_stats(id) VALUES ({});
+                    "#,
+                    // Until we have generalized bind parameters
+                    id
+                );
+
+                conn.execute(&statement[..]).await?;
+                Ok(())
+            })
+        })
+        .before_acquire(|conn, meta| {
+            // `age` and `idle_for` should both be nonzero
+            assert_ne!(meta.age, Duration::ZERO);
+            assert_ne!(meta.idle_for, Duration::ZERO);
+
+            Box::pin(async move {
+                // MSSQL doesn't support UPDATE ... RETURNING either
+                sqlx::query(
+                    r#"
+                        UPDATE #conn_stats 
+                        SET before_acquire_calls = before_acquire_calls + 1
+                    "#,
+                )
+                .execute(&mut *conn)
+                .await?;
+
+                let stats: ConnStats = sqlx::query_as("SELECT * FROM #conn_stats")
+                    .fetch_one(conn)
+                    .await?;
+
+                // For even IDs, cap by the number of before_acquire calls.
+                // Ignore the check for odd IDs.
+                Ok((stats.id & 1) == 1 || stats.before_acquire_calls < 3)
+            })
+        })
+        .after_release(|conn, meta| {
+            // `age` should be nonzero but `idle_for` should be zero.
+            assert_ne!(meta.age, Duration::ZERO);
+            assert_eq!(meta.idle_for, Duration::ZERO);
+
+            Box::pin(async move {
+                sqlx::query(
+                    r#"
+                        UPDATE #conn_stats 
+                        SET after_release_calls = after_release_calls + 1
+                    "#,
+                )
+                .execute(&mut *conn)
+                .await?;
+
+                let stats: ConnStats = sqlx::query_as("SELECT * FROM #conn_stats")
+                    .fetch_one(conn)
+                    .await?;
+
+                // For odd IDs, cap by the number of before_release calls.
+                // Ignore the check for even IDs.
+                Ok((stats.id & 1) == 0 || stats.after_release_calls < 4)
+            })
+        })
+        // Don't establish a connection yet.
+        .connect_lazy(&std::env::var("DATABASE_URL")?)?;
+
+    // Expected pattern of (id, before_acquire_calls, after_release_calls)
+    let pattern = [
+        // The connection pool starts empty.
+        (0, 0, 0),
+        (0, 1, 1),
+        (0, 2, 2),
+        (1, 0, 0),
+        (1, 1, 1),
+        (1, 2, 2),
+        // We should expect one more `acquire` because the ID is odd
+        (1, 3, 3),
+        (2, 0, 0),
+        (2, 1, 1),
+        (2, 2, 2),
+        (3, 0, 0),
+    ];
+
+    for (id, before_acquire_calls, after_release_calls) in pattern {
+        let conn_stats: ConnStats = sqlx::query_as("SELECT * FROM #conn_stats")
+            .fetch_one(&pool)
+            .await?;
+
+        assert_eq!(
+            conn_stats,
+            ConnStats {
+                id,
+                before_acquire_calls,
+                after_release_calls
+            }
+        );
+    }
+
+    pool.close().await;
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mssql/setup.sql

@@ -0,0 +1,20 @@
+IF DB_ID('sqlx') IS NULL
+    BEGIN
+        CREATE DATABASE sqlx;
+    END;
+GO
+
+USE sqlx;
+GO
+
+IF OBJECT_ID('tweet') IS NULL
+    BEGIN
+        CREATE TABLE tweet
+        (
+            id       BIGINT          NOT NULL PRIMARY KEY,
+            text     NVARCHAR(4000)  NOT NULL,
+            is_sent  TINYINT         NOT NULL DEFAULT 1,
+            owner_id BIGINT
+        );
+    END;
+GO

notes-service/vendor/sqlx/tests/mssql/types.rs

@@ -0,0 +1,50 @@
+use sqlx::mssql::Mssql;
+use sqlx_test::test_type;
+
+test_type!(null<Option<i32>>(Mssql,
+    "CAST(NULL as INT)" == None::<i32>
+));
+
+test_type!(u8(
+    Mssql,
+    "CAST(5 AS TINYINT)" == 5_u8,
+    "CAST(0 AS TINYINT)" == 0_u8,
+    "CAST(255 AS TINYINT)" == 255_u8,
+));
+
+test_type!(i8(
+    Mssql,
+    "CAST(5 AS TINYINT)" == 5_i8,
+    "CAST(0 AS TINYINT)" == 0_i8
+));
+
+test_type!(i16(Mssql, "CAST(21415 AS SMALLINT)" == 21415_i16));
+
+test_type!(i32(Mssql, "CAST(2141512 AS INT)" == 2141512_i32));
+
+test_type!(i64(Mssql, "CAST(32324324432 AS BIGINT)" == 32324324432_i64));
+
+test_type!(f32(
+    Mssql,
+    "CAST(3.1410000324249268 AS REAL)" == 3.141f32 as f64 as f32
+));
+
+test_type!(f64(
+    Mssql,
+    "CAST(939399419.1225182 AS FLOAT)" == 939399419.1225182_f64
+));
+
+test_type!(str_nvarchar<String>(Mssql,
+    "CAST('this is foo' as NVARCHAR)" == "this is foo",
+));
+
+test_type!(str<String>(Mssql,
+    "'this is foo'" == "this is foo",
+    "''" == "",
+));
+
+test_type!(bool(
+    Mssql,
+    "CAST(1 as BIT)" == true,
+    "CAST(0 as BIT)" == false
+));

notes-service/vendor/sqlx/tests/mysql/Dockerfile

@@ -0,0 +1,19 @@
+ARG IMAGE
+FROM ${IMAGE}
+
+# Allow using alternate cert sets for older server images (e.g. MySQL 5.7).
+ARG SSL_CERT_DIR=certs
+ARG SSL_KEY_DIR=certs/keys
+
+# Copy SSL certificate (and key)
+COPY ${SSL_CERT_DIR}/server.crt /etc/mysql/ssl/server.crt
+COPY ${SSL_CERT_DIR}/ca.crt /etc/mysql/ssl/ca.crt
+COPY ${SSL_KEY_DIR}/server.key /etc/mysql/ssl/server.key
+COPY mysql/my.cnf /etc/mysql/conf.d/sqlx-ssl.cnf
+
+# Fix permissions
+RUN chown mysql:mysql /etc/mysql/ssl/server.crt /etc/mysql/ssl/server.key
+RUN chmod 0600 /etc/mysql/ssl/server.crt /etc/mysql/ssl/server.key
+
+# Create dir for secure-file-priv
+RUN mkdir -p /var/lib/mysql-files

notes-service/vendor/sqlx/tests/mysql/derives.rs

@@ -0,0 +1,322 @@
+use sqlx_mysql::MySql;
+use sqlx_test::{new, test_type};
+
+#[sqlx::test]
+async fn test_derive_strong_enum() -> anyhow::Result<()> {
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "PascalCase")]
+    enum PascalCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "camelCase")]
+    enum CamelCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "snake_case")]
+    enum SnakeCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "SCREAMING_SNAKE_CASE")]
+    enum ScreamingSnakeCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "kebab-case")]
+    enum KebabCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "lowercase")]
+    enum LowerCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    #[sqlx(rename_all = "UPPERCASE")]
+    enum UpperCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::Type, PartialEq, Eq, Debug)]
+    enum DefaultCaseEnum {
+        FooFoo,
+        BarBar,
+        BazBaz,
+    }
+
+    #[derive(sqlx::FromRow, PartialEq, Eq, Debug)]
+    struct StrongEnumRow {
+        pascal_case: PascalCaseEnum,
+        camel_case: CamelCaseEnum,
+        snake_case: SnakeCaseEnum,
+        screaming_snake_case: ScreamingSnakeCaseEnum,
+        kebab_case: KebabCaseEnum,
+        lowercase: LowerCaseEnum,
+        uppercase: UpperCaseEnum,
+        default_case: DefaultCaseEnum,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::raw_sql(
+        r#"
+            CREATE TEMPORARY TABLE strong_enum (
+                pascal_case ENUM('FooFoo', 'BarBar', 'BazBaz'),
+                camel_case ENUM('fooFoo', 'barBar', 'bazBaz'),
+                snake_case ENUM('foo_foo', 'bar_bar', 'baz_baz'),
+                screaming_snake_case ENUM('FOO_FOO', 'BAR_BAR', 'BAZ_BAZ'),
+                kebab_case ENUM('foo-foo', 'bar-bar', 'baz-baz'),
+                lowercase ENUM('foofoo', 'barbar', 'bazbaz'),
+                uppercase ENUM('FOOFOO', 'BARBAR', 'BAZBAZ'),
+                default_case ENUM('FooFoo', 'BarBar', 'BazBaz')
+            );
+        "#,
+    )
+    .execute(&mut conn)
+    .await?;
+
+    let input = StrongEnumRow {
+        pascal_case: PascalCaseEnum::FooFoo,
+        camel_case: CamelCaseEnum::BarBar,
+        snake_case: SnakeCaseEnum::BazBaz,
+        screaming_snake_case: ScreamingSnakeCaseEnum::FooFoo,
+        kebab_case: KebabCaseEnum::BarBar,
+        lowercase: LowerCaseEnum::BazBaz,
+        uppercase: UpperCaseEnum::FooFoo,
+        default_case: DefaultCaseEnum::BarBar,
+    };
+
+    sqlx::query(
+        r#"
+            INSERT INTO strong_enum(
+                pascal_case,
+                camel_case,
+                snake_case,
+                screaming_snake_case,
+                kebab_case,
+                lowercase,
+                uppercase,
+                default_case
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        "#,
+    )
+    .bind(&input.pascal_case)
+    .bind(&input.camel_case)
+    .bind(&input.snake_case)
+    .bind(&input.screaming_snake_case)
+    .bind(&input.kebab_case)
+    .bind(&input.lowercase)
+    .bind(&input.uppercase)
+    .bind(&input.default_case)
+    .execute(&mut conn)
+    .await?;
+
+    let output: StrongEnumRow = sqlx::query_as("SELECT * FROM strong_enum")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(input, output);
+
+    Ok(())
+}
+
+#[sqlx::test]
+async fn test_derive_weak_enum() -> anyhow::Result<()> {
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(i8)]
+    enum WeakEnumI8 {
+        Foo = i8::MIN,
+        Bar = 0,
+        Baz = i8::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(i16)]
+    enum WeakEnumI16 {
+        Foo = i16::MIN,
+        Bar = 0,
+        Baz = i16::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(i32)]
+    enum WeakEnumI32 {
+        Foo = i32::MIN,
+        Bar = 0,
+        Baz = i32::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(i64)]
+    enum WeakEnumI64 {
+        Foo = i64::MIN,
+        Bar = 0,
+        Baz = i64::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    enum WeakEnumU8 {
+        Foo = 0,
+        Bar = 1,
+        Baz = u8::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(u16)]
+    enum WeakEnumU16 {
+        Foo = 0,
+        Bar = 1,
+        Baz = u16::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(u32)]
+    enum WeakEnumU32 {
+        Foo = 0,
+        Bar = 1,
+        Baz = u32::MAX,
+    }
+
+    #[derive(sqlx::Type, Debug, PartialEq, Eq)]
+    #[repr(u64)]
+    enum WeakEnumU64 {
+        Foo = 0,
+        Bar = 1,
+        Baz = u64::MAX,
+    }
+
+    #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
+    struct WeakEnumRow {
+        i8: WeakEnumI8,
+        i16: WeakEnumI16,
+        i32: WeakEnumI32,
+        i64: WeakEnumI64,
+        u8: WeakEnumU8,
+        u16: WeakEnumU16,
+        u32: WeakEnumU32,
+        u64: WeakEnumU64,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::raw_sql(
+        r#"
+            CREATE TEMPORARY TABLE weak_enum (
+                i8 TINYINT,
+                i16 SMALLINT,
+                i32 INT,
+                i64 BIGINT,
+                u8 TINYINT UNSIGNED,
+                u16 SMALLINT UNSIGNED,
+                u32 INT UNSIGNED,
+                u64 BIGINT UNSIGNED
+            )
+        "#,
+    )
+    .execute(&mut conn)
+    .await?;
+
+    let rows_in = vec![
+        WeakEnumRow {
+            i8: WeakEnumI8::Foo,
+            i16: WeakEnumI16::Foo,
+            i32: WeakEnumI32::Foo,
+            i64: WeakEnumI64::Foo,
+            u8: WeakEnumU8::Foo,
+            u16: WeakEnumU16::Foo,
+            u32: WeakEnumU32::Foo,
+            u64: WeakEnumU64::Foo,
+        },
+        WeakEnumRow {
+            i8: WeakEnumI8::Bar,
+            i16: WeakEnumI16::Bar,
+            i32: WeakEnumI32::Bar,
+            i64: WeakEnumI64::Bar,
+            u8: WeakEnumU8::Bar,
+            u16: WeakEnumU16::Bar,
+            u32: WeakEnumU32::Bar,
+            u64: WeakEnumU64::Bar,
+        },
+        WeakEnumRow {
+            i8: WeakEnumI8::Baz,
+            i16: WeakEnumI16::Baz,
+            i32: WeakEnumI32::Baz,
+            i64: WeakEnumI64::Baz,
+            u8: WeakEnumU8::Baz,
+            u16: WeakEnumU16::Baz,
+            u32: WeakEnumU32::Baz,
+            u64: WeakEnumU64::Baz,
+        },
+    ];
+
+    for row in &rows_in {
+        sqlx::query(
+            r#"
+                INSERT INTO weak_enum(i8, i16, i32, i64, u8, u16, u32, u64)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            "#,
+        )
+        .bind(&row.i8)
+        .bind(&row.i16)
+        .bind(&row.i32)
+        .bind(&row.i64)
+        .bind(&row.u8)
+        .bind(&row.u16)
+        .bind(&row.u32)
+        .bind(&row.u64)
+        .execute(&mut conn)
+        .await?;
+    }
+
+    let rows_out: Vec<WeakEnumRow> = sqlx::query_as("SELECT * FROM weak_enum")
+        .fetch_all(&mut conn)
+        .await?;
+
+    assert_eq!(rows_in, rows_out);
+
+    Ok(())
+}
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct TransparentTuple(i64);
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct TransparentNamed {
+    field: i64,
+}
+
+test_type!(transparent_tuple<TransparentTuple>(MySql,
+    "0" == TransparentTuple(0),
+    "23523" == TransparentTuple(23523)
+));
+
+test_type!(transparent_named<TransparentNamed>(MySql,
+    "0" == TransparentNamed { field: 0 },
+    "23523" == TransparentNamed { field: 23523 },
+));

notes-service/vendor/sqlx/tests/mysql/describe.rs

@@ -0,0 +1,73 @@
+use sqlx::mysql::MySql;
+use sqlx::{Column, Executor, SqlSafeStr, Type, TypeInfo};
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_describes_simple() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let d = conn.describe("SELECT * FROM tweet".into_sql_str()).await?;
+
+    assert_eq!(d.columns()[0].name(), "id");
+    assert_eq!(d.columns()[1].name(), "created_at");
+    assert_eq!(d.columns()[2].name(), "text");
+    assert_eq!(d.columns()[3].name(), "owner_id");
+
+    assert_eq!(d.nullable(0), Some(false));
+    assert_eq!(d.nullable(1), Some(false));
+    assert_eq!(d.nullable(2), Some(false));
+    assert_eq!(d.nullable(3), Some(true));
+
+    assert_eq!(d.columns()[0].type_info().name(), "BIGINT");
+    assert_eq!(d.columns()[1].type_info().name(), "TIMESTAMP");
+    assert_eq!(d.columns()[2].type_info().name(), "TEXT");
+    assert_eq!(d.columns()[3].type_info().name(), "BIGINT");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_boolean() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    conn.execute(
+        r#"
+CREATE TEMPORARY TABLE with_bit_and_tinyint (
+    id INT PRIMARY KEY AUTO_INCREMENT,
+    value_bit_1 BIT(1),
+    value_bool BOOLEAN,
+    bit_n BIT(64),
+    value_int TINYINT
+);
+    "#,
+    )
+    .await?;
+
+    let d = conn
+        .describe("SELECT * FROM with_bit_and_tinyint".into_sql_str())
+        .await?;
+
+    assert_eq!(d.column(2).name(), "value_bool");
+    assert_eq!(d.column(2).type_info().name(), "BOOLEAN");
+
+    assert_eq!(d.column(1).name(), "value_bit_1");
+    assert_eq!(d.column(1).type_info().name(), "BIT");
+
+    assert!(<bool as Type<MySql>>::compatible(&d.column(1).type_info()));
+    assert!(<bool as Type<MySql>>::compatible(&d.column(2).type_info()));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn uses_alias_name() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let d = conn
+        .describe("SELECT text AS tweet_text FROM tweet".into_sql_str())
+        .await?;
+
+    assert_eq!(d.columns()[0].name(), "tweet_text");
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mysql/error.rs

@@ -0,0 +1,176 @@
+use sqlx::{error::ErrorKind, mysql::MySql, Connection, Error};
+use sqlx_test::new;
+
+fn mysql_supports_check_constraints(version: &str) -> bool {
+    if version.contains("MariaDB") {
+        return true;
+    }
+
+    let numeric = match version.split(|c| c == '-' || c == ' ').next() {
+        Some(numeric) => numeric,
+        None => return false,
+    };
+    let mut parts = numeric.split('.');
+    let major: u64 = match parts.next().and_then(|part| part.parse().ok()) {
+        Some(major) => major,
+        None => return false,
+    };
+    let minor: u64 = parts.next().unwrap_or("0").parse().unwrap_or_default();
+    let patch: u64 = parts.next().unwrap_or("0").parse().unwrap_or_default();
+
+    (major, minor, patch) >= (8, 0, 16)
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_unique_violation() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let mut tx = conn.begin().await?;
+
+    sqlx::query("INSERT INTO tweet(id, text, owner_id) VALUES (1, 'Foo', 1)")
+        .execute(&mut *tx)
+        .await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("INSERT INTO tweet VALUES (1, NOW(), 'Foo', 1);")
+        .execute(&mut *tx)
+        .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::UniqueViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_foreign_key_violation() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO tweet_reply (tweet_id, text) VALUES (1, 'Reply!');")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::ForeignKeyViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_not_null_violation() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("INSERT INTO tweet (text) VALUES (null);")
+        .execute(&mut *tx)
+        .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::NotNullViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_check_violation() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let mut tx = conn.begin().await?;
+
+    let version: String = sqlx::query_scalar("SELECT VERSION()")
+        .fetch_one(&mut *tx)
+        .await?;
+    if !mysql_supports_check_constraints(&version) {
+        return Ok(());
+    }
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO products VALUES (1, 'Product 1', 0);")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::CheckViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_begin_failed() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let res = conn.begin_with("SELECT * FROM tweet").await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::BeginFailed), "{err:?}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_invalid_save_point_statement() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let mut txn = conn.begin().await?;
+    let txn_conn = sqlx::Acquire::acquire(&mut txn).await?;
+    let res = txn_conn.begin_with("BEGIN").await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::InvalidSavePointStatement), "{err}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_parameter_count_mismatch_too_few() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("SELECT * FROM tweet WHERE id = ? AND owner_id = ?")
+            .bind(1_i64)
+            .execute(&mut conn)
+            .await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::Protocol(_)), "{err}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_parameter_count_mismatch_too_many() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let res: Result<_, sqlx::Error> = sqlx::query("SELECT * FROM tweet WHERE id = ?")
+        .bind(1_i64)
+        .bind(2_i64)
+        .execute(&mut conn)
+        .await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::Protocol(_)), "{err}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_parameter_count_mismatch_zero_expected() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let res: Result<_, sqlx::Error> = sqlx::query("SELECT COUNT(*) FROM tweet")
+        .bind(1_i64)
+        .execute(&mut conn)
+        .await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::Protocol(_)), "{err}");
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mysql/fixtures/comments.sql

@@ -0,0 +1,16 @@
+insert into comment(comment_id, post_id, user_id, content, created_at)
+values (1,
+        1,
+        2,
+        'lol bet ur still bad, 1v1 me',
+        timestamp(now(), '-0:50:00')),
+       (2,
+        1,
+        1,
+        'you''re on!',
+        timestamp(now(), '-0:45:00')),
+       (3,
+        2,
+        1,
+        'lol you''re just mad you lost :P',
+        timestamp(now(), '-0:15:00'));

notes-service/vendor/sqlx/tests/mysql/fixtures/posts.sql

@@ -0,0 +1,9 @@
+insert into post(post_id, user_id, content, created_at)
+values (1,
+        1,
+        'This new computer is lightning-fast!',
+        timestamp(now(), '-1:00:00')),
+       (2,
+        2,
+        '@alice is a haxxor :(',
+        timestamp(now(), '-0:30:00'));

notes-service/vendor/sqlx/tests/mysql/fixtures/users.sql

@@ -0,0 +1,2 @@
+insert into user(user_id, username)
+values (1, 'alice'), (2, 'bob');

notes-service/vendor/sqlx/tests/mysql/macros.rs

@@ -0,0 +1,588 @@
+use sqlx::{Connection, MySql, MySqlConnection, Transaction};
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn macro_select_from_cte() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let account =
+        sqlx::query!("select * from (select (1) as id, 'Herp Derpinson' as name, cast(null as char) email) accounts")
+            .fetch_one(&mut conn)
+            .await?;
+
+    assert_eq!(account.id, 1);
+    assert_eq!(account.name, "Herp Derpinson");
+    // MySQL can tell us the nullability of expressions, ain't that cool
+    assert_eq!(account.email, None);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn macro_select_from_cte_bind() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let account = sqlx::query!(
+        "select * from (select (1) as id, 'Herp Derpinson' as name) accounts where id = ?",
+        1i32
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    println!("{account:?}");
+    println!("{}: {}", account.id, account.name);
+
+    Ok(())
+}
+
+#[derive(Debug)]
+struct RawAccount {
+    r#type: i32,
+    name: Option<String>,
+}
+
+#[sqlx_macros::test]
+async fn test_query_as_raw() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let account = sqlx::query_as!(
+        RawAccount,
+        "SELECT * from (select 1 as type, cast(null as char) as name) accounts"
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(account.name, None);
+    assert_eq!(account.r#type, 1);
+
+    println!("{account:?}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_query_scalar() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let id = sqlx::query_scalar!("select 1").fetch_one(&mut conn).await?;
+    // MySQL tells us `LONG LONG` while MariaDB just `LONG`
+    assert_eq!(id, 1);
+
+    // invalid column names are ignored
+    let id = sqlx::query_scalar!(r#"select 1 as `&foo`"#)
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(id, 1);
+
+    let id = sqlx::query_scalar!(r#"select 1 as `foo!`"#)
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(id, 1);
+
+    let id = sqlx::query_scalar!(r#"select 1 as `foo?`"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, Some(1));
+
+    let id = sqlx::query_scalar!(r#"select 1 as `foo: MyInt`"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, MyInt(1));
+
+    let id = sqlx::query_scalar!(r#"select 1 as `foo?: MyInt`"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, Some(MyInt(1)));
+
+    let id = sqlx::query_scalar!(r#"select 1 as `foo!: MyInt`"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, MyInt(1));
+
+    let id: MyInt = sqlx::query_scalar!(r#"select 1 as `foo: _`"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, MyInt(1));
+
+    let id: MyInt = sqlx::query_scalar!(r#"select 1 as `foo?: _`"#)
+        .fetch_one(&mut conn)
+        .await?
+        // don't hint that it should be `Option<MyInt>`
+        .unwrap();
+
+    assert_eq!(id, MyInt(1));
+
+    let id: MyInt = sqlx::query_scalar!(r#"select 1 as `foo!: _`"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, MyInt(1));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_query_as_bool() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    struct Article {
+        id: i32,
+        deleted: bool,
+    }
+
+    let article = sqlx::query_as_unchecked!(
+        Article,
+        "select * from (select 51 as id, true as deleted) articles"
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(51, article.id);
+    assert_eq!(true, article.deleted);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_query_bytes() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let rec = sqlx::query!("SELECT X'01AF' as _1")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(rec._1, &[0x01_u8, 0xAF_u8]);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_not_null() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let record = sqlx::query!("select * from (select 1 as `id!`) records")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.id, 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_nullable() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    // MySQL by default tells us `id` is not-null
+    let record = sqlx::query!("select * from (select 1 as `id?`) records")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.id, Some(1));
+
+    Ok(())
+}
+
+async fn with_test_row<'a>(
+    conn: &'a mut MySqlConnection,
+) -> anyhow::Result<(Transaction<'a, MySql>, MyInt)> {
+    let mut transaction = conn.begin().await?;
+    let id = sqlx::query!("INSERT INTO tweet(text, owner_id) VALUES ('#sqlx is pretty cool!', 1)")
+        .execute(&mut *transaction)
+        .await?
+        .last_insert_id();
+    Ok((transaction, MyInt(id as i64)))
+}
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct MyInt(i64);
+
+struct Record {
+    id: MyInt,
+}
+
+struct OptionalRecord {
+    id: Option<MyInt>,
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_wildcard() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as!(Record, "select id as `id: _` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, id);
+
+    // this syntax is also useful for expressions
+    let record = sqlx::query_as!(Record, "select * from (select 1 as `id: _`) records")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    let record = sqlx::query_as!(OptionalRecord, "select owner_id as `id: _` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(MyInt(1)));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_wildcard_not_null() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, _) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as!(Record, "select owner_id as `id!: _` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_wildcard_nullable() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as!(OptionalRecord, "select id as `id?: _` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(id));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query!("select id as `id: MyInt` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, id);
+
+    // we can also support this syntax for expressions
+    let record = sqlx::query!("select * from (select 1 as `id: MyInt`) records")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    let record = sqlx::query!("select owner_id as `id: MyInt` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(MyInt(1)));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact_not_null() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, _) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query!("select owner_id as `id!: MyInt` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact_nullable() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query!("select id as `id?: MyInt` from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(id));
+
+    Ok(())
+}
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(rename_all = "lowercase")]
+enum MyEnum {
+    Red,
+    Green,
+    Blue,
+}
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[repr(i32)]
+enum MyCEnum {
+    Red = 0,
+    Green,
+    Blue,
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact_enum() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let record = sqlx::query!("select * from (select 'red' as `color: MyEnum`) records")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.color, MyEnum::Red);
+
+    let record = sqlx::query!("select * from (select 2 as `color: MyCEnum`) records")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.color, MyCEnum::Blue);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_try_from_attr_for_native_type() -> anyhow::Result<()> {
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(try_from = "i64")]
+        id: u64,
+    }
+
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as::<_, Record>("select id from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, id.0 as u64);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_try_from_attr_for_custom_type() -> anyhow::Result<()> {
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(try_from = "i64")]
+        id: Id,
+    }
+
+    #[derive(Debug, PartialEq)]
+    struct Id(i64);
+    impl std::convert::TryFrom<i64> for Id {
+        type Error = std::io::Error;
+        fn try_from(value: i64) -> Result<Self, Self::Error> {
+            Ok(Id(value))
+        }
+    }
+
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as::<_, Record>("select id from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Id(id.0));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_try_from_attr_with_flatten() -> anyhow::Result<()> {
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(try_from = "Id", flatten)]
+        id: u64,
+    }
+
+    #[derive(Debug, PartialEq, sqlx::FromRow)]
+    struct Id {
+        id: i64,
+    }
+
+    impl std::convert::TryFrom<Id> for u64 {
+        type Error = std::io::Error;
+        fn try_from(value: Id) -> Result<Self, Self::Error> {
+            Ok(value.id as u64)
+        }
+    }
+
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as::<_, Record>("select id from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, id.0 as u64);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_try_from_attr_with_complex_type() -> anyhow::Result<()> {
+    mod m {
+        #[derive(sqlx::Type)]
+        #[sqlx(transparent)]
+        pub struct ComplexType<T>(T);
+
+        impl std::convert::TryFrom<ComplexType<i64>> for u64 {
+            type Error = std::num::TryFromIntError;
+            fn try_from(value: ComplexType<i64>) -> Result<Self, Self::Error> {
+                u64::try_from(value.0)
+            }
+        }
+    }
+
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(try_from = "m::ComplexType<i64>")]
+        id: u64,
+    }
+
+    let mut conn = new::<MySql>().await?;
+    let (mut conn, id) = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as::<_, Record>("select id from tweet")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, id.0 as u64);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_from_row_json_attr() -> anyhow::Result<()> {
+    #[derive(serde::Deserialize)]
+    struct J {
+        a: u32,
+        b: u32,
+    }
+
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(json)]
+        j: J,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    let record = sqlx::query_as::<_, Record>("select json_object('a', 1, 'b', 2) as j")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.j.a, 1);
+    assert_eq!(record.j.b, 2);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_from_row_json_attr_nullable() -> anyhow::Result<()> {
+    #[derive(serde::Deserialize)]
+    #[allow(dead_code)]
+    struct J {
+        a: u32,
+        b: u32,
+    }
+
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(json(nullable))]
+        j: Option<J>,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    let record = sqlx::query_as::<_, Record>("select NULL as j")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert!(record.j.is_none());
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_from_row_json_try_from_attr() -> anyhow::Result<()> {
+    #[derive(serde::Deserialize)]
+    struct J {
+        a: u32,
+        b: u32,
+    }
+
+    // Non-deserializable
+    struct J2 {
+        sum: u32,
+    }
+
+    impl std::convert::From<J> for J2 {
+        fn from(j: J) -> Self {
+            Self { sum: j.a + j.b }
+        }
+    }
+
+    #[derive(sqlx::FromRow)]
+    struct Record {
+        #[sqlx(json, try_from = "J")]
+        j: J2,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    let record = sqlx::query_as::<_, Record>("select json_object('a', 1, 'b', 2) as j")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.j.sum, 3);
+
+    Ok(())
+}
+
+#[cfg(all(mariadb, not(mariadb = "10_6"), feature = "time"))]
+#[sqlx_macros::test]
+async fn test_uuid_is_compatible_mariadb() -> anyhow::Result<()> {
+    use sqlx::types::time::OffsetDateTime;
+    use sqlx::types::Uuid;
+
+    struct Tweet {
+        id: Uuid,
+        text: String,
+        created_at: OffsetDateTime,
+        owner_id: Option<Uuid>,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::query!("INSERT INTO tweet_with_uuid(text) VALUES ('Hello, world!')")
+        .execute(&mut conn)
+        .await?;
+
+    let tweets: Vec<Tweet> = sqlx::query_as!(Tweet, "SELECT * FROM tweet_with_uuid")
+        .fetch_all(&mut conn)
+        .await?;
+
+    assert_eq!(tweets.len(), 1);
+
+    assert_eq!(tweets[0].text, "Hello, world!");
+
+    Ok(())
+}
+
+// we don't emit bind parameter type-checks for MySQL so testing the overrides is redundant

notes-service/vendor/sqlx/tests/mysql/migrate.rs

@@ -0,0 +1,123 @@
+use sqlx::migrate::Migrator;
+use sqlx::mysql::{MySql, MySqlConnection};
+use sqlx::pool::PoolConnection;
+use sqlx::Executor;
+use sqlx::Row;
+use std::path::Path;
+
+#[sqlx::test(migrations = false)]
+async fn simple(mut conn: PoolConnection<MySql>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+
+    let migrator = Migrator::new(Path::new("tests/mysql/migrations_simple")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: String = conn
+        .fetch_one("SELECT some_payload FROM migrations_simple_test")
+        .await?
+        .get(0);
+    assert_eq!(res, "110_suffix");
+
+    // running it a 2nd time should still work
+    migrator.run(&mut conn).await?;
+
+    Ok(())
+}
+
+#[sqlx::test(migrations = false)]
+async fn reversible(mut conn: PoolConnection<MySql>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+
+    let migrator = Migrator::new(Path::new("tests/mysql/migrations_reversible")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back nothing (last version)
+    migrator.undo(&mut conn, 20220721125033).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back one version
+    migrator.undo(&mut conn, 20220721124650).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    Ok(())
+}
+
+#[sqlx::test(migrations = false)]
+async fn skip(mut conn: PoolConnection<MySql>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+    let migrator = Migrator::new(Path::new("tests/mysql/migrations_reversible")).await?;
+
+    // get to the state of after the first migration manually
+    let sql = include_str!("migrations_reversible/20220721124650_add_table.up.sql");
+    let statements: Vec<&str> = sql.split(';').filter(|s| !s.trim().is_empty()).collect();
+    for statement in statements {
+        conn.execute(statement).await?;
+    }
+
+    // skip first migration
+    migrator.skip(&mut conn, Some(20220721124650)).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    // run remaining migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back one version
+    migrator.undo(&mut conn, 20220721124650).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    Ok(())
+}
+
+/// Ensure that we have a clean initial state.
+async fn clean_up(conn: &mut MySqlConnection) -> anyhow::Result<()> {
+    conn.execute("DROP TABLE migrations_simple_test").await.ok();
+    conn.execute("DROP TABLE migrations_reversible_test")
+        .await
+        .ok();
+    conn.execute("DROP TABLE _sqlx_migrations").await.ok();
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mysql/migrations/1_user.sql

@@ -0,0 +1,7 @@
+create table user
+(
+    -- integer primary keys are the most efficient in SQLite
+    user_id  integer primary key auto_increment,
+    -- indexed text values have to have a max length
+    username varchar(16) unique not null
+);

notes-service/vendor/sqlx/tests/mysql/migrations/2_post.sql

@@ -0,0 +1,10 @@
+create table post
+(
+    post_id    integer primary key auto_increment,
+    user_id    integer not null references user (user_id),
+    content    text    not null,
+    -- Defaults have to be wrapped in parenthesis
+    created_at datetime default current_timestamp
+);
+
+create index post_created_at on post (created_at desc);

notes-service/vendor/sqlx/tests/mysql/migrations/3_comment.sql

@@ -0,0 +1,10 @@
+create table comment
+(
+    comment_id integer primary key,
+    post_id    integer not null references post (post_id),
+    user_id    integer not null references user (user_id),
+    content    text    not null,
+    created_at datetime default current_timestamp
+);
+
+create index comment_created_at on comment (created_at desc);

notes-service/vendor/sqlx/tests/mysql/migrations_reversible/20220721124650_add_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE migrations_reversible_test;

notes-service/vendor/sqlx/tests/mysql/migrations_reversible/20220721124650_add_table.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_reversible_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_reversible_test (some_id, some_payload)
+VALUES (1, 100);

notes-service/vendor/sqlx/tests/mysql/migrations_reversible/20220721125033_modify_column.down.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload - 1;

notes-service/vendor/sqlx/tests/mysql/migrations_reversible/20220721125033_modify_column.up.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload + 1;

notes-service/vendor/sqlx/tests/mysql/migrations_simple/20220721115250_add_test_table.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_simple_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_simple_test (some_id, some_payload)
+VALUES (1, 100);

notes-service/vendor/sqlx/tests/mysql/migrations_simple/20220721115524_convert_type.sql

@@ -0,0 +1,34 @@
+-- Perform a tricky conversion of the payload.
+--
+-- This script will only succeed once and will fail if executed twice.
+
+-- set up temporary target column
+ALTER TABLE migrations_simple_test
+ADD some_payload_tmp TEXT;
+
+-- perform conversion
+-- This will fail if `some_payload` is already a string column due to the addition.
+-- We add a suffix after the addition to ensure that the SQL database does not silently cast the string back to an 
+-- integer.
+UPDATE migrations_simple_test
+SET some_payload_tmp = CONCAT(CAST((some_payload + 10) AS CHAR(3)), '_suffix');
+
+-- remove original column including the content
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload;
+
+-- prepare new payload column (nullable, so we can copy over the data)
+ALTER TABLE migrations_simple_test
+ADD some_payload TEXT;
+
+-- copy new values
+UPDATE migrations_simple_test
+SET some_payload = some_payload_tmp;
+
+-- "freeze" column
+ALTER TABLE migrations_simple_test
+MODIFY some_payload TEXT NOT NULL;
+
+-- clean up
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload_tmp;

notes-service/vendor/sqlx/tests/mysql/my.cnf

@@ -0,0 +1,4 @@
+[mysqld]
+ssl-ca=/etc/mysql/ssl/ca.crt
+ssl-cert=/etc/mysql/ssl/server.crt
+ssl-key=/etc/mysql/ssl/server.key

notes-service/vendor/sqlx/tests/mysql/mysql.rs

@@ -0,0 +1,729 @@
+use anyhow::Context;
+use futures_util::TryStreamExt;
+use sqlx::mysql::{MySql, MySqlConnection, MySqlPool, MySqlPoolOptions, MySqlRow};
+use sqlx::{Column, Connection, Executor, Row, SqlSafeStr, Statement, TypeInfo};
+use sqlx_core::connection::ConnectOptions;
+use sqlx_core::types::Type;
+use sqlx_mysql::MySqlConnectOptions;
+use sqlx_test::{new, setup_if_needed};
+use std::env;
+use url::Url;
+
+#[sqlx_macros::test]
+async fn it_connects() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    conn.ping().await?;
+    conn.close().await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_connects_without_password() -> anyhow::Result<()> {
+    setup_if_needed();
+
+    let mut url = Url::parse(&env::var("DATABASE_URL").context("expected DATABASE_URL")?)
+        .context("error parsing DATABASE_URL")?;
+
+    url.set_username("no_password").unwrap();
+    url.set_password(None).unwrap();
+
+    let mut conn = MySqlConnectOptions::from_url(&url)?.connect().await?;
+
+    let vars = sqlx::raw_sql("SHOW VARIABLES").fetch_all(&mut conn).await?;
+
+    assert!(!vars.is_empty());
+
+    conn.close().await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_maths() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let value = sqlx::query("select 1 + CAST(? AS SIGNED)")
+        .bind(5_i32)
+        .try_map(|row: MySqlRow| row.try_get::<i32, _>(0))
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(6i32, value);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_fail_at_querying() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let _ = conn.execute(sqlx::query("SELECT 1")).await?;
+
+    // we are testing that this does not cause a panic!
+    let _ = conn
+        .execute(sqlx::query("SELECT non_existence_table"))
+        .await;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_executes() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let _ = conn
+        .execute(
+            r#"
+CREATE TEMPORARY TABLE users (id INTEGER PRIMARY KEY);
+            "#,
+        )
+        .await?;
+
+    for index in 1..=10_i32 {
+        let done = sqlx::query("INSERT INTO users (id) VALUES (?)")
+            .bind(index)
+            .execute(&mut conn)
+            .await?;
+
+        assert_eq!(done.rows_affected(), 1);
+    }
+
+    let sum: i32 = sqlx::query("SELECT id FROM users")
+        .try_map(|row: MySqlRow| row.try_get::<i32, _>(0))
+        .fetch(&mut conn)
+        .try_fold(0_i32, |acc, x| async move { Ok(acc + x) })
+        .await?;
+
+    assert_eq!(sum, 55);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_executes_with_pool() -> anyhow::Result<()> {
+    let pool: MySqlPool = MySqlPoolOptions::new()
+        .min_connections(2)
+        .max_connections(2)
+        .test_before_acquire(false)
+        .connect(&dotenvy::var("DATABASE_URL")?)
+        .await?;
+
+    let rows = pool.fetch_all("SELECT 1; SELECT 2").await?;
+
+    assert_eq!(rows.len(), 2);
+
+    let count = pool
+        .fetch("SELECT 1; SELECT 2")
+        .try_fold(0, |acc, _| async move { Ok(acc + 1) })
+        .await?;
+
+    assert_eq!(count, 2);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_works_with_cache_disabled() -> anyhow::Result<()> {
+    setup_if_needed();
+
+    let mut url = url::Url::parse(&env::var("DATABASE_URL")?)?;
+    url.query_pairs_mut()
+        .append_pair("statement-cache-capacity", "0");
+
+    let mut conn = MySqlConnection::connect(url.as_ref()).await?;
+
+    for index in 1..=10_i32 {
+        let _ = sqlx::query("SELECT ?")
+            .bind(index)
+            .execute(&mut conn)
+            .await?;
+    }
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_drops_results_in_affected_rows() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    // ~1800 rows should be iterated and dropped
+    let done = conn
+        .execute("select * from mysql.time_zone limit 1575")
+        .await?;
+
+    // In MySQL, rows being returned isn't enough to flag it as an _affected_ row
+    assert_eq!(0, done.rows_affected());
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_selects_null() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let (val,): (Option<i32>,) = sqlx::query_as("SELECT NULL").fetch_one(&mut conn).await?;
+
+    assert!(val.is_none());
+
+    let val: Option<i32> = conn.fetch_one("SELECT NULL").await?.try_get(0)?;
+
+    assert!(val.is_none());
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_fetch_one_and_ping() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let (_id,): (i32,) = sqlx::query_as("SELECT 1 as id")
+        .fetch_one(&mut conn)
+        .await?;
+
+    conn.ping().await?;
+
+    let (_id,): (i32,) = sqlx::query_as("SELECT 1 as id")
+        .fetch_one(&mut conn)
+        .await?;
+
+    Ok(())
+}
+
+/// Test that we can interleave reads and writes to the database in one simple query.
+#[sqlx_macros::test]
+async fn it_interleaves_reads_and_writes() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let mut s = conn.fetch(
+        "
+CREATE TEMPORARY TABLE messages (
+    id BIGINT PRIMARY KEY AUTO_INCREMENT,
+    text TEXT NOT NULL
+);
+
+SELECT 'Hello World' as _1;
+
+INSERT INTO messages (text) VALUES ('this is a test');
+
+SELECT id, text FROM messages;
+        ",
+    );
+
+    let row = s.try_next().await?.unwrap();
+
+    assert!("Hello World" == row.try_get::<&str, _>("_1")?);
+
+    let row = s.try_next().await?.unwrap();
+
+    let id: i64 = row.try_get("id")?;
+    let text: &str = row.try_get("text")?;
+
+    assert_eq!(1_i64, id);
+    assert_eq!("this is a test", text);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_caches_statements() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    for i in 0..2 {
+        let row = sqlx::query("SELECT ? AS val")
+            .bind(i)
+            .persistent(true)
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: u32 = row.get("val");
+
+        assert_eq!(i, val);
+    }
+
+    assert_eq!(1, conn.cached_statements_size());
+    conn.clear_cached_statements().await?;
+    assert_eq!(0, conn.cached_statements_size());
+
+    for i in 0..2 {
+        let row = sqlx::query("SELECT ? AS val")
+            .bind(i)
+            .persistent(false)
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: u32 = row.get("val");
+
+        assert_eq!(i, val);
+    }
+
+    assert_eq!(0, conn.cached_statements_size());
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_closes_statements_with_persistent_disabled() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let old_statement_count = select_statement_count(&mut conn).await.unwrap_or_default();
+
+    for i in 0..2 {
+        let row = sqlx::query("SELECT ? AS val")
+            .bind(i)
+            .persistent(false)
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: i32 = row.get("val");
+
+        assert_eq!(i, val);
+    }
+
+    let new_statement_count = select_statement_count(&mut conn).await.unwrap_or_default();
+
+    assert_eq!(old_statement_count, new_statement_count);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_closes_statements_with_cache_disabled() -> anyhow::Result<()> {
+    setup_if_needed();
+
+    let mut url = url::Url::parse(&env::var("DATABASE_URL")?)?;
+    url.query_pairs_mut()
+        .append_pair("statement-cache-capacity", "0");
+
+    let mut conn = MySqlConnection::connect(url.as_ref()).await?;
+
+    let old_statement_count = select_statement_count(&mut conn).await.unwrap_or_default();
+
+    for index in 1..=10_i32 {
+        let _ = sqlx::query("SELECT ?")
+            .bind(index)
+            .execute(&mut conn)
+            .await?;
+    }
+
+    let new_statement_count = select_statement_count(&mut conn).await.unwrap_or_default();
+
+    assert_eq!(old_statement_count, new_statement_count);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_bind_null_and_non_null_issue_540() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let row = sqlx::query("SELECT ?, ?")
+        .bind(50_i32)
+        .bind(None::<i32>)
+        .fetch_one(&mut conn)
+        .await?;
+
+    let v0: Option<i32> = row.get(0);
+    let v1: Option<i32> = row.get(1);
+
+    assert_eq!(v0, Some(50));
+    assert_eq!(v1, None);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_bind_only_null_issue_540() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    let row = sqlx::query("SELECT ?")
+        .bind(None::<i32>)
+        .fetch_one(&mut conn)
+        .await?;
+
+    let v0: Option<i32> = row.get(0);
+
+    assert_eq!(v0, None);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_bind_and_return_years() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::raw_sql(
+        r#"
+CREATE TEMPORARY TABLE too_many_years (
+    id INT PRIMARY KEY AUTO_INCREMENT,
+    the YEAR NOT NULL
+);
+    "#,
+    )
+    .execute(&mut conn)
+    .await?;
+
+    sqlx::query(
+        r#"
+INSERT INTO too_many_years ( the ) VALUES ( ? );
+    "#,
+    )
+    .bind(2142)
+    .execute(&mut conn)
+    .await?;
+
+    let the: u16 = sqlx::query_scalar("SELECT the FROM too_many_years")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(the, 2142);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_prepare_then_execute() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    let mut tx = conn.begin().await?;
+
+    let tweet_id: u64 = sqlx::query("INSERT INTO tweet ( text ) VALUES ( 'Hello, World' )")
+        .execute(&mut *tx)
+        .await?
+        .last_insert_id();
+
+    let statement = tx
+        .prepare("SELECT * FROM tweet WHERE id = ?".into_sql_str())
+        .await?;
+
+    assert_eq!(statement.column(0).name(), "id");
+    assert_eq!(statement.column(1).name(), "created_at");
+    assert_eq!(statement.column(2).name(), "text");
+    assert_eq!(statement.column(3).name(), "owner_id");
+
+    assert_eq!(statement.column(0).type_info().name(), "BIGINT");
+    assert_eq!(statement.column(1).type_info().name(), "TIMESTAMP");
+    assert_eq!(statement.column(2).type_info().name(), "TEXT");
+    assert_eq!(statement.column(3).type_info().name(), "BIGINT");
+
+    let row = statement.query().bind(tweet_id).fetch_one(&mut *tx).await?;
+    let tweet_text: &str = row.try_get("text")?;
+
+    assert_eq!(tweet_text, "Hello, World");
+
+    Ok(())
+}
+
+// repro is more reliable with the basic scheduler used by `#[tokio::test]`
+#[cfg(feature = "_rt-tokio")]
+#[tokio::test]
+async fn test_issue_622() -> anyhow::Result<()> {
+    use std::time::Instant;
+
+    setup_if_needed();
+
+    let pool = MySqlPoolOptions::new()
+        .max_connections(1) // also fails with higher counts, e.g. 5
+        .connect(&std::env::var("DATABASE_URL").unwrap())
+        .await?;
+
+    println!("pool state: {pool:?}");
+
+    let mut handles = vec![];
+
+    // given repro spawned 100 tasks but I found it reliably reproduced with 3
+    for i in 0..3 {
+        let pool = pool.clone();
+
+        handles.push(sqlx_core::rt::spawn(async move {
+            {
+                let mut conn = pool.acquire().await.unwrap();
+
+                let _ = sqlx::query("SELECT 1").fetch_one(&mut *conn).await.unwrap();
+
+                // conn gets dropped here and should be returned to the pool
+            }
+
+            // (do some other work here without holding on to a connection)
+            // this actually fixes the issue, depending on the timeout used
+            // sqlx_core::rt::sleep(Duration::from_millis(500)).await;
+
+            {
+                let start = Instant::now();
+                match pool.acquire().await {
+                    Ok(conn) => {
+                        println!("{} acquire took {:?}", i, start.elapsed());
+                        drop(conn);
+                    }
+                    Err(e) => panic!("{i} acquire returned error: {e} pool state: {pool:?}"),
+                }
+            }
+
+            Result::<(), anyhow::Error>::Ok(())
+        }));
+    }
+
+    futures_util::future::try_join_all(handles).await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_work_with_transactions() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+    sqlx::raw_sql("CREATE TEMPORARY TABLE users (id INTEGER PRIMARY KEY);")
+        .execute(&mut conn)
+        .await?;
+
+    // begin .. rollback
+
+    let mut tx = conn.begin().await?;
+    sqlx::query("INSERT INTO users (id) VALUES (?)")
+        .bind(1_i32)
+        .execute(&mut *tx)
+        .await?;
+    let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users")
+        .fetch_one(&mut *tx)
+        .await?;
+    assert_eq!(count, 1);
+    tx.rollback().await?;
+    let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users")
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(count, 0);
+
+    // begin .. commit
+
+    let mut tx = conn.begin().await?;
+    sqlx::query("INSERT INTO users (id) VALUES (?)")
+        .bind(1_i32)
+        .execute(&mut *tx)
+        .await?;
+    tx.commit().await?;
+    let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users")
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(count, 1);
+
+    // begin .. (drop)
+
+    {
+        let mut tx = conn.begin().await?;
+
+        sqlx::query("INSERT INTO users (id) VALUES (?)")
+            .bind(2)
+            .execute(&mut *tx)
+            .await?;
+        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users")
+            .fetch_one(&mut *tx)
+            .await?;
+        assert_eq!(count, 2);
+        // tx is dropped
+    }
+    let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users")
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(count, 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_can_handle_split_packets() -> anyhow::Result<()> {
+    // This will only take effect on new connections
+    new::<MySql>()
+        .await?
+        .execute("SET GLOBAL max_allowed_packet = 4294967297")
+        .await?;
+
+    let mut conn = new::<MySql>().await?;
+
+    conn.execute(
+        r#"
+CREATE TEMPORARY TABLE large_table (data LONGBLOB);
+        "#,
+    )
+    .await?;
+
+    let data = vec![0x41; 0xFF_FF_FF * 2];
+
+    sqlx::query("INSERT INTO large_table (data) VALUES (?)")
+        .bind(&data)
+        .execute(&mut conn)
+        .await?;
+
+    let ret: Vec<u8> = sqlx::query_scalar("SELECT * FROM large_table")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(ret, data);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_shrink_buffers() -> anyhow::Result<()> {
+    // We don't really have a good way to test that `.shrink_buffers()` functions as expected
+    // without exposing a lot of internals, but we can at least be sure it doesn't
+    // materially affect the operation of the connection.
+
+    let mut conn = new::<MySql>().await?;
+
+    // The connection buffer is only 8 KiB by default so this should definitely force it to grow.
+    let data = "This string should be 32 bytes!\n".repeat(1024);
+    assert_eq!(data.len(), 32 * 1024);
+
+    let ret: String = sqlx::query_scalar("SELECT ?")
+        .bind(&data)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(ret, data);
+
+    conn.shrink_buffers();
+
+    let ret: i64 = sqlx::query_scalar("SELECT ?")
+        .bind(12345678i64)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(ret, 12345678i64);
+
+    Ok(())
+}
+
+async fn select_statement_count(conn: &mut MySqlConnection) -> Result<i64, sqlx::Error> {
+    // Fails if performance schema does not exist
+    sqlx::query_scalar(
+        r#"
+        SELECT COUNT(*)
+        FROM performance_schema.threads AS t
+        INNER JOIN performance_schema.prepared_statements_instances AS psi
+            ON psi.OWNER_THREAD_ID = t.THREAD_ID 
+        WHERE t.processlist_id = CONNECTION_ID()
+        "#,
+    )
+    .fetch_one(conn)
+    .await
+}
+
+#[sqlx_macros::test]
+async fn issue_3200() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::raw_sql(
+        "\
+        CREATE TABLE IF NOT EXISTS users
+        (
+            `id`                     BIGINT AUTO_INCREMENT,
+            `username`               VARCHAR(128) NOT NULL,
+            PRIMARY KEY (id)
+        );
+    ",
+    )
+    .execute(&mut conn)
+    .await?;
+
+    let result = sqlx::raw_sql(
+        "\
+        SET @myvar := 'test@test.com';
+        select id from users where username = @myvar;
+    ",
+    )
+    .fetch_optional(&mut conn)
+    .await?;
+
+    assert!(result.is_none(), "{result:?}");
+
+    Ok(())
+}
+
+#[cfg(mariadb)]
+#[sqlx_macros::test]
+async fn it_can_name_columns_issue_2206() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::raw_sql(
+        "\
+        CREATE TABLE IF NOT EXISTS issue_2206
+        (
+            `id`                     BIGINT AUTO_INCREMENT,
+            `name`                   VARCHAR(128) NOT NULL,
+            PRIMARY KEY (id)
+        );
+    ",
+    )
+    .execute(&mut conn)
+    .await?;
+
+    let row = sqlx::query("INSERT INTO issue_2206 (name) VALUES (?) RETURNING *")
+        .bind("Alice")
+        .fetch_one(&mut conn)
+        .await?;
+    let _id: i64 = row.get("id");
+    let name: String = row.get("name");
+
+    assert_eq!(&name, "Alice");
+
+    Ok(())
+}
+
+#[cfg(feature = "any")]
+#[sqlx_macros::test]
+async fn any_blob_conversions() -> anyhow::Result<()> {
+    use sqlx::Any;
+    use sqlx::Decode;
+    use sqlx::ValueRef;
+
+    sqlx::any::install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    sqlx::raw_sql(
+        r#"
+        CREATE TEMPORARY TABLE any_blob_conversions(
+            id INTEGER PRIMARY KEY,
+            regular_text TEXT NOT NULL,
+            text_binary TEXT COLLATE "utf8mb4_bin" NOT NULL,
+            binary_blob BLOB NOT NULL
+        );
+
+        INSERT INTO any_blob_conversions(id, regular_text, text_binary, binary_blob)
+        VALUES (1, 'Hello, world!', 'Lorem ipsum dolor sit amet', X'01020304DEADBEEF');
+   "#,
+    )
+    .execute(&mut conn)
+    .await?;
+
+    let row = sqlx::query("SELECT * FROM any_blob_conversions")
+        .fetch_one(&mut conn)
+        .await?;
+
+    let id = row.try_get_raw("id")?;
+    let regular_text = row.try_get_raw("regular_text")?;
+    let text_binary = row.try_get_raw("text_binary")?;
+    let binary_blob = row.try_get_raw("binary_blob")?;
+
+    assert_eq!(*id.type_info(), <i32 as Type<Any>>::type_info());
+    assert_eq!(<i32 as Decode<Any>>::decode(id).unwrap(), 1);
+
+    assert_eq!(*regular_text.type_info(), <str as Type<Any>>::type_info());
+    assert_eq!(
+        <&str as Decode<Any>>::decode(regular_text).unwrap(),
+        "Hello, world!"
+    );
+
+    assert_eq!(*text_binary.type_info(), <str as Type<Any>>::type_info());
+    assert_eq!(
+        <&str as Decode<Any>>::decode(text_binary).unwrap(),
+        "Lorem ipsum dolor sit amet"
+    );
+
+    assert_eq!(*binary_blob.type_info(), <[u8] as Type<Any>>::type_info());
+    assert_eq!(
+        <&[u8] as Decode<Any>>::decode(binary_blob).unwrap(),
+        [0x01, 0x02, 0x03, 0x04, 0xDE, 0xAD, 0xBE, 0xEF],
+    );
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mysql/rustsec.rs

@@ -0,0 +1,67 @@
+use sqlx::{Error, MySql};
+use std::io;
+
+use sqlx_test::new;
+
+// https://rustsec.org/advisories/RUSTSEC-2024-0363.html
+//
+// During the audit the MySQL driver was found to be *unlikely* to be vulnerable to the exploit,
+// so this just serves as a sanity check.
+#[sqlx::test]
+async fn rustsec_2024_0363() -> anyhow::Result<()> {
+    let overflow_len = 4 * 1024 * 1024 * 1024; // 4 GiB
+
+    let padding = " ".repeat(overflow_len);
+
+    let payload = "UPDATE injection_target SET message = 'you''ve been pwned!' WHERE id = 1";
+
+    let mut injected_value = String::with_capacity(overflow_len + payload.len());
+
+    injected_value.push_str(&padding);
+    injected_value.push_str(payload);
+
+    // Since this is so large, keeping it around until the end *can* lead to getting OOM-killed.
+    drop(padding);
+
+    let mut conn = new::<MySql>().await?;
+
+    sqlx::raw_sql(
+        "CREATE TEMPORARY TABLE injection_target(id INTEGER PRIMARY KEY AUTO_INCREMENT, message TEXT);\n\
+         INSERT INTO injection_target(message) VALUES ('existing message');",
+    )
+    .execute(&mut conn)
+    .await?;
+
+    // We can't concatenate a query string together like the other tests
+    // because it would just demonstrate a regular old SQL injection.
+    let res = sqlx::query("INSERT INTO injection_target(message) VALUES (?)")
+        .bind(&injected_value)
+        .execute(&mut conn)
+        .await;
+
+    if let Err(e) = res {
+        // Connection rejected the query; we're happy.
+        //
+        // Current observed behavior is that `mysqld` closes the connection before we're even done
+        // sending the message, giving us a "Broken pipe" error.
+        //
+        // As it turns out, MySQL has a tight limit on packet sizes (even after splitting)
+        // by default: https://dev.mysql.com/doc/refman/8.4/en/packet-too-large.html
+        if matches!(e, Error::Io(ref ioe) if ioe.kind() == io::ErrorKind::BrokenPipe) {
+            return Ok(());
+        }
+
+        panic!("unexpected error: {e:?}");
+    }
+
+    let messages: Vec<String> =
+        sqlx::query_scalar("SELECT message FROM injection_target ORDER BY id")
+            .fetch_all(&mut conn)
+            .await?;
+
+    assert_eq!(messages[0], "existing_message");
+    assert_eq!(messages[1].len(), injected_value.len());
+
+    // Injection didn't affect our database; we're happy.
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mysql/setup-mariadb.sql

@@ -0,0 +1,10 @@
+-- additional SQL to execute for MariaDB databases
+
+CREATE TABLE tweet_with_uuid
+(
+    -- UUID is only a bespoke datatype in MariaDB.
+    id         UUID PRIMARY KEY   DEFAULT UUID(),
+    created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+    text       TEXT      NOT NULL,
+    owner_id   UUID
+);

notes-service/vendor/sqlx/tests/mysql/setup.sql

@@ -0,0 +1,32 @@
+-- https://github.com/prisma/database-schema-examples/tree/master/postgres/basic-twitter#basic-twitter
+CREATE TABLE tweet
+(
+    id         BIGINT PRIMARY KEY AUTO_INCREMENT,
+    created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+    text       TEXT      NOT NULL,
+    owner_id   BIGINT
+);
+
+CREATE TABLE tweet_reply
+(
+    id         BIGINT PRIMARY KEY AUTO_INCREMENT,
+    tweet_id   BIGINT    NOT NULL,
+    created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+    text       TEXT      NOT NULL,
+    owner_id   BIGINT,
+    CONSTRAINT tweet_id_fk FOREIGN KEY (tweet_id) REFERENCES tweet(id)
+);
+
+CREATE TABLE products (
+    product_no INTEGER,
+    name TEXT,
+    price NUMERIC CHECK (price > 0)
+);
+
+-- Create a user without a password to test passwordless auth.
+CREATE USER 'no_password'@'%';
+
+-- The minimum privilege apparently needed to connect to a specific database.
+-- Granting no privileges, or just `GRANT USAGE`, gives an "access denied" error.
+-- https://github.com/launchbadge/sqlx/issues/3484#issuecomment-2350901546
+GRANT SELECT ON sqlx.* TO 'no_password'@'%';

notes-service/vendor/sqlx/tests/mysql/test-attr.rs

@@ -0,0 +1,174 @@
+// The no-arg variant is covered by other tests already.
+
+use sqlx::MySqlPool;
+
+const MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("tests/mysql/migrations");
+
+#[sqlx::test]
+async fn it_gets_a_pool(pool: MySqlPool) -> sqlx::Result<()> {
+    let mut conn = pool.acquire().await?;
+
+    let db_name: String = sqlx::query_scalar("select database()")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert!(db_name.starts_with("_sqlx_test_"), "db_name: {:?}", db_name);
+
+    Ok(())
+}
+
+// This should apply migrations and then `fixtures/users.sql`
+#[sqlx::test(migrations = "tests/mysql/migrations", fixtures("users"))]
+async fn it_gets_users(pool: MySqlPool) -> sqlx::Result<()> {
+    let usernames: Vec<String> =
+        sqlx::query_scalar(r#"SELECT username FROM user ORDER BY username"#)
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(usernames, ["alice", "bob"]);
+
+    let post_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM post)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!post_exists);
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+#[sqlx::test(migrations = "tests/mysql/migrations", fixtures("users", "posts"))]
+async fn it_gets_posts(pool: MySqlPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+#[sqlx::test(
+    migrations = "tests/mysql/migrations",
+    fixtures("../fixtures/mysql/users.sql", "../fixtures/mysql/posts.sql")
+)]
+async fn it_gets_posts_explicit_fixtures_path(pool: MySqlPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+#[sqlx::test(
+    migrations = "tests/mysql/migrations",
+    fixtures("../fixtures/mysql/users.sql"),
+    fixtures("posts")
+)]
+async fn it_gets_posts_mixed_fixtures_path(pool: MySqlPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+#[sqlx::test(
+    migrations = "tests/mysql/migrations",
+    fixtures(path = "../fixtures/mysql", scripts("users", "posts"))
+)]
+async fn it_gets_posts_custom_relative_fixtures_path(pool: MySqlPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+// Try `migrator`
+#[sqlx::test(migrator = "MIGRATOR", fixtures("users", "posts", "comments"))]
+async fn it_gets_comments(pool: MySqlPool) -> sqlx::Result<()> {
+    let post_1_comments: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM comment WHERE post_id = ? ORDER BY created_at")
+            .bind(&1)
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_1_comments,
+        ["lol bet ur still bad, 1v1 me", "you're on!"]
+    );
+
+    let post_2_comments: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM comment WHERE post_id = ? ORDER BY created_at")
+            .bind(&2)
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(post_2_comments, ["lol you're just mad you lost :P"]);
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/mysql/types.rs

@@ -0,0 +1,404 @@
+extern crate time_ as time;
+
+use std::borrow::Cow;
+use std::net::SocketAddr;
+use std::rc::Rc;
+#[cfg(feature = "rust_decimal")]
+use std::str::FromStr;
+use std::sync::Arc;
+
+use sqlx::mysql::MySql;
+use sqlx::{Executor, Row};
+
+use sqlx::types::Text;
+
+use sqlx::mysql::types::MySqlTime;
+use sqlx_mysql::types::MySqlTimeSign;
+
+use sqlx_test::{new, test_prepared_type, test_type};
+
+test_type!(bool(MySql, "false" == false, "true" == true));
+
+test_type!(u8(MySql, "CAST(253 AS UNSIGNED)" == 253_u8));
+test_type!(i8(MySql, "5" == 5_i8, "0" == 0_i8));
+
+test_type!(u16(MySql, "CAST(21415 AS UNSIGNED)" == 21415_u16));
+test_type!(i16(MySql, "21415" == 21415_i16));
+
+test_type!(u32(MySql, "CAST(2141512 AS UNSIGNED)" == 2141512_u32));
+test_type!(i32(MySql, "2141512" == 2141512_i32));
+
+test_type!(u64(MySql, "CAST(2141512 AS UNSIGNED)" == 2141512_u64));
+test_type!(i64(MySql, "2141512" == 2141512_i64));
+
+test_type!(f64(MySql, "3.14159265e0" == 3.14159265_f64));
+
+// NOTE: This behavior can be very surprising. MySQL implicitly widens FLOAT bind parameters
+//       to DOUBLE. This results in the weirdness you see below. MySQL generally recommends to stay
+//       away from FLOATs.
+test_type!(f32(MySql, "3.1410000324249268e0" == 3.141f32 as f64 as f32));
+
+test_type!(string<String>(MySql,
+    "'helloworld'" == "helloworld",
+    "''" == ""
+));
+
+test_type!(bytes<Vec<u8>>(MySql,
+    "X'DEADBEEF'"
+        == vec![0xDE_u8, 0xAD, 0xBE, 0xEF],
+    "X''"
+        == Vec::<u8>::new(),
+    "X'0000000052'"
+        == vec![0_u8, 0, 0, 0, 0x52]
+));
+
+#[cfg(feature = "uuid")]
+test_type!(uuid<sqlx::types::Uuid>(MySql,
+    "x'b731678f636f4135bc6f19440c13bd19'"
+        == sqlx::types::Uuid::parse_str("b731678f-636f-4135-bc6f-19440c13bd19").unwrap(),
+    "x'00000000000000000000000000000000'"
+        == sqlx::types::Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap()
+));
+
+#[cfg(feature = "uuid")]
+test_type!(uuid_hyphenated<sqlx::types::uuid::fmt::Hyphenated>(MySql,
+    "'b731678f-636f-4135-bc6f-19440c13bd19'"
+        == sqlx::types::Uuid::parse_str("b731678f-636f-4135-bc6f-19440c13bd19").unwrap().hyphenated(),
+    "'00000000-0000-0000-0000-000000000000'"
+        == sqlx::types::Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap().hyphenated()
+));
+
+#[cfg(feature = "uuid")]
+test_type!(uuid_simple<sqlx::types::uuid::fmt::Simple>(MySql,
+    "'b731678f636f4135bc6f19440c13bd19'"
+        == sqlx::types::Uuid::parse_str("b731678f636f4135bc6f19440c13bd19").unwrap().simple(),
+    "'00000000000000000000000000000000'"
+        == sqlx::types::Uuid::parse_str("00000000000000000000000000000000").unwrap().simple()
+));
+
+test_type!(mysql_time<MySqlTime>(MySql,
+    "TIME '00:00:00.000000'" == MySqlTime::ZERO,
+    "TIME '-00:00:00.000000'" == MySqlTime::ZERO,
+    "TIME '838:59:59.0'" == MySqlTime::MAX,
+    "TIME '-838:59:59.0'" == MySqlTime::MIN,
+    "TIME '123:45:56.890'" == MySqlTime::new(MySqlTimeSign::Positive, 123, 45, 56, 890_000).unwrap(),
+    "TIME '-123:45:56.890'" == MySqlTime::new(MySqlTimeSign::Negative, 123, 45, 56, 890_000).unwrap(),
+    "TIME '123:45:56.890011'" == MySqlTime::new(MySqlTimeSign::Positive, 123, 45, 56, 890_011).unwrap(),
+    "TIME '-123:45:56.890011'" == MySqlTime::new(MySqlTimeSign::Negative, 123, 45, 56, 890_011).unwrap(),
+));
+
+#[cfg(feature = "chrono")]
+mod chrono {
+    use sqlx::types::chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc};
+
+    use super::*;
+
+    test_type!(chrono_date<NaiveDate>(MySql,
+        "DATE '2001-01-05'" == NaiveDate::from_ymd_opt(2001, 1, 5).unwrap(),
+        "DATE '2050-11-23'" == NaiveDate::from_ymd_opt(2050, 11, 23).unwrap()
+    ));
+
+    test_type!(chrono_time_zero<NaiveTime>(MySql,
+        "TIME '00:00:00.000000'" == NaiveTime::from_hms_micro_opt(0, 0, 0, 0).unwrap()
+    ));
+
+    test_type!(chrono_time<NaiveTime>(MySql,
+        "TIME '05:10:20.115100'" == NaiveTime::from_hms_micro_opt(5, 10, 20, 115100).unwrap()
+    ));
+
+    test_type!(chrono_date_time<NaiveDateTime>(MySql,
+        "TIMESTAMP '2019-01-02 05:10:20'" == NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_opt(5, 10, 20).unwrap()
+    ));
+
+    test_type!(chrono_timestamp<DateTime::<Utc>>(MySql,
+        "TIMESTAMP '2019-01-02 05:10:20.115100'"
+            == Utc.from_utc_datetime(
+                &NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_micro_opt(5, 10, 20, 115100).unwrap(),
+            )
+    ));
+
+    #[sqlx_macros::test]
+    async fn test_type_chrono_zero_date() -> anyhow::Result<()> {
+        let mut conn = sqlx_test::new::<MySql>().await?;
+
+        // ensure that zero dates are turned on
+        // newer MySQL has these disabled by default
+
+        conn.execute("SET @@sql_mode := REPLACE(@@sql_mode, 'NO_ZERO_IN_DATE', '');")
+            .await?;
+
+        conn.execute("SET @@sql_mode := REPLACE(@@sql_mode, 'NO_ZERO_DATE', '');")
+            .await?;
+
+        // date
+
+        let row = sqlx::query("SELECT DATE '0000-00-00'")
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: Option<NaiveDate> = row.get(0);
+
+        assert_eq!(val, None);
+        assert!(row.try_get::<NaiveDate, _>(0).is_err());
+
+        // datetime
+
+        let row = sqlx::query("SELECT TIMESTAMP '0000-00-00 00:00:00'")
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: Option<NaiveDateTime> = row.get(0);
+
+        assert_eq!(val, None);
+        assert!(row.try_get::<NaiveDateTime, _>(0).is_err());
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "time")]
+mod time_tests {
+    use time::macros::{date, time};
+
+    use sqlx::types::time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
+
+    use super::*;
+
+    test_type!(time_date<Date>(
+        MySql,
+        "DATE '2001-01-05'" == date!(2001 - 1 - 5),
+        "DATE '2050-11-23'" == date!(2050 - 11 - 23)
+    ));
+
+    test_type!(time_time_zero<Time>(
+        MySql,
+        "TIME '00:00:00.000000'" == time!(00:00:00.000000)
+    ));
+
+    test_type!(time_time<Time>(
+        MySql,
+        "TIME '05:10:20.115100'" == time!(5:10:20.115100)
+    ));
+
+    test_type!(time_date_time<PrimitiveDateTime>(
+        MySql,
+        "TIMESTAMP '2019-01-02 05:10:20'" == date!(2019 - 1 - 2).with_time(time!(5:10:20)),
+        "TIMESTAMP '2019-01-02 05:10:20.115100'"
+            == date!(2019 - 1 - 2).with_time(time!(5:10:20.115100))
+    ));
+
+    test_type!(time_timestamp<OffsetDateTime>(
+        MySql,
+        "TIMESTAMP '2019-01-02 05:10:20.115100'"
+            == date!(2019 - 1 - 2)
+                .with_time(time!(5:10:20.115100))
+                .assume_utc()
+    ));
+
+    #[sqlx_macros::test]
+    async fn test_type_time_zero_date() -> anyhow::Result<()> {
+        let mut conn = sqlx_test::new::<MySql>().await?;
+
+        // ensure that zero dates are turned on
+        // newer MySQL has these disabled by default
+
+        conn.execute("SET @@sql_mode := REPLACE(@@sql_mode, 'NO_ZERO_IN_DATE', '');")
+            .await?;
+
+        conn.execute("SET @@sql_mode := REPLACE(@@sql_mode, 'NO_ZERO_DATE', '');")
+            .await?;
+
+        // date
+
+        let row = sqlx::query("SELECT DATE '0000-00-00'")
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: Option<Date> = row.get(0);
+
+        assert_eq!(val, None);
+        assert!(row.try_get::<Date, _>(0).is_err());
+
+        // datetime
+
+        let row = sqlx::query("SELECT TIMESTAMP '0000-00-00 00:00:00'")
+            .fetch_one(&mut conn)
+            .await?;
+
+        let val: Option<PrimitiveDateTime> = row.get(0);
+
+        assert_eq!(val, None);
+        assert!(row.try_get::<PrimitiveDateTime, _>(0).is_err());
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "bigdecimal")]
+test_type!(bigdecimal<sqlx::types::BigDecimal>(
+    MySql,
+    "CAST(0 as DECIMAL(0, 0))" == "0".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "CAST(1 AS DECIMAL(1, 0))" == "1".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "CAST(10000 AS DECIMAL(5, 0))" == "10000".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "CAST(0.1 AS DECIMAL(2, 1))" == "0.1".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "CAST(0.01234 AS DECIMAL(6, 5))" == "0.01234".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "CAST(12.34 AS DECIMAL(4, 2))" == "12.34".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "CAST(12345.6789 AS DECIMAL(9, 4))" == "12345.6789".parse::<sqlx::types::BigDecimal>().unwrap(),
+));
+
+#[cfg(feature = "rust_decimal")]
+test_type!(decimal<sqlx::types::Decimal>(MySql,
+    "CAST(0 as DECIMAL(0, 0))" == sqlx::types::Decimal::from_str("0").unwrap(),
+    "CAST(1 AS DECIMAL(1, 0))" == sqlx::types::Decimal::from_str("1").unwrap(),
+    "CAST(10000 AS DECIMAL(5, 0))" == sqlx::types::Decimal::from_str("10000").unwrap(),
+    "CAST(0.1 AS DECIMAL(2, 1))" == sqlx::types::Decimal::from_str("0.1").unwrap(),
+    "CAST(0.01234 AS DECIMAL(6, 5))" == sqlx::types::Decimal::from_str("0.01234").unwrap(),
+    "CAST(12.34 AS DECIMAL(4, 2))" == sqlx::types::Decimal::from_str("12.34").unwrap(),
+    "CAST(12345.6789 AS DECIMAL(9, 4))" == sqlx::types::Decimal::from_str("12345.6789").unwrap(),
+));
+
+#[cfg(feature = "json")]
+mod json_tests {
+    use serde_json::{json, Value as JsonValue};
+
+    use sqlx::types::Json;
+    use sqlx_test::test_type;
+
+    use super::*;
+
+    test_type!(json<JsonValue>(
+        MySql,
+        // MySQL 8.0.27 changed `<=>` to return an unsigned integer
+        "SELECT CAST(CAST({0} AS BINARY) <=> CAST(? AS BINARY) AS SIGNED INTEGER), CAST({0} AS BINARY) as _2, ? as _3",
+        "'\"Hello, World\"'" == json!("Hello, World"),
+        "'\"😎\"'" == json!("😎"),
+        "'\"🙋‍♀️\"'" == json!("🙋‍♀️"),
+        "'[\"Hello\",\"World!\"]'" == json!(["Hello", "World!"])
+    ));
+
+    #[derive(serde::Deserialize, serde::Serialize, Debug, PartialEq)]
+    struct Friend {
+        name: String,
+        age: u32,
+    }
+
+    test_type!(json_struct<Json<Friend>>(
+        MySql,
+        // MySQL 8.0.27 changed `<=>` to return an unsigned integer
+        "SELECT CAST(CAST({0} AS BINARY) <=> CAST(? AS BINARY) AS SIGNED INTEGER), CAST({0} AS BINARY) as _2, ? as _3",
+        "\'{\"name\":\"Joe\",\"age\":33}\'" == Json(Friend { name: "Joe".to_string(), age: 33 })
+    ));
+
+    // NOTE: This is testing recursive (and transparent) usage of the `Json` wrapper. You don't
+    //       need to wrap the Vec in Json<_> to make the example work.
+
+    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+    struct Customer {
+        json_column: Json<Vec<i64>>,
+    }
+
+    test_type!(json_struct_json_column<Json<Customer>>(
+        MySql,
+        "\'{\"json_column\":[1,2]}\'" == Json(Customer { json_column: Json(vec![1, 2]) })
+    ));
+}
+
+test_type!(test_arc<Arc<i32>>(MySql, "1" == Arc::new(1i32)));
+test_type!(test_cow<Cow<'_, i32>>(MySql, "1" == Cow::<i32>::Owned(1i32)));
+test_type!(test_box<Box<i32>>(MySql, "1" == Box::new(1i32)));
+test_type!(test_rc<Rc<i32>>(MySql, "1" == Rc::new(1i32)));
+
+test_type!(test_box_str<Box<str>>(MySql, "'John'" == Box::<str>::from("John")));
+test_type!(test_cow_str<Cow<'_, str>>(MySql, "'Phil'" == Cow::<'static, str>::from("Phil")));
+test_type!(test_arc_str<Arc<str>>(MySql, "'1234'" == Arc::<str>::from("1234")));
+test_type!(test_rc_str<Rc<str>>(MySql, "'5678'" == Rc::<str>::from("5678")));
+
+test_prepared_type!(test_box_slice<Box<[u8]>>(MySql, "X'01020304'" == Box::<[u8]>::from([1,2,3,4])));
+test_prepared_type!(test_cow_slice<Cow<'_, [u8]>>(MySql, "X'01020304'" == Cow::<'static, [u8]>::from(&[1,2,3,4])));
+test_prepared_type!(test_arc_slice<Arc<[u8]>>(MySql, "X'01020304'" == Arc::<[u8]>::from([1,2,3,4])));
+test_prepared_type!(test_rc_slice<Rc<[u8]>>(MySql, "X'01020304'" == Rc::<[u8]>::from([1,2,3,4])));
+
+#[sqlx_macros::test]
+async fn test_bits() -> anyhow::Result<()> {
+    let mut conn = new::<MySql>().await?;
+
+    conn.execute(
+        r#"
+CREATE TEMPORARY TABLE with_bits (
+    id INT PRIMARY KEY AUTO_INCREMENT,
+    value_1 BIT(1) NOT NULL,
+    value_n BIT(64) NOT NULL
+);
+    "#,
+    )
+    .await?;
+
+    sqlx::query("INSERT INTO with_bits (value_1, value_n) VALUES (?, ?)")
+        .bind(1_u8)
+        .bind(510202_u32)
+        .execute(&mut conn)
+        .await?;
+
+    // BINARY
+    let (v1, vn): (u8, u64) = sqlx::query_as("SELECT value_1, value_n FROM with_bits")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(v1, 1);
+    assert_eq!(vn, 510202);
+
+    // TEXT
+    let row = conn
+        .fetch_one("SELECT value_1, value_n FROM with_bits")
+        .await?;
+    let v1: u8 = row.try_get(0)?;
+    let vn: u64 = row.try_get(1)?;
+
+    assert_eq!(v1, 1);
+    assert_eq!(vn, 510202);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_text_adapter() -> anyhow::Result<()> {
+    #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
+    struct Login {
+        user_id: i32,
+        socket_addr: Text<SocketAddr>,
+        #[cfg(feature = "time")]
+        login_at: time::OffsetDateTime,
+    }
+
+    let mut conn = new::<MySql>().await?;
+
+    conn.execute(
+        r#"
+CREATE TEMPORARY TABLE user_login (
+    user_id INT PRIMARY KEY AUTO_INCREMENT,
+    socket_addr TEXT NOT NULL,
+    login_at TIMESTAMP NOT NULL
+);
+    "#,
+    )
+    .await?;
+
+    let user_id = 1234;
+    let socket_addr: SocketAddr = "198.51.100.47:31790".parse().unwrap();
+
+    sqlx::query("INSERT INTO user_login (user_id, socket_addr, login_at) VALUES (?, ?, NOW())")
+        .bind(user_id)
+        .bind(Text(socket_addr))
+        .execute(&mut conn)
+        .await?;
+
+    let last_login: Login =
+        sqlx::query_as("SELECT * FROM user_login ORDER BY login_at DESC LIMIT 1")
+            .fetch_one(&mut conn)
+            .await?;
+
+    assert_eq!(last_login.user_id, user_id);
+    assert_eq!(*last_login.socket_addr, socket_addr);
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/Dockerfile

@@ -0,0 +1,12 @@
+ARG VERSION
+FROM postgres:${VERSION}-alpine
+
+# Copy SSL certificate (and key)
+COPY certs/server.crt /var/lib/postgresql/server.crt
+COPY certs/ca.crt /var/lib/postgresql/ca.crt
+COPY certs/keys/server.key /var/lib/postgresql/server.key
+COPY postgres/pg_hba.conf /var/lib/postgresql/pg_hba.conf
+
+# Fix permissions
+RUN chown 70:70 /var/lib/postgresql/server.crt /var/lib/postgresql/server.key
+RUN chmod 0600 /var/lib/postgresql/server.crt /var/lib/postgresql/server.key

notes-service/vendor/sqlx/tests/postgres/derives.rs

@@ -0,0 +1,888 @@
+use futures_util::TryStreamExt;
+use sqlx::postgres::types::PgRange;
+use sqlx::{Connection, Executor, FromRow, Postgres};
+use sqlx_core::sql_str::AssertSqlSafe;
+use sqlx_postgres::PgHasArrayType;
+use sqlx_test::{new, test_type};
+use std::fmt::Debug;
+use std::ops::Bound;
+
+// Transparent types are rust-side wrappers over DB types
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct Transparent(i32);
+
+// Also possible for single-field named structs
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct TransparentNamed {
+    field: i32,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+// https://github.com/launchbadge/sqlx/issues/2611
+// Previously, the derive would generate a `PgHasArrayType` impl that errored on an
+// impossible-to-satisfy `where` bound. This attribute allows the user to opt-out.
+#[sqlx(transparent, no_pg_array)]
+struct TransparentArray(Vec<i64>);
+
+#[sqlx_macros::test]
+async fn test_transparent_slice_to_array() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let values = vec![Transparent(1), Transparent(2), Transparent(3)];
+
+    sqlx::query("SELECT 2 = ANY($1);")
+        .bind(&values)
+        .fetch_one(&mut conn)
+        .await?;
+
+    Ok(())
+}
+
+// "Weak" enums map to an integer type indicated by #[repr]
+#[derive(PartialEq, Copy, Clone, Debug, sqlx::Type)]
+#[repr(i32)]
+enum Weak {
+    One = 0,
+    Two = 2,
+    Three = 4,
+}
+
+// "Strong" enums can map to TEXT (25)
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "text")]
+#[sqlx(rename_all = "lowercase")]
+enum Strong {
+    One,
+    Two,
+
+    #[sqlx(rename = "four")]
+    Three,
+}
+
+// rename_all variants
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_lower")]
+#[sqlx(rename_all = "lowercase")]
+enum ColorLower {
+    Red,
+    Green,
+    Blue,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_snake")]
+#[sqlx(rename_all = "snake_case")]
+enum ColorSnake {
+    RedGreen,
+    BlueBlack,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_upper")]
+#[sqlx(rename_all = "UPPERCASE")]
+enum ColorUpper {
+    Red,
+    Green,
+    Blue,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_screaming_snake")]
+#[sqlx(rename_all = "SCREAMING_SNAKE_CASE")]
+enum ColorScreamingSnake {
+    RedGreen,
+    BlueBlack,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_kebab_case")]
+#[sqlx(rename_all = "kebab-case")]
+enum ColorKebabCase {
+    RedGreen,
+    BlueBlack,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_mixed_case")]
+#[sqlx(rename_all = "camelCase")]
+enum ColorCamelCase {
+    RedGreen,
+    BlueBlack,
+}
+
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "color_camel_case")]
+#[sqlx(rename_all = "PascalCase")]
+enum ColorPascalCase {
+    RedGreen,
+    BlueBlack,
+}
+
+// "Strong" enum can map to a custom type
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "mood")]
+#[sqlx(rename_all = "lowercase")]
+enum Mood {
+    Ok,
+    Happy,
+    Sad,
+}
+
+// Records must map to a custom type
+// Note that all types are types in Postgres
+#[derive(PartialEq, Debug, sqlx::Type)]
+#[sqlx(type_name = "inventory_item")]
+struct InventoryItem {
+    name: String,
+    supplier_id: Option<i32>,
+    price: Option<i64>,
+}
+
+// Custom range type
+#[derive(sqlx::Type, Debug, PartialEq)]
+#[sqlx(type_name = "float_range")]
+struct FloatRange(PgRange<f64>);
+
+// Manual `PgHasArrayType` impl
+#[derive(sqlx::Type)]
+#[sqlx(no_pg_array)]
+pub struct User {
+    pub id: i32,
+    pub username: String,
+}
+
+impl PgHasArrayType for User {
+    fn array_type_info() -> sqlx::postgres::PgTypeInfo {
+        sqlx::postgres::PgTypeInfo::array_of("User")
+    }
+}
+
+test_type!(transparent_tuple<Transparent>(Postgres,
+    "0" == Transparent(0),
+    "23523" == Transparent(23523)
+));
+
+test_type!(transparent_named<TransparentNamed>(Postgres,
+    "0" == TransparentNamed { field: 0 },
+    "23523" == TransparentNamed { field: 23523 },
+));
+
+test_type!(transparent_array<TransparentArray>(Postgres,
+    "'{}'::int8[]" == TransparentArray(vec![]),
+    "'{ 23523, 123456, 789 }'::int8[]" == TransparentArray(vec![23523, 123456, 789])
+));
+
+test_type!(weak_enum<Weak>(Postgres,
+    "0::int4" == Weak::One,
+    "2::int4" == Weak::Two,
+    "4::int4" == Weak::Three,
+));
+
+test_type!(weak_enum_array<Vec<Weak>>(Postgres,
+    "'{0, 2, 4}'::int4[]" == vec![Weak::One, Weak::Two, Weak::Three],
+));
+
+test_type!(strong_enum<Strong>(Postgres,
+    "'one'::text" == Strong::One,
+    "'two'::text" == Strong::Two,
+    "'four'::text" == Strong::Three,
+));
+
+test_type!(strong_enum_array<Vec<Strong>>(Postgres,
+    "ARRAY['one', 'two', 'four']" == vec![Strong::One, Strong::Two, Strong::Three],
+));
+
+test_type!(floatrange<FloatRange>(Postgres,
+    "'[1.234, 5.678]'::float_range" == FloatRange(PgRange::from((Bound::Included(1.234), Bound::Included(5.678)))),
+));
+
+#[sqlx_macros::test]
+async fn test_enum_type() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    conn.execute(
+        r#"
+DROP TABLE IF EXISTS people;
+
+DROP TYPE IF EXISTS mood CASCADE;
+
+CREATE TYPE mood AS ENUM ( 'ok', 'happy', 'sad' );
+
+DROP TYPE IF EXISTS color_lower CASCADE;
+DROP TYPE IF EXISTS color_snake CASCADE;
+DROP TYPE IF EXISTS color_upper CASCADE;
+DROP TYPE IF EXISTS color_screaming_snake CASCADE;
+DROP TYPE IF EXISTS color_kebab_case CASCADE;
+DROP TYPE IF EXISTS color_mixed_case CASCADE;
+DROP TYPE IF EXISTS color_camel_case CASCADE;
+
+
+CREATE TYPE color_lower AS ENUM ( 'red', 'green', 'blue' );
+CREATE TYPE color_snake AS ENUM ( 'red_green', 'blue_black' );
+CREATE TYPE color_upper AS ENUM ( 'RED', 'GREEN', 'BLUE' );
+CREATE TYPE color_screaming_snake AS ENUM ( 'RED_GREEN', 'BLUE_BLACK' );
+CREATE TYPE color_kebab_case AS ENUM ( 'red-green', 'blue-black' );
+CREATE TYPE color_mixed_case AS ENUM ( 'redGreen', 'blueBlack' );
+CREATE TYPE color_camel_case AS ENUM ( 'RedGreen', 'BlueBlack' );
+
+
+CREATE TABLE people (
+    id      serial PRIMARY KEY,
+    mood    mood not null
+);
+    "#,
+    )
+    .await?;
+
+    // Drop and re-acquire the connection
+    conn.close().await?;
+    let mut conn = new::<Postgres>().await?;
+
+    // Select from table test
+    let (people_id,): (i32,) = sqlx::query_as(
+        "
+INSERT INTO people (mood)
+VALUES ($1)
+RETURNING id
+        ",
+    )
+    .bind(Mood::Sad)
+    .fetch_one(&mut conn)
+    .await?;
+
+    // Drop and re-acquire the connection
+    conn.close().await?;
+    let mut conn = new::<Postgres>().await?;
+
+    #[derive(sqlx::FromRow)]
+    struct PeopleRow {
+        id: i32,
+        mood: Mood,
+    }
+
+    let rec: PeopleRow = sqlx::query_as(
+        "
+SELECT id, mood FROM people WHERE id = $1
+            ",
+    )
+    .bind(people_id)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(rec.id, people_id);
+    assert_eq!(rec.mood, Mood::Sad);
+
+    // Drop and re-acquire the connection
+    conn.close().await?;
+    let mut conn = new::<Postgres>().await?;
+
+    let stmt = format!("SELECT id, mood FROM people WHERE id = {people_id}");
+    dbg!(&stmt);
+
+    let mut cursor = conn.fetch(AssertSqlSafe(stmt));
+
+    let row = cursor.try_next().await?.unwrap();
+    let rec = PeopleRow::from_row(&row)?;
+
+    assert_eq!(rec.id, people_id);
+    assert_eq!(rec.mood, Mood::Sad);
+
+    drop(cursor);
+
+    // Normal type equivalency test
+
+    let rec: (bool, Mood) = sqlx::query_as(
+        "
+    SELECT $1 = 'happy'::mood, $1
+            ",
+    )
+    .bind(&Mood::Happy)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, Mood::Happy);
+
+    let rec: (bool, ColorLower) = sqlx::query_as(
+        "
+    SELECT $1 = 'green'::color_lower, $1
+            ",
+    )
+    .bind(&ColorLower::Green)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorLower::Green);
+
+    let rec: (bool, ColorSnake) = sqlx::query_as(
+        "
+    SELECT $1 = 'red_green'::color_snake, $1
+            ",
+    )
+    .bind(&ColorSnake::RedGreen)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorSnake::RedGreen);
+
+    let rec: (bool, ColorUpper) = sqlx::query_as(
+        "
+    SELECT $1 = 'RED'::color_upper, $1
+            ",
+    )
+    .bind(&ColorUpper::Red)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorUpper::Red);
+
+    let rec: (bool, ColorScreamingSnake) = sqlx::query_as(
+        "
+    SELECT $1 = 'RED_GREEN'::color_screaming_snake, $1
+            ",
+    )
+    .bind(&ColorScreamingSnake::RedGreen)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorScreamingSnake::RedGreen);
+
+    let rec: (bool, ColorKebabCase) = sqlx::query_as(
+        "
+    SELECT $1 = 'red-green'::color_kebab_case, $1
+            ",
+    )
+    .bind(&ColorKebabCase::RedGreen)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorKebabCase::RedGreen);
+
+    let rec: (bool, ColorCamelCase) = sqlx::query_as(
+        "
+    SELECT $1 = 'redGreen'::color_mixed_case, $1
+            ",
+    )
+    .bind(&ColorCamelCase::RedGreen)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorCamelCase::RedGreen);
+
+    let rec: (bool, ColorPascalCase) = sqlx::query_as(
+        "
+    SELECT $1 = 'RedGreen'::color_camel_case, $1
+            ",
+    )
+    .bind(&ColorPascalCase::RedGreen)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, ColorPascalCase::RedGreen);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_record_type() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let value = InventoryItem {
+        name: "fuzzy dice".to_owned(),
+        supplier_id: Some(42),
+        price: Some(199),
+    };
+
+    let rec: (bool, InventoryItem) = sqlx::query_as(
+        "
+SELECT $1 = ROW('fuzzy dice', 42, 199)::inventory_item, $1
+        ",
+    )
+    .bind(&value)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert!(rec.0);
+    assert_eq!(rec.1, value);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_new_type() {
+    struct NewType(i32);
+
+    impl From<i32> for NewType {
+        fn from(value: i32) -> Self {
+            NewType(value)
+        }
+    }
+
+    let mut conn = new::<Postgres>().await.unwrap();
+
+    struct NewTypeRow {
+        id: NewType,
+    }
+
+    let res = sqlx::query_as!(NewTypeRow, r#"SELECT 1 as "id!""#)
+        .fetch_one(&mut conn)
+        .await
+        .unwrap();
+    assert_eq!(res.id.0, 1);
+
+    struct NormalRow {
+        id: i32,
+    }
+
+    let res = sqlx::query_as!(NormalRow, r#"SELECT 1 as "id!""#)
+        .fetch_one(&mut conn)
+        .await
+        .unwrap();
+
+    assert_eq!(res.id, 1);
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_from_row() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    #[derive(sqlx::FromRow)]
+    struct Account {
+        id: i32,
+        name: String,
+    }
+
+    let account: Account = sqlx::query_as(
+        "SELECT * from (VALUES (1, 'Herp Derpinson')) accounts(id, name) where id = $1",
+    )
+    .bind(1_i32)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(account.id, 1);
+    assert_eq!(account.name, "Herp Derpinson");
+
+    // A _single_ lifetime may be used but only when using the lowest-level API currently (Query::fetch)
+
+    #[derive(sqlx::FromRow)]
+    struct RefAccount<'a> {
+        id: i32,
+        name: &'a str,
+    }
+
+    let mut cursor = sqlx::query(
+        "SELECT * from (VALUES (1, 'Herp Derpinson')) accounts(id, name) where id = $1",
+    )
+    .bind(1_i32)
+    .fetch(&mut conn);
+
+    let row = cursor.try_next().await?.unwrap();
+    let account = RefAccount::from_row(&row)?;
+
+    assert_eq!(account.id, 1);
+    assert_eq!(account.name, "Herp Derpinson");
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_from_row_with_keyword() -> anyhow::Result<()> {
+    #[derive(Debug, sqlx::FromRow)]
+    struct AccountKeyword {
+        r#type: i32,
+        r#static: String,
+        r#let: Option<String>,
+        r#struct: Option<String>,
+        name: Option<String>,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let account: AccountKeyword = sqlx::query_as(
+        r#"SELECT * from (VALUES (1, 'foo', 'bar', null, null)) accounts(type, static, let, struct, name)"#
+    )
+    .fetch_one(&mut conn)
+    .await?;
+    println!("{account:?}");
+
+    assert_eq!(1, account.r#type);
+    assert_eq!("foo", account.r#static);
+    assert_eq!(None, account.r#struct);
+    assert_eq!(Some("bar".to_owned()), account.r#let);
+    assert_eq!(None, account.name);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_from_row_with_rename() -> anyhow::Result<()> {
+    #[derive(Debug, sqlx::FromRow)]
+    struct AccountKeyword {
+        #[sqlx(rename = "type")]
+        own_type: i32,
+
+        #[sqlx(rename = "static")]
+        my_static: String,
+
+        #[sqlx(rename = "let")]
+        custom_let: Option<String>,
+
+        #[sqlx(rename = "struct")]
+        def_struct: Option<String>,
+
+        name: Option<String>,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let account: AccountKeyword = sqlx::query_as(
+        r#"SELECT * from (VALUES (1, 'foo', 'bar', null, null)) accounts(type, static, let, struct, name)"#
+    )
+    .fetch_one(&mut conn)
+    .await?;
+    println!("{account:?}");
+
+    assert_eq!(1, account.own_type);
+    assert_eq!("foo", account.my_static);
+    assert_eq!(None, account.def_struct);
+    assert_eq!(Some("bar".to_owned()), account.custom_let);
+    assert_eq!(None, account.name);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_from_row_with_rename_all() -> anyhow::Result<()> {
+    #[derive(Debug, sqlx::FromRow)]
+    #[sqlx(rename_all = "camelCase")]
+    struct AccountKeyword {
+        user_id: i32,
+        user_name: String,
+        user_surname: String,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let account: AccountKeyword = sqlx::query_as(
+        r#"SELECT * from (VALUES (1, 'foo', 'bar')) accounts("userId", "userName", "userSurname")"#,
+    )
+    .fetch_one(&mut conn)
+    .await?;
+    println!("{account:?}");
+
+    assert_eq!(1, account.user_id);
+    assert_eq!("foo", account.user_name);
+    assert_eq!("bar", account.user_surname);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_from_row_tuple() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    #[derive(Debug, sqlx::FromRow)]
+    struct Account(i32, String);
+
+    let account: Account = sqlx::query_as(
+        "SELECT * from (VALUES (1, 'Herp Derpinson')) accounts(id, name) where id = $1",
+    )
+    .bind(1_i32)
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(account.0, 1);
+    assert_eq!(account.1, "Herp Derpinson");
+
+    // A _single_ lifetime may be used but only when using the lowest-level API currently (Query::fetch)
+
+    #[derive(sqlx::FromRow)]
+    struct RefAccount<'a>(i32, &'a str);
+
+    let mut cursor = sqlx::query(
+        "SELECT * from (VALUES (1, 'Herp Derpinson')) accounts(id, name) where id = $1",
+    )
+    .bind(1_i32)
+    .fetch(&mut conn);
+
+    let row = cursor.try_next().await?.unwrap();
+    let account = RefAccount::from_row(&row)?;
+
+    assert_eq!(account.0, 1);
+    assert_eq!(account.1, "Herp Derpinson");
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_default() -> anyhow::Result<()> {
+    #[derive(Debug, sqlx::FromRow)]
+    struct HasDefault {
+        not_default: i32,
+        #[sqlx(default)]
+        default: Option<i32>,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let has_default: HasDefault = sqlx::query_as(r#"SELECT 1 AS not_default"#)
+        .fetch_one(&mut conn)
+        .await?;
+    println!("{has_default:?}");
+
+    assert_eq!(has_default.not_default, 1);
+    assert_eq!(has_default.default, None);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_struct_default() -> anyhow::Result<()> {
+    #[derive(Debug, sqlx::FromRow)]
+    #[sqlx(default)]
+    struct HasDefault {
+        not_default: Option<i32>,
+        default_a: Option<String>,
+        default_b: Option<i32>,
+    }
+
+    impl Default for HasDefault {
+        fn default() -> HasDefault {
+            HasDefault {
+                not_default: None,
+                default_a: None,
+                default_b: Some(0),
+            }
+        }
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let has_default: HasDefault = sqlx::query_as(r#"SELECT 1 AS not_default"#)
+        .fetch_one(&mut conn)
+        .await?;
+    println!("{has_default:?}");
+
+    assert_eq!(has_default.not_default, Some(1));
+    assert_eq!(has_default.default_a, None);
+    assert_eq!(has_default.default_b, Some(0));
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_flatten() -> anyhow::Result<()> {
+    #[derive(Debug, Default, sqlx::FromRow)]
+    struct AccountDefault {
+        default: Option<i32>,
+    }
+
+    #[derive(Debug, sqlx::FromRow)]
+    struct UserInfo {
+        name: String,
+        surname: String,
+    }
+
+    #[derive(Debug, sqlx::FromRow)]
+    struct AccountKeyword {
+        id: i32,
+        #[sqlx(flatten)]
+        info: UserInfo,
+        #[sqlx(default)]
+        #[sqlx(flatten)]
+        default: AccountDefault,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let account: AccountKeyword = sqlx::query_as(
+        r#"SELECT * from (VALUES (1, 'foo', 'bar')) accounts("id", "name", "surname")"#,
+    )
+    .fetch_one(&mut conn)
+    .await?;
+    println!("{account:?}");
+
+    assert_eq!(1, account.id);
+    assert_eq!("foo", account.info.name);
+    assert_eq!("bar", account.info.surname);
+    assert_eq!(None, account.default.default);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_skip() -> anyhow::Result<()> {
+    #[derive(Debug, Default, sqlx::FromRow)]
+    struct AccountDefault {
+        default: Option<i32>,
+    }
+
+    #[derive(Debug, sqlx::FromRow)]
+    struct AccountKeyword {
+        id: i32,
+        #[sqlx(skip)]
+        default: AccountDefault,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let account: AccountKeyword = sqlx::query_as(r#"SELECT * from (VALUES (1)) accounts("id")"#)
+        .fetch_one(&mut conn)
+        .await?;
+    println!("{account:?}");
+
+    assert_eq!(1, account.id);
+    assert_eq!(None, account.default.default);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_enum_with_schema() -> anyhow::Result<()> {
+    #[derive(Debug, PartialEq, Eq, sqlx::Type)]
+    #[sqlx(type_name = "foo.\"Foo\"")]
+    enum Foo {
+        Bar,
+        Baz,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let foo: Foo = sqlx::query_scalar("SELECT $1::foo.\"Foo\"")
+        .bind(Foo::Bar)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(foo, Foo::Bar);
+
+    let foo: Foo = sqlx::query_scalar("SELECT $1::foo.\"Foo\"")
+        .bind(Foo::Baz)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(foo, Foo::Baz);
+
+    let foos: Vec<Foo> = sqlx::query_scalar("SELECT ARRAY[$1::foo.\"Foo\", $2::foo.\"Foo\"]")
+        .bind(Foo::Bar)
+        .bind(Foo::Baz)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(foos, [Foo::Bar, Foo::Baz]);
+
+    Ok(())
+}
+
+#[cfg(feature = "macros")]
+#[sqlx_macros::test]
+async fn test_from_row_hygiene() -> anyhow::Result<()> {
+    // A field named `row` previously would shadow the `row` parameter of `FromRow::from_row()`:
+    // https://github.com/launchbadge/sqlx/issues/3344
+    #[derive(Debug, sqlx::FromRow)]
+    pub struct Foo {
+        pub row: i32,
+        pub bar: i32,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let foo: Foo = sqlx::query_as("SELECT 1234 as row, 5678 as bar")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(foo.row, 1234);
+    assert_eq!(foo.bar, 5678);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_custom_pg_array() -> anyhow::Result<()> {
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_record_array_type() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    conn.execute(
+        r#"
+DROP TABLE IF EXISTS responses;
+
+DROP TYPE IF EXISTS http_response CASCADE;
+DROP TYPE IF EXISTS header_pair CASCADE;
+
+CREATE TYPE header_pair AS (
+    name TEXT,
+    value TEXT
+);
+
+CREATE TYPE http_response AS (
+    headers header_pair[]
+);
+
+CREATE TABLE responses (
+    response http_response NOT NULL
+);
+    "#,
+    )
+    .await?;
+
+    #[derive(Debug, sqlx::Type)]
+    #[sqlx(type_name = "http_response")]
+    struct HttpResponseRecord {
+        headers: Vec<HeaderPairRecord>,
+    }
+
+    #[derive(Debug, sqlx::Type)]
+    #[sqlx(type_name = "header_pair")]
+    struct HeaderPairRecord {
+        name: String,
+        value: String,
+    }
+
+    let value = HttpResponseRecord {
+        headers: vec![
+            HeaderPairRecord {
+                name: "Content-Type".to_owned(),
+                value: "text/html; charset=utf-8".to_owned(),
+            },
+            HeaderPairRecord {
+                name: "Cache-Control".to_owned(),
+                value: "max-age=0".to_owned(),
+            },
+        ],
+    };
+
+    sqlx::query(
+        "
+INSERT INTO responses (response)
+VALUES ($1)
+        ",
+    )
+    .bind(&value)
+    .execute(&mut conn)
+    .await?;
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/describe.rs

@@ -0,0 +1,99 @@
+use sqlx::{postgres::Postgres, Column, Executor, SqlSafeStr, TypeInfo};
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_describes_simple() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let d = conn.describe("SELECT * FROM tweet".into_sql_str()).await?;
+
+    assert_eq!(d.columns()[0].name(), "id");
+    assert_eq!(d.columns()[1].name(), "created_at");
+    assert_eq!(d.columns()[2].name(), "text");
+    assert_eq!(d.columns()[3].name(), "owner_id");
+
+    assert_eq!(d.nullable(0), Some(false));
+    assert_eq!(d.nullable(1), Some(false));
+    assert_eq!(d.nullable(2), Some(false));
+    assert_eq!(d.nullable(3), Some(true));
+
+    assert_eq!(d.columns()[0].type_info().name(), "INT8");
+    assert_eq!(d.columns()[1].type_info().name(), "TIMESTAMPTZ");
+    assert_eq!(d.columns()[2].type_info().name(), "TEXT");
+    assert_eq!(d.columns()[3].type_info().name(), "INT8");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_describes_expression() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let d = conn.describe("SELECT 1::int8 + 10".into_sql_str()).await?;
+
+    // ?column? will cause the macro to emit an error ad ask the user to explicitly name the type
+    assert_eq!(d.columns()[0].name(), "?column?");
+
+    // postgres cannot infer nullability from an expression
+    // this will cause the macro to emit `Option<_>`
+    assert_eq!(d.nullable(0), None);
+    assert_eq!(d.columns()[0].type_info().name(), "INT8");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_describes_enum() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let d = conn
+        .describe("SELECT 'open'::status as _1".into_sql_str())
+        .await?;
+
+    assert_eq!(d.columns()[0].name(), "_1");
+
+    let ty = d.columns()[0].type_info();
+
+    assert_eq!(ty.name(), "status");
+
+    assert_eq!(
+        format!("{:?}", ty.kind()),
+        r#"Enum(["new", "open", "closed"])"#
+    );
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_describes_record() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let d = conn
+        .describe("SELECT (true, 10::int2)".into_sql_str())
+        .await?;
+
+    let ty = d.columns()[0].type_info();
+    assert_eq!(ty.name(), "RECORD");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_describes_composite() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let d = conn
+        .describe("SELECT ROW('name',10,500)::inventory_item".into_sql_str())
+        .await?;
+
+    let ty = d.columns()[0].type_info();
+
+    assert_eq!(ty.name(), "inventory_item");
+
+    assert_eq!(
+        format!("{:?}", ty.kind()),
+        r#"Composite([("name", PgTypeInfo(Text)), ("supplier_id", PgTypeInfo(Int4)), ("price", PgTypeInfo(Int8))])"#
+    );
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/error.rs

@@ -0,0 +1,124 @@
+use sqlx::{error::ErrorKind, postgres::Postgres, Connection, Error};
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_fails_with_unique_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    sqlx::query("INSERT INTO tweet(id, text, owner_id) VALUES (1, 'Foo', 1);")
+        .execute(&mut *tx)
+        .await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("INSERT INTO tweet VALUES (1, NOW(), 'Foo', 1);")
+        .execute(&mut *tx)
+        .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::UniqueViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_foreign_key_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO tweet_reply (tweet_id, text) VALUES (1, 'Reply!');")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::ForeignKeyViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_not_null_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("INSERT INTO tweet (text) VALUES (null);")
+        .execute(&mut *tx)
+        .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::NotNullViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_check_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO products VALUES (1, 'Product 1', 0);")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::CheckViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_exclude_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    sqlx::query("INSERT INTO circles VALUES (circle('(0,0)'::point, 5.0));")
+        .execute(&mut *tx)
+        .await?;
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO circles VALUES (circle('(0,2.0)'::point, 2.0));")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::ExclusionViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_begin_failed() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let res = conn.begin_with("SELECT * FROM tweet").await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::BeginFailed), "{err:?}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_invalid_save_point_statement() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut txn = conn.begin().await?;
+    let txn_conn = sqlx::Acquire::acquire(&mut txn).await?;
+    let res = txn_conn.begin_with("BEGIN").await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::InvalidSavePointStatement), "{err}");
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/fixtures/comments.sql

@@ -0,0 +1,16 @@
+insert into comment(comment_id, post_id, user_id, content, created_at)
+values ('fbbbb7dc-dc6f-4649-b663-8d3636035164',
+        '252c1d98-a9b0-4f18-8298-e59058bdfe16',
+        '297923c5-a83c-4052-bab0-030887154e52',
+        'lol bet ur still bad, 1v1 me',
+        now() + '50 minutes ago'::interval),
+       ('cb7612a2-cff4-4e3e-a768-055f01f25dc4',
+        '252c1d98-a9b0-4f18-8298-e59058bdfe16',
+        '297923c5-a83c-4052-bab0-030887154e52',
+        'you''re on!',
+        now() + '45 minutes ago'::interval),
+       ('f2164fcc-a770-4f52-8714-d9cc6a1c89cf',
+        '844265f7-2472-4689-9a2e-b21f40dbf401',
+        '297923c5-a83c-4052-bab0-030887154e52',
+        'lol you''re just mad you lost :P',
+        now() + '15 minutes ago'::interval);

notes-service/vendor/sqlx/tests/postgres/fixtures/posts.sql

@@ -0,0 +1,14 @@
+insert into post(post_id, user_id, content, created_at)
+values
+       (
+        '252c1d98-a9b0-4f18-8298-e59058bdfe16',
+        '6592b7c0-b531-4613-ace5-94246b7ce0c3',
+        'This new computer is lightning-fast!',
+        now() + '1 hour ago'::interval
+        ),
+       (
+        '844265f7-2472-4689-9a2e-b21f40dbf401',
+        '6592b7c0-b531-4613-ace5-94246b7ce0c3',
+        '@alice is a haxxor :(',
+        now() + '30 minutes ago'::interval
+        );

notes-service/vendor/sqlx/tests/postgres/fixtures/rustsec/2024_0363.sql

@@ -0,0 +1,4 @@
+-- https://rustsec.org/advisories/RUSTSEC-2024-0363.html
+-- https://github.com/launchbadge/sqlx/issues/3440
+CREATE TABLE injection_target(id BIGSERIAL PRIMARY KEY, message TEXT);
+INSERT INTO injection_target(message) VALUES ('existing value');

notes-service/vendor/sqlx/tests/postgres/fixtures/users.sql

@@ -0,0 +1,2 @@
+insert into "user"(user_id, username)
+values ('6592b7c0-b531-4613-ace5-94246b7ce0c3', 'alice'), ('297923c5-a83c-4052-bab0-030887154e52', 'bob');

notes-service/vendor/sqlx/tests/postgres/macros.rs

@@ -0,0 +1,662 @@
+use sqlx::{Connection, PgConnection, Postgres, Transaction};
+use sqlx_postgres::types::PgHstore;
+use sqlx_test::new;
+
+use futures_util::TryStreamExt;
+
+#[sqlx_macros::test]
+async fn test_query() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let account = sqlx::query!(
+        "SELECT * from (VALUES (1, 'Herp Derpinson')) accounts(id, name) where id = $1",
+        1i32
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(account.id, Some(1));
+    assert_eq!(account.name.as_deref(), Some("Herp Derpinson"));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_non_null() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    let _ = sqlx::query!("INSERT INTO tweet (text) VALUES ('Hello')")
+        .execute(&mut *tx)
+        .await?;
+
+    let row = sqlx::query!("SELECT id, text, owner_id FROM tweet LIMIT 1")
+        .fetch_one(&mut *tx)
+        .await?;
+
+    assert!(row.id > 0);
+    assert_eq!(row.text, "Hello");
+    assert_eq!(row.owner_id, None);
+
+    // let the transaction rollback so we don't actually insert the tweet
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_no_result() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut tx = conn.begin().await?;
+
+    let _ = sqlx::query!("DELETE FROM tweet").execute(&mut *tx).await?;
+
+    // let the transaction rollback so we don't actually delete the tweets
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_text_var_char_char_n() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    // TEXT
+    // we cannot infer nullability from an expression
+    let rec = sqlx::query!("SELECT 'Hello'::text as greeting")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(rec.greeting.as_deref(), Some("Hello"));
+
+    // VARCHAR(N)
+
+    let rec = sqlx::query!("SELECT 'Hello'::varchar(5) as greeting")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(rec.greeting.as_deref(), Some("Hello"));
+
+    // CHAR(N)
+
+    let rec = sqlx::query!("SELECT 'Hello'::char(5) as greeting")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(rec.greeting.as_deref(), Some("Hello"));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_void() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let _ = sqlx::query!(r#"select pg_notify('chan', 'message')"#)
+        .execute(&mut conn)
+        .await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_call_procedure() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let row = sqlx::query!(r#"CALL forty_two(null)"#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(row.forty_two, Some(42));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_query_file() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    // keep trailing comma as a test
+    let account = sqlx::query_file!("tests/postgres/test-query.sql")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(account.id, 1);
+    assert_eq!(account.name, Option::<String>::None);
+
+    Ok(())
+}
+
+#[derive(Debug)]
+struct Account {
+    id: i32,
+    name: Option<String>,
+}
+
+#[sqlx_macros::test]
+async fn test_query_as() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let name: Option<&str> = None;
+    let account = sqlx::query_as!(
+        Account,
+        r#"SELECT id "id!", name from (VALUES (1, $1)) accounts(id, name)"#,
+        name
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(1, account.id);
+    assert_eq!(None, account.name);
+
+    println!("{account:?}");
+
+    Ok(())
+}
+
+#[derive(Debug)]
+struct RawAccount {
+    r#type: i32,
+    name: Option<String>,
+}
+
+#[sqlx_macros::test]
+async fn test_query_as_raw() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let account = sqlx::query_as!(
+        RawAccount,
+        r#"SELECT type "type!", name from (VALUES (1, null)) accounts(type, name)"#
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(None, account.name);
+    assert_eq!(1, account.r#type);
+
+    println!("{account:?}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_query_file_as() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let account = sqlx::query_file_as!(Account, "tests/postgres/test-query.sql")
+        .fetch_one(&mut conn)
+        .await?;
+
+    println!("{account:?}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_query_scalar() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let id = sqlx::query_scalar!("select 1").fetch_one(&mut conn).await?;
+    // nullability inference can't handle expressions
+    assert_eq!(id, Some(1i32));
+
+    // invalid column names are ignored
+    let id = sqlx::query_scalar!(r#"select 1 as "&foo""#)
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(id, Some(1i32));
+
+    let id = sqlx::query_scalar!(r#"select 1 as "foo!""#)
+        .fetch_one(&mut conn)
+        .await?;
+    assert_eq!(id, 1i32);
+
+    let id = sqlx::query_scalar!(r#"select 1 as "foo?""#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, Some(1i32));
+
+    let id = sqlx::query_scalar!(r#"select 1 as "foo: MyInt4""#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, Some(MyInt4(1i32)));
+
+    let id = sqlx::query_scalar!(r#"select 1 as "foo?: MyInt4""#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, Some(MyInt4(1i32)));
+
+    let id = sqlx::query_scalar!(r#"select 1 as "foo!: MyInt4""#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, MyInt4(1i32));
+
+    let id: MyInt4 = sqlx::query_scalar!(r#"select 1 as "foo: _""#)
+        .fetch_one(&mut conn)
+        .await?
+        // don't hint that it should be `Option<MyInt4>`
+        .unwrap();
+
+    assert_eq!(id, MyInt4(1i32));
+
+    let id: MyInt4 = sqlx::query_scalar!(r#"select 1 as "foo?: _""#)
+        .fetch_one(&mut conn)
+        .await?
+        // don't hint that it should be `Option<MyInt4>`
+        .unwrap();
+
+    assert_eq!(id, MyInt4(1i32));
+
+    let id: MyInt4 = sqlx::query_scalar!(r#"select 1 as "foo!: _""#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(id, MyInt4(1i32));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn query_by_string() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let string = "Hello, world!".to_string();
+    let ref tuple = ("Hello, world!".to_string(),);
+
+    let result = sqlx::query!(
+        "SELECT * from (VALUES('Hello, world!')) strings(string)\
+         where string in ($1, $2, $3, $4, $5, $6, $7)",
+        string, // make sure we don't actually take ownership here
+        &string[..],
+        Some(&string),
+        Some(&string[..]),
+        Option::<String>::None,
+        string.clone(),
+        tuple.0 // make sure we're not trying to move out of a field expression
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(result.string, Some(string));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+#[cfg(feature = "bigdecimal")]
+async fn query_by_bigdecimal() -> anyhow::Result<()> {
+    use sqlx::types::BigDecimal;
+    let mut conn = new::<Postgres>().await?;
+
+    // this tests querying by a non-`Copy` type that doesn't have special reborrow semantics
+
+    let decimal = "1234".parse::<BigDecimal>()?;
+    let ref tuple = ("51245.121232".parse::<BigDecimal>()?,);
+
+    #[cfg_attr(feature = "rust_decimal", allow(deprecated))] // TODO: upgrade to `expect`
+    let result = sqlx::query!(
+        "SELECT * from (VALUES(1234.0)) decimals(decimal)\
+         where decimal in ($1, $2, $3, $4, $5, $6, $7)",
+        decimal,  // make sure we don't actually take ownership here
+        &decimal, // allow query-by-reference
+        Some(&decimal),
+        Some(&decimal),
+        Option::<BigDecimal>::None,
+        decimal.clone(),
+        tuple.0 // make sure we're not trying to move out of a field expression
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(result.decimal, Some(decimal));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_nullable_err() -> anyhow::Result<()> {
+    #[allow(dead_code)]
+    #[derive(Debug)]
+    struct Account {
+        id: i32,
+        name: String,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    let err = sqlx::query_as!(
+        Account,
+        r#"SELECT id "id!", name "name!" from (VALUES (1, null::text)) accounts(id, name)"#
+    )
+    .fetch_one(&mut conn)
+    .await
+    .unwrap_err();
+
+    if let sqlx::Error::ColumnDecode { source, .. } = &err {
+        if let Some(sqlx::error::UnexpectedNullError) = source.downcast_ref() {
+            return Ok(());
+        }
+    }
+
+    panic!("expected `UnexpectedNullError`, got {err}")
+}
+
+#[sqlx_macros::test]
+async fn test_many_args() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    // previous implementation would only have supported 10 bind parameters
+    // (this is really gross to test in MySQL)
+    let rows = sqlx::query!(
+        "SELECT * from unnest(array[$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12]::int[]) ids(id);",
+        0i32, 1i32, 2i32, 3i32, 4i32, 5i32, 6i32, 7i32, 8i32, 9i32, 10i32, 11i32
+    )
+        .fetch_all(&mut conn)
+        .await?;
+
+    for (i, row) in rows.iter().enumerate() {
+        assert_eq!(Some(i as i32), row.id);
+    }
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_array_from_slice() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let list: &[i32] = &[1, 2, 3, 4i32];
+
+    let result = sqlx::query!("SELECT $1::int[] as my_array", list)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(result.my_array, Some(vec![1, 2, 3, 4]));
+
+    println!("result ID: {:?}", result.my_array);
+
+    let account = sqlx::query!("SELECT ARRAY[4,3,2,1] as my_array")
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(account.my_array, Some(vec![4, 3, 2, 1]));
+
+    println!("account ID: {:?}", account.my_array);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn fetch_is_usable_issue_224() -> anyhow::Result<()> {
+    // ensures that the stream returned by `query::Map::fetch()` is usable with `TryStreamExt`
+    let mut conn = new::<Postgres>().await?;
+
+    let mut stream =
+        sqlx::query!("select * from generate_series(1, 3) as series(num);").fetch(&mut conn);
+
+    // `num` is generated by a function so we can't assume it's non-null
+    assert_eq!(stream.try_next().await?.unwrap().num, Some(1));
+    assert_eq!(stream.try_next().await?.unwrap().num, Some(2));
+    assert_eq!(stream.try_next().await?.unwrap().num, Some(3));
+    assert!(stream.try_next().await?.is_none());
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_not_null() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let record = sqlx::query!(r#"select 1 as "id!""#)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.id, 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_nullable() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    // workaround for https://github.com/launchbadge/sqlx/issues/367
+    // declare a `NOT NULL` column from a left-joined table to be nullable
+    let record = sqlx::query!(
+        r#"select text as "text?" from (values (1)) foo(id) left join tweet on false"#
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(record.text, None);
+
+    Ok(())
+}
+
+async fn with_test_row<'a>(
+    conn: &'a mut PgConnection,
+) -> anyhow::Result<Transaction<'a, Postgres>> {
+    let mut transaction = conn.begin().await?;
+    sqlx::query!("INSERT INTO tweet(id, text, owner_id) VALUES (1, '#sqlx is pretty cool!', 1)")
+        .execute(&mut *transaction)
+        .await?;
+    Ok(transaction)
+}
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct MyInt(i64);
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct MyInt4(i32);
+
+struct Record {
+    id: MyInt,
+}
+
+struct OptionalRecord {
+    id: Option<MyInt>,
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_wildcard() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut conn = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as!(Record, r#"select id as "id: _" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    let record = sqlx::query_as!(OptionalRecord, r#"select owner_id as "id: _" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(MyInt(1)));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_wildcard_not_null() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut conn = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as!(Record, r#"select owner_id as "id!: _" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_wildcard_nullable() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut conn = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query_as!(OptionalRecord, r#"select id as "id?: _" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(MyInt(1)));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut conn = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query!(r#"select id as "id: MyInt" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    let record = sqlx::query!(r#"select owner_id as "id: MyInt" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(MyInt(1)));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact_not_null() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut conn = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query!(r#"select owner_id as "id!: MyInt" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, MyInt(1));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_column_override_exact_nullable() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+    let mut conn = with_test_row(&mut conn).await?;
+
+    let record = sqlx::query!(r#"select id as "id?: MyInt" from tweet"#)
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert_eq!(record.id, Some(MyInt(1)));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_bind_arg_override_exact() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let my_int = MyInt4(1);
+
+    // this query should require a bind parameter override as we would otherwise expect the bind
+    // to be the same type
+    let record = sqlx::query!(
+        "select * from (select 1::int4) records(id) where id = $1",
+        my_int as MyInt4
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(record.id, Some(1i32));
+
+    // test that we're actually emitting the typecast by requiring the bound type to be the same
+    let record = sqlx::query!("select $1::int8 as id", 1i32 as i64)
+        .fetch_one(&mut conn)
+        .await?;
+
+    assert_eq!(record.id, Some(1i64));
+
+    // test the override with `Option`
+    let my_opt_int = Some(MyInt4(1));
+
+    let record = sqlx::query!(
+        "select * from (select 1::int4) records(id) where id = $1",
+        my_opt_int as Option<MyInt4>
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(record.id, Some(1i32));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_bind_arg_override_wildcard() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let my_int = MyInt4(1);
+
+    let record = sqlx::query!(
+        "select * from (select 1::int4) records(id) where id = $1",
+        my_int as _
+    )
+    .fetch_one(&mut conn)
+    .await?;
+
+    assert_eq!(record.id, Some(1i32));
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn test_to_from_citext() -> anyhow::Result<()> {
+    // Ensure that the macros consider `CITEXT` to be compatible with `String` and friends
+
+    let mut conn = new::<Postgres>().await?;
+
+    let mut tx = conn.begin().await?;
+
+    let foo_in = "Hello, world!";
+
+    sqlx::query!("insert into test_citext(foo) values ($1)", foo_in)
+        .execute(&mut *tx)
+        .await?;
+
+    let foo_out: String = sqlx::query_scalar!("select foo from test_citext")
+        .fetch_one(&mut *tx)
+        .await?;
+
+    assert_eq!(foo_in, foo_out);
+
+    tx.rollback().await?;
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn pghstore_tests() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let mut store = PgHstore::default();
+    let stores = vec![store.clone(), store.clone()];
+
+    store.insert("key".into(), Some("value".to_string()));
+    sqlx::query!("         insert into mytable(f) values ($1)", store)
+        .execute(&mut conn)
+        .await?;
+
+    sqlx::query!(
+        "         insert into mytable(f) select * from unnest($1::hstore[])",
+        &stores
+    )
+    .execute(&mut conn)
+    .await?;
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/migrate.rs

@@ -0,0 +1,143 @@
+use sqlx::migrate::Migrator;
+use sqlx::pool::PoolConnection;
+use sqlx::postgres::{PgConnection, Postgres};
+use sqlx::Executor;
+use sqlx::Row;
+use std::path::Path;
+
+#[sqlx::test(migrations = false)]
+async fn simple(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+
+    let migrator = Migrator::new(Path::new("tests/postgres/migrations_simple")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: String = conn
+        .fetch_one("SELECT some_payload FROM migrations_simple_test")
+        .await?
+        .get(0);
+    assert_eq!(res, "110_suffix");
+
+    // running it a 2nd time should still work
+    migrator.run(&mut conn).await?;
+
+    Ok(())
+}
+
+#[sqlx::test(migrations = false)]
+async fn reversible(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+
+    let migrator = Migrator::new(Path::new("tests/postgres/migrations_reversible")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back nothing (last version)
+    migrator.undo(&mut conn, 20220721125033).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back one version
+    migrator.undo(&mut conn, 20220721124650).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    Ok(())
+}
+
+#[sqlx::test(migrations = false)]
+async fn skip(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+    let migrator = Migrator::new(Path::new("tests/postgres/migrations_reversible")).await?;
+
+    // get to the state of after the first migration manually
+    let sql = include_str!("migrations_reversible/20220721124650_add_table.up.sql");
+    let statements: Vec<&str> = sql.split(';').filter(|s| !s.trim().is_empty()).collect();
+    for statement in statements {
+        conn.execute(statement).await?;
+    }
+
+    // skip first migration
+    migrator.skip(&mut conn, Some(20220721124650)).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    // run remaining migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 101);
+
+    // roll back one version
+    migrator.undo(&mut conn, 20220721124650).await?;
+
+    // check outcome
+    let res: i64 = conn
+        .fetch_one("SELECT some_payload FROM migrations_reversible_test")
+        .await?
+        .get(0);
+    assert_eq!(res, 100);
+
+    Ok(())
+}
+
+#[sqlx::test(migrations = false)]
+async fn no_tx(mut conn: PoolConnection<Postgres>) -> anyhow::Result<()> {
+    clean_up(&mut conn).await?;
+    let migrator = Migrator::new(Path::new("tests/postgres/migrations_no_tx")).await?;
+
+    // run migration
+    migrator.run(&mut conn).await?;
+
+    // check outcome
+    let res: String = conn
+        .fetch_one("SELECT datname FROM pg_database WHERE datname = 'test_db'")
+        .await?
+        .get(0);
+
+    assert_eq!(res, "test_db");
+
+    Ok(())
+}
+
+/// Ensure that we have a clean initial state.
+async fn clean_up(conn: &mut PgConnection) -> anyhow::Result<()> {
+    conn.execute("DROP DATABASE IF EXISTS test_db").await.ok();
+    conn.execute("DROP TABLE migrations_simple_test").await.ok();
+    conn.execute("DROP TABLE migrations_reversible_test")
+        .await
+        .ok();
+    conn.execute("DROP TABLE _sqlx_migrations").await.ok();
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/migrations/0_setup.sql

@@ -0,0 +1,2 @@
+-- `gen_random_uuid()` wasn't added until Postgres 13
+create extension if not exists "uuid-ossp";

notes-service/vendor/sqlx/tests/postgres/migrations/1_user.sql

@@ -0,0 +1,5 @@
+create table "user"
+(
+    user_id  uuid primary key default uuid_generate_v1mc(),
+    username text unique not null
+);

notes-service/vendor/sqlx/tests/postgres/migrations/2_post.sql

@@ -0,0 +1,8 @@
+create table post (
+    post_id uuid primary key default uuid_generate_v1mc(),
+    user_id uuid not null references "user"(user_id),
+    content text not null,
+    created_at timestamptz default now()
+);
+
+create index on post(created_at desc);

notes-service/vendor/sqlx/tests/postgres/migrations/3_comment.sql

@@ -0,0 +1,9 @@
+create table comment (
+    comment_id uuid primary key default uuid_generate_v1mc(),
+    post_id uuid not null references post(post_id),
+    user_id uuid not null references "user"(user_id),
+    content text not null,
+    created_at timestamptz not null default now()
+);
+
+create index on comment(created_at desc);

notes-service/vendor/sqlx/tests/postgres/migrations_no_tx/0_create_db.sql

@@ -0,0 +1,3 @@
+-- no-transaction
+
+CREATE DATABASE test_db;

notes-service/vendor/sqlx/tests/postgres/migrations_reversible/20220721124650_add_table.down.sql

@@ -0,0 +1 @@
+DROP TABLE migrations_reversible_test;

notes-service/vendor/sqlx/tests/postgres/migrations_reversible/20220721124650_add_table.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_reversible_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_reversible_test (some_id, some_payload)
+VALUES (1, 100);

notes-service/vendor/sqlx/tests/postgres/migrations_reversible/20220721125033_modify_column.down.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload - 1;

notes-service/vendor/sqlx/tests/postgres/migrations_reversible/20220721125033_modify_column.up.sql

@@ -0,0 +1,2 @@
+UPDATE migrations_reversible_test
+SET some_payload = some_payload + 1;

notes-service/vendor/sqlx/tests/postgres/migrations_simple/20220721115250_add_test_table.sql

@@ -0,0 +1,7 @@
+CREATE TABLE migrations_simple_test (
+    some_id BIGINT NOT NULL PRIMARY KEY,
+    some_payload BIGINT NOT NUll
+);
+
+INSERT INTO migrations_simple_test (some_id, some_payload)
+VALUES (1, 100);

notes-service/vendor/sqlx/tests/postgres/migrations_simple/20220721115524_convert_type.sql

@@ -0,0 +1,34 @@
+-- Perform a tricky conversion of the payload.
+--
+-- This script will only succeed once and will fail if executed twice.
+
+-- set up temporary target column
+ALTER TABLE migrations_simple_test
+ADD some_payload_tmp TEXT;
+
+-- perform conversion
+-- This will fail if `some_payload` is already a string column due to the addition.
+-- We add a suffix after the addition to ensure that the SQL database does not silently cast the string back to an 
+-- integer.
+UPDATE migrations_simple_test
+SET some_payload_tmp = CONCAT(CAST((some_payload + 10) AS TEXT), '_suffix');
+
+-- remove original column including the content
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload;
+
+-- prepare new payload column (nullable, so we can copy over the data)
+ALTER TABLE migrations_simple_test
+ADD some_payload TEXT;
+
+-- copy new values
+UPDATE migrations_simple_test
+SET some_payload = some_payload_tmp;
+
+-- "freeze" column
+ALTER TABLE migrations_simple_test
+ALTER COLUMN some_payload SET NOT NULL;
+
+-- clean up
+ALTER TABLE migrations_simple_test
+DROP COLUMN some_payload_tmp;

notes-service/vendor/sqlx/tests/postgres/pg_hba.conf

@@ -0,0 +1,4 @@
+# only needed for certificate authentication tests
+# omit host to prevent fallback to non certificate authentication
+local   all all     trust
+hostssl all all all cert

notes-service/vendor/sqlx/tests/postgres/query_builder.rs

@@ -0,0 +1,162 @@
+use sqlx::postgres::Postgres;
+use sqlx::query_builder::QueryBuilder;
+use sqlx::Executor;
+use sqlx::Type;
+use sqlx::{Either, Execute};
+use sqlx_test::new;
+
+#[test]
+fn test_new() {
+    let qb: QueryBuilder<Postgres> = QueryBuilder::new("SELECT * FROM users");
+    assert_eq!(qb.sql(), "SELECT * FROM users");
+}
+
+#[test]
+fn test_push() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("SELECT * FROM users");
+    let second_line = " WHERE last_name LIKE '[A-N]%';";
+    qb.push(second_line);
+
+    assert_eq!(
+        qb.sql(),
+        "SELECT * FROM users WHERE last_name LIKE '[A-N]%';".to_string(),
+    );
+}
+
+#[test]
+#[should_panic]
+fn test_push_panics_after_build_without_reset() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("SELECT * FROM users;");
+
+    let _query = qb.build();
+
+    qb.push("SELECT * FROM users;");
+}
+
+#[test]
+fn test_push_bind() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("SELECT * FROM users WHERE id = ");
+
+    qb.push_bind(42i32)
+        .push(" OR membership_level = ")
+        .push_bind(3i32);
+
+    assert_eq!(
+        qb.sql(),
+        "SELECT * FROM users WHERE id = $1 OR membership_level = $2"
+    );
+}
+
+#[test]
+fn test_build() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("SELECT * FROM users");
+
+    qb.push(" WHERE id = ").push_bind(42i32);
+    let query = qb.build();
+
+    assert!(Execute::persistent(&query));
+    assert_eq!(query.sql(), "SELECT * FROM users WHERE id = $1");
+}
+
+#[test]
+fn test_reset() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("");
+
+    {
+        let _query = qb
+            .push("SELECT * FROM users WHERE id = ")
+            .push_bind(42i32)
+            .build();
+    }
+
+    qb.reset();
+
+    assert_eq!(qb.sql(), "");
+}
+
+#[test]
+fn test_query_builder_reuse() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("");
+
+    let _query = qb
+        .push("SELECT * FROM users WHERE id = ")
+        .push_bind(42i32)
+        .build();
+
+    qb.reset();
+
+    let query = qb.push("SELECT * FROM users WHERE id = 99").build();
+
+    assert_eq!(query.sql(), "SELECT * FROM users WHERE id = 99");
+}
+
+#[test]
+fn test_query_builder_with_args() {
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("");
+
+    let mut query = qb
+        .push("SELECT * FROM users WHERE id = ")
+        .push_bind(42i32)
+        .build();
+
+    let args = query.take_arguments().unwrap().unwrap();
+
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::with_arguments(query.sql().as_str(), args);
+    let query = qb.push(" OR membership_level = ").push_bind(3i32).build();
+
+    assert_eq!(
+        query.sql(),
+        "SELECT * FROM users WHERE id = $1 OR membership_level = $2"
+    );
+}
+
+#[sqlx::test]
+async fn test_max_number_of_binds() -> anyhow::Result<()> {
+    // The maximum number of binds is 65535 (u16::MAX), not 32567 (i16::MAX)
+    // as the protocol documentation would imply
+    //
+    // https://github.com/launchbadge/sqlx/issues/3464
+
+    let mut qb: QueryBuilder<Postgres> = QueryBuilder::new("SELECT ARRAY[");
+
+    let mut elements = qb.separated(',');
+
+    let max_bind = u16::MAX as i32;
+
+    for i in 1..=max_bind {
+        elements.push_bind(i);
+    }
+
+    qb.push("]::int4[]");
+
+    let mut conn = new::<Postgres>().await?;
+
+    // Indirectly ensures the macros support this many binds since this is what they use.
+    let describe = conn.describe(qb.sql()).await?;
+
+    match describe
+        .parameters
+        .expect("describe() returned no parameter information")
+    {
+        Either::Left(params) => {
+            assert_eq!(params.len(), 65535);
+
+            for param in params {
+                assert_eq!(param, <i32 as Type<Postgres>>::type_info())
+            }
+        }
+        Either::Right(num_params) => {
+            assert_eq!(num_params, 65535);
+        }
+    }
+
+    let values: Vec<i32> = qb.build_query_scalar().fetch_one(&mut conn).await?;
+
+    assert_eq!(values.len(), 65535);
+
+    for (idx, (i, j)) in (1..=max_bind).zip(values).enumerate() {
+        assert_eq!(i, j, "mismatch at index {idx}");
+    }
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/rustsec.rs

@@ -0,0 +1,147 @@
+use sqlx::{Error, PgPool};
+use sqlx_core::sql_str::AssertSqlSafe;
+
+use std::{cmp, str};
+
+// https://rustsec.org/advisories/RUSTSEC-2024-0363.html
+#[sqlx::test(migrations = false, fixtures("./fixtures/rustsec/2024_0363.sql"))]
+async fn rustsec_2024_0363(pool: PgPool) -> anyhow::Result<()> {
+    let overflow_len = 4 * 1024 * 1024 * 1024; // 4 GiB
+
+    // These three strings concatenated together will be the first query the Postgres backend "sees"
+    //
+    // Rather contrived because this already represents an injection vulnerability,
+    // but it's easier to demonstrate the bug with a simple `Query` message
+    // than the `Prepare` -> `Bind` -> `Execute` flow.
+    let real_query_prefix = "INSERT INTO injection_target(message) VALUES ('";
+    let fake_message = "fake_msg') RETURNING id;\0";
+    let real_query_suffix = "') RETURNING id";
+
+    // Our payload is another simple `Query` message
+    let real_payload =
+        "Q\0\0\0\x4DUPDATE injection_target SET message = 'you''ve been pwned!' WHERE id = 1\0";
+
+    // This is the value we want the length prefix to overflow to (including the length of the prefix itself)
+    // This will leave the backend's buffer pointing at our real payload.
+    let fake_payload_len = real_query_prefix.len() + fake_message.len() + 4;
+
+    // Pretty easy to see that this should overflow to `fake_payload_len`
+    let target_payload_len = overflow_len + fake_payload_len;
+
+    // This is the length we expect `injected_value` to be
+    let expected_inject_len = target_payload_len
+        - 4 // Length prefix
+        - real_query_prefix.len()
+        - (real_query_suffix.len() + 1 /* NUL terminator */);
+
+    let pad_to_len = expected_inject_len - 5; // Header for FLUSH message that eats `real_query_suffix` (see below)
+
+    let expected_payload_len = 4 // length prefix
+        + real_query_prefix.len()
+        + expected_inject_len
+        + real_query_suffix.len()
+        + 1; // NUL terminator
+
+    let expected_wrapped_len = expected_payload_len % overflow_len;
+    assert_eq!(expected_wrapped_len, fake_payload_len);
+
+    // This will be the string we inject into the query.
+    let mut injected_value = String::with_capacity(expected_inject_len);
+
+    injected_value.push_str(fake_message);
+    injected_value.push_str(real_payload);
+
+    // The Postgres backend reads the `FLUSH` message but ignores its contents.
+    // This gives us a variable-length NOP that lets us pad to the length we want,
+    // as well as a way to eat `real_query_suffix` without breaking the connection.
+    let flush_fill = "\0".repeat(9996);
+
+    let flush_fmt_code = 'H'; // note: 'F' is `FunctionCall`.
+
+    'outer: while injected_value.len() < pad_to_len {
+        let remaining_len = pad_to_len - injected_value.len();
+
+        // The max length of a FLUSH message is 10,000, including the length prefix.
+        let flush_len = cmp::min(
+            remaining_len - 1, // minus format code
+            10000,
+        );
+
+        // We need `flush_len` to be valid UTF-8 when encoded in big-endian
+        // in order to push it to the string.
+        //
+        // Not every value is going to be valid though, so we search for one that is.
+        'inner: for flush_len in (4..=flush_len).rev() {
+            let flush_len_be = (flush_len as i32).to_be_bytes();
+
+            let Ok(flush_len_str) = str::from_utf8(&flush_len_be) else {
+                continue 'inner;
+            };
+
+            let fill_len = flush_len - 4;
+
+            injected_value.push(flush_fmt_code);
+            injected_value.push_str(flush_len_str);
+            injected_value.push_str(&flush_fill[..fill_len]);
+
+            continue 'outer;
+        }
+
+        panic!("unable to find a valid encoding/split for {flush_len}");
+    }
+
+    assert_eq!(injected_value.len(), pad_to_len);
+
+    // The amount of data the last FLUSH message has to eat
+    let eat_len = real_query_suffix.len() + 1; // plus NUL terminator
+
+    // Push the FLUSH message that will eat `real_query_suffix`
+    injected_value.push(flush_fmt_code);
+    injected_value.push_str(str::from_utf8(&(eat_len as i32).to_be_bytes()).unwrap());
+    // The value will be in the buffer already.
+
+    assert_eq!(expected_inject_len, injected_value.len());
+
+    let query = format!("{real_query_prefix}{injected_value}{real_query_suffix}");
+
+    // The length of the `Query` message we've created
+    let final_payload_len = 4 // length prefix
+        + query.len()
+        + 1; // NUL terminator
+
+    assert_eq!(expected_payload_len, final_payload_len);
+
+    let wrapped_len = final_payload_len % overflow_len;
+
+    assert_eq!(wrapped_len, fake_payload_len);
+
+    let res = sqlx::raw_sql(AssertSqlSafe(query))
+        // Note: the connection may hang afterward
+        // because `pending_ready_for_query_count` will underflow.
+        .execute(&pool)
+        .await;
+
+    if let Err(e) = res {
+        // Connection rejected the query; we're happy.
+        if matches!(e, Error::Protocol(_)) {
+            return Ok(());
+        }
+
+        panic!("unexpected error: {e:?}");
+    }
+
+    let messages: Vec<String> =
+        sqlx::query_scalar("SELECT message FROM injection_target ORDER BY id")
+            .fetch_all(&pool)
+            .await?;
+
+    // If the injection succeeds, `messages` will look like:
+    // ["you've been pwned!'.to_string(), "fake_msg".to_string()]
+    assert_eq!(
+        messages,
+        ["existing message".to_string(), "fake_msg".to_string()]
+    );
+
+    // Injection didn't affect our database; we're happy.
+    Ok(())
+}

notes-service/vendor/sqlx/tests/postgres/setup.sql

@@ -0,0 +1,83 @@
+-- https://www.postgresql.org/docs/current/ltree.html
+CREATE EXTENSION IF NOT EXISTS ltree;
+
+-- https://www.postgresql.org/docs/current/cube.html
+CREATE EXTENSION IF NOT EXISTS cube;
+
+-- https://www.postgresql.org/docs/current/citext.html
+CREATE EXTENSION IF NOT EXISTS citext;
+
+-- https://www.postgresql.org/docs/current/hstore.html
+CREATE EXTENSION IF NOT EXISTS hstore;
+
+-- https://www.postgresql.org/docs/current/sql-createtype.html
+CREATE TYPE status AS ENUM ('new', 'open', 'closed');
+
+-- https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-DECLARING
+CREATE TYPE inventory_item AS
+(
+    name        TEXT,
+    supplier_id INT,
+    price       BIGINT
+);
+
+-- https://github.com/prisma/database-schema-examples/tree/master/postgres/basic-twitter#basic-twitter
+CREATE TABLE tweet
+(
+    id         BIGSERIAL PRIMARY KEY,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    text       TEXT        NOT NULL,
+    owner_id   BIGINT
+);
+
+CREATE TABLE tweet_reply
+(
+    id         BIGSERIAL PRIMARY KEY,
+    tweet_id   BIGINT      NOT NULL REFERENCES tweet(id),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    text       TEXT        NOT NULL,
+    owner_id   BIGINT
+);
+
+CREATE TYPE float_range AS RANGE
+(
+    subtype = float8,
+    subtype_diff = float8mi
+);
+
+CREATE TABLE products (
+    product_no INTEGER,
+    name TEXT,
+    price NUMERIC CHECK (price > 0)
+);
+
+CREATE OR REPLACE PROCEDURE forty_two(INOUT forty_two INT = NULL)
+    LANGUAGE plpgsql AS 'begin forty_two := 42; end;';
+
+CREATE TABLE test_citext (
+    foo CITEXT NOT NULL
+);
+
+CREATE SCHEMA IF NOT EXISTS foo;
+
+CREATE TYPE foo."Foo" as ENUM ('Bar', 'Baz');
+
+CREATE TABLE mytable(f HSTORE);
+
+CREATE TABLE circles (
+    c circle,
+    EXCLUDE USING gist (c WITH &&)
+);
+
+CREATE DOMAIN positive_int AS integer CHECK (VALUE > 0);
+CREATE DOMAIN percentage AS positive_int CHECK (VALUE <= 100);
+
+CREATE TYPE person as (
+    id int,
+    age positive_int,
+    percent percentage
+);
+
+CREATE TYPE leaf_composite AS (prim integer);
+CREATE DOMAIN domain AS leaf_composite;
+CREATE TYPE root_composite AS (domain domain);

notes-service/vendor/sqlx/tests/postgres/test-attr.rs

@@ -0,0 +1,201 @@
+// The no-arg variant is covered by other tests already.
+
+use sqlx::PgPool;
+
+const MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("tests/postgres/migrations");
+
+#[sqlx::test]
+async fn it_gets_a_pool(pool: PgPool) -> sqlx::Result<()> {
+    let mut conn = pool.acquire().await?;
+
+    let db_name: String = sqlx::query_scalar("SELECT current_database()")
+        .fetch_one(&mut *conn)
+        .await?;
+
+    assert!(db_name.starts_with("_sqlx_test"), "dbname: {db_name:?}");
+
+    Ok(())
+}
+
+// This should apply migrations and then `fixtures/users.sql`
+#[sqlx::test(migrations = "tests/postgres/migrations", fixtures("users"))]
+async fn it_gets_users(pool: PgPool) -> sqlx::Result<()> {
+    let usernames: Vec<String> =
+        sqlx::query_scalar(r#"SELECT username FROM "user" ORDER BY username"#)
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(usernames, ["alice", "bob"]);
+
+    let post_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM post)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!post_exists);
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+// This should apply migrations and then fixtures `fixtures/users.sql` and `fixtures/posts.sql`
+#[sqlx::test(migrations = "tests/postgres/migrations", fixtures("users", "posts"))]
+async fn it_gets_posts(pool: PgPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+// This should apply migrations and then `../fixtures/postgres/users.sql` and `../fixtures/postgres/posts.sql`
+#[sqlx::test(
+    migrations = "tests/postgres/migrations",
+    fixtures("../fixtures/postgres/users.sql", "../fixtures/postgres/posts.sql")
+)]
+async fn it_gets_posts_explicit_fixtures_path(pool: PgPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+// This should apply migrations and then `../fixtures/postgres/users.sql` and `fixtures/posts.sql`
+#[sqlx::test(
+    migrations = "tests/postgres/migrations",
+    fixtures("../fixtures/postgres/users.sql"),
+    fixtures("posts")
+)]
+async fn it_gets_posts_mixed_fixtures_path(pool: PgPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+// This should apply migrations and then `../fixtures/postgres/users.sql` and `../fixtures/postgres/posts.sql`
+#[sqlx::test(
+    migrations = "tests/postgres/migrations",
+    fixtures("../fixtures/postgres/users.sql", "../fixtures/postgres/posts.sql")
+)]
+async fn it_gets_posts_custom_relative_fixtures_path(pool: PgPool) -> sqlx::Result<()> {
+    let post_contents: Vec<String> =
+        sqlx::query_scalar("SELECT content FROM post ORDER BY created_at")
+            .fetch_all(&pool)
+            .await?;
+
+    assert_eq!(
+        post_contents,
+        [
+            "This new computer is lightning-fast!",
+            "@alice is a haxxor :("
+        ]
+    );
+
+    let comment_exists: bool = sqlx::query_scalar("SELECT exists(SELECT 1 FROM comment)")
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(!comment_exists);
+
+    Ok(())
+}
+
+// Try `migrator`
+#[sqlx::test(migrator = "MIGRATOR", fixtures("users", "posts", "comments"))]
+async fn it_gets_comments(pool: PgPool) -> sqlx::Result<()> {
+    let post_1_comments: Vec<String> = sqlx::query_scalar(
+        "SELECT content FROM comment WHERE post_id = $1::uuid ORDER BY created_at",
+    )
+    .bind("252c1d98-a9b0-4f18-8298-e59058bdfe16")
+    .fetch_all(&pool)
+    .await?;
+
+    assert_eq!(
+        post_1_comments,
+        ["lol bet ur still bad, 1v1 me", "you're on!"]
+    );
+
+    let post_2_comments: Vec<String> = sqlx::query_scalar(
+        "SELECT content FROM comment WHERE post_id = $1::uuid ORDER BY created_at",
+    )
+    .bind("844265f7-2472-4689-9a2e-b21f40dbf401")
+    .fetch_all(&pool)
+    .await?;
+
+    assert_eq!(post_2_comments, ["lol you're just mad you lost :P"]);
+
+    Ok(())
+}
+
+#[sqlx::test(
+    migrations = "tests/postgres/migrations",
+    fixtures(path = "../fixtures/postgres", scripts("users", "posts"))
+)]
+async fn this_should_compile(_pool: PgPool) -> sqlx::Result<()> {
+    Ok(())
+}
+
+macro_rules! macro_using_test {
+    ($migrations: literal) => {
+        #[sqlx::test(
+                            migrations = $migrations,
+                            fixtures(path = "../fixtures/postgres", scripts("users", "posts"))
+                        )]
+        async fn macro_using_macro(_pool: PgPool) -> sqlx::Result<()> {
+            Ok(())
+        }
+    };
+}
+macro_using_test!("tests/postgres/migrations");

notes-service/vendor/sqlx/tests/postgres/test-query.sql

@@ -0,0 +1 @@
+SELECT id "id!", name from (VALUES (1, null)) accounts(id, name)

notes-service/vendor/sqlx/tests/postgres/types.rs

@@ -0,0 +1,816 @@
+extern crate time_ as time;
+
+use std::borrow::Cow;
+use std::net::SocketAddr;
+use std::ops::Bound;
+use std::rc::Rc;
+use std::str::FromStr;
+use std::sync::Arc;
+
+use sqlx::postgres::types::{Oid, PgCiText, PgInterval, PgMoney, PgRange};
+use sqlx::postgres::Postgres;
+use sqlx_test::{new, test_decode_type, test_prepared_type, test_type};
+
+use sqlx_core::executor::Executor;
+use sqlx_core::types::Text;
+
+test_type!(null<Option<i16>>(Postgres,
+    "NULL::int2" == None::<i16>
+));
+
+test_type!(null_vec<Vec<Option<i16>>>(Postgres,
+    "array[10,NULL,50]::int2[]" == vec![Some(10_i16), None, Some(50)],
+));
+
+test_type!(null_array<[Option<i16>; 3]>(Postgres,
+    "array[10,NULL,50]::int2[]" == vec![Some(10_i16), None, Some(50)],
+));
+
+test_type!(bool<bool>(Postgres,
+    "false::boolean" == false,
+    "true::boolean" == true
+));
+
+test_type!(bool_vec<Vec<bool>>(Postgres,
+    "array[true,false,true]::bool[]" == vec![true, false, true],
+));
+
+test_type!(bool_array<[bool; 3]>(Postgres,
+    "array[true,false,true]::bool[]" == vec![true, false, true],
+));
+
+test_type!(byte_vec<Vec<u8>>(Postgres,
+    "E'\\\\xDEADBEEF'::bytea"
+        == vec![0xDE_u8, 0xAD, 0xBE, 0xEF],
+    "E'\\\\x'::bytea"
+        == Vec::<u8>::new(),
+    "E'\\\\x0000000052'::bytea"
+        == vec![0_u8, 0, 0, 0, 0x52]
+));
+
+// BYTEA cannot be decoded by-reference from a simple query as postgres sends it as hex
+test_prepared_type!(byte_slice<&[u8]>(Postgres,
+    "E'\\\\xDEADBEEF'::bytea"
+        == &[0xDE_u8, 0xAD, 0xBE, 0xEF][..],
+    "E'\\\\x0000000052'::bytea"
+        == &[0_u8, 0, 0, 0, 0x52][..]
+));
+
+test_type!(byte_array_empty<[u8; 0]>(Postgres,
+    "E'\\\\x'::bytea" == [0_u8; 0],
+));
+
+test_type!(byte_array<[u8; 4]>(Postgres,
+    "E'\\\\xDEADBEEF'::bytea" == [0xDE_u8, 0xAD, 0xBE, 0xEF],
+));
+
+test_type!(str<&str>(Postgres,
+    "'this is foo'" == "this is foo",
+    "''" == "",
+    "'identifier'::name" == "identifier",
+    "'five'::char(4)" == "five",
+    "'more text'::varchar" == "more text",
+    "'case insensitive searching'::citext" == "case insensitive searching",
+));
+
+test_type!(string<String>(Postgres,
+    "'this is foo'" == format!("this is foo"),
+));
+
+test_type!(string_vec<Vec<String>>(Postgres,
+    "array['one','two','three']::text[]"
+        == vec!["one","two","three"],
+
+    "array['', '\"']::text[]"
+        == vec!["", "\""],
+
+    "array['Hello, World', '', 'Goodbye']::text[]"
+        == vec!["Hello, World", "", "Goodbye"],
+));
+
+test_type!(string_array<[String; 3]>(Postgres,
+    "array['one','two','three']::text[]" == ["one","two","three"],
+));
+
+test_type!(i8(
+    Postgres,
+    "0::\"char\"" == 0_i8,
+    "120::\"char\"" == 120_i8,
+));
+
+test_type!(Oid(Postgres, "325235::oid" == Oid(325235),));
+
+test_type!(i16(
+    Postgres,
+    "-2144::smallint" == -2144_i16,
+    "821::smallint" == 821_i16,
+));
+
+test_type!(i32(
+    Postgres,
+    "94101::int" == 94101_i32,
+    "-5101::int" == -5101_i32
+));
+
+test_type!(i32_vec<Vec<i32>>(Postgres,
+    "'{5,10,50,100}'::int[]" == vec![5_i32, 10, 50, 100],
+    "'{1050}'::int[]" == vec![1050_i32],
+    "'{}'::int[]" == Vec::<i32>::new(),
+    "'{1,3,-5}'::int[]" == vec![1_i32, 3, -5]
+));
+
+test_type!(i32_array_empty<[i32; 0]>(Postgres,
+    "'{}'::int[]" == [0_i32; 0],
+));
+
+test_type!(i32_array<[i32; 4]>(Postgres,
+    "'{5,10,50,100}'::int[]" == [5_i32, 10, 50, 100],
+));
+
+test_type!(i64(Postgres, "9358295312::bigint" == 9358295312_i64));
+
+test_type!(f32(Postgres, "9419.122::real" == 9419.122_f32));
+
+test_type!(f64(
+    Postgres,
+    "939399419.1225182::double precision" == 939399419.1225182_f64
+));
+
+test_type!(f64_vec<Vec<f64>>(Postgres,
+    "'{939399419.1225182,-12.0}'::float8[]" == vec![939399419.1225182_f64, -12.0]
+));
+
+test_decode_type!(bool_tuple<(bool,)>(Postgres, "row(true)" == (true,)));
+
+test_decode_type!(num_tuple<(i32, i64, f64,)>(Postgres, "row(10,515::int8,3.124::float8)" == (10,515,3.124)));
+
+test_decode_type!(empty_tuple<()>(Postgres, "row()" == ()));
+
+test_decode_type!(string_tuple<(String, String, String)>(Postgres,
+    "row('one','two','three')"
+        == ("one".to_string(), "two".to_string(), "three".to_string()),
+
+    "row('', '\"', '\"\"\"\"\"\"')"
+        == ("".to_string(), "\"".to_string(), "\"\"\"\"\"\"".to_string()),
+
+    "row('Hello, World', '', 'Goodbye')"
+        == ("Hello, World".to_string(), "".to_string(), "Goodbye".to_string())
+));
+
+#[cfg(feature = "uuid")]
+test_type!(uuid<sqlx::types::Uuid>(Postgres,
+    "'b731678f-636f-4135-bc6f-19440c13bd19'::uuid"
+        == sqlx::types::Uuid::parse_str("b731678f-636f-4135-bc6f-19440c13bd19").unwrap(),
+    "'00000000-0000-0000-0000-000000000000'::uuid"
+        == sqlx::types::Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap()
+));
+
+#[cfg(feature = "uuid")]
+test_type!(uuid_vec<Vec<sqlx::types::Uuid>>(Postgres,
+    "'{b731678f-636f-4135-bc6f-19440c13bd19,00000000-0000-0000-0000-000000000000}'::uuid[]"
+        == vec![
+           sqlx::types::Uuid::parse_str("b731678f-636f-4135-bc6f-19440c13bd19").unwrap(),
+           sqlx::types::Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap()
+        ]
+));
+
+#[cfg(feature = "ipnet")]
+test_type!(ipnet<sqlx::types::ipnet::IpNet>(Postgres,
+    "'127.0.0.1'::inet"
+        == "127.0.0.1/32"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+    "'8.8.8.8/24'::inet"
+        == "8.8.8.8/24"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+    "'10.1.1/24'::inet"
+        == "10.1.1.0/24"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+    "'::ffff:1.2.3.0'::inet"
+        == "::ffff:1.2.3.0/128"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+    "'2001:4f8:3:ba::/64'::inet"
+        == "2001:4f8:3:ba::/64"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+    "'192.168'::cidr"
+        == "192.168.0.0/24"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+    "'::ffff:1.2.3.0/120'::cidr"
+        == "::ffff:1.2.3.0/120"
+            .parse::<sqlx::types::ipnet::IpNet>()
+            .unwrap(),
+));
+
+#[cfg(feature = "ipnetwork")]
+test_type!(ipnetwork<sqlx::types::ipnetwork::IpNetwork>(Postgres,
+    "'127.0.0.1'::inet"
+        == "127.0.0.1"
+            .parse::<sqlx::types::ipnetwork::IpNetwork>()
+            .unwrap(),
+    "'8.8.8.8/24'::inet"
+        == "8.8.8.8/24"
+            .parse::<sqlx::types::ipnetwork::IpNetwork>()
+            .unwrap(),
+    "'::ffff:1.2.3.0'::inet"
+        == "::ffff:1.2.3.0"
+            .parse::<sqlx::types::ipnetwork::IpNetwork>()
+            .unwrap(),
+    "'2001:4f8:3:ba::/64'::inet"
+        == "2001:4f8:3:ba::/64"
+            .parse::<sqlx::types::ipnetwork::IpNetwork>()
+            .unwrap(),
+    "'192.168'::cidr"
+        == "192.168.0.0/24"
+            .parse::<sqlx::types::ipnetwork::IpNetwork>()
+            .unwrap(),
+    "'::ffff:1.2.3.0/120'::cidr"
+        == "::ffff:1.2.3.0/120"
+            .parse::<sqlx::types::ipnetwork::IpNetwork>()
+            .unwrap(),
+));
+
+#[cfg(feature = "mac_address")]
+test_type!(mac_address<sqlx::types::mac_address::MacAddress>(Postgres,
+    "'00:01:02:03:04:05'::macaddr"
+        == "00:01:02:03:04:05"
+            .parse::<sqlx::types::mac_address::MacAddress>()
+            .unwrap()
+));
+
+#[cfg(feature = "bit-vec")]
+test_type!(bitvec<sqlx::types::BitVec>(
+    Postgres,
+    // A full byte VARBIT
+    "B'01101001'" == sqlx::types::BitVec::from_bytes(&[0b0110_1001]),
+    // A VARBIT value missing five bits from a byte
+    "B'110'" == {
+        let mut bit_vec = sqlx::types::BitVec::with_capacity(4);
+        bit_vec.push(true);
+        bit_vec.push(true);
+        bit_vec.push(false);
+        bit_vec
+    },
+    // A BIT value
+    "B'01101'::bit(5)" == {
+        let mut bit_vec = sqlx::types::BitVec::with_capacity(5);
+        bit_vec.push(false);
+        bit_vec.push(true);
+        bit_vec.push(true);
+        bit_vec.push(false);
+        bit_vec.push(true);
+        bit_vec
+    },
+));
+
+#[cfg(feature = "ipnet")]
+test_type!(ipnet_vec<Vec<sqlx::types::ipnet::IpNet>>(Postgres,
+    "'{127.0.0.1,8.8.8.8/24}'::inet[]"
+        == vec![
+           "127.0.0.1/32".parse::<sqlx::types::ipnet::IpNet>().unwrap(),
+           "8.8.8.8/24".parse::<sqlx::types::ipnet::IpNet>().unwrap()
+        ]
+));
+
+#[cfg(feature = "ipnetwork")]
+test_type!(ipnetwork_vec<Vec<sqlx::types::ipnetwork::IpNetwork>>(Postgres,
+    "'{127.0.0.1,8.8.8.8/24}'::inet[]"
+        == vec![
+           "127.0.0.1".parse::<sqlx::types::ipnetwork::IpNetwork>().unwrap(),
+           "8.8.8.8/24".parse::<sqlx::types::ipnetwork::IpNetwork>().unwrap()
+        ]
+));
+
+#[cfg(feature = "mac_address")]
+test_type!(mac_address_vec<Vec<sqlx::types::mac_address::MacAddress>>(Postgres,
+    "'{01:02:03:04:05:06,FF:FF:FF:FF:FF:FF}'::macaddr[]"
+        == vec![
+           "01:02:03:04:05:06".parse::<sqlx::types::mac_address::MacAddress>().unwrap(),
+           "FF:FF:FF:FF:FF:FF".parse::<sqlx::types::mac_address::MacAddress>().unwrap()
+        ]
+));
+
+#[cfg(feature = "chrono")]
+mod chrono {
+    use super::*;
+    use sqlx::types::chrono::{
+        DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc,
+    };
+
+    type PgTimeTz = sqlx::postgres::types::PgTimeTz<NaiveTime, FixedOffset>;
+
+    test_type!(chrono_date<NaiveDate>(Postgres,
+        "DATE '2001-01-05'" == NaiveDate::from_ymd_opt(2001, 1, 5).unwrap(),
+        "DATE '2050-11-23'" == NaiveDate::from_ymd_opt(2050, 11, 23).unwrap()
+    ));
+
+    test_type!(chrono_time<NaiveTime>(Postgres,
+        "TIME '05:10:20.115100'" == NaiveTime::from_hms_micro_opt(5, 10, 20, 115100).unwrap()
+    ));
+
+    test_type!(chrono_date_time<NaiveDateTime>(Postgres,
+        "'2019-01-02 05:10:20'::timestamp" == NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_opt(5, 10, 20).unwrap()
+    ));
+
+    test_type!(chrono_date_time_vec<Vec<NaiveDateTime>>(Postgres,
+        "array['2019-01-02 05:10:20']::timestamp[]"
+            == vec![NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_opt(5, 10, 20).unwrap()]
+    ));
+
+    test_type!(chrono_date_time_tz_utc<DateTime::<Utc>>(Postgres,
+        "TIMESTAMPTZ '2019-01-02 05:10:20.115100'"
+            == Utc.from_utc_datetime(
+                &NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_micro_opt(5, 10, 20, 115100).unwrap(),
+            )
+    ));
+
+    test_type!(chrono_date_time_tz<DateTime::<FixedOffset>>(Postgres,
+        "TIMESTAMPTZ '2019-01-02 05:10:20.115100+06:30'"
+            == FixedOffset::east_opt(60 * 60 * 6 + 1800)
+                .unwrap()
+                .from_local_datetime(
+                    &NaiveDate::from_ymd_opt(2019, 1, 2)
+                        .unwrap()
+                        .and_hms_micro_opt(5, 10, 20, 115_100)
+                        .unwrap()
+                )
+                .unwrap()
+    ));
+
+    test_type!(chrono_date_time_tz_vec<Vec<DateTime::<Utc>>>(Postgres,
+        "array['2019-01-02 05:10:20.115100']::timestamptz[]"
+            == vec![
+                Utc.from_utc_datetime(
+                    &NaiveDate::from_ymd_opt(2019, 1, 2).unwrap().and_hms_micro_opt(5, 10, 20, 115100).unwrap(),
+                )
+            ]
+    ));
+
+    test_type!(chrono_time_tz<PgTimeTz>(Postgres,
+        "TIMETZ '05:10:20.115100+00'" == PgTimeTz { time: NaiveTime::from_hms_micro_opt(5, 10, 20, 115100).unwrap(), offset: FixedOffset::east_opt(0).unwrap() },
+        "TIMETZ '05:10:20.115100+06:30'" == PgTimeTz { time: NaiveTime::from_hms_micro_opt(5, 10, 20, 115100).unwrap(), offset: FixedOffset::east_opt(60 * 60 * 6 + 1800).unwrap() },
+        "TIMETZ '05:10:20.115100-05'" == PgTimeTz { time: NaiveTime::from_hms_micro_opt(5, 10, 20, 115100).unwrap(), offset: FixedOffset::west_opt(60 * 60 * 5).unwrap() },
+        "TIMETZ '05:10:20+02'" == PgTimeTz { time: NaiveTime::from_hms_opt(5, 10, 20).unwrap(), offset: FixedOffset::east_opt(60 * 60 * 2 ).unwrap() }
+    ));
+}
+
+#[cfg(feature = "time")]
+mod time_tests {
+    use super::*;
+    use sqlx::types::time::{Date, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
+    use time::macros::{date, time};
+
+    type PgTimeTz = sqlx::postgres::types::PgTimeTz<Time, UtcOffset>;
+
+    test_type!(time_date<Date>(
+        Postgres,
+        "DATE '2001-01-05'" == date!(2001 - 1 - 5),
+        "DATE '2050-11-23'" == date!(2050 - 11 - 23)
+    ));
+
+    test_type!(time_time<Time>(
+        Postgres,
+        "TIME '05:10:20.115100'" == time!(5:10:20.115100),
+        "TIME '05:10:20'" == time!(5:10:20)
+    ));
+
+    test_type!(time_date_time<PrimitiveDateTime>(
+        Postgres,
+        "TIMESTAMP '2019-01-02 05:10:20'" == date!(2019 - 1 - 2).with_time(time!(5:10:20)),
+        "TIMESTAMP '2019-01-02 05:10:20.1151'" == date!(2019 - 1 - 2).with_time(time!(5:10:20.115100))
+    ));
+
+    test_type!(time_timestamp<OffsetDateTime>(
+        Postgres,
+        "TIMESTAMPTZ '2019-01-02 05:10:20.115100'"
+            == date!(2019 - 1 - 2)
+                .with_time(time!(5:10:20.115100))
+                .assume_utc()
+    ));
+
+    test_prepared_type!(time_time_tz<PgTimeTz>(Postgres,
+        "TIMETZ '05:10:20.115100+00'" == PgTimeTz { time: time!(5:10:20.115100), offset: UtcOffset::from_whole_seconds(0).unwrap() },
+        "TIMETZ '05:10:20.115100+00'" == PgTimeTz { time: time!(5:10:20.115100), offset: UtcOffset::from_whole_seconds(0).unwrap() },
+        "TIMETZ '05:10:20.115100+06:30'" == PgTimeTz { time: time!(5:10:20.115100), offset: UtcOffset::from_whole_seconds(60 * 60 * 6 + 1800).unwrap() },
+        "TIMETZ '05:10:20.115100-05'" == PgTimeTz { time: time!(5:10:20.115100), offset: UtcOffset::from_whole_seconds(-(60 * 60 * 5)).unwrap() },
+        "TIMETZ '05:10:20+02'" == PgTimeTz { time: time!(5:10:20), offset: UtcOffset::from_whole_seconds(60 * 60 * 2 ).unwrap() }
+    ));
+}
+
+#[cfg(feature = "json")]
+mod json {
+    use super::*;
+    use serde_json::value::RawValue as JsonRawValue;
+    use serde_json::{json, Value as JsonValue};
+    use sqlx::postgres::PgRow;
+    use sqlx::types::Json;
+    use sqlx::{Executor, Row};
+    use sqlx_test::new;
+
+    // When testing JSON, coerce to JSONB for `=` comparison as `JSON = JSON` is not
+    // supported in PostgreSQL
+
+    test_type!(json<JsonValue>(
+        Postgres,
+        "SELECT ({0}::jsonb is not distinct from $1::jsonb)::int4, {0} as _2, $2 as _3",
+        "'\"Hello, World\"'::json" == json!("Hello, World"),
+        "'\"😎\"'::json" == json!("😎"),
+        "'\"🙋‍♀️\"'::json" == json!("🙋‍♀️"),
+        "'[\"Hello\", \"World!\"]'::json" == json!(["Hello", "World!"])
+    ));
+
+    test_type!(json_vec<Vec<JsonValue>>(
+        Postgres,
+        "SELECT ({0}::jsonb[] is not distinct from $1::jsonb[])::int4, {0} as _2, $2 as _3",
+        "array['\"😎\"'::json, '\"🙋‍♀️\"'::json]::json[]" == vec![json!("😎"), json!("🙋‍♀️")],
+    ));
+
+    test_type!(json_array<[JsonValue; 2]>(
+        Postgres,
+        "SELECT ({0}::jsonb[] is not distinct from $1::jsonb[])::int4, {0} as _2, $2 as _3",
+        "array['\"😎\"'::json, '\"🙋‍♀️\"'::json]::json[]" == [json!("😎"), json!("🙋‍♀️")],
+    ));
+
+    test_type!(jsonb<JsonValue>(
+        Postgres,
+        "'\"Hello, World\"'::jsonb" == json!("Hello, World"),
+        "'\"😎\"'::jsonb" == json!("😎"),
+        "'\"🙋‍♀️\"'::jsonb" == json!("🙋‍♀️"),
+        "'[\"Hello\", \"World!\"]'::jsonb" == json!(["Hello", "World!"])
+    ));
+
+    test_type!(jsonb_array<Vec<JsonValue>>(
+        Postgres,
+        "array['\"😎\"'::jsonb, '\"🙋‍♀️\"'::jsonb]::jsonb[]" == vec![json!("😎"), json!("🙋‍♀️")],
+    ));
+
+    #[derive(serde::Deserialize, serde::Serialize, Debug, PartialEq)]
+    struct Friend {
+        name: String,
+        age: u32,
+    }
+
+    test_type!(json_struct<Json<Friend>>(Postgres,
+        "'{\"name\":\"Joe\",\"age\":33}'::jsonb" == Json(Friend { name: "Joe".to_string(), age: 33 })
+    ));
+
+    test_type!(json_struct_vec<Vec<Json<Friend>>>(Postgres,
+        "array['{\"name\":\"Joe\",\"age\":33}','{\"name\":\"Bob\",\"age\":22}']::jsonb[]"
+            == vec![
+                Json(Friend { name: "Joe".to_string(), age: 33 }),
+                Json(Friend { name: "Bob".to_string(), age: 22 }),
+            ]
+    ));
+
+    #[sqlx_macros::test]
+    async fn test_json_raw_value() -> anyhow::Result<()> {
+        let mut conn = new::<Postgres>().await?;
+
+        // unprepared, text API
+        let row: PgRow = conn
+            .fetch_one("SELECT '{\"hello\": \"world\"}'::jsonb")
+            .await?;
+
+        let value: &JsonRawValue = row.try_get(0)?;
+        assert_eq!(value.get(), "{\"hello\": \"world\"}");
+
+        let value: Box<JsonRawValue> = row.try_get(0)?;
+        assert_eq!(value.get(), "{\"hello\": \"world\"}");
+
+        // prepared, binary API
+        let row: PgRow = conn
+            .fetch_one(sqlx::query("SELECT '{\"hello\": \"world\"}'::jsonb"))
+            .await?;
+
+        let value: &JsonRawValue = row.try_get(0)?;
+        assert_eq!(value.get(), "{\"hello\": \"world\"}");
+
+        let value: Box<JsonRawValue> = row.try_get(0)?;
+        assert_eq!(value.get(), "{\"hello\": \"world\"}");
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "bigdecimal")]
+test_type!(bigdecimal<sqlx::types::BigDecimal>(Postgres,
+
+    // https://github.com/launchbadge/sqlx/issues/283
+    "0::numeric" == "0".parse::<sqlx::types::BigDecimal>().unwrap(),
+
+    "1::numeric" == "1".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "10000::numeric" == "10000".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.1::numeric" == "0.1".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.01::numeric" == "0.01".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.012::numeric" == "0.012".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.0123::numeric" == "0.0123".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.01234::numeric" == "0.01234".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.012345::numeric" == "0.012345".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.0123456::numeric" == "0.0123456".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.01234567::numeric" == "0.01234567".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.012345678::numeric" == "0.012345678".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.0123456789::numeric" == "0.0123456789".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.002::numeric" == "0.002".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.0002::numeric" == "0.0002".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.00002::numeric" == "0.00002".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.000002::numeric" == "0.000002".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.0000002::numeric" == "0.0000002".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "0.00000002::numeric" == "0.00000002".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "12.34::numeric" == "12.34".parse::<sqlx::types::BigDecimal>().unwrap(),
+    "12345.6789::numeric" == "12345.6789".parse::<sqlx::types::BigDecimal>().unwrap(),
+));
+
+#[cfg(feature = "bigdecimal")]
+test_type!(numrange_bigdecimal<PgRange<sqlx::types::BigDecimal>>(Postgres,
+    "'(1.3,2.4)'::numrange" == PgRange::from(
+        (Bound::Excluded("1.3".parse::<sqlx::types::BigDecimal>().unwrap()),
+         Bound::Excluded("2.4".parse::<sqlx::types::BigDecimal>().unwrap())))
+));
+
+#[cfg(not(postgres = "13"))]
+test_type!(cube<sqlx::postgres::types::PgCube>(Postgres,
+    "cube(2)" == sqlx::postgres::types::PgCube::Point(2.),
+    "cube(2.1)" == sqlx::postgres::types::PgCube::Point(2.1),
+    "cube(2,3)" == sqlx::postgres::types::PgCube::OneDimensionInterval(2., 3.),
+    "cube(2.2,-3.4)" == sqlx::postgres::types::PgCube::OneDimensionInterval(2.2, -3.4),
+    "cube(array[2,3])" == sqlx::postgres::types::PgCube::ZeroVolume(vec![2., 3.]),
+    "cube(array[2,3],array[4,5])" == sqlx::postgres::types::PgCube::MultiDimension(vec![vec![2.,3.],vec![4.,5.]]),
+    "cube(array[2,3,4],array[4,5,6])" == sqlx::postgres::types::PgCube::MultiDimension(vec![vec![2.,3.,4.],vec![4.,5.,6.]]),
+));
+
+#[cfg(not(postgres = "13"))]
+test_type!(_cube<Vec<sqlx::postgres::types::PgCube>>(Postgres,
+    "array[cube(2),cube(2)]" == vec![sqlx::postgres::types::PgCube::Point(2.), sqlx::postgres::types::PgCube::Point(2.)],
+    "array[cube(2.2,-3.4)]" == vec![sqlx::postgres::types::PgCube::OneDimensionInterval(2.2, -3.4)],
+));
+
+test_type!(point<sqlx::postgres::types::PgPoint>(Postgres,
+    "point(2.2,-3.4)" ~= sqlx::postgres::types::PgPoint { x: 2.2, y:-3.4 },
+));
+
+test_type!(_point<Vec<sqlx::postgres::types::PgPoint>>(Postgres,
+    "array[point(2,3),point(2.1,3.4)]" @= vec![sqlx::postgres::types::PgPoint { x:2., y: 3. }, sqlx::postgres::types::PgPoint { x:2.1, y: 3.4 }],
+    "array[point(2.2,-3.4)]" @= vec![sqlx::postgres::types::PgPoint { x: 2.2, y: -3.4 }],
+));
+
+test_type!(line<sqlx::postgres::types::PgLine>(Postgres,
+    "line('{1.1, -2.2, 3.3}')" == sqlx::postgres::types::PgLine { a: 1.1, b:-2.2, c: 3.3 },
+    "line('((0.0, 0.0), (1.0,1.0))')" == sqlx::postgres::types::PgLine { a: 1., b: -1., c: 0. },
+));
+
+test_type!(lseg<sqlx::postgres::types::PgLSeg>(Postgres,
+    "lseg('((1.0, 2.0), (3.0,4.0))')" == sqlx::postgres::types::PgLSeg { start_x: 1., start_y: 2., end_x: 3. , end_y: 4.},
+));
+
+test_type!(box<sqlx::postgres::types::PgBox>(Postgres,
+    "box('((1.0, 2.0), (3.0,4.0))')" == sqlx::postgres::types::PgBox { upper_right_x: 3., upper_right_y: 4., lower_left_x: 1. , lower_left_y: 2.},
+));
+
+test_type!(_box<Vec<sqlx::postgres::types::PgBox>>(Postgres,
+    "array[box('1,2,3,4'),box('((1.1, 2.2), (3.3, 4.4))')]" @= vec![sqlx::postgres::types::PgBox { upper_right_x: 3., upper_right_y: 4., lower_left_x: 1., lower_left_y: 2. }, sqlx::postgres::types::PgBox { upper_right_x: 3.3, upper_right_y: 4.4, lower_left_x: 1.1, lower_left_y: 2.2 }],
+));
+
+test_type!(path<sqlx::postgres::types::PgPath>(Postgres,
+    "path('((1.0, 2.0), (3.0,4.0))')" == sqlx::postgres::types::PgPath { closed: true, points: vec![ sqlx::postgres::types::PgPoint { x: 1., y: 2. }, sqlx::postgres::types::PgPoint { x: 3. , y: 4. } ]},
+    "path('[(1.0, 2.0), (3.0,4.0)]')" == sqlx::postgres::types::PgPath { closed: false, points: vec![ sqlx::postgres::types::PgPoint { x: 1., y: 2. }, sqlx::postgres::types::PgPoint { x: 3. , y: 4. } ]},
+));
+
+test_type!(polygon<sqlx::postgres::types::PgPolygon>(Postgres,
+    "polygon('((-2,-3),(-1,-3),(-1,-1),(1,1),(1,3),(2,3),(2,-3),(1,-3),(1,0),(-1,0),(-1,-2),(-2,-2))')" ~= sqlx::postgres::types::PgPolygon {  points: vec![
+            sqlx::postgres::types::PgPoint { x: -2., y: -3. }, sqlx::postgres::types::PgPoint { x: -1., y: -3. }, sqlx::postgres::types::PgPoint { x: -1., y: -1. }, sqlx::postgres::types::PgPoint { x: 1., y: 1. },
+            sqlx::postgres::types::PgPoint { x: 1., y: 3. },   sqlx::postgres::types::PgPoint { x: 2., y: 3. },   sqlx::postgres::types::PgPoint { x: 2., y: -3. },  sqlx::postgres::types::PgPoint { x: 1., y: -3. },
+            sqlx::postgres::types::PgPoint { x: 1., y: 0. },   sqlx::postgres::types::PgPoint { x: -1., y: 0. },  sqlx::postgres::types::PgPoint { x: -1., y: -2. }, sqlx::postgres::types::PgPoint { x: -2., y: -2. },
+    ]},
+));
+
+test_type!(circle<sqlx::postgres::types::PgCircle>(Postgres,
+    "circle('<(1.1, -2.2), 3.3>')" ~= sqlx::postgres::types::PgCircle { x: 1.1, y:-2.2, radius: 3.3 },
+    "circle('((1.1, -2.2), 3.3)')" ~= sqlx::postgres::types::PgCircle { x: 1.1, y:-2.2, radius: 3.3 },
+    "circle('(1.1, -2.2), 3.3')" ~= sqlx::postgres::types::PgCircle { x: 1.1, y:-2.2, radius: 3.3 },
+    "circle('1.1, -2.2, 3.3')" ~= sqlx::postgres::types::PgCircle { x: 1.1, y:-2.2, radius: 3.3 },
+));
+
+#[cfg(feature = "rust_decimal")]
+test_type!(decimal<sqlx::types::Decimal>(Postgres,
+    "0::numeric" == sqlx::types::Decimal::from_str("0").unwrap(),
+    "1::numeric" == sqlx::types::Decimal::from_str("1").unwrap(),
+    "10000::numeric" == sqlx::types::Decimal::from_str("10000").unwrap(),
+    "0.1::numeric" == sqlx::types::Decimal::from_str("0.1").unwrap(),
+    "0.01234::numeric" == sqlx::types::Decimal::from_str("0.01234").unwrap(),
+    "12.34::numeric" == sqlx::types::Decimal::from_str("12.34").unwrap(),
+    "12345.6789::numeric" == sqlx::types::Decimal::from_str("12345.6789").unwrap(),
+    // https://github.com/launchbadge/sqlx/issues/666#issuecomment-683872154
+    "17.905625985174584660842500258::numeric" == sqlx::types::Decimal::from_str("17.905625985174584660842500258").unwrap(),
+    "-17.905625985174584660842500258::numeric" == sqlx::types::Decimal::from_str("-17.905625985174584660842500258").unwrap(),
+));
+
+#[cfg(feature = "rust_decimal")]
+test_type!(numrange_decimal<PgRange<sqlx::types::Decimal>>(Postgres,
+    "'(1.3,2.4)'::numrange" == PgRange::from(
+        (Bound::Excluded(sqlx::types::Decimal::from_str("1.3").unwrap()),
+         Bound::Excluded(sqlx::types::Decimal::from_str("2.4").unwrap()))),
+));
+
+const EXC2: Bound<i32> = Bound::Excluded(2);
+const EXC3: Bound<i32> = Bound::Excluded(3);
+const INC1: Bound<i32> = Bound::Included(1);
+const INC2: Bound<i32> = Bound::Included(2);
+const UNB: Bound<i32> = Bound::Unbounded;
+
+test_type!(int4range<PgRange<i32>>(Postgres,
+    "'(,)'::int4range" == PgRange::from((UNB, UNB)),
+    "'(,]'::int4range" == PgRange::from((UNB, UNB)),
+    "'(,2)'::int4range" == PgRange::from((UNB, EXC2)),
+    "'(,2]'::int4range" == PgRange::from((UNB, EXC3)),
+    "'(1,)'::int4range" == PgRange::from((INC2, UNB)),
+    "'(1,]'::int4range" == PgRange::from((INC2, UNB)),
+    "'(1,2]'::int4range" == PgRange::from((INC2, EXC3)),
+    "'[,)'::int4range" == PgRange::from((UNB, UNB)),
+    "'[,]'::int4range" == PgRange::from((UNB, UNB)),
+    "'[,2)'::int4range" == PgRange::from((UNB, EXC2)),
+    "'[,2]'::int4range" == PgRange::from((UNB, EXC3)),
+    "'[1,)'::int4range" == PgRange::from((INC1, UNB)),
+    "'[1,]'::int4range" == PgRange::from((INC1, UNB)),
+    "'[1,2)'::int4range" == PgRange::from((INC1, EXC2)),
+    "'[1,2]'::int4range" == PgRange::from((INC1, EXC3)),
+));
+
+test_prepared_type!(interval<PgInterval>(
+    Postgres,
+    "INTERVAL '1h'"
+        == PgInterval {
+            months: 0,
+            days: 0,
+            microseconds: 3_600_000_000
+        },
+    "INTERVAL '-1 hours'"
+        == PgInterval {
+            months: 0,
+            days: 0,
+            microseconds: -3_600_000_000
+        },
+    "INTERVAL '3 months 12 days 1h 15 minutes 10 second '"
+        == PgInterval {
+            months: 3,
+            days: 12,
+            microseconds: (3_600 + 15 * 60 + 10) * 1_000_000
+        },
+    "INTERVAL '03:10:20.116100'"
+        == PgInterval {
+            months: 0,
+            days: 0,
+            microseconds: (3 * 3_600 + 10 * 60 + 20) * 1_000_000 + 116100
+        },
+));
+
+test_prepared_type!(money<PgMoney>(Postgres, "123.45::money" == PgMoney(12345)));
+
+test_prepared_type!(money_vec<Vec<PgMoney>>(Postgres,
+    "array[123.45,420.00,666.66]::money[]" == vec![PgMoney(12345), PgMoney(42000), PgMoney(66666)],
+));
+
+test_prepared_type!(citext_array<Vec<PgCiText>>(Postgres,
+    "array['one','two','three']::citext[]" == vec![
+        PgCiText("one".to_string()),
+        PgCiText("two".to_string()),
+        PgCiText("three".to_string()),
+    ],
+));
+
+test_type!(ltree<sqlx::postgres::types::PgLTree>(Postgres,
+    "'Foo.Bar.Baz.Quux'::ltree" == sqlx::postgres::types::PgLTree::from_str("Foo.Bar.Baz.Quux").unwrap(),
+    "'Alpha.Beta.Delta.Gamma'::ltree" == sqlx::postgres::types::PgLTree::try_from_iter(["Alpha", "Beta", "Delta", "Gamma"]).unwrap(),
+));
+
+test_type!(ltree_vec<Vec<sqlx::postgres::types::PgLTree>>(Postgres,
+    "array['Foo.Bar.Baz.Quux', 'Alpha.Beta.Delta.Gamma']::ltree[]" ==
+        vec![
+            sqlx::postgres::types::PgLTree::from_str("Foo.Bar.Baz.Quux").unwrap(),
+            sqlx::postgres::types::PgLTree::try_from_iter(["Alpha", "Beta", "Delta", "Gamma"]).unwrap()
+        ]
+));
+
+#[derive(sqlx::Type, Debug, PartialEq)]
+#[sqlx(type_name = "positive_int")]
+struct PositiveInt(i32);
+
+#[derive(sqlx::Type, Debug, PartialEq)]
+#[sqlx(type_name = "percentage")]
+struct Percentage(PositiveInt);
+
+#[derive(sqlx::Type, Debug, PartialEq)]
+struct Person {
+    id: i32,
+    age: PositiveInt,
+    percent: Percentage,
+}
+
+test_type!(nested_domain_types_1<Person>(Postgres,
+    "ROW(1, 21::positive_int, 50::percentage)::person" == Person { id: 1, age: PositiveInt(21), percent: Percentage(PositiveInt(50)) })
+);
+
+test_type!(domain_type_array_1<Vec<PositiveInt>>(Postgres,
+    "ARRAY[1, 50, 1000]::positive_int[]" == vec![
+        PositiveInt(1),
+        PositiveInt(50),
+        PositiveInt(1000),
+    ],
+));
+
+test_type!(domain_type_array_2<Vec<Percentage>>(Postgres,
+    "ARRAY[4, 66, 100]::percentage[]" == vec![
+        Percentage(PositiveInt(4)),
+        Percentage(PositiveInt(66)),
+        Percentage(PositiveInt(100))
+    ],
+));
+
+#[derive(sqlx::Type, Debug, PartialEq)]
+#[sqlx(type_name = "leaf_composite")]
+struct LeafComposite {
+    prim: i32,
+}
+
+#[derive(sqlx::Type, Debug, PartialEq)]
+#[sqlx(type_name = "domain")]
+struct Domain(LeafComposite);
+
+#[derive(sqlx::Type, Debug, PartialEq)]
+#[sqlx(type_name = "root_composite")]
+struct RootComposite {
+    domain: Domain,
+}
+
+test_type!(nested_domain_types_2<RootComposite>(Postgres,
+    "ROW(ROW(1))::root_composite" == RootComposite { domain: Domain(LeafComposite { prim: 1 }) })
+);
+
+test_type!(domain_type_array_3<Vec<Domain>>(Postgres,
+    "ARRAY[ROW(50), ROW(1), ROW(1000)]::domain[]" == vec![
+        Domain(LeafComposite { prim: 50 }),
+        Domain(LeafComposite { prim: 1 }),
+        Domain(LeafComposite { prim: 1000 }),
+    ]
+));
+
+test_type!(test_arc<Arc<i32>>(Postgres, "1::INT4" == Arc::new(1i32)));
+test_type!(test_cow<Cow<'_, i32>>(Postgres, "1::INT4" == Cow::<i32>::Owned(1i32)));
+test_type!(test_box<Box<i32>>(Postgres, "1::INT4" == Box::new(1i32)));
+test_type!(test_rc<Rc<i32>>(Postgres, "1::INT4" == Rc::new(1i32)));
+
+test_type!(test_box_str<Box<str>>(Postgres, "'John'::TEXT" == Box::<str>::from("John")));
+test_type!(test_cow_str<Cow<'_, str>>(Postgres, "'Phil'::TEXT" == Cow::<'static, str>::from("Phil")));
+test_type!(test_arc_str<Arc<str>>(Postgres, "'1234'::TEXT" == Arc::<str>::from("1234")));
+test_type!(test_rc_str<Rc<str>>(Postgres, "'5678'::TEXT" == Rc::<str>::from("5678")));
+
+test_prepared_type!(test_box_slice<Box<[u8]>>(Postgres, "'\\x01020304'::BYTEA" == Box::<[u8]>::from([1,2,3,4])));
+test_prepared_type!(test_cow_slice<Cow<'_, [u8]>>(Postgres, "'\\x01020304'::BYTEA" == Cow::<'static, [u8]>::from(&[1,2,3,4])));
+test_prepared_type!(test_arc_slice<Arc<[u8]>>(Postgres, "'\\x01020304'::BYTEA" == Arc::<[u8]>::from([1,2,3,4])));
+test_prepared_type!(test_rc_slice<Rc<[u8]>>(Postgres, "'\\x01020304'::BYTEA" == Rc::<[u8]>::from([1,2,3,4])));
+
+#[sqlx_macros::test]
+async fn test_text_adapter() -> anyhow::Result<()> {
+    #[derive(sqlx::FromRow, Debug, PartialEq, Eq)]
+    struct Login {
+        user_id: i32,
+        socket_addr: Text<SocketAddr>,
+        #[cfg(feature = "time")]
+        login_at: time::OffsetDateTime,
+    }
+
+    let mut conn = new::<Postgres>().await?;
+
+    conn.execute(
+        r#"
+CREATE TEMPORARY TABLE user_login (
+    user_id INT PRIMARY KEY,
+    socket_addr TEXT NOT NULL,
+    login_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+    "#,
+    )
+    .await?;
+
+    let user_id = 1234;
+    let socket_addr: SocketAddr = "198.51.100.47:31790".parse().unwrap();
+
+    sqlx::query("INSERT INTO user_login (user_id, socket_addr) VALUES ($1, $2)")
+        .bind(user_id)
+        .bind(Text(socket_addr))
+        .execute(&mut conn)
+        .await?;
+
+    let last_login: Login =
+        sqlx::query_as("SELECT * FROM user_login ORDER BY login_at DESC LIMIT 1")
+            .fetch_one(&mut conn)
+            .await?;
+
+    assert_eq!(last_login.user_id, user_id);
+    assert_eq!(*last_login.socket_addr, socket_addr);
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/sqlite/any.rs

@@ -0,0 +1,35 @@
+use sqlx::Any;
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_encodes_bool_with_any() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+    let mut conn = new::<Any>().await?;
+
+    let res = sqlx::query("INSERT INTO accounts (name, is_active) VALUES (?, ?)")
+        .bind("Harrison Ford")
+        .bind(true)
+        .execute(&mut conn)
+        .await
+        .expect("failed to encode bool");
+    assert_eq!(res.rows_affected(), 1);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn issue_3179() -> anyhow::Result<()> {
+    sqlx::any::install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    // 4294967297 = 2^32
+    let number: i64 = sqlx::query_scalar("SELECT 4294967296")
+        .fetch_one(&mut conn)
+        .await?;
+
+    // Previously, the decoding would use `i32` as an intermediate which would overflow to 0.
+    assert_eq!(number, 4294967296);
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/sqlite/derives.rs

@@ -0,0 +1,34 @@
+use sqlx::Sqlite;
+use sqlx_test::test_type;
+
+#[derive(Debug, PartialEq, sqlx::Type)]
+#[repr(u32)]
+enum Origin {
+    Foo = 1,
+    Bar = 2,
+}
+
+test_type!(origin_enum<Origin>(Sqlite,
+    "1" == Origin::Foo,
+    "2" == Origin::Bar,
+));
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct TransparentTuple(i64);
+
+#[derive(PartialEq, Eq, Debug, sqlx::Type)]
+#[sqlx(transparent)]
+struct TransparentNamed {
+    field: i64,
+}
+
+test_type!(transparent_tuple<TransparentTuple>(Sqlite,
+    "0" == TransparentTuple(0),
+    "23523" == TransparentTuple(23523)
+));
+
+test_type!(transparent_named<TransparentNamed>(Sqlite,
+    "0" == TransparentNamed { field: 0 },
+    "23523" == TransparentNamed { field: 23523 },
+));

notes-service/vendor/sqlx/tests/sqlite/error.rs

@@ -0,0 +1,98 @@
+use sqlx::{error::ErrorKind, sqlite::Sqlite, Connection, Error};
+use sqlx_test::new;
+
+#[sqlx_macros::test]
+async fn it_fails_with_unique_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("INSERT INTO tweet VALUES (1, 'Foo', true, 1);")
+        .execute(&mut *tx)
+        .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::UniqueViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_foreign_key_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO tweet_reply (id, tweet_id, text) VALUES (2, 2, 'Reply!');")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::ForeignKeyViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_not_null_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> = sqlx::query("INSERT INTO tweet (text) VALUES (null);")
+        .execute(&mut *tx)
+        .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::NotNullViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_check_violation() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+    let mut tx = conn.begin().await?;
+
+    let res: Result<_, sqlx::Error> =
+        sqlx::query("INSERT INTO products VALUES (1, 'Product 1', 0);")
+            .execute(&mut *tx)
+            .await;
+    let err = res.unwrap_err();
+
+    let err = err.into_database_error().unwrap();
+
+    assert_eq!(err.kind(), ErrorKind::CheckViolation);
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_begin_failed() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+    let res = conn.begin_with("SELECT * FROM tweet").await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::BeginFailed), "{err:?}");
+
+    Ok(())
+}
+
+#[sqlx_macros::test]
+async fn it_fails_with_invalid_save_point_statement() -> anyhow::Result<()> {
+    let mut conn = new::<Sqlite>().await?;
+    let mut txn = conn.begin().await?;
+    let txn_conn = sqlx::Acquire::acquire(&mut txn).await?;
+    let res = txn_conn.begin_with("BEGIN").await;
+
+    let err = res.unwrap_err();
+
+    assert!(matches!(err, Error::InvalidSavePointStatement), "{err}");
+
+    Ok(())
+}

notes-service/vendor/sqlx/tests/sqlite/fixtures/comments.sql

@@ -0,0 +1,16 @@
+insert into comment(comment_id, post_id, user_id, content, created_at)
+values (1,
+        1,
+        2,
+        'lol bet ur still bad, 1v1 me',
+        datetime('now', '-50 minutes')),
+       (2,
+        1,
+        1,
+        'you''re on!',
+        datetime('now', '-45 minutes')),
+       (3,
+        2,
+        1,
+        'lol you''re just mad you lost :P',
+        datetime('now', '-15 minutes'));