tenant.openagents/omega

1#[macro_export]
2macro_rules! query {
3    ($vis:vis fn $id:ident() -> Result<()> { $($sql:tt)+ }) => {
4        $vis fn $id(&self) -> $crate::anyhow::Result<()> {
5            use $crate::anyhow::Context;
6
7            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
8
9            self.exec(sql_stmt)?().context(::std::format!(
10                "Error in {}, exec failed to execute or parse for: {}",
11                ::std::stringify!($id),
12                sql_stmt,
13            ))
14        }
15    };
16    ($vis:vis async fn $id:ident() -> Result<()> { $($sql:tt)+ }) => {
17        $vis async fn $id(&self) -> $crate::anyhow::Result<()> {
18            use $crate::anyhow::Context;
19
20            self.write(|connection| {
21                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
22
23                connection.exec(sql_stmt)?().context(::std::format!(
24                    "Error in {}, exec failed to execute or parse for: {}",
25                    ::std::stringify!($id),
26                    sql_stmt
27                ))
28            }).await
29        }
30    };
31    ($vis:vis fn $id:ident($($arg:ident: $arg_type:ty),+) -> Result<()> { $($sql:tt)+ }) => {
32        $vis fn $id(&self, $($arg: $arg_type),+) -> $crate::anyhow::Result<()> {
33            use $crate::anyhow::Context;
34
35            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
36
37            self.exec_bound::<($($arg_type),+)>(sql_stmt)?(($($arg),+))
38                .context(::std::format!(
39                    "Error in {}, exec_bound failed to execute or parse for: {}",
40                    ::std::stringify!($id),
41                    sql_stmt
42                ))
43        }
44    };
45    ($vis:vis async fn $id:ident($arg:ident: $arg_type:ty) -> Result<()> { $($sql:tt)+ }) => {
46        $vis async fn $id(&self, $arg: $arg_type) -> $crate::anyhow::Result<()> {
47            use $crate::anyhow::Context;
48
49            self.write(move |connection| {
50                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
51
52                connection.exec_bound::<$arg_type>(sql_stmt)?($arg)
53                    .context(::std::format!(
54                        "Error in {}, exec_bound failed to execute or parse for: {}",
55                        ::std::stringify!($id),
56                        sql_stmt
57                    ))
58            }).await
59        }
60    };
61    ($vis:vis async fn $id:ident($($arg:ident: $arg_type:ty),+) -> Result<()> { $($sql:tt)+ }) => {
62        $vis async fn $id(&self, $($arg: $arg_type),+) -> $crate::anyhow::Result<()> {
63            use $crate::anyhow::Context;
64
65            self.write(move |connection| {
66                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
67
68                connection.exec_bound::<($($arg_type),+)>(sql_stmt)?(($($arg),+))
69                    .context(::std::format!(
70                        "Error in {}, exec_bound failed to execute or parse for: {}",
71                        ::std::stringify!($id),
72                        sql_stmt
73                    ))
74            }).await
75        }
76    };
77    ($vis:vis fn $id:ident() ->  Result<Vec<$return_type:ty>> { $($sql:tt)+ }) => {
78        $vis fn $id(&self) -> $crate::anyhow::Result<Vec<$return_type>> {
79            use $crate::anyhow::Context;
80
81            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
82
83            self.select::<$return_type>(sql_stmt)?()
84                .context(::std::format!(
85                    "Error in {}, select_row failed to execute or parse for: {}",
86                    ::std::stringify!($id),
87                    sql_stmt
88                ))
89        }
90    };
91    ($vis:vis async fn $id:ident() -> Result<Vec<$return_type:ty>> { $($sql:tt)+ }) => {
92        pub async fn $id(&self) -> $crate::anyhow::Result<Vec<$return_type>> {
93            use $crate::anyhow::Context;
94
95            self.write(|connection| {
96                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
97
98                connection.select::<$return_type>(sql_stmt)?()
99                    .context(::std::format!(
100                        "Error in {}, select_row failed to execute or parse for: {}",
101                        ::std::stringify!($id),
102                        sql_stmt
103                    ))
104            }).await
105        }
106    };
107    ($vis:vis fn $id:ident($($arg:ident: $arg_type:ty),+) -> Result<Vec<$return_type:ty>> { $($sql:tt)+ }) => {
108        $vis fn $id(&self, $($arg: $arg_type),+) -> $crate::anyhow::Result<Vec<$return_type>> {
109            use $crate::anyhow::Context;
110
111            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
112
113            self.select_bound::<($($arg_type),+), $return_type>(sql_stmt)?(($($arg),+))
114                .context(::std::format!(
115                    "Error in {}, exec_bound failed to execute or parse for: {}",
116                    ::std::stringify!($id),
117                    sql_stmt
118                ))
119        }
120    };
121    ($vis:vis async fn $id:ident($($arg:ident: $arg_type:ty),+) -> Result<Vec<$return_type:ty>> { $($sql:tt)+ }) => {
122        $vis async fn $id(&self, $($arg: $arg_type),+) -> $crate::anyhow::Result<Vec<$return_type>> {
123            use $crate::anyhow::Context;
124
125            self.write(|connection| {
126                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
127
128                connection.select_bound::<($($arg_type),+), $return_type>(sql_stmt)?(($($arg),+))
129                    .context(::std::format!(
130                        "Error in {}, exec_bound failed to execute or parse for: {}",
131                        ::std::stringify!($id),
132                        sql_stmt
133                    ))
134            }).await
135        }
136    };
137    ($vis:vis fn $id:ident() ->  Result<Option<$return_type:ty>> { $($sql:tt)+ }) => {
138        $vis fn $id(&self) -> $crate::anyhow::Result<Option<$return_type>> {
139            use $crate::anyhow::Context;
140
141            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
142
143            self.select_row::<$return_type>(sql_stmt)?()
144                .context(::std::format!(
145                    "Error in {}, select_row failed to execute or parse for: {}",
146                    ::std::stringify!($id),
147                    sql_stmt
148                ))
149        }
150    };
151    ($vis:vis async fn $id:ident() ->  Result<Option<$return_type:ty>> { $($sql:tt)+ }) => {
152        $vis async fn $id(&self) -> $crate::anyhow::Result<Option<$return_type>> {
153            use $crate::anyhow::Context;
154
155            self.write(|connection| {
156                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
157
158                connection.select_row::<$return_type>(sql_stmt)?()
159                    .context(::std::format!(
160                        "Error in {}, select_row failed to execute or parse for: {}",
161                        ::std::stringify!($id),
162                        sql_stmt
163                    ))
164            }).await
165        }
166    };
167    ($vis:vis fn $id:ident($arg:ident: $arg_type:ty) ->  Result<Option<$return_type:ty>> { $($sql:tt)+ }) => {
168        $vis fn $id(&self, $arg: $arg_type) -> $crate::anyhow::Result<Option<$return_type>>  {
169            use $crate::anyhow::Context;
170
171            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
172
173            self.select_row_bound::<$arg_type, $return_type>(sql_stmt)?($arg)
174                .context(::std::format!(
175                    "Error in {}, select_row_bound failed to execute or parse for: {}",
176                    ::std::stringify!($id),
177                    sql_stmt
178                ))
179
180        }
181    };
182    ($vis:vis fn $id:ident($($arg:ident: $arg_type:ty),+) ->  Result<Option<$return_type:ty>> { $($sql:tt)+ }) => {
183        $vis fn $id(&self, $($arg: $arg_type),+) -> $crate::anyhow::Result<Option<$return_type>>  {
184            use $crate::anyhow::Context;
185
186            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
187
188            self.select_row_bound::<($($arg_type),+), $return_type>(sql_stmt)?(($($arg),+))
189                .context(::std::format!(
190                    "Error in {}, select_row_bound failed to execute or parse for: {}",
191                    ::std::stringify!($id),
192                    sql_stmt
193                ))
194
195        }
196    };
197    ($vis:vis async fn $id:ident($($arg:ident: $arg_type:ty),+) ->  Result<Option<$return_type:ty>> { $($sql:tt)+ }) => {
198        $vis async fn $id(&self, $($arg: $arg_type),+) -> $crate::anyhow::Result<Option<$return_type>>  {
199            use $crate::anyhow::Context;
200
201
202            self.write(move |connection| {
203                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
204
205                connection.select_row_bound::<($($arg_type),+), $return_type>(sql_stmt)?(($($arg),+))
206                    .context(::std::format!(
207                        "Error in {}, select_row_bound failed to execute or parse for: {}",
208                        ::std::stringify!($id),
209                        sql_stmt
210                    ))
211            }).await
212        }
213    };
214    ($vis:vis fn $id:ident() ->  Result<$return_type:ty> { $($sql:tt)+ }) => {
215        $vis fn $id(&self) ->  $crate::anyhow::Result<$return_type>  {
216            use $crate::anyhow::Context;
217
218            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
219
220            self.select_row::<$return_type>(sql_stmt)?()
221                .context(::std::format!(
222                    "Error in {}, select_row_bound failed to execute or parse for: {}",
223                    ::std::stringify!($id),
224                    sql_stmt
225                ))?
226                .context(::std::format!(
227                    "Error in {}, select_row_bound expected single row result but found none for: {}",
228                    ::std::stringify!($id),
229                    sql_stmt
230                ))
231        }
232    };
233    ($vis:vis async fn $id:ident() ->  Result<$return_type:ty> { $($sql:tt)+ }) => {
234        $vis async fn $id(&self) ->  $crate::anyhow::Result<$return_type>  {
235            use $crate::anyhow::Context;
236
237            self.write(|connection| {
238                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
239
240                connection.select_row::<$return_type>(sql_stmt)?()
241                    .context(::std::format!(
242                        "Error in {}, select_row_bound failed to execute or parse for: {}",
243                        ::std::stringify!($id),
244                        sql_stmt
245                    ))?
246                    .context(::std::format!(
247                        "Error in {}, select_row_bound expected single row result but found none for: {}",
248                        ::std::stringify!($id),
249                        sql_stmt
250                    ))
251            }).await
252        }
253    };
254    ($vis:vis fn $id:ident($arg:ident: $arg_type:ty) ->  Result<$return_type:ty> { $($sql:tt)+ }) => {
255        pub fn $id(&self, $arg: $arg_type) ->  $crate::anyhow::Result<$return_type>  {
256            use $crate::anyhow::Context;
257
258            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
259
260            self.select_row_bound::<$arg_type, $return_type>(sql_stmt)?($arg)
261                .context(::std::format!(
262                    "Error in {}, select_row_bound failed to execute or parse for: {}",
263                    ::std::stringify!($id),
264                    sql_stmt
265                ))?
266                .context(::std::format!(
267                    "Error in {}, select_row_bound expected single row result but found none for: {}",
268                    ::std::stringify!($id),
269                    sql_stmt
270                ))
271        }
272    };
273    ($vis:vis fn $id:ident($($arg:ident: $arg_type:ty),+) ->  Result<$return_type:ty> { $($sql:tt)+ }) => {
274        $vis fn $id(&self, $($arg: $arg_type),+) ->  $crate::anyhow::Result<$return_type>  {
275            use $crate::anyhow::Context;
276
277            let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
278
279            self.select_row_bound::<($($arg_type),+), $return_type>(sql_stmt)?(($($arg),+))
280                .context(::std::format!(
281                    "Error in {}, select_row_bound failed to execute or parse for: {}",
282                    ::std::stringify!($id),
283                    sql_stmt
284                ))?
285                .context(::std::format!(
286                    "Error in {}, select_row_bound expected single row result but found none for: {}",
287                    ::std::stringify!($id),
288                    sql_stmt
289                ))
290        }
291    };
292    ($vis:vis fn async $id:ident($($arg:ident: $arg_type:ty),+) ->  Result<$return_type:ty> { $($sql:tt)+ }) => {
293        $vis async fn $id(&self, $($arg: $arg_type),+) ->  $crate::anyhow::Result<$return_type>  {
294            use $crate::anyhow::Context;
295
296
297            self.write(|connection| {
298                let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
299
300                connection.select_row_bound::<($($arg_type),+), $return_type>(sql_stmt)?(($($arg),+))
301                    .context(::std::format!(
302                        "Error in {}, select_row_bound failed to execute or parse for: {}",
303                        ::std::stringify!($id),
304                        sql_stmt
305                    ))?
306                    .context(::std::format!(
307                        "Error in {}, select_row_bound expected single row result but found none for: {}",
308                        ::std::stringify!($id),
309                        sql_stmt
310                    ))
311            }).await
312        }
313    };
314}
315