bmbp_rdbc_sql/dsl/
dsl_trait.rs

1use bmbp_rdbc_type::{RdbcIdent, RdbcValue};
2
3use crate::{QueryFilter, QueryWrapper, RdbcColumn, RdbcConcatType, RdbcTableInner};
4
5use super::RdbcTableJoinType;
6
7/// RdbcTableFilter query filter trait
8pub trait RdbcTableFilter {
9    fn init_filter(&mut self) -> &mut Self;
10    fn get_filter_mut(&mut self) -> &mut QueryFilter;
11    fn with_filter(&mut self, concat_type: RdbcConcatType) -> &mut Self;
12    fn add_filter(&mut self, filter: QueryFilter) -> &mut Self {
13        self.get_filter_mut().add_filter(filter);
14        self
15    }
16
17    fn and(&mut self) -> &mut Self {
18        self.with_filter(RdbcConcatType::And);
19        self
20    }
21    fn or(&mut self) -> &mut Self {
22        self.with_filter(RdbcConcatType::And);
23        self
24    }
25    fn eq_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
26    where
27        RdbcColumn: From<RC>,
28        RdbcValue: From<RV>,
29    {
30        self.get_filter_mut()
31            .eq_(RdbcColumn::from(column), RdbcValue::from(value));
32        self
33    }
34    fn eq_col<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
35    where
36        RdbcColumn: From<RC>,
37        RdbcColumn: From<RV>,
38    {
39        self.get_filter_mut()
40            .eq_column(RdbcColumn::from(column), RdbcColumn::from(value));
41        self
42    }
43
44    fn ne_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
45    where
46        RdbcColumn: From<RC>,
47        RdbcValue: From<RV>,
48    {
49        self.get_filter_mut()
50            .ne_(RdbcColumn::from(column), RdbcValue::from(value));
51        self
52    }
53    fn ne_col<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
54    where
55        RdbcColumn: From<RC>,
56        RdbcColumn: From<RV>,
57    {
58        self.get_filter_mut()
59            .ne_column(RdbcColumn::from(column), RdbcColumn::from(value));
60        self
61    }
62
63    fn ge_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
64    where
65        RdbcColumn: From<RC>,
66        RdbcValue: From<RV>,
67    {
68        self.get_filter_mut()
69            .ge_(RdbcColumn::from(column), RdbcValue::from(value));
70        self
71    }
72    fn ge_col<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
73    where
74        RdbcColumn: From<RC>,
75        RdbcColumn: From<RV>,
76    {
77        self.get_filter_mut()
78            .ge_column(RdbcColumn::from(column), RdbcColumn::from(value));
79        self
80    }
81    fn gt_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
82    where
83        RdbcColumn: From<RC>,
84        RdbcValue: From<RV>,
85    {
86        self.get_filter_mut()
87            .gt_(RdbcColumn::from(column), RdbcValue::from(value));
88        self
89    }
90    fn gt_col<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
91    where
92        RdbcColumn: From<RC>,
93        RdbcColumn: From<RV>,
94    {
95        self.get_filter_mut()
96            .gt_column(RdbcColumn::from(column), RdbcColumn::from(value));
97        self
98    }
99    fn le_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
100    where
101        RdbcColumn: From<RC>,
102        RdbcValue: From<RV>,
103    {
104        self.get_filter_mut()
105            .le_(RdbcColumn::from(column), RdbcValue::from(value));
106        self
107    }
108    fn le_col<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
109    where
110        RdbcColumn: From<RC>,
111        RdbcColumn: From<RV>,
112    {
113        self.get_filter_mut()
114            .le_column(RdbcColumn::from(column), RdbcColumn::from(value));
115        self
116    }
117
118    fn lt_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
119    where
120        RdbcColumn: From<RC>,
121        RdbcValue: From<RV>,
122    {
123        self.get_filter_mut()
124            .lt_(RdbcColumn::from(column), RdbcValue::from(value));
125        self
126    }
127    fn lt_col<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
128    where
129        RdbcColumn: From<RC>,
130        RdbcColumn: From<RV>,
131    {
132        self.get_filter_mut()
133            .lt_column(RdbcColumn::from(column), RdbcColumn::from(value));
134        self
135    }
136    fn like_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
137    where
138        RdbcColumn: From<RC>,
139        RdbcValue: From<RV>,
140    {
141        self.get_filter_mut()
142            .like_(RdbcColumn::from(column), RdbcValue::from(value));
143        self
144    }
145    fn like_left_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
146    where
147        RdbcColumn: From<RC>,
148        RdbcValue: From<RV>,
149    {
150        self.get_filter_mut()
151            .like_left_(RdbcColumn::from(column), RdbcValue::from(value));
152        self
153    }
154    fn like_right_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
155    where
156        RdbcColumn: From<RC>,
157        RdbcValue: From<RV>,
158    {
159        self.get_filter_mut()
160            .like_right_(RdbcColumn::from(column), RdbcValue::from(value));
161        self
162    }
163    fn not_like_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
164    where
165        RdbcColumn: From<RC>,
166        RdbcValue: From<RV>,
167    {
168        self.get_filter_mut()
169            .not_like_(RdbcColumn::from(column), RdbcValue::from(value));
170        self
171    }
172    fn not_like_left_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
173    where
174        RdbcColumn: From<RC>,
175        RdbcValue: From<RV>,
176    {
177        self.get_filter_mut()
178            .not_like_left_(RdbcColumn::from(column), RdbcValue::from(value));
179        self
180    }
181    fn not_like_right_<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
182    where
183        RdbcColumn: From<RC>,
184        RdbcValue: From<RV>,
185    {
186        self.get_filter_mut()
187            .not_like_right_(RdbcColumn::from(column), RdbcValue::from(value));
188        self
189    }
190    fn null_<RC>(&mut self, column: RC) -> &mut Self
191    where
192        RdbcColumn: From<RC>,
193    {
194        self.get_filter_mut().null_(RdbcColumn::from(column));
195        self
196    }
197    fn not_null_<RC>(&mut self, column: RC) -> &mut Self
198    where
199        RdbcColumn: From<RC>,
200    {
201        self.get_filter_mut().not_null_(RdbcColumn::from(column));
202        self
203    }
204    fn between_<RC, RVS, RVE>(&mut self, column: RC, value_start: RVS, value_end: RVE) -> &mut Self
205    where
206        RdbcColumn: From<RC>,
207        RdbcValue: From<RVS>,
208        RdbcValue: From<RVE>,
209    {
210        self.get_filter_mut().between_(
211            RdbcColumn::from(column),
212            RdbcValue::from(value_start),
213            RdbcValue::from(value_end),
214        );
215        self
216    }
217    fn not_between_<RC, RVS, RVE>(
218        &mut self,
219        column: RC,
220        value_start: RVS,
221        value_end: RVE,
222    ) -> &mut Self
223    where
224        RdbcColumn: From<RC>,
225        RdbcValue: From<RVS>,
226        RdbcValue: From<RVE>,
227    {
228        self.get_filter_mut().not_between_(
229            RdbcColumn::from(column),
230            RdbcValue::from(value_start),
231            RdbcValue::from(value_end),
232        );
233        self
234    }
235    fn in_v<RC, RV>(&mut self, column: RC, value: Vec<RV>) -> &mut Self
236    where
237        RdbcColumn: From<RC>,
238        RdbcValue: From<RV>,
239    {
240        let v_vec = value.into_iter().map(|v| RdbcValue::from(v)).collect();
241        self.get_filter_mut().in_v(RdbcColumn::from(column), v_vec);
242        self
243    }
244    fn in_v_slice<RC, RV>(&mut self, column: RC, value: &[RV]) -> &mut Self
245    where
246        RdbcColumn: From<RC>,
247        RdbcValue: From<RV>,
248        RV: Clone,
249    {
250        let v_vec = value
251            .into_iter()
252            .map(|v| RdbcValue::from(v.clone()))
253            .collect();
254        self.get_filter_mut().in_v(RdbcColumn::from(column), v_vec);
255        self
256    }
257    fn in_query<RC>(&mut self, column: RC, value: QueryWrapper) -> &mut Self
258    where
259        RdbcColumn: From<RC>,
260    {
261        self.get_filter_mut()
262            .in_query(RdbcColumn::from(column), value);
263        self
264    }
265    fn not_in_v<RC, RV>(&mut self, column: RC, value: Vec<RV>) -> &mut Self
266    where
267        RdbcColumn: From<RC>,
268        RdbcValue: From<RV>,
269    {
270        let v_vec = value.into_iter().map(|v| RdbcValue::from(v)).collect();
271        self.get_filter_mut()
272            .not_in_v(RdbcColumn::from(column), v_vec);
273        self
274    }
275    fn not_in_v_slice<RC, RV>(&mut self, column: RC, value: &[RV]) -> &mut Self
276    where
277        RdbcColumn: From<RC>,
278        RdbcValue: From<RV>,
279        RV: Clone,
280    {
281        let v_vec = value
282            .into_iter()
283            .map(|v| RdbcValue::from(v.clone()))
284            .collect();
285        self.get_filter_mut()
286            .not_in_v(RdbcColumn::from(column), v_vec);
287        self
288    }
289
290    fn not_in_query<RC>(&mut self, column: RC, value: QueryWrapper) -> &mut Self
291    where
292        RdbcColumn: From<RC>,
293    {
294        self.get_filter_mut()
295            .not_in_query(RdbcColumn::from(column), value);
296        self
297    }
298
299    fn exists_<RC>(&mut self, column: RC, value: QueryWrapper) -> &mut Self
300    where
301        RdbcColumn: From<RC>,
302    {
303        self.get_filter_mut()
304            .exists_(RdbcColumn::from(column), value);
305        self
306    }
307    fn not_exists_<RC>(&mut self, column: RC, value: QueryWrapper) -> &mut Self
308    where
309        RdbcColumn: From<RC>,
310    {
311        self.get_filter_mut()
312            .not_exists_(RdbcColumn::from(column), value);
313        self
314    }
315}
316
317pub trait RdbcTableWrapper {
318    fn get_table_mut(&mut self) -> &mut Vec<RdbcTableInner>;
319    fn get_join_mut(&mut self) -> &mut Vec<RdbcTableInner>;
320    fn table<ST>(&mut self, table: ST) -> &mut Self
321    where
322        ST: RdbcIdent,
323    {
324        self.get_table_mut()
325            .push(RdbcTableInner::table(table.get_ident()));
326        self
327    }
328    fn table_alias<ST, SA>(&mut self, table: ST, alias: SA) -> &mut Self
329    where
330        ST: RdbcIdent,
331        SA: RdbcIdent,
332    {
333        self.get_table_mut().push(RdbcTableInner::table_alias(
334            table.get_ident(),
335            alias.get_ident(),
336        ));
337        self
338    }
339    fn schema_table<TS, TT>(&mut self, schema: TS, table: TT) -> &mut Self
340    where
341        TS: RdbcIdent,
342        TT: RdbcIdent,
343    {
344        self.get_table_mut().push(RdbcTableInner::schema_table(
345            schema.get_ident(),
346            table.get_ident(),
347        ));
348        self
349    }
350    fn schema_table_alias<SS, ST, SA>(&mut self, schema: SS, table: ST, alias: SA) -> &mut Self
351    where
352        SS: RdbcIdent,
353        ST: RdbcIdent,
354        SA: RdbcIdent,
355    {
356        self.get_table_mut()
357            .push(RdbcTableInner::schema_table_alias(
358                schema.get_ident(),
359                table.get_ident(),
360                alias.get_ident(),
361            ));
362        self
363    }
364    fn temp_table(&mut self, table: QueryWrapper) -> &mut Self {
365        self.get_table_mut().push(RdbcTableInner::temp_table(table));
366        self
367    }
368    fn temp_table_alias<T>(&mut self, table: QueryWrapper, alias: T) -> &mut Self
369    where
370        T: RdbcIdent,
371    {
372        self.get_table_mut()
373            .push(RdbcTableInner::temp_table_alias(table, alias.get_ident()));
374        self
375    }
376    fn rdbc_table<T>(&mut self, table: T) -> &mut Self
377    where
378        RdbcTableInner: From<T>,
379    {
380        self.get_table_mut().push(RdbcTableInner::from(table));
381        self
382    }
383
384    fn join_table<T>(&mut self, table: T) -> &mut Self
385    where
386        T: RdbcIdent,
387    {
388        self.get_join_mut()
389            .push(RdbcTableInner::table(table.get_ident()));
390        self
391    }
392    fn join_table_alias<TS, TA>(&mut self, table: TS, alias: TA) -> &mut Self
393    where
394        TS: RdbcIdent,
395        TA: RdbcIdent,
396    {
397        self.get_join_mut().push(RdbcTableInner::table_alias(
398            table.get_ident(),
399            alias.get_ident(),
400        ));
401        self
402    }
403    fn join_schema_table<SS, ST>(&mut self, schema: SS, table: ST) -> &mut Self
404    where
405        SS: RdbcIdent,
406        ST: RdbcIdent,
407    {
408        self.get_join_mut().push(RdbcTableInner::schema_table(
409            schema.get_ident(),
410            table.get_ident(),
411        ));
412        self
413    }
414    fn join_schema_table_alias<SS, ST, SA>(&mut self, schema: SS, table: ST, alias: SA) -> &mut Self
415    where
416        SS: RdbcIdent,
417        ST: RdbcIdent,
418        SA: RdbcIdent,
419    {
420        self.get_join_mut().push(RdbcTableInner::schema_table_alias(
421            schema.get_ident(),
422            table.get_ident(),
423            alias.get_ident(),
424        ));
425        self
426    }
427
428    fn join_temp_table(&mut self, table: QueryWrapper) -> &mut Self {
429        self.get_join_mut().push(RdbcTableInner::temp_table(table));
430        self
431    }
432    fn join_temp_table_alias<T>(&mut self, table: QueryWrapper, alias: T) -> &mut Self
433    where
434        T: RdbcIdent,
435    {
436        self.get_join_mut()
437            .push(RdbcTableInner::temp_table_alias(table, alias.get_ident()));
438        self
439    }
440    fn join_rdbc_table(&mut self, table: RdbcTableInner) -> &mut Self {
441        self.get_join_mut().push(table);
442        self
443    }
444    fn left_join_table<T>(&mut self, table: T) -> &mut Self
445    where
446        T: RdbcIdent,
447    {
448        self.get_join_mut().push(RdbcTableInner::join_table(
449            table.get_ident(),
450            RdbcTableJoinType::Left,
451        ));
452        self
453    }
454    fn left_join_table_alias<T, A>(&mut self, table: T, alias: A) -> &mut Self
455    where
456        T: RdbcIdent,
457        A: RdbcIdent,
458    {
459        self.get_join_mut().push(RdbcTableInner::join_table_alias(
460            table.get_ident(),
461            alias.get_ident(),
462            RdbcTableJoinType::Left,
463        ));
464        self
465    }
466    fn left_join_schema_table<S, T>(&mut self, schema: S, table: T) -> &mut Self
467    where
468        S: RdbcIdent,
469        T: RdbcIdent,
470    {
471        self.get_join_mut().push(RdbcTableInner::join_schema_table(
472            schema.get_ident(),
473            table.get_ident(),
474            RdbcTableJoinType::Left,
475        ));
476        self
477    }
478
479    fn left_join_schema_table_alias<S, T, A>(&mut self, schema: S, table: T, alias: A) -> &mut Self
480    where
481        S: RdbcIdent,
482        T: RdbcIdent,
483        A: RdbcIdent,
484    {
485        self.get_join_mut()
486            .push(RdbcTableInner::join_schema_table_alias(
487                schema.get_ident(),
488                table.get_ident(),
489                alias.get_ident(),
490                RdbcTableJoinType::Left,
491            ));
492        self
493    }
494    fn left_join_temp_table(&mut self, table: QueryWrapper) -> &mut Self {
495        self.get_join_mut().push(RdbcTableInner::join_temp_table(
496            table,
497            RdbcTableJoinType::Left,
498        ));
499        self
500    }
501    fn left_join_temp_table_alias<T>(&mut self, table: QueryWrapper, alias: T) -> &mut Self
502    where
503        T: RdbcIdent,
504    {
505        self.get_join_mut()
506            .push(RdbcTableInner::join_temp_table_alias(
507                table,
508                alias.get_ident(),
509                RdbcTableJoinType::Left,
510            ));
511        self
512    }
513
514    fn right_join_table<T>(&mut self, table: T) -> &mut Self
515    where
516        T: RdbcIdent,
517    {
518        self.get_join_mut().push(RdbcTableInner::join_table(
519            table.get_ident(),
520            RdbcTableJoinType::Right,
521        ));
522        self
523    }
524    fn right_join_table_alias<T, A>(&mut self, table: T, alias: A) -> &mut Self
525    where
526        T: RdbcIdent,
527        A: RdbcIdent,
528    {
529        self.get_join_mut().push(RdbcTableInner::join_table_alias(
530            table.get_ident(),
531            alias.get_ident(),
532            RdbcTableJoinType::Right,
533        ));
534        self
535    }
536    fn right_join_schema_table<S, T>(&mut self, schema: S, table: T) -> &mut Self
537    where
538        S: RdbcIdent,
539        T: RdbcIdent,
540    {
541        self.get_join_mut().push(RdbcTableInner::join_schema_table(
542            schema.get_ident(),
543            table.get_ident(),
544            RdbcTableJoinType::Right,
545        ));
546        self
547    }
548
549    fn right_join_schema_table_alias<S, T, A>(&mut self, schema: S, table: T, alias: A) -> &mut Self
550    where
551        S: RdbcIdent,
552        T: RdbcIdent,
553        A: RdbcIdent,
554    {
555        self.get_join_mut()
556            .push(RdbcTableInner::join_schema_table_alias(
557                schema.get_ident(),
558                table.get_ident(),
559                alias.get_ident(),
560                RdbcTableJoinType::Right,
561            ));
562        self
563    }
564    fn right_join_temp_table(&mut self, table: QueryWrapper) -> &mut Self {
565        self.get_join_mut().push(RdbcTableInner::join_temp_table(
566            table,
567            RdbcTableJoinType::Right,
568        ));
569        self
570    }
571    fn right_join_temp_table_alias<T>(&mut self, table: QueryWrapper, alias: T) -> &mut Self
572    where
573        T: RdbcIdent,
574    {
575        self.get_join_mut()
576            .push(RdbcTableInner::join_temp_table_alias(
577                table,
578                alias.get_ident(),
579                RdbcTableJoinType::Right,
580            ));
581        self
582    }
583
584    fn full_join_table<T>(&mut self, table: T) -> &mut Self
585    where
586        T: RdbcIdent,
587    {
588        self.get_join_mut().push(RdbcTableInner::join_table(
589            table.get_ident(),
590            RdbcTableJoinType::Full,
591        ));
592        self
593    }
594    fn full_join_table_alias<T, A>(&mut self, table: T, alias: A) -> &mut Self
595    where
596        T: RdbcIdent,
597        A: RdbcIdent,
598    {
599        self.get_join_mut().push(RdbcTableInner::join_table_alias(
600            table.get_ident(),
601            alias.get_ident(),
602            RdbcTableJoinType::Full,
603        ));
604        self
605    }
606    fn full_join_schema_table<S, T>(&mut self, schema: S, table: T) -> &mut Self
607    where
608        S: RdbcIdent,
609        T: RdbcIdent,
610    {
611        self.get_join_mut().push(RdbcTableInner::join_schema_table(
612            schema.get_ident(),
613            table.get_ident(),
614            RdbcTableJoinType::Full,
615        ));
616        self
617    }
618
619    fn full_join_schema_table_alias<S, T, A>(&mut self, schema: S, table: T, alias: A) -> &mut Self
620    where
621        S: RdbcIdent,
622        T: RdbcIdent,
623        A: RdbcIdent,
624    {
625        self.get_join_mut()
626            .push(RdbcTableInner::join_schema_table_alias(
627                schema.get_ident(),
628                table.get_ident(),
629                alias.get_ident(),
630                RdbcTableJoinType::Full,
631            ));
632        self
633    }
634    fn full_join_temp_table(&mut self, table: QueryWrapper) -> &mut Self {
635        self.get_join_mut().push(RdbcTableInner::join_temp_table(
636            table,
637            RdbcTableJoinType::Full,
638        ));
639        self
640    }
641    fn full_join_temp_table_alias<T>(&mut self, table: QueryWrapper, alias: T) -> &mut Self
642    where
643        T: RdbcIdent,
644    {
645        self.get_join_mut()
646            .push(RdbcTableInner::join_temp_table_alias(
647                table,
648                alias.get_ident(),
649                RdbcTableJoinType::Full,
650            ));
651        self
652    }
653
654    fn inner_join_table<T>(&mut self, table: T) -> &mut Self
655    where
656        T: RdbcIdent,
657    {
658        self.get_join_mut().push(RdbcTableInner::join_table(
659            table.get_ident(),
660            RdbcTableJoinType::Inner,
661        ));
662        self
663    }
664    fn inner_join_table_alias<T, A>(&mut self, table: T, alias: A) -> &mut Self
665    where
666        T: RdbcIdent,
667        A: RdbcIdent,
668    {
669        self.get_join_mut().push(RdbcTableInner::join_table_alias(
670            table.get_ident(),
671            alias.get_ident(),
672            RdbcTableJoinType::Inner,
673        ));
674        self
675    }
676    fn inner_join_schema_table<S, T>(&mut self, schema: S, table: T) -> &mut Self
677    where
678        S: RdbcIdent,
679        T: RdbcIdent,
680    {
681        self.get_join_mut().push(RdbcTableInner::join_schema_table(
682            schema.get_ident(),
683            table.get_ident(),
684            RdbcTableJoinType::Inner,
685        ));
686        self
687    }
688
689    fn inner_join_schema_table_alias<S, T, A>(&mut self, schema: S, table: T, alias: A) -> &mut Self
690    where
691        S: RdbcIdent,
692        T: RdbcIdent,
693        A: RdbcIdent,
694    {
695        self.get_join_mut()
696            .push(RdbcTableInner::join_schema_table_alias(
697                schema.get_ident(),
698                table.get_ident(),
699                alias.get_ident(),
700                RdbcTableJoinType::Inner,
701            ));
702        self
703    }
704    fn inner_join_temp_table(&mut self, table: QueryWrapper) -> &mut Self {
705        self.get_join_mut().push(RdbcTableInner::join_temp_table(
706            table,
707            RdbcTableJoinType::Inner,
708        ));
709        self
710    }
711    fn inner_join_temp_table_alias<T>(&mut self, table: QueryWrapper, alias: T) -> &mut Self
712    where
713        T: RdbcIdent,
714    {
715        self.get_join_mut()
716            .push(RdbcTableInner::join_temp_table_alias(
717                table,
718                alias.get_ident(),
719                RdbcTableJoinType::Inner,
720            ));
721        self
722    }
723
724    fn on(&mut self) -> &mut QueryFilter {
725        let join_vec = self.get_join_mut();
726        let len = join_vec.len();
727        let join_table = join_vec.get_mut(len - 1).unwrap();
728        join_table.get_filter_mut()
729    }
730}
bmbp_rdbc_sql/dsl/dsl_trait.rs

bmbp_rdbc_sql/dsl/
dsl_trait.rs
