rbatis_plus_extension/service/
service_impl.rs1use super::i_service::IService;
4use async_trait::async_trait;
5use rbatis::executor::Executor;
6use rbatis::Error;
7use rbatis_plus_core::conditions::query::QueryWrapper;
8use rbatis_plus_core::conditions::update::UpdateWrapper;
9use rbatis_plus_core::page::Page;
10use serde::de::DeserializeOwned;
11use serde::Serialize;
12use std::marker::PhantomData;
13
14pub struct ServiceImpl<E, T>
43where
44 E: Executor + Send + Sync + Clone + 'static,
45 T: Serialize + DeserializeOwned + Send + Sync,
46{
47 executor: E,
49 table_name: String,
51 id_column: String,
53 _phantom: PhantomData<T>,
55}
56
57impl<E, T> ServiceImpl<E, T>
58where
59 E: Executor + Send + Sync + Clone + 'static,
60 T: Serialize + DeserializeOwned + Send + Sync,
61{
62 pub fn new(executor: E, table_name: impl Into<String>) -> Self {
68 Self {
69 executor,
70 table_name: table_name.into(),
71 id_column: "id".to_string(),
72 _phantom: PhantomData,
73 }
74 }
75
76 pub fn with_id_column(mut self, column: impl Into<String>) -> Self {
78 self.id_column = column.into();
79 self
80 }
81
82 pub fn table_name(&self) -> &str {
84 &self.table_name
85 }
86
87 pub fn id_column(&self) -> &str {
89 &self.id_column
90 }
91
92 pub fn executor(&self) -> &E {
94 &self.executor
95 }
96
97 fn extract_id(map: &rbs::Value, id_column: &str) -> rbs::Value {
99 if let rbs::Value::Map(m) = map {
100 for (k, v) in m {
101 if let rbs::Value::String(col_name) = k {
102 if col_name == id_column {
103 return v.clone();
104 }
105 }
106 }
107 }
108 rbs::Value::Null
109 }
110
111 fn decode_rows(value: rbs::Value) -> Result<Vec<T>, Error> {
113 match value {
114 rbs::Value::Array(arr) => {
115 let mut result = Vec::with_capacity(arr.len());
116 for item in arr {
117 let row: T = rbs::from_value(item)?;
118 result.push(row);
119 }
120 Ok(result)
121 }
122 _ => Ok(Vec::new()),
123 }
124 }
125
126 fn extract_count(value: &rbs::Value) -> u64 {
128 match value {
129 rbs::Value::Map(map) => {
130 for (_, v) in map {
131 match v {
132 rbs::Value::U64(n) => return *n,
133 rbs::Value::I64(n) => return *n as u64,
134 rbs::Value::U32(n) => return *n as u64,
135 rbs::Value::I32(n) => return *n as u64,
136 _ => {}
137 }
138 }
139 0
140 }
141 rbs::Value::U64(n) => *n,
142 rbs::Value::I64(n) => *n as u64,
143 _ => 0,
144 }
145 }
146}
147
148#[async_trait]
149impl<E, T> IService<T> for ServiceImpl<E, T>
150where
151 E: Executor + Send + Sync + Clone + 'static,
152 T: Serialize + DeserializeOwned + Send + Sync,
153{
154 async fn save(&self, entity: &T) -> Result<bool, Error> {
156 let map = rbs::to_value(entity)?;
157 let (cols, placeholders, values) = Self::build_insert_params(&map, &self.id_column);
158 let sql = format!(
159 "INSERT INTO {} ({}) VALUES ({})",
160 self.table_name, cols, placeholders
161 );
162 let result = self.executor.exec(&sql, values).await?;
163 Ok(result.rows_affected > 0)
164 }
165
166 async fn save_or_update(&self, entity: &T) -> Result<bool, Error> {
168 let map = rbs::to_value(entity)?;
169 let id = Self::extract_id(&map, &self.id_column);
170 if !matches!(id, rbs::Value::Null) {
171 let (set_clause, values) = Self::build_update_params(&map, &self.id_column);
172 let sql = format!(
173 "UPDATE {} SET {} WHERE {} = ?",
174 self.table_name, set_clause, self.id_column
175 );
176 let mut all_values = values;
177 all_values.push(id);
178 let result = self.executor.exec(&sql, all_values).await?;
179 if result.rows_affected > 0 {
180 return Ok(true);
181 }
182 }
183 self.save(entity).await
184 }
185
186 async fn remove_by_id(&self, id: &rbs::Value) -> Result<bool, Error> {
188 let sql = format!("DELETE FROM {} WHERE {} = ?", self.table_name, self.id_column);
189 let result = self.executor.exec(&sql, vec![id.clone()]).await?;
190 Ok(result.rows_affected > 0)
191 }
192
193 async fn remove(&self, wrapper: &QueryWrapper, table_name: &str) -> Result<bool, Error> {
195 let where_clause = wrapper.inner.build_where();
196 let sql = format!("DELETE FROM {}{}", table_name, where_clause);
197 let result = self.executor.exec(&sql, wrapper.params().to_vec()).await?;
198 Ok(result.rows_affected > 0)
199 }
200
201 async fn update_by_id(&self, entity: &T) -> Result<bool, Error> {
203 let map = rbs::to_value(entity)?;
204 let id = Self::extract_id(&map, &self.id_column);
205 let (set_clause, values) = Self::build_update_params(&map, &self.id_column);
206 let sql = format!(
207 "UPDATE {} SET {} WHERE {} = ?",
208 self.table_name, set_clause, self.id_column
209 );
210 let mut all_values = values;
211 all_values.push(id);
212 let result = self.executor.exec(&sql, all_values).await?;
213 Ok(result.rows_affected > 0)
214 }
215
216 async fn update(
218 &self,
219 wrapper: &UpdateWrapper,
220 table_name: &str,
221 ) -> Result<bool, Error> {
222 let sql = wrapper.build_update_sql(table_name);
223 let result = self.executor.exec(&sql, wrapper.params().to_vec()).await?;
224 Ok(result.rows_affected > 0)
225 }
226
227 async fn get_by_id(&self, id: &rbs::Value) -> Result<Option<T>, Error> {
229 let sql = format!(
230 "SELECT * FROM {} WHERE {} = ? LIMIT 1",
231 self.table_name, self.id_column
232 );
233 let value = self.executor.query(&sql, vec![id.clone()]).await?;
234 let rows = Self::decode_rows(value)?;
235 Ok(rows.into_iter().next())
236 }
237
238 async fn list(&self, wrapper: &QueryWrapper, table_name: &str) -> Result<Vec<T>, Error> {
240 let sql = wrapper.build_select_sql(table_name);
241 let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
242 Self::decode_rows(value)
243 }
244
245 async fn get_one(
247 &self,
248 wrapper: &QueryWrapper,
249 table_name: &str,
250 ) -> Result<Option<T>, Error> {
251 let sql = format!("{} LIMIT 1", wrapper.build_select_sql(table_name));
252 let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
253 let rows = Self::decode_rows(value)?;
254 Ok(rows.into_iter().next())
255 }
256
257 async fn count(&self, wrapper: &QueryWrapper, table_name: &str) -> Result<u64, Error> {
259 let sql = wrapper.build_count_sql(table_name);
260 let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
261 Ok(Self::extract_count(&value))
262 }
263
264 async fn page(
266 &self,
267 wrapper: &QueryWrapper,
268 table_name: &str,
269 page_no: u64,
270 page_size: u64,
271 ) -> Result<Page<T>, Error> {
272 let total = self.count(wrapper, table_name).await?;
274
275 let offset = (page_no - 1) * page_size;
277 let sql = format!(
278 "{} LIMIT {}, {}",
279 wrapper.build_select_sql(table_name),
280 offset,
281 page_size
282 );
283 let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
284 let records = Self::decode_rows(value)?;
285
286 Ok(Page::new(records, total, page_no, page_size))
287 }
288}
289
290impl<E, T> ServiceImpl<E, T>
291where
292 E: Executor + Send + Sync + Clone + 'static,
293 T: Serialize + DeserializeOwned + Send + Sync,
294{
295 fn build_insert_params(map: &rbs::Value, id_column: &str) -> (String, String, Vec<rbs::Value>) {
297 let mut cols = Vec::new();
298 let mut placeholders = Vec::new();
299 let mut values = Vec::new();
300
301 if let rbs::Value::Map(m) = map {
302 for (k, v) in m {
303 if let rbs::Value::String(col_name) = k {
304 if col_name == id_column && matches!(v, rbs::Value::Null) {
306 continue;
307 }
308 cols.push(col_name.clone());
309 placeholders.push("?".to_string());
310 values.push(v.clone());
311 }
312 }
313 }
314
315 (cols.join(", "), placeholders.join(", "), values)
316 }
317
318 fn build_update_params(map: &rbs::Value, id_column: &str) -> (String, Vec<rbs::Value>) {
320 let mut set_parts = Vec::new();
321 let mut values = Vec::new();
322
323 if let rbs::Value::Map(m) = map {
324 for (k, v) in m {
325 if let rbs::Value::String(col_name) = k {
326 if col_name == id_column {
327 continue; }
329 set_parts.push(format!("{} = ?", col_name));
330 values.push(v.clone());
331 }
332 }
333 }
334
335 (set_parts.join(", "), values)
336 }
337}