Function vector_extension_server_sqlx_smoke

tests/extensions_smoke.rs:600–664

()

#[tokio::test(flavor = "multi_thread")]
async fn vector_extension_server_sqlx_smoke() -> Result<()> {
    let _trace = TestTrace::new("vector_extension_server_sqlx_smoke");
    let server = PgliteServer::builder()
        .temporary()
        .extension(extensions::VECTOR)
        .start()?;
    let mut conn = sqlx::PgConnection::connect(&server.connection_uri()).await?;

    sqlx::query("CREATE TABLE oxide_vec_server (embedding vector(3))")
        .execute(&mut conn)
        .await?;
    sqlx::query("INSERT INTO oxide_vec_server VALUES ('[1,2,3]')")
        .execute(&mut conn)
        .await?;
    let row =
        sqlx::query("SELECT embedding <-> '[1,2,4]'::vector AS distance FROM oxide_vec_server")
            .fetch_one(&mut conn)
            .await?;

    assert_eq!(row.try_get::<f64, _>("distance")?, 1.0);

    trace_expected("vector_server_sqlx division-by-zero");
    let err = sqlx::query("SELECT 10 / $1::int4 AS impossible_after_vector")
        .bind(0_i32)
        .fetch_one(&mut conn)
        .await
        .expect_err("division by zero after vector load should fail");
    assert_sqlx_code(&err, "22012");
    let row = sqlx::query("SELECT 14::int4 AS recovered_after_vector_error")
        .fetch_one(&mut conn)
        .await?;
    assert_eq!(row.try_get::<i32, _>("recovered_after_vector_error")?, 14);

    trace_expected("vector_server_sqlx invalid-vector-literal");
    let err = sqlx::query("SELECT $1::text::vector AS embedding")
        .bind("[hello,1]")
        .fetch_one(&mut conn)
        .await
        .expect_err("invalid vector input through SQLx should fail in the vector extension");
    assert_sqlx_code(&err, "22P02");
    let row = sqlx::query("SELECT 18::int4 AS recovered_after_invalid_vector")
        .fetch_one(&mut conn)
        .await?;
    assert_eq!(row.try_get::<i32, _>("recovered_after_invalid_vector")?, 18);

    trace_expected("vector_server_sqlx dimension-mismatch");
    let err = sqlx::query("SELECT $1::text::vector <-> $2::text::vector AS distance")
        .bind("[1,2]")
        .bind("[3]")
        .fetch_one(&mut conn)
        .await
        .expect_err("vector distance should reject mismatched dimensions through SQLx");
    assert_sqlx_code(&err, "22000");
    let row = sqlx::query("SELECT 19::int4 AS recovered_after_dimension_mismatch")
        .fetch_one(&mut conn)
        .await?;
    assert_eq!(
        row.try_get::<i32, _>("recovered_after_dimension_mismatch")?,