Vendor dependencies

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(())
+}