Update bench

Author: Huliiiiii

benches/value.rs

@@ -10,59 +10,102 @@ pub enum Char {
     Character,
 }
 
-fn vanilla() -> String {
-    format!(
-        "SELECT `{}` from `{}` where `character` = {}",
-        "character",
-        "character".to_owned(),
-        "foobar"
-    )
+fn small_type(value: i32) -> SelectStatement {
+    Query::select()
+        .column(Char::Character)
+        .from(Char::Table)
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .and_where(Expr::col(Char::Character).eq(value))
+        .to_owned()
 }
 
-fn select() -> SelectStatement {
+fn large_type(value: jiff::Zoned) -> SelectStatement {
     Query::select()
         .column(Char::Character)
         .from(Char::Table)
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
-        .and_where(Expr::col(Char::Character).eq("foobar"))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value.clone()))
+        .and_where(Expr::col(Char::Character).eq(value))
         .to_owned()
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("value");
-    group.bench_function("vanilla", |b| b.iter(vanilla));
-    group.bench_function("select", |b| b.iter(select));
+    let value = black_box(jiff::Zoned::now());
 
-    let select = black_box(select());
-    group.bench_function("select_and_build::mysql", |b| {
-        b.iter(|| select.build(MysqlQueryBuilder))
+    group.bench_function("select_construction/small", |b| {
+        b.iter(|| small_type(black_box(123)))
     });
-    group.bench_function("select_and_build::pg", |b| {
-        b.iter(|| select.build(PostgresQueryBuilder))
+
+    group.bench_function("select_construction/large", |b| {
+        b.iter(|| large_type(value.clone()))
     });
-    group.bench_function("select_and_build::sqlite", |b| {
-        b.iter(|| select.build(SqliteQueryBuilder))
+
+    let select_small = black_box(small_type(black_box(123)));
+    group.bench_function("select_and_build/small/mysql", |b| {
+        b.iter(|| select_small.build(MysqlQueryBuilder))
+    });
+    group.bench_function("select_and_build/small/pg", |b| {
+        b.iter(|| select_small.build(PostgresQueryBuilder))
     });
-    group.bench_function("select_and_to_string::mysql", |b| {
-        b.iter(|| select.to_string(MysqlQueryBuilder))
+    group.bench_function("select_and_build/small/sqlite", |b| {
+        b.iter(|| select_small.build(SqliteQueryBuilder))
     });
-    group.bench_function("select_and_to_string::pg", |b| {
-        b.iter(|| select.to_string(PostgresQueryBuilder))
+    group.bench_function("select_and_to_string/small/mysql", |b| {
+        b.iter(|| select_small.to_string(MysqlQueryBuilder))
     });
-    group.bench_function("select_and_to_string::sqlite", |b| {
-        b.iter(|| select.to_string(SqliteQueryBuilder))
+    group.bench_function("select_and_to_string/small/pg", |b| {
+        b.iter(|| select_small.to_string(PostgresQueryBuilder))
+    });
+    group.bench_function("select_and_to_string/small/sqlite", |b| {
+        b.iter(|| select_small.to_string(SqliteQueryBuilder))
+    });
+
+    let select_large = black_box(large_type(value));
+    group.bench_function("select_and_build/large/mysql", |b| {
+        b.iter(|| select_large.build(MysqlQueryBuilder))
+    });
+    group.bench_function("select_and_build/large/pg", |b| {
+        b.iter(|| select_large.build(PostgresQueryBuilder))
+    });
+    group.bench_function("select_and_build/large/sqlite", |b| {
+        b.iter(|| select_large.build(SqliteQueryBuilder))
+    });
+    group.bench_function("select_and_to_string/large/mysql", |b| {
+        b.iter(|| select_large.to_string(MysqlQueryBuilder))
+    });
+    group.bench_function("select_and_to_string/large/pg", |b| {
+        b.iter(|| select_large.to_string(PostgresQueryBuilder))
+    });
+    group.bench_function("select_and_to_string/large/sqlite", |b| {
+        b.iter(|| select_large.to_string(SqliteQueryBuilder))
     });
 
     group.finish();
 }
 
-criterion_group!(benches, criterion_benchmark);
+fn config() -> Criterion {
+    Criterion::default().measurement_time(std::time::Duration::new(10, 0))
+}
+
+criterion_group!(
+    name = benches;
+    config = config();
+    targets = criterion_benchmark
+);
 criterion_main!(benches);