Skip to main content

chronon_backend_sql_common/
macros.rs

1//! Internal SQL query helpers for dialect-aware pool dispatch.
2//!
3//! **Audience:** internal — used by [`SqlSchedulerStore`](crate::SqlSchedulerStore) modules.
4
5/// Execute a parameterized SQL statement on the store pool.
6#[macro_export]
7macro_rules! sql_execute {
8    ($store:expr, $sql:expr, |$q:ident| $body:expr) => {{
9        match &$store.pool {
10            $crate::SqlPool::Sqlite(pool) => {
11                let $q = sqlx::query($sql);
12                let $q = $body;
13                $q.execute(pool).await.map_err($crate::error_map::map_err)?;
14            }
15            $crate::SqlPool::Postgres(pool) => {
16                let $q = sqlx::query($sql);
17                let $q = $body;
18                $q.execute(pool).await.map_err($crate::error_map::map_err)?;
19            }
20        }
21        Ok::<(), chronon_core::error::ChrononError>(())
22    }};
23}
24
25/// Fetch zero or one row and map it through a closure.
26#[macro_export]
27macro_rules! sql_fetch_optional_map {
28    ($store:expr, $sql:expr, |$q:ident| $bind:expr, |$row:ident| $map:expr) => {{
29        match &$store.pool {
30            $crate::SqlPool::Sqlite(pool) => {
31                let $q = sqlx::query($sql);
32                let $q = $bind;
33                match $q
34                    .fetch_optional(pool)
35                    .await
36                    .map_err($crate::error_map::map_err)?
37                {
38                    Some($row) => Ok(Some($map?)),
39                    None => Ok(None),
40                }
41            }
42            $crate::SqlPool::Postgres(pool) => {
43                let $q = sqlx::query($sql);
44                let $q = $bind;
45                match $q
46                    .fetch_optional(pool)
47                    .await
48                    .map_err($crate::error_map::map_err)?
49                {
50                    Some($row) => Ok(Some($map?)),
51                    None => Ok(None),
52                }
53            }
54        }
55    }};
56}
57
58/// Fetch exactly one row and map it through a closure.
59#[macro_export]
60macro_rules! sql_fetch_one_map {
61    ($store:expr, $sql:expr, |$q:ident| $bind:expr, |$row:ident| $map:expr) => {{
62        match &$store.pool {
63            $crate::SqlPool::Sqlite(pool) => {
64                let $q = sqlx::query($sql);
65                let $q = $bind;
66                let $row = $q
67                    .fetch_one(pool)
68                    .await
69                    .map_err($crate::error_map::map_err)?;
70                $map
71            }
72            $crate::SqlPool::Postgres(pool) => {
73                let $q = sqlx::query($sql);
74                let $q = $bind;
75                let $row = $q
76                    .fetch_one(pool)
77                    .await
78                    .map_err($crate::error_map::map_err)?;
79                $map
80            }
81        }
82    }};
83}
84
85/// Fetch all rows and map each through a closure.
86#[macro_export]
87macro_rules! sql_fetch_all_map {
88    ($store:expr, $sql:expr, |$q:ident| $bind:expr, |$row:ident| $map:expr) => {{
89        match &$store.pool {
90            $crate::SqlPool::Sqlite(pool) => {
91                let $q = sqlx::query($sql);
92                let $q = $bind;
93                let rows = $q
94                    .fetch_all(pool)
95                    .await
96                    .map_err($crate::error_map::map_err)?;
97                rows.iter()
98                    .map(|$row| $map)
99                    .collect::<chronon_core::Result<Vec<_>>>()
100            }
101            $crate::SqlPool::Postgres(pool) => {
102                let $q = sqlx::query($sql);
103                let $q = $bind;
104                let rows = $q
105                    .fetch_all(pool)
106                    .await
107                    .map_err($crate::error_map::map_err)?;
108                rows.iter()
109                    .map(|$row| $map)
110                    .collect::<chronon_core::Result<Vec<_>>>()
111            }
112        }
113    }};
114}