Update crud-bench benchmarks

.github/workflows/crud-bench.yml

@@ -52,12 +52,12 @@ jobs:
       - name: Bench Redis
         run: cargo run -- -d redis -s 10000 -t 3
 
-      - name: Bench SurrealDB/Memory
+      - name: Bench SurrealDB+Memory
         run: cargo run -- -d surrealdb-memory -s 10000 -t 3
 
-      - name: Bench SurrealDB/RocksDB
+      - name: Bench SurrealDB+RocksDB
         run: cargo run -- -d surrealdb-rocksdb -s 10000 -t 3
 
-      - name: Bench SurrealDB/KV
-        run: cargo run -- -d surrealdb-kv -s 10000 -t 3
+      - name: Bench SurrealDB+SurrealKV
+        run: cargo run -- -d surrealdb-surrealkv -s 10000 -t 3
 

crud-bench/Cargo.toml

@@ -1,21 +1,21 @@
 [package]
 name = "crud-bench"
 edition = "2021"
-version = "0.0.1"
+version = "0.1.0"
 license = "Apache-2.0"
 readme = "README.md"
 
 [dependencies]
-anyhow = "1.0.80"
-clap = { version = "4.5.1", features = ["derive"] }
-env_logger = "0.11.2"
-log = "0.4.21"
-mongodb = "2.8.1"
+anyhow = "1.0.88"
+clap = { version = "4.5.17", features = ["derive"] }
+env_logger = "0.11.5"
+log = "0.4.22"
+mongodb = "2.8.2"
 rand = { version = "0.8.5", features = ["small_rng"] }
-rayon = "1.9.0"
+rayon = "1.10.0"
 redis = { version = "0.24.0", features = ["tokio-comp"] }
-serde = { version = "1.0.197", features = ["derive"] }
-surrealdb = "1.2.0"
-tokio = { version = "1.36.0", features = ["macros", "rt-multi-thread"] }
-tokio-postgres = "0.7.10"
-serde_json = "1.0.114"
+serde = { version = "1.0.210", features = ["derive"] }
+surrealdb = { version = "2.0.2", package = "surrealdb-beta" }
+tokio = { version = "1.40.0", features = ["macros", "rt-multi-thread"] }
+tokio-postgres = "0.7.11"
+serde_json = "1.0.128"

crud-bench/README.md

@@ -36,7 +36,7 @@ Usage: crud-bench [OPTIONS] --database <DATABASE> --samples <SAMPLES> --threads
 
 Options:
   -i, --image <IMAGE>        Docker image
-  -d, --database <DATABASE>  Database [possible values: dry, surrealdb, surrealdb-memory, surrealdb-rocksdb, surrealdb-speedb, mongodb, postgresql]
+  -d, --database <DATABASE>  Database [possible values: dry, surrealdb-memory, surrealdb-rocksdb, surrealdb-surrealkv, mongodb, postgresql]
   -s, --samples <SAMPLES>    Number of samples
   -t, --threads <THREADS>    Number of concurrent threads
   -h, --help                 Print help
@@ -74,38 +74,38 @@ Run the benchmark against Redis:
 cargo run -r -- -d redis -s 100000 -t 3
 ```
 
-## SurrealDB/Memory benchmark
+## SurrealDB+Memory benchmark
 
 Run the benchmark against SurrealDB in memory:
 
 ```bash
 cargo run -r -- -d surrealdb-memory -s 100000 -t 3
 ```
 
-## SurrealDB/RocksDB benchmark
+## SurrealDB+RocksDB benchmark
 
 Run the benchmark against SurreadDB with RocksDB:
 
 ```bash
 cargo run -r -- -d surrealdb-rocksdb -s 100000 -t 3
 ```
 
-## SurrealDB/SurrealKV benchmark
+## SurrealDB+SurrealKV benchmark
 
 Run the benchmark against SurreadDB with SurrealKV:
 
 ```bash
-cargo run -r -- -d surrealdb-kv -s 100000 -t 3
+cargo run -r -- -d surrealdb-surrealkv -s 100000 -t 3
 ```
 
 ## SurrealDB local benchmark
 
 Run the benchmark against an already running SurrealDB instance:
 
-Eg.: Start a Speedb based Surreal instance:
+Eg.: Start a SurrealKV based SurrealDB instance:
 
 ```bash
