cargo fmt

Author: sivukhin

libsql/tests/integration_tests.rs

@@ -1,14 +1,14 @@
 #![allow(deprecated)]
 
-use rand::prelude::*;
-use rand::distributions::Uniform;
-use std::collections::HashSet;
 use futures::{StreamExt, TryStreamExt};
 use libsql::{
     named_params, params,
     params::{IntoParams, IntoValue},
     Connection, Database, Value,
 };
+use rand::distributions::Uniform;
+use rand::prelude::*;
+use std::collections::HashSet;
 
 async fn setup() -> Connection {
     let db = Database::open(":memory:").unwrap();
@@ -663,43 +663,85 @@ async fn vector_fuzz_test() {
     for attempt in 0..10000 {
         let seed = global_rng.next_u64();
 
-        let mut rng = rand::rngs::StdRng::from_seed(unsafe { std::mem::transmute([seed, seed, seed, seed]) });
+        let mut rng =
+            rand::rngs::StdRng::from_seed(unsafe { std::mem::transmute([seed, seed, seed, seed]) });
         let db = Database::open(":memory:").unwrap();
         let conn = db.connect().unwrap();
         let dim = rng.gen_range(1..=1536);
         let operations = rng.gen_range(1..128);
-        println!("============== ATTEMPT {} (seed {}u64, dim {}, operations {}) ================", attempt, seed, dim, operations);
-
-        let _ = conn.execute(&format!("CREATE TABLE users (id INTEGER PRIMARY KEY, v FLOAT32({}) )", dim), ()).await;
+        println!(
+            "============== ATTEMPT {} (seed {}u64, dim {}, operations {}) ================",
+            attempt, seed, dim, operations
+        );
+
+        let _ = conn
+            .execute(
+                &format!(
+                    "CREATE TABLE users (id INTEGER PRIMARY KEY, v FLOAT32({}) )",
+                    dim
+                ),
+                (),
+            )
+            .await;
         // println!("CREATE TABLE users (id INTEGER PRIMARY KEY, v FLOAT32({}) );", dim);
-        let _ = conn.execute("CREATE INDEX users_idx ON users ( libsql_vector_idx(v) );", ()).await;
+        let _ = conn
+            .execute(
+                "CREATE INDEX users_idx ON users ( libsql_vector_idx(v) );",
+                (),
+            )
+            .await;
         // println!("CREATE INDEX users_idx ON users ( libsql_vector_idx(v) );");
 
         let mut next_id = 1;
         let mut alive = HashSet::new();
         let uniform = Uniform::new(-1.0, 1.0);
         for _ in 0..operations {
             let operation = rng.gen_range(0..4);
-            let vector : Vec<f32> = (0..dim).map(|_| rng.sample(uniform)).collect();
-            let vector_str = format!("[{}]", vector.iter().map(|x| format!("{}", x)).collect::<Vec<String>>().join(","));
+            let vector: Vec<f32> = (0..dim).map(|_| rng.sample(uniform)).collect();
+            let vector_str = format!(
+                "[{}]",
+                vector
+                    .iter()
+                    .map(|x| format!("{}", x))
+                    .collect::<Vec<String>>()
+                    .join(",")
+            );
             if operation == 0 {
                 // println!("INSERT INTO users VALUES ({}, vector('{}') );", next_id, vector_str);
-                conn.execute("INSERT INTO users VALUES (?, vector(?) )", libsql::params![next_id, vector_str]).await.unwrap();
+                conn.execute(
+                    "INSERT INTO users VALUES (?, vector(?) )",
+                    libsql::params![next_id, vector_str],
+                )
+                .await
+                .unwrap();
                 alive.insert(next_id);
                 next_id += 1;
             } else if operation == 1 {
                 let id = rng.gen_range(0..next_id);
                 // println!("DELETE FROM users WHERE id = {};", id);
-                conn.execute("DELETE FROM users WHERE id = ?", libsql::params![id]).await.unwrap();
+                conn.execute("DELETE FROM users WHERE id = ?", libsql::params![id])
+                    .await
+                    .unwrap();
                 alive.remove(&id);
             } else if operation == 2 && !alive.is_empty() {
                 let id = alive.iter().collect::<Vec<_>>()[rng.gen_range(0..alive.len())];
                 // println!("UPDATE users SET v = vector('{}') WHERE id = {};", vector_str, id);
-                conn.execute("UPDATE users SET v = vector(?) WHERE id = ?", libsql::params![vector_str, id]).await.unwrap();
+                conn.execute(
+                    "UPDATE users SET v = vector(?) WHERE id = ?",
+                    libsql::params![vector_str, id],
+                )
+                .await
+                .unwrap();
             } else if operation == 3 {
                 let k = rng.gen_range(1..200);
                 // println!("SELECT * FROM vector_top_k('users_idx', '{}', {});", vector_str, k);
-                let result = conn.query("SELECT * FROM vector_top_k('users_idx', ?, ?)", libsql::params![vector_str, k]).await.unwrap();
+                let result = conn
+                    .query(
+                        "SELECT * FROM vector_top_k('users_idx', ?, ?)",
+                        libsql::params![vector_str, k],
+                    )
+                    .await
+                    .unwrap();
                 let count = result.into_stream().count().await;
                 assert!(count <= alive.len());
                 if alive.len() > 0 {