refactor(data): introduce simple query helper

2026-10-07 01:47:47 +08:00 · 2026-05-17 14:07:23 +08:00
parent a2f91b4108
commit f0a6fffa87
39 changed files with 3169 additions and 2037 deletions
@@ -10,6 +10,9 @@ use super::{
 use crate::driver::mysql::MysqlPool;
 use crate::error::SqlResultExt;
 use crate::DataLayerError;
+use aether_data_query::{
+    push_ci_contains, push_eq, push_limit, push_limit_offset, SqlDialect, WhereClause,
+};

 const RUN_COLUMNS: &str = r#"
 SELECT
@@ -57,44 +60,29 @@ impl MysqlBackgroundTaskRepository {
    }

    fn apply_run_filter(builder: &mut QueryBuilder<'_, MySql>, query: &BackgroundTaskListQuery) {
-        let mut has_where = false;
+        let mut where_clause = WhereClause::new();
        if let Some(kind) = query.kind {
-            if !has_where {
-                builder.push(" WHERE ");
-                has_where = true;
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("kind = ").push_bind(kind.as_database());
+            push_eq(builder, &mut where_clause, "kind", kind.as_database());
        }
        if let Some(status) = query.status {
-            if !has_where {
-                builder.push(" WHERE ");
-                has_where = true;
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("status = ").push_bind(status.as_database());
+            push_eq(builder, &mut where_clause, "status", status.as_database());
        }
        if let Some(trigger) = query.trigger.as_deref() {
-            if !has_where {
-                builder.push(" WHERE ");
-                has_where = true;
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("`trigger` = ").push_bind(trigger.to_string());
+            push_eq(
+                builder,
+                &mut where_clause,
+                &SqlDialect::Mysql.quote_ident("trigger"),
+                trigger.to_string(),
+            );
        }
        if let Some(task_key_substring) = query.task_key_substring.as_deref() {
-            if !has_where {
-                builder.push(" WHERE ");
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("LOWER(task_key) LIKE ").push_bind(format!(
-                "%{}%",
-                task_key_substring.trim().to_ascii_lowercase()
-            ));
+            push_ci_contains(
+                builder,
+                &mut where_clause,
+                SqlDialect::Mysql,
+                "task_key",
+                task_key_substring,
+            );
        }
    }
 }
@@ -105,8 +93,12 @@ impl BackgroundTaskReadRepository for MysqlBackgroundTaskRepository {
        &self,
        run_id: &str,
    ) -> Result<Option<StoredBackgroundTaskRun>, DataLayerError> {
-        let row = sqlx::query(&format!("{RUN_COLUMNS} WHERE id = ? LIMIT 1"))
-            .bind(run_id)
+        let mut builder = QueryBuilder::<MySql>::new(RUN_COLUMNS);
+        let mut where_clause = WhereClause::new();
+        push_eq(&mut builder, &mut where_clause, "id", run_id.to_string());
+        push_limit(&mut builder, 1);
+        let row = builder
+            .build()
            .fetch_optional(&self.pool)
            .await
            .map_sql_err()?;
@@ -129,12 +121,12 @@ impl BackgroundTaskReadRepository for MysqlBackgroundTaskRepository {

        let mut builder = QueryBuilder::<MySql>::new(RUN_COLUMNS);
        Self::apply_run_filter(&mut builder, query);
-        builder
-            .push(" ORDER BY created_at_unix_secs DESC, updated_at_unix_secs DESC")
-            .push(" LIMIT ")
-            .push_bind(i64_from_usize(limit, "run limit")?)
-            .push(" OFFSET ")
-            .push_bind(i64_from_usize(query.offset, "run offset")?);
+        builder.push(" ORDER BY created_at_unix_secs DESC, updated_at_unix_secs DESC");
+        push_limit_offset(
+            &mut builder,
+            i64_from_usize(limit, "run limit")?,
+            i64_from_usize(query.offset, "run offset")?,
+        );
        let rows = builder.build().fetch_all(&self.pool).await.map_sql_err()?;
        let items = rows
            .iter()
@@ -153,15 +145,21 @@ impl BackgroundTaskReadRepository for MysqlBackgroundTaskRepository {
        limit: usize,
    ) -> Result<Vec<StoredBackgroundTaskEvent>, DataLayerError> {
        let limit = limit.max(1);
-        let rows = sqlx::query(&format!(
-            "{EVENT_COLUMNS} WHERE run_id = ? ORDER BY created_at_unix_secs ASC, id ASC LIMIT ? OFFSET ?"
-        ))
-        .bind(run_id)
-        .bind(i64_from_usize(limit, "event limit")?)
-        .bind(i64_from_usize(offset, "event offset")?)
-        .fetch_all(&self.pool)
-        .await
-        .map_sql_err()?;
+        let mut builder = QueryBuilder::<MySql>::new(EVENT_COLUMNS);
+        let mut where_clause = WhereClause::new();
+        push_eq(
+            &mut builder,
+            &mut where_clause,
+            "run_id",
+            run_id.to_string(),
+        );
+        builder.push(" ORDER BY created_at_unix_secs ASC, id ASC");
+        push_limit_offset(
+            &mut builder,
+            i64_from_usize(limit, "event limit")?,
+            i64_from_usize(offset, "event offset")?,
+        );
+        let rows = builder.build().fetch_all(&self.pool).await.map_sql_err()?;
        rows.iter().map(map_event_row).collect()
    }

@@ -9,6 +9,9 @@ use super::{
 };
 use crate::error::SqlxResultExt;
 use crate::DataLayerError;
+use aether_data_query::{
+    push_ci_contains, push_eq, push_limit, push_limit_offset, SqlDialect, WhereClause,
+};

 const RUN_COLUMNS: &str = r#"
 SELECT
@@ -60,35 +63,33 @@ impl SqlxBackgroundTaskRepository {
        query: &BackgroundTaskListQuery,
        include_where: bool,
    ) {
-        let mut has_where = include_where;
-        let mut push_where = |builder: &mut QueryBuilder<'_, Postgres>| {
-            if has_where {
-                builder.push(" AND ");
-            } else {
-                builder.push(" WHERE ");
-                has_where = true;
-            }
+        let mut where_clause = if include_where {
+            WhereClause::with_existing_clause()
+        } else {
+            WhereClause::new()
        };
-
        if let Some(kind) = query.kind {
-            push_where(builder);
-            builder.push("kind = ").push_bind(kind.as_database());
+            push_eq(builder, &mut where_clause, "kind", kind.as_database());
        }
        if let Some(status) = query.status {
-            push_where(builder);
-            builder.push("status = ").push_bind(status.as_database());
+            push_eq(builder, &mut where_clause, "status", status.as_database());
        }
        if let Some(trigger) = query.trigger.as_deref() {
-            push_where(builder);
-            builder
-                .push("\"trigger\" = ")
-                .push_bind(trigger.to_string());
+            push_eq(
+                builder,
+                &mut where_clause,
+                &SqlDialect::Postgres.quote_ident("trigger"),
+                trigger.to_string(),
+            );
        }
        if let Some(task_key_substring) = query.task_key_substring.as_deref() {
-            push_where(builder);
-            builder
-                .push("task_key ILIKE ")
-                .push_bind(format!("%{}%", task_key_substring.trim()));
+            push_ci_contains(
+                builder,
+                &mut where_clause,
+                SqlDialect::Postgres,
+                "task_key",
+                task_key_substring,
+            );
        }
    }
 }
@@ -99,8 +100,12 @@ impl BackgroundTaskReadRepository for SqlxBackgroundTaskRepository {
        &self,
        run_id: &str,
    ) -> Result<Option<StoredBackgroundTaskRun>, DataLayerError> {
-        let row = sqlx::query(&format!("{RUN_COLUMNS} WHERE id = $1 LIMIT 1"))
-            .bind(run_id)
+        let mut builder = QueryBuilder::<Postgres>::new(RUN_COLUMNS);
+        let mut where_clause = WhereClause::new();
+        push_eq(&mut builder, &mut where_clause, "id", run_id.to_string());
+        push_limit(&mut builder, 1);
+        let row = builder
+            .build()
            .fetch_optional(&self.pool)
            .await
            .map_postgres_err()?;
@@ -124,12 +129,12 @@ impl BackgroundTaskReadRepository for SqlxBackgroundTaskRepository {

        let mut builder = QueryBuilder::<Postgres>::new(RUN_COLUMNS);
        Self::apply_run_filter(&mut builder, query, false);
-        builder
-            .push(" ORDER BY created_at_unix_secs DESC, updated_at_unix_secs DESC")
-            .push(" LIMIT ")
-            .push_bind(i64_from_usize(limit, "background task run limit")?)
-            .push(" OFFSET ")
-            .push_bind(i64_from_usize(query.offset, "background task run offset")?);
+        builder.push(" ORDER BY created_at_unix_secs DESC, updated_at_unix_secs DESC");
+        push_limit_offset(
+            &mut builder,
+            i64_from_usize(limit, "background task run limit")?,
+            i64_from_usize(query.offset, "background task run offset")?,
+        );
        let rows = builder
            .build()
            .fetch_all(&self.pool)
@@ -153,15 +158,25 @@ impl BackgroundTaskReadRepository for SqlxBackgroundTaskRepository {
        limit: usize,
    ) -> Result<Vec<StoredBackgroundTaskEvent>, DataLayerError> {
        let limit = limit.max(1);
-        let rows = sqlx::query(&format!(
-            "{EVENT_COLUMNS} WHERE run_id = $1 ORDER BY created_at_unix_secs ASC, id ASC LIMIT $2 OFFSET $3"
-        ))
-        .bind(run_id)
-        .bind(i64_from_usize(limit, "background task event limit")?)
-        .bind(i64_from_usize(offset, "background task event offset")?)
-        .fetch_all(&self.pool)
-        .await
-        .map_postgres_err()?;
+        let mut builder = QueryBuilder::<Postgres>::new(EVENT_COLUMNS);
+        let mut where_clause = WhereClause::new();
+        push_eq(
+            &mut builder,
+            &mut where_clause,
+            "run_id",
+            run_id.to_string(),
+        );
+        builder.push(" ORDER BY created_at_unix_secs ASC, id ASC");
+        push_limit_offset(
+            &mut builder,
+            i64_from_usize(limit, "background task event limit")?,
+            i64_from_usize(offset, "background task event offset")?,
+        );
+        let rows = builder
+            .build()
+            .fetch_all(&self.pool)
+            .await
+            .map_postgres_err()?;
        rows.iter().map(map_event_row).collect()
    }

@@ -10,6 +10,9 @@ use super::{
 use crate::driver::sqlite::SqlitePool;
 use crate::error::SqlResultExt;
 use crate::DataLayerError;
+use aether_data_query::{
+    push_ci_contains, push_eq, push_limit, push_limit_offset, SqlDialect, WhereClause,
+};

 const RUN_COLUMNS: &str = r#"
 SELECT
@@ -57,46 +60,29 @@ impl SqliteBackgroundTaskRepository {
    }

    fn apply_run_filter(builder: &mut QueryBuilder<'_, Sqlite>, query: &BackgroundTaskListQuery) {
-        let mut has_where = false;
+        let mut where_clause = WhereClause::new();
        if let Some(kind) = query.kind {
-            if !has_where {
-                builder.push(" WHERE ");
-                has_where = true;
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("kind = ").push_bind(kind.as_database());
+            push_eq(builder, &mut where_clause, "kind", kind.as_database());
        }
        if let Some(status) = query.status {
-            if !has_where {
-                builder.push(" WHERE ");
-                has_where = true;
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("status = ").push_bind(status.as_database());
+            push_eq(builder, &mut where_clause, "status", status.as_database());
        }
        if let Some(trigger) = query.trigger.as_deref() {
-            if !has_where {
-                builder.push(" WHERE ");
-                has_where = true;
-            } else {
-                builder.push(" AND ");
-            }
-            builder
-                .push("\"trigger\" = ")
-                .push_bind(trigger.to_string());
+            push_eq(
+                builder,
+                &mut where_clause,
+                &SqlDialect::Sqlite.quote_ident("trigger"),
+                trigger.to_string(),
+            );
        }
        if let Some(task_key_substring) = query.task_key_substring.as_deref() {
-            if !has_where {
-                builder.push(" WHERE ");
-            } else {
-                builder.push(" AND ");
-            }
-            builder.push("LOWER(task_key) LIKE ").push_bind(format!(
-                "%{}%",
-                task_key_substring.trim().to_ascii_lowercase()
-            ));
+            push_ci_contains(
+                builder,
+                &mut where_clause,
+                SqlDialect::Sqlite,
+                "task_key",
+                task_key_substring,
+            );
        }
    }
 }
@@ -107,8 +93,12 @@ impl BackgroundTaskReadRepository for SqliteBackgroundTaskRepository {
        &self,
        run_id: &str,
    ) -> Result<Option<StoredBackgroundTaskRun>, DataLayerError> {
-        let row = sqlx::query(&format!("{RUN_COLUMNS} WHERE id = ? LIMIT 1"))
-            .bind(run_id)
+        let mut builder = QueryBuilder::<Sqlite>::new(RUN_COLUMNS);
+        let mut where_clause = WhereClause::new();
+        push_eq(&mut builder, &mut where_clause, "id", run_id.to_string());
+        push_limit(&mut builder, 1);
+        let row = builder
+            .build()
            .fetch_optional(&self.pool)
            .await
            .map_sql_err()?;
@@ -131,12 +121,12 @@ impl BackgroundTaskReadRepository for SqliteBackgroundTaskRepository {

        let mut builder = QueryBuilder::<Sqlite>::new(RUN_COLUMNS);
        Self::apply_run_filter(&mut builder, query);
-        builder
-            .push(" ORDER BY created_at_unix_secs DESC, updated_at_unix_secs DESC")
-            .push(" LIMIT ")
-            .push_bind(i64_from_usize(limit, "run limit")?)
-            .push(" OFFSET ")
-            .push_bind(i64_from_usize(query.offset, "run offset")?);
+        builder.push(" ORDER BY created_at_unix_secs DESC, updated_at_unix_secs DESC");
+        push_limit_offset(
+            &mut builder,
+            i64_from_usize(limit, "run limit")?,
+            i64_from_usize(query.offset, "run offset")?,
+        );
        let rows = builder.build().fetch_all(&self.pool).await.map_sql_err()?;
        let items = rows
            .iter()
@@ -155,15 +145,21 @@ impl BackgroundTaskReadRepository for SqliteBackgroundTaskRepository {
        limit: usize,
    ) -> Result<Vec<StoredBackgroundTaskEvent>, DataLayerError> {
        let limit = limit.max(1);
-        let rows = sqlx::query(&format!(
-            "{EVENT_COLUMNS} WHERE run_id = ? ORDER BY created_at_unix_secs ASC, id ASC LIMIT ? OFFSET ?"
-        ))
-        .bind(run_id)
-        .bind(i64_from_usize(limit, "event limit")?)
-        .bind(i64_from_usize(offset, "event offset")?)
-        .fetch_all(&self.pool)
-        .await
-        .map_sql_err()?;
+        let mut builder = QueryBuilder::<Sqlite>::new(EVENT_COLUMNS);
+        let mut where_clause = WhereClause::new();
+        push_eq(
+            &mut builder,
+            &mut where_clause,
+            "run_id",
+            run_id.to_string(),
+        );
+        builder.push(" ORDER BY created_at_unix_secs ASC, id ASC");
+        push_limit_offset(
+            &mut builder,
+            i64_from_usize(limit, "event limit")?,
+            i64_from_usize(offset, "event offset")?,
+        );
+        let rows = builder.build().fetch_all(&self.pool).await.map_sql_err()?;
        rows.iter().map(map_event_row).collect()
    }