-cargo run --features=storage-speedb -r -- start --auth --user root --pass root speedb:/tmp/sur-bench.db
+cargo run --features=storage-surrealkv -r -- start --auth --user root --pass root surrealkv:/tmp/sur-bench.db
 ```
 
 Then run the bench:

crud-bench/src/main.rs

@@ -8,8 +8,8 @@ use crate::mongodb::{MongoDBClientProvider, MONGODB_DOCKER_PARAMS};
 use crate::postgres::{PostgresClientProvider, POSTGRES_DOCKER_PARAMS};
 use crate::redis::{RedisClientProvider, REDIS_DOCKER_PARAMS};
 use crate::surrealdb::{
-	SurrealDBClientProvider, SURREAL_KV_DOCKER_PARAMS, SURREAL_MEMORY_DOCKER_PARAMS,
-	SURREAL_ROCKSDB_DOCKER_PARAMS, SURREAL_SPEEDB_DOCKER_PARAMS,
+	SurrealDBClientProvider, SURREALDB_MEMORY_DOCKER_PARAMS, SURREALDB_ROCKSDB_DOCKER_PARAMS,
+	SURREALDB_SURREALKV_DOCKER_PARAMS,
 };
 
 mod benchmark;
@@ -45,8 +45,7 @@ pub(crate) enum Database {
 	Surrealdb,
 	SurrealdbMemory,
 	SurrealdbRocksdb,
-	SurrealdbSpeedb,
-	SurrealdbKv,
+	SurrealdbSurrealkv,
 	Mongodb,
 	Postgresql,
 	Redis,
@@ -57,10 +56,9 @@ impl Database {
 		let params = match self {
 			Database::Dry => return None,
 			Database::Surrealdb => return None,
-			Database::SurrealdbMemory => SURREAL_MEMORY_DOCKER_PARAMS,
-			Database::SurrealdbRocksdb => SURREAL_ROCKSDB_DOCKER_PARAMS,
-			Database::SurrealdbSpeedb => SURREAL_SPEEDB_DOCKER_PARAMS,
-			Database::SurrealdbKv => SURREAL_KV_DOCKER_PARAMS,
+			Database::SurrealdbMemory => SURREALDB_MEMORY_DOCKER_PARAMS,
+			Database::SurrealdbRocksdb => SURREALDB_ROCKSDB_DOCKER_PARAMS,
+			Database::SurrealdbSurrealkv => SURREALDB_SURREALKV_DOCKER_PARAMS,
 			Database::Mongodb => MONGODB_DOCKER_PARAMS,
 			Database::Postgresql => POSTGRES_DOCKER_PARAMS,
 			Database::Redis => REDIS_DOCKER_PARAMS,
@@ -76,8 +74,7 @@ impl Database {
 			Database::Surrealdb
 			| Database::SurrealdbMemory
 			| Database::SurrealdbRocksdb
-			| Database::SurrealdbSpeedb
-			| Database::SurrealdbKv => benchmark.run(SurrealDBClientProvider::default()),
+			| Database::SurrealdbSurrealkv => benchmark.run(SurrealDBClientProvider::default()),
 			Database::Mongodb => benchmark.run(MongoDBClientProvider::default()),
 			Database::Postgresql => benchmark.run(PostgresClientProvider::default()),
 			Database::Redis => benchmark.run(RedisClientProvider::default()),

crud-bench/src/mongodb.rs

@@ -58,19 +58,19 @@ impl BenchmarkClient for MongoDBClient {
 		Ok(())
 	}
 
-	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
-		let doc = MongoDBRecord::new(key, record);
-		self.collection.insert_one(doc, None).await?;
-		Ok(())
-	}
-
 	async fn read(&mut self, key: i32) -> Result<()> {
 		let filter = doc! { "id": key };
 		let doc = self.collection.find_one(Some(filter), None).await?;
 		assert_eq!(doc.unwrap().id, key);
 		Ok(())
 	}
 
+	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
+		let doc = MongoDBRecord::new(key, record);
+		self.collection.insert_one(doc, None).await?;
+		Ok(())
+	}
+
 	async fn update(&mut self, key: i32, record: &Record) -> Result<()> {
 		let doc = MongoDBRecord::new(key, record);
 		let filter = doc! { "id": key };

crud-bench/src/postgres.rs

@@ -38,16 +38,24 @@ impl BenchmarkClient for PostgresClient {
 		self.client
 			.batch_execute(
 				"
-    CREATE TABLE record (
-        id      SERIAL PRIMARY KEY,
-        text    TEXT NOT NULL,
-        integer    INTEGER NOT NULL
-    )",
+					CREATE TABLE record (
+						id      SERIAL PRIMARY KEY,
+						text    TEXT NOT NULL,
+						integer    INTEGER NOT NULL
+					)
+				",
 			)
 			.await?;
 		Ok(())
 	}
 
+	async fn read(&mut self, key: i32) -> Result<()> {
+		let res =
+			self.client.query("SELECT id, text, integer FROM record WHERE id=$1", &[&key]).await?;
+		assert_eq!(res.len(), 1);
+		Ok(())
+	}
+
 	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
 		let res = self
 			.client
@@ -60,13 +68,6 @@ impl BenchmarkClient for PostgresClient {
 		Ok(())
 	}
 
-	async fn read(&mut self, key: i32) -> Result<()> {
-		let res =
-			self.client.query("SELECT id, text, integer FROM record WHERE id=$1", &[&key]).await?;
-		assert_eq!(res.len(), 1);
-		Ok(())
-	}
-
 	async fn update(&mut self, key: i32, record: &Record) -> Result<()> {
 		let res = self
 			.client

crud-bench/src/redis.rs

@@ -34,22 +34,27 @@ impl BenchmarkClient for RedisClient {
 		Ok(())
 	}
 
-	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
-		let json = serde_json::to_string(record)?;
-		self.conn.set(key, json).await?;
+	async fn read(&mut self, key: i32) -> Result<()> {
+		let json: String = self.conn.get(key).await?;
+		assert!(json.starts_with(r#"{"text":""#), "{}", json);
 		Ok(())
 	}
 
-	async fn read(&mut self, key: i32) -> Result<()> {
-		let json: String = self.conn.get(key).await?;
-		assert!(json.starts_with("{\"text\":\""), "{}", json);
+	#[allow(dependency_on_unit_never_type_fallback)]
+	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
+		let json = serde_json::to_string(record)?;
+		self.conn.set(key, json).await?;
 		Ok(())
 	}
 
+	#[allow(dependency_on_unit_never_type_fallback)]
 	async fn update(&mut self, key: i32, record: &Record) -> Result<()> {
-		self.create(key, record).await
+		let json = serde_json::to_string(record)?;
+		self.conn.set(key, json).await?;
+		Ok(())
 	}
 
+	#[allow(dependency_on_unit_never_type_fallback)]
 	async fn delete(&mut self, key: i32) -> Result<()> {
 		self.conn.del(key).await?;
 		Ok(())

crud-bench/src/surrealdb.rs

@@ -8,28 +8,22 @@ use surrealdb::Surreal;
 use crate::benchmark::{BenchmarkClient, BenchmarkClientProvider, Record};
 use crate::docker::DockerParams;
 
-pub(crate) const SURREAL_SPEEDB_DOCKER_PARAMS: DockerParams = DockerParams {
+pub(crate) const SURREALDB_MEMORY_DOCKER_PARAMS: DockerParams = DockerParams {
 	image: "surrealdb/surrealdb:nightly",
 	pre_args: "-p 127.0.0.1:8000:8000",
-	post_args: "start --auth --user root --pass root speedb://tmp/crud-bench.db",
+	post_args: "start --user root --pass root memory",
 };
 
-pub(crate) const SURREAL_ROCKSDB_DOCKER_PARAMS: DockerParams = DockerParams {
+pub(crate) const SURREALDB_ROCKSDB_DOCKER_PARAMS: DockerParams = DockerParams {
 	image: "surrealdb/surrealdb:nightly",
 	pre_args: "-p 127.0.0.1:8000:8000",
-	post_args: "start --auth --user root --pass root rocksdb://tmp/crud-bench.db",
+	post_args: "start --user root --pass root rocksdb://tmp/crud-bench.db",
 };
 
-pub(crate) const SURREAL_KV_DOCKER_PARAMS: DockerParams = DockerParams {
+pub(crate) const SURREALDB_SURREALKV_DOCKER_PARAMS: DockerParams = DockerParams {
 	image: "surrealdb/surrealdb:nightly",
 	pre_args: "-p 127.0.0.1:8000:8000",
-	post_args: "start --auth --user root --pass root surrealkv://tmp/crud-bench.db",
-};
-
-pub(crate) const SURREAL_MEMORY_DOCKER_PARAMS: DockerParams = DockerParams {
-	image: "surrealdb/surrealdb:nightly",
-	pre_args: "-p 127.0.0.1:8000:8000",
-	post_args: "start --auth --user root --pass root memory",
+	post_args: "start --user root --pass root surrealkv://tmp/crud-bench.db",
 };
 
 #[derive(Default)]
@@ -79,28 +73,28 @@ impl BenchmarkClient for SurrealDBClient {
 		Ok(())
 	}
 
-	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
-		let created: Option<SurrealRecord> =
-			self.db.create(("record", key)).content(record.clone()).await?;
-		assert!(created.is_some());
+	async fn read(&mut self, key: i32) -> Result<()> {
+		let read: Option<Record> = self.db.select(("record", key as i64)).await?;
+		assert!(read.is_some());
 		Ok(())
 	}
 
-	async fn read(&mut self, key: i32) -> Result<()> {
-		let read: Option<Record> = self.db.select(("record", key)).await?;
-		assert!(read.is_some());
+	async fn create(&mut self, key: i32, record: &Record) -> Result<()> {
+		let created: Option<SurrealRecord> =
+			self.db.create(("record", key as i64)).content(record.clone()).await?;
+		assert!(created.is_some());
 		Ok(())
 	}
 
 	async fn update(&mut self, key: i32, record: &Record) -> Result<()> {
 		let updated: Option<SurrealRecord> =
-			self.db.update(("record", key)).content(record.clone()).await?;
+			self.db.update(("record", key as i64)).content(record.clone()).await?;
 		assert!(updated.is_some());
 		Ok(())
 	}
 
 	async fn delete(&mut self, key: i32) -> Result<()> {
-		let deleted: Option<Record> = self.db.delete(("record", key)).await?;
+		let deleted: Option<Record> = self.db.delete(("record", key as i64)).await?;
 		assert!(deleted.is_some());
 		Ok(())
 	}