More sai workload files

workloads/sai/read-equals-hc.rn

@@ -0,0 +1,33 @@
+mod common;
+
+use common::{KEYSPACE, TABLE, LC, HC};
+use latte::*;
+
+pub const LOAD_COUNT = latte::param!("rows", 100000);
+
+const READ_SIZE = latte::param!("read_size", 10);
+
+const READ = "read";
+
+pub async fn schema(db) {
+    common::init_schema(db).await?;
+}
+
+pub async fn erase(db) {
+    common::erase(db).await?;
+}
+
+pub async fn prepare(db) {
+    common::prepare(db).await?;
+    db.prepare(READ, `SELECT * FROM ${KEYSPACE}.${TABLE}
+        WHERE hc = ? LIMIT ${READ_SIZE}`).await?;
+}
+
+pub async fn load(db, i) {
+    common::insert_row(db, i).await?;
+}
+
+pub async fn run(db, i) {
+    let hc = hash2(i, 26709) % HC;
+    db.execute_prepared(READ, [hc]).await?;
+}

workloads/sai/read-equals-lc.rn

@@ -0,0 +1,33 @@
+mod common;
+
+use common::{KEYSPACE, TABLE, LC, HC};
+use latte::*;
+
+pub const LOAD_COUNT = latte::param!("rows", 100000);
+
+const READ_SIZE = latte::param!("read_size", 10);
+
+const READ = "read";
+
+pub async fn schema(db) {
+    common::init_schema(db).await?;
+}
+
+pub async fn erase(db) {
+    common::erase(db).await?;
+}
+
+pub async fn prepare(db) {
+    common::prepare(db).await?;
+    db.prepare(READ, `SELECT * FROM ${KEYSPACE}.${TABLE}
+        WHERE lc = ? LIMIT ${READ_SIZE}`).await?;
+}
+
+pub async fn load(db, i) {
+    common::insert_row(db, i).await?;
+}
+
+pub async fn run(db, i) {
+    let lc = hash2(i, 26709) % LC;
+    db.execute_prepared(READ, [lc]).await?;
+}

workloads/sai/read-intersect-lc-hc.rn

@@ -0,0 +1,34 @@
+mod common;
+
+use common::{KEYSPACE, TABLE, LC, HC};
+use latte::*;
+
+pub const LOAD_COUNT = latte::param!("rows", 100000);
+
+const READ_SIZE = latte::param!("read_size", 10);
+
+const READ = "read";
+
+pub async fn schema(db) {
+    common::init_schema(db).await?;
+}
+
+pub async fn erase(db) {
+    common::erase(db).await?;
+}
+
+pub async fn prepare(db) {
+    common::prepare(db).await?;
+    db.prepare(READ, `SELECT * FROM ${KEYSPACE}.${TABLE}
+        WHERE lc = ? AND hc = ? LIMIT ${READ_SIZE}`).await?;
+}
+
+pub async fn load(db, i) {
+    common::insert_row(db, i).await?;
+}
+
+pub async fn run(db, i) {
+    let lc = hash2(i, 26709) % LC;
+    let hc = hash2(i, 67633) % HC;
+    db.execute_prepared(READ, [lc, hc]).await?;
+}

workloads/sai/read-intersect-lc-mc.rn

@@ -0,0 +1,34 @@
+mod common;
+
+use common::{KEYSPACE, TABLE, LC, MC};
+use latte::*;
+
+pub const LOAD_COUNT = latte::param!("rows", 100000);
+
+const READ_SIZE = latte::param!("read_size", 10);
+
+const READ = "read";
+
+pub async fn schema(db) {
+    common::init_schema(db).await?;
+}
+
+pub async fn erase(db) {
+    common::erase(db).await?;
+}
+
+pub async fn prepare(db) {
+    common::prepare(db).await?;
+    db.prepare(READ, `SELECT * FROM ${KEYSPACE}.${TABLE}
+        WHERE lc = ? AND mc = ? LIMIT ${READ_SIZE}`).await?;
+}
+
+pub async fn load(db, i) {
+    common::insert_row(db, i).await?;
+}
+
+pub async fn run(db, i) {
+    let lc = hash2(i, 26709) % LC;
+    let mc = hash2(i, 6773) % MC;
+    db.execute_prepared(READ, [lc, mc]).await?;
+}

workloads/sai/read-union-hc-hc.rn

@@ -0,0 +1,34 @@
+mod common;
+
+use common::{KEYSPACE, TABLE, HC};
+use latte::*;
+
+pub const LOAD_COUNT = latte::param!("rows", 100000);
+
+const READ_SIZE = latte::param!("read_size", 10);
+
+const READ = "read";
+
+pub async fn schema(db) {
+    common::init_schema(db).await?;
+}
+
+pub async fn erase(db) {
+    common::erase(db).await?;
+}
+
+pub async fn prepare(db) {
+    common::prepare(db).await?;
+    db.prepare(READ, `SELECT * FROM ${KEYSPACE}.${TABLE}
+        WHERE hc = ? OR hc = ? LIMIT ${READ_SIZE}`).await?;
+}
+
+pub async fn load(db, i) {
+    common::insert_row(db, i).await?;
+}
+
+pub async fn run(db, i) {
+    let hc1 = hash2(i, 85790) % HC;
+    let hc2 = hash2(i, 24303) % HC;
+    db.execute_prepared(READ, [hc1, hc2]).await?;
+}

workloads/sai/read-union-lc-lc.rn

@@ -0,0 +1,34 @@
+mod common;
+
+use common::{KEYSPACE, TABLE, LC};
+use latte::*;
+
+pub const LOAD_COUNT = latte::param!("rows", 100000);
+
+const READ_SIZE = latte::param!("read_size", 10);
+
+const READ = "read";
+
+pub async fn schema(db) {
+    common::init_schema(db).await?;
+}
+
+pub async fn erase(db) {
+    common::erase(db).await?;
+}
+
+pub async fn prepare(db) {
+    common::prepare(db).await?;
+    db.prepare(READ, `SELECT * FROM ${KEYSPACE}.${TABLE}
+        WHERE lc = ? OR lc = ? LIMIT ${READ_SIZE}`).await?;
+}
+
+pub async fn load(db, i) {
+    common::insert_row(db, i).await?;
+}
+
+pub async fn run(db, i) {
+    let lc1 = hash2(i, 85790) % LC;
+    let lc2 = hash2(i, 24303) % LC;
+    db.execute_prepared(READ, [lc1, lc2]).await?;
+}