bmbp_rdbc_sql/dsl/
dsl_model.rs

1use bmbp_rdbc_type::{RdbcIdent, RdbcValue};
2use std::collections::HashMap;
3
4use crate::{QueryWrapper, RdbcFunc};
5
6/// RdbcColumn SELECT 返回列
7
8pub enum RdbcColumn {
9    Table(RdbcTableColumn),
10    Query(RdbcQueryColumn),
11    Func(RdbcFuncColumn),
12    Value(RdbcValueColumn),
13}
14
15impl RdbcColumn {
16    pub fn is_value(&self) -> bool {
17        match self {
18            RdbcColumn::Value(_) => true,
19            _ => false,
20        }
21    }
22
23    pub fn get_value(&self) -> Option<&RdbcValue> {
24        match self {
25            RdbcColumn::Value(column) => Some(column.get_name()),
26            _ => None,
27        }
28    }
29    pub fn is_query(&self) -> bool {
30        match self {
31            RdbcColumn::Query(_) => true,
32            _ => false,
33        }
34    }
35    pub fn get_query(&self) -> Option<&QueryWrapper> {
36        match self {
37            RdbcColumn::Query(column) => Some(column.get_name()),
38            _ => None,
39        }
40    }
41}
42
43impl From<RdbcTableColumn> for RdbcColumn {
44    fn from(column: RdbcTableColumn) -> Self {
45        RdbcColumn::Table(column)
46    }
47}
48
49impl From<RdbcQueryColumn> for RdbcColumn {
50    fn from(column: RdbcQueryColumn) -> Self {
51        RdbcColumn::Query(column)
52    }
53}
54
55impl From<RdbcFuncColumn> for RdbcColumn {
56    fn from(column: RdbcFuncColumn) -> Self {
57        RdbcColumn::Func(column)
58    }
59}
60
61impl From<RdbcValueColumn> for RdbcColumn {
62    fn from(column: RdbcValueColumn) -> Self {
63        RdbcColumn::Value(column)
64    }
65}
66
67/// impl RdbcIdent impl RdbcColumn
68impl<T> From<T> for RdbcColumn
69where
70    T: RdbcIdent,
71{
72    fn from(value: T) -> Self {
73        RdbcColumn::Table(RdbcTableColumn::column(value.get_ident()))
74    }
75}
76
77impl RdbcColumn {
78    pub fn column<T>(name: T) -> RdbcColumn
79    where
80        T: ToString,
81    {
82        RdbcColumn::Table(RdbcTableColumn::column(name))
83    }
84    pub fn column_as_alias<T, E>(name: T, alias: E) -> RdbcColumn
85    where
86        T: ToString,
87        E: ToString,
88    {
89        RdbcColumn::Table(RdbcTableColumn::column_as_alias(name, alias))
90    }
91    pub fn table_column<T, C>(table: T, name: C) -> RdbcColumn
92    where
93        T: ToString,
94        C: ToString,
95    {
96        RdbcColumn::Table(RdbcTableColumn::table_column(table, name))
97    }
98    pub fn table_column_as_alias<ST, SC, SA>(table: ST, column: SC, alias: SA) -> RdbcColumn
99    where
100        ST: ToString,
101        SC: ToString,
102        SA: ToString,
103    {
104        RdbcColumn::Table(RdbcTableColumn::table_column_as_alias(table, column, alias))
105    }
106
107    pub fn schema_table_column<S, T, C>(schema: S, table: T, name: C) -> RdbcColumn
108    where
109        S: ToString,
110        T: ToString,
111        C: ToString,
112    {
113        RdbcColumn::Table(RdbcTableColumn::schema_table_column(schema, table, name))
114    }
115    pub fn schema_table_column_as_alias<S, T, C, A>(
116        schema: S,
117        table: T,
118        name: C,
119        alias: A,
120    ) -> RdbcColumn
121    where
122        S: ToString,
123        T: ToString,
124        C: ToString,
125        A: ToString,
126    {
127        RdbcColumn::Table(RdbcTableColumn::schema_table_column_as_alias(
128            schema, table, name, alias,
129        ))
130    }
131    pub fn rdbc_value(value: RdbcValue) -> RdbcColumn {
132        RdbcColumn::Value(RdbcValueColumn::rdbc_value(value))
133    }
134
135    pub fn rdbc_value_alias<T>(value: RdbcValue, alias: T) -> RdbcColumn
136    where
137        T: ToString,
138    {
139        RdbcColumn::Value(RdbcValueColumn::rdbc_value_alias(value, alias))
140    }
141    pub fn raw_value<T>(value: T) -> RdbcColumn
142    where
143        T: ToString,
144    {
145        RdbcColumn::Value(RdbcValueColumn::raw_value(value))
146    }
147    pub fn raw_value_alias<T>(value: T, alias: T) -> RdbcColumn
148    where
149        T: ToString,
150    {
151        RdbcColumn::Value(RdbcValueColumn::raw_value_alias(value, alias))
152    }
153
154    pub fn string_value<T>(value: T) -> RdbcColumn
155    where
156        T: ToString,
157    {
158        RdbcColumn::Value(RdbcValueColumn::string_value(value))
159    }
160    pub fn string_value_alias<T>(value: T, alias: T) -> RdbcColumn
161    where
162        T: ToString,
163    {
164        RdbcColumn::Value(RdbcValueColumn::string_value_alias(value, alias))
165    }
166    pub fn query(query: QueryWrapper) -> RdbcColumn {
167        RdbcColumn::Query(RdbcQueryColumn::query(query))
168    }
169    pub fn query_alias<T>(query: QueryWrapper, alias: T) -> RdbcColumn
170    where
171        T: ToString,
172    {
173        RdbcColumn::Query(RdbcQueryColumn::query_alias(query, alias))
174    }
175
176    pub fn concat_split(columns: Vec<RdbcColumn>, split_: Option<String>) -> RdbcColumn {
177        RdbcColumn::Func(RdbcFuncColumn::concat_split(columns, split_))
178    }
179    pub fn concat(columns: Vec<RdbcColumn>) -> RdbcColumn {
180        RdbcColumn::Func(RdbcFuncColumn::concat(columns))
181    }
182    pub fn replace<C, OV, NV>(column: C, old_value: OV, new_value: NV) -> RdbcColumn
183    where
184        RdbcTableColumn: From<C>,
185        OV: ToString,
186        NV: ToString,
187    {
188        RdbcColumn::Func(RdbcFuncColumn::replace(
189            RdbcTableColumn::from(column),
190            old_value.to_string(),
191            new_value.to_string(),
192        ))
193    }
194}
195
196pub struct RdbcTableColumn {
197    schema_: Option<String>,
198    table_: Option<String>,
199    name_: String,
200    alias_: Option<String>,
201}
202
203impl RdbcTableColumn {
204    pub fn get_schema(&self) -> Option<&String> {
205        self.schema_.as_ref()
206    }
207    pub fn get_table(&self) -> Option<&String> {
208        self.table_.as_ref()
209    }
210    pub fn get_name(&self) -> &String {
211        &self.name_
212    }
213    pub fn get_alias(&self) -> Option<&String> {
214        self.alias_.as_ref()
215    }
216}
217
218impl RdbcTableColumn {
219    fn column<T>(name: T) -> RdbcTableColumn
220    where
221        T: ToString,
222    {
223        RdbcTableColumn {
224            schema_: None,
225            table_: None,
226            name_: name.to_string(),
227            alias_: None,
228        }
229    }
230    fn column_as_alias<T, E>(name: T, alias: E) -> RdbcTableColumn
231    where
232        T: ToString,
233        E: ToString,
234    {
235        RdbcTableColumn {
236            schema_: None,
237            table_: None,
238            name_: name.to_string(),
239            alias_: Some(alias.to_string()),
240        }
241    }
242    fn table_column<T, C>(table: T, name: C) -> RdbcTableColumn
243    where
244        T: ToString,
245        C: ToString,
246    {
247        RdbcTableColumn {
248            schema_: None,
249            table_: Some(table.to_string()),
250            name_: name.to_string(),
251            alias_: None,
252        }
253    }
254    fn table_column_as_alias<ST, SC, SA>(table: ST, name: SC, alias: SA) -> RdbcTableColumn
255    where
256        ST: ToString,
257        SC: ToString,
258        SA: ToString,
259    {
260        RdbcTableColumn {
261            schema_: None,
262            table_: Some(table.to_string()),
263            name_: name.to_string(),
264            alias_: Some(alias.to_string()),
265        }
266    }
267    fn schema_table_column<S, T, C>(schema: S, table: T, name: C) -> RdbcTableColumn
268    where
269        S: ToString,
270        T: ToString,
271        C: ToString,
272    {
273        RdbcTableColumn {
274            schema_: Some(schema.to_string()),
275            table_: Some(table.to_string()),
276            name_: name.to_string(),
277            alias_: None,
278        }
279    }
280    fn schema_table_column_as_alias<S, T, C, A>(
281        schema: S,
282        table: T,
283        name: C,
284        alias: A,
285    ) -> RdbcTableColumn
286    where
287        S: ToString,
288        T: ToString,
289        C: ToString,
290        A: ToString,
291    {
292        RdbcTableColumn {
293            schema_: Some(schema.to_string()),
294            table_: Some(table.to_string()),
295            name_: name.to_string(),
296            alias_: Some(alias.to_string()),
297        }
298    }
299}
300
301impl<T> From<T> for RdbcTableColumn
302where
303    T: ToString,
304{
305    fn from(value: T) -> Self {
306        RdbcTableColumn::column(value)
307    }
308}
309
310pub struct RdbcValueColumn {
311    name_: RdbcValue,
312    alias_: Option<String>,
313}
314
315impl RdbcValueColumn {
316    pub fn get_name(&self) -> &RdbcValue {
317        &self.name_
318    }
319    pub fn get_alias(&self) -> Option<&String> {
320        self.alias_.as_ref()
321    }
322}
323
324impl RdbcValueColumn {
325    pub fn rdbc_value(value: RdbcValue) -> RdbcValueColumn {
326        RdbcValueColumn {
327            name_: value,
328            alias_: None,
329        }
330    }
331    pub fn rdbc_value_alias<T>(value: RdbcValue, alias: T) -> RdbcValueColumn
332    where
333        T: ToString,
334    {
335        RdbcValueColumn {
336            name_: value,
337            alias_: Some(alias.to_string()),
338        }
339    }
340    fn raw_value<T>(value: T) -> RdbcValueColumn
341    where
342        T: ToString,
343    {
344        RdbcValueColumn {
345            name_: RdbcValue::String(value.to_string()),
346            alias_: None,
347        }
348    }
349    fn raw_value_alias<T>(value: T, alias: T) -> RdbcValueColumn
350    where
351        T: ToString,
352    {
353        RdbcValueColumn {
354            name_: RdbcValue::String(value.to_string()),
355            alias_: Some(alias.to_string()),
356        }
357    }
358
359    fn string_value<T>(value: T) -> RdbcValueColumn
360    where
361        T: ToString,
362    {
363        RdbcValueColumn {
364            name_: RdbcValue::String(format!("'{}'", value.to_string())),
365            alias_: None,
366        }
367    }
368    fn string_value_alias<T>(value: T, alias: T) -> RdbcValueColumn
369    where
370        T: ToString,
371    {
372        RdbcValueColumn {
373            name_: RdbcValue::String(format!("'{}'", value.to_string())),
374            alias_: Some(alias.to_string()),
375        }
376    }
377}
378
379pub struct RdbcFuncColumn {
380    columns_: RdbcFunc,
381    alias_: Option<String>,
382}
383
384impl RdbcFuncColumn {
385    pub fn get_name(&self) -> &RdbcFunc {
386        &self.columns_
387    }
388    pub fn get_alias(&self) -> Option<&String> {
389        self.alias_.as_ref()
390    }
391}
392
393impl RdbcFuncColumn {
394    fn concat_split(columns: Vec<RdbcColumn>, split_: Option<String>) -> RdbcFuncColumn {
395        RdbcFuncColumn {
396            columns_: RdbcFunc::concat_split(columns, split_),
397            alias_: None,
398        }
399    }
400    fn concat(columns: Vec<RdbcColumn>) -> RdbcFuncColumn {
401        RdbcFuncColumn {
402            columns_: RdbcFunc::concat(columns),
403            alias_: None,
404        }
405    }
406    fn replace(column: RdbcTableColumn, old_value: String, new_value: String) -> RdbcFuncColumn {
407        RdbcFuncColumn {
408            columns_: RdbcFunc::replace(column, old_value, new_value),
409            alias_: None,
410        }
411    }
412}
413
414pub struct RdbcQueryColumn {
415    name_: QueryWrapper,
416    alias_: Option<String>,
417}
418
419impl RdbcQueryColumn {
420    pub fn get_name(&self) -> &QueryWrapper {
421        &self.name_
422    }
423    pub fn get_alias(&self) -> Option<&String> {
424        self.alias_.as_ref()
425    }
426}
427
428impl RdbcQueryColumn {
429    fn query(query: QueryWrapper) -> RdbcQueryColumn {
430        RdbcQueryColumn {
431            name_: query,
432            alias_: None,
433        }
434    }
435    fn query_alias<T>(query: QueryWrapper, alias: T) -> RdbcQueryColumn
436    where
437        T: ToString,
438    {
439        RdbcQueryColumn {
440            name_: query,
441            alias_: Some(alias.to_string()),
442        }
443    }
444}
445
446pub enum RdbcTableInner {
447    Table(RdbcSchemaTable),
448    Query(RdbcQueryTable),
449}
450
451impl RdbcTableInner {
452    pub fn get_join(&self) -> Option<&RdbcTableJoinType> {
453        match self {
454            RdbcTableInner::Table(table) => table.get_join(),
455            RdbcTableInner::Query(query) => query.get_join(),
456        }
457    }
458    pub fn get_filter(&self) -> Option<&QueryFilter> {
459        match self {
460            RdbcTableInner::Table(table) => table.get_filter(),
461            RdbcTableInner::Query(query) => query.get_filter(),
462        }
463    }
464    pub fn get_filter_mut(&mut self) -> &mut QueryFilter {
465        match self {
466            RdbcTableInner::Table(table) => table.get_filter_mut(),
467            RdbcTableInner::Query(query) => query.get_filter_mut(),
468        }
469    }
470    pub fn set_filter(&mut self, filter: QueryFilter) -> &mut Self {
471        let _ = match self {
472            RdbcTableInner::Table(table) => {
473                let _ = table.set_filter(filter);
474            }
475            RdbcTableInner::Query(query) => {
476                let _ = query.set_filter(filter);
477            }
478        };
479        self
480    }
481}
482
483impl RdbcTableInner {
484    pub(crate) fn table<T>(table: T) -> RdbcTableInner
485    where
486        T: ToString,
487    {
488        RdbcTableInner::Table(RdbcSchemaTable::table(table))
489    }
490    pub fn table_alias<T, V>(table: T, alias: V) -> RdbcTableInner
491    where
492        T: ToString,
493        V: ToString,
494    {
495        RdbcTableInner::Table(RdbcSchemaTable::table_alias(table, alias))
496    }
497    pub fn schema_table<T>(schema: T, table: T) -> RdbcTableInner
498    where
499        T: ToString,
500    {
501        RdbcTableInner::Table(RdbcSchemaTable::schema_table(schema, table))
502    }
503    pub fn schema_table_alias<SS, ST, SA>(schema: SS, table: ST, alias: SA) -> RdbcTableInner
504    where
505        SS: ToString,
506        ST: ToString,
507        SA: ToString,
508    {
509        RdbcTableInner::Table(RdbcSchemaTable::schema_table_alias(schema, table, alias))
510    }
511
512    pub fn temp_table(table: QueryWrapper) -> RdbcTableInner {
513        RdbcTableInner::Query(RdbcQueryTable::query(table))
514    }
515    pub fn temp_table_alias<T>(table: QueryWrapper, alias: T) -> RdbcTableInner
516    where
517        T: ToString,
518    {
519        RdbcTableInner::Query(RdbcQueryTable::query_alias(table, alias))
520    }
521    pub fn join_table<T>(table: T, left: RdbcTableJoinType) -> RdbcTableInner
522    where
523        T: ToString,
524    {
525        RdbcTableInner::Table(RdbcSchemaTable::join_table(table, left))
526    }
527    pub fn join_table_alias<T, A>(table: T, alias: A, left: RdbcTableJoinType) -> RdbcTableInner
528    where
529        T: ToString,
530        A: ToString,
531    {
532        RdbcTableInner::Table(RdbcSchemaTable::join_table_alias(table, alias, left))
533    }
534    pub fn join_schema_table<S, T>(schema: S, table: T, left: RdbcTableJoinType) -> RdbcTableInner
535    where
536        S: ToString,
537        T: ToString,
538    {
539        RdbcTableInner::Table(RdbcSchemaTable::join_schema_table(schema, table, left))
540    }
541    pub fn join_schema_table_alias<S, T, A>(
542        schema: S,
543        table: T,
544        alias: A,
545        left: RdbcTableJoinType,
546    ) -> RdbcTableInner
547    where
548        S: ToString,
549        T: ToString,
550        A: ToString,
551    {
552        RdbcTableInner::Table(RdbcSchemaTable::join_schema_table_alias(
553            schema, table, alias, left,
554        ))
555    }
556    pub(crate) fn join_temp_table(
557        table: QueryWrapper,
558        join_type: RdbcTableJoinType,
559    ) -> RdbcTableInner {
560        RdbcTableInner::Query(RdbcQueryTable::join_table(table, join_type))
561    }
562    pub(crate) fn join_temp_table_alias<SA>(
563        table: QueryWrapper,
564        alias: SA,
565        join_type: RdbcTableJoinType,
566    ) -> RdbcTableInner
567    where
568        SA: ToString,
569    {
570        RdbcTableInner::Query(RdbcQueryTable::join_table_alias(table, alias, join_type))
571    }
572}
573
574impl RdbcTableInner {
575    pub fn or(&mut self) -> &mut Self {
576        match self {
577            RdbcTableInner::Table(ref mut table) => {
578                table.or();
579            }
580            RdbcTableInner::Query(ref mut table) => {
581                table.or();
582            }
583        }
584        self
585    }
586
587    pub fn on_eq<T, V, E, F>(&mut self, t1: T, c1: V, t2: E, c2: F) -> &mut Self
588    where
589        T: ToString,
590        E: ToString,
591        V: ToString,
592        F: ToString,
593    {
594        match self {
595            RdbcTableInner::Table(ref mut table) => {
596                table.eq_column(simple_column(t1, c1), simple_column(t2, c2));
597            }
598            RdbcTableInner::Query(ref mut table) => {
599                table.eq_column(simple_column(t1, c1), simple_column(t2, c2));
600            }
601        }
602        self
603    }
604
605    pub fn on_eq_col<RT, RC>(&mut self, column1: RT, column2: RC) -> &mut Self
606    where
607        RdbcColumn: From<RT>,
608        RdbcColumn: From<RC>,
609    {
610        match self {
611            RdbcTableInner::Table(ref mut table) => {
612                table.eq_column(RdbcColumn::from(column1), RdbcColumn::from(column2));
613            }
614            RdbcTableInner::Query(ref mut table) => {
615                table.eq_column(RdbcColumn::from(column1), RdbcColumn::from(column2));
616            }
617        }
618        self
619    }
620}
621
622pub enum RdbcTableJoinType {
623    Left,
624    Right,
625    Inner,
626    Full,
627}
628
629pub struct RdbcSchemaTable {
630    schema_: Option<String>,
631    name_: String,
632    alias_: Option<String>,
633    join_: Option<RdbcTableJoinType>,
634    filter_: Option<QueryFilter>,
635    params_: Option<HashMap<String, RdbcValue>>,
636}
637
638impl RdbcSchemaTable {
639    pub fn get_schema(&self) -> Option<&String> {
640        self.schema_.as_ref()
641    }
642    pub fn get_name(&self) -> &String {
643        &self.name_
644    }
645    pub fn get_alias(&self) -> Option<&String> {
646        self.alias_.as_ref()
647    }
648    pub fn get_join(&self) -> Option<&RdbcTableJoinType> {
649        self.join_.as_ref()
650    }
651    pub fn get_filter(&self) -> Option<&QueryFilter> {
652        self.filter_.as_ref()
653    }
654
655    pub fn get_mut_params(&mut self) -> Option<&mut HashMap<String, RdbcValue>> {
656        self.params_.as_mut()
657    }
658}
659
660impl RdbcSchemaTable {
661    pub fn table<T>(table: T) -> RdbcSchemaTable
662    where
663        T: ToString,
664    {
665        RdbcSchemaTable {
666            schema_: None,
667            name_: table.to_string(),
668            alias_: None,
669            join_: None,
670            filter_: Some(QueryFilter::new()),
671            params_: None,
672        }
673    }
674    fn table_alias<T, V>(table: T, alias: V) -> RdbcSchemaTable
675    where
676        T: ToString,
677        V: ToString,
678    {
679        RdbcSchemaTable {
680            schema_: None,
681            name_: table.to_string(),
682            alias_: Some(alias.to_string()),
683            join_: None,
684            filter_: Some(QueryFilter::new()),
685            params_: None,
686        }
687    }
688    fn schema_table<T>(schema: T, table: T) -> RdbcSchemaTable
689    where
690        T: ToString,
691    {
692        RdbcSchemaTable {
693            schema_: Some(schema.to_string()),
694            name_: table.to_string(),
695            alias_: None,
696            join_: None,
697            filter_: Some(QueryFilter::new()),
698            params_: None,
699        }
700    }
701    pub fn schema_table_alias<SS, ST, SA>(schema: SS, table: ST, alias: SA) -> RdbcSchemaTable
702    where
703        SS: ToString,
704        ST: ToString,
705        SA: ToString,
706    {
707        RdbcSchemaTable {
708            schema_: Some(schema.to_string()),
709            name_: table.to_string(),
710            alias_: Some(alias.to_string()),
711            join_: None,
712            filter_: Some(QueryFilter::new()),
713            params_: None,
714        }
715    }
716    pub fn join_table<T>(table: T, join_type: RdbcTableJoinType) -> RdbcSchemaTable
717    where
718        T: ToString,
719    {
720        RdbcSchemaTable {
721            schema_: None,
722            name_: table.to_string(),
723            alias_: None,
724            join_: Some(join_type),
725            filter_: Some(QueryFilter::new()),
726            params_: None,
727        }
728    }
729    pub fn join_table_alias<T, A>(
730        table: T,
731        alias: A,
732        join_type: RdbcTableJoinType,
733    ) -> RdbcSchemaTable
734    where
735        T: ToString,
736        A: ToString,
737    {
738        RdbcSchemaTable {
739            schema_: None,
740            name_: table.to_string(),
741            alias_: Some(alias.to_string()),
742            join_: Some(join_type),
743            filter_: Some(QueryFilter::new()),
744            params_: None,
745        }
746    }
747    fn join_schema_table<S, T>(schmea: S, table: T, join_type: RdbcTableJoinType) -> RdbcSchemaTable
748    where
749        S: ToString,
750        T: ToString,
751    {
752        RdbcSchemaTable {
753            schema_: Some(schmea.to_string()),
754            name_: table.to_string(),
755            alias_: None,
756            join_: Some(join_type),
757            filter_: Some(QueryFilter::new()),
758            params_: None,
759        }
760    }
761
762    pub fn join_schema_table_alias<S, T, A>(
763        schmea: S,
764        table: T,
765        alias: A,
766        join_type: RdbcTableJoinType,
767    ) -> RdbcSchemaTable
768    where
769        S: ToString,
770        T: ToString,
771        A: ToString,
772    {
773        RdbcSchemaTable {
774            schema_: Some(schmea.to_string()),
775            name_: table.to_string(),
776            alias_: Some(alias.to_string()),
777            join_: Some(join_type),
778            filter_: Some(QueryFilter::new()),
779            params_: None,
780        }
781    }
782}
783
784impl RdbcSchemaTable {
785    fn set_filter(&mut self, filter: QueryFilter) -> &mut Self {
786        self.filter_ = Some(filter);
787        self
788    }
789    fn get_filter_mut(&mut self) -> &mut QueryFilter {
790        if self.filter_.is_none() {
791            self.filter_ = Some(QueryFilter::new());
792        }
793        self.filter_.as_mut().unwrap()
794    }
795    fn create_filter(&mut self, concat: RdbcConcatType) -> &mut Self {
796        let filter = self.filter_.take().unwrap();
797        let new_filter = QueryFilter::concat_with_filter(concat, filter);
798        self.filter_ = Some(new_filter);
799        self
800    }
801    pub fn left_join(&mut self) -> &mut Self {
802        self.join_ = Some(RdbcTableJoinType::Left);
803        self
804    }
805    pub fn eq<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
806    where
807        RdbcColumn: From<RC>,
808        RdbcValue: From<RV>,
809    {
810        self.filter_
811            .as_mut()
812            .unwrap()
813            .eq_(RdbcColumn::from(column), RdbcValue::from(value));
814        self
815    }
816    pub fn eq_column(&mut self, col: RdbcColumn, val: RdbcColumn) -> &mut Self {
817        self.filter_.as_mut().unwrap().eq_column(col, val);
818        self
819    }
820    pub fn or(&mut self) -> &mut Self {
821        self.create_filter(RdbcConcatType::Or);
822        self
823    }
824    pub fn and(&mut self) -> &mut Self {
825        self.create_filter(RdbcConcatType::And);
826        self
827    }
828}
829
830pub struct RdbcQueryTable {
831    name_: QueryWrapper,
832    alias_: Option<String>,
833    join_: Option<RdbcTableJoinType>,
834    filter_: Option<QueryFilter>,
835}
836
837impl RdbcQueryTable {
838    pub fn get_name(&self) -> &QueryWrapper {
839        &self.name_
840    }
841    pub fn get_alias(&self) -> Option<&String> {
842        self.alias_.as_ref()
843    }
844    pub fn get_join(&self) -> Option<&RdbcTableJoinType> {
845        self.join_.as_ref()
846    }
847    pub fn get_filter(&self) -> Option<&QueryFilter> {
848        self.filter_.as_ref()
849    }
850    pub fn get_filter_mut(&mut self) -> &mut QueryFilter {
851        if self.filter_.is_none() {
852            self.filter_ = Some(QueryFilter::new());
853        }
854        self.filter_.as_mut().unwrap()
855    }
856    fn set_filter(&mut self, filter: QueryFilter) -> &mut Self {
857        self.filter_ = Some(filter);
858        self
859    }
860}
861
862impl RdbcQueryTable {
863    fn query(table: QueryWrapper) -> RdbcQueryTable {
864        RdbcQueryTable {
865            name_: table,
866            alias_: None,
867            join_: None,
868            filter_: None,
869        }
870    }
871    fn query_alias<T>(table: QueryWrapper, alias: T) -> RdbcQueryTable
872    where
873        T: ToString,
874    {
875        RdbcQueryTable {
876            name_: table,
877            alias_: Some(alias.to_string()),
878            join_: None,
879            filter_: None,
880        }
881    }
882
883    pub fn eq_column(&mut self, col: RdbcColumn, val: RdbcColumn) -> &mut Self {
884        self.filter_.as_mut().unwrap().eq_column(col, val);
885        self
886    }
887    fn join_table(table: QueryWrapper, join_type: RdbcTableJoinType) -> RdbcQueryTable {
888        RdbcQueryTable {
889            name_: table,
890            alias_: None,
891            join_: Some(join_type),
892            filter_: None,
893        }
894    }
895    fn join_table_alias<A>(
896        table: QueryWrapper,
897        alias: A,
898        join_type: RdbcTableJoinType,
899    ) -> RdbcQueryTable
900    where
901        A: ToString,
902    {
903        RdbcQueryTable {
904            name_: table,
905            alias_: Some(alias.to_string()),
906            join_: Some(join_type),
907            filter_: None,
908        }
909    }
910    // TODO
911    fn or(&mut self) -> &mut Self {
912        self
913    }
914}
915
916pub enum RdbcConcatType {
917    And,
918    Or,
919}
920
921/// RdbcTableFilterImpl 表查询条件实现
922pub struct QueryFilter {
923    concat_: RdbcConcatType,
924    item_: Vec<QueryFilterItem>,
925    params_: Option<HashMap<String, RdbcValue>>,
926}
927impl QueryFilter {
928    pub fn get_concat(&self) -> &RdbcConcatType {
929        &self.concat_
930    }
931    pub fn get_item(&self) -> &Vec<QueryFilterItem> {
932        &self.item_
933    }
934    pub fn get_params(&self) -> Option<&HashMap<String, RdbcValue>> {
935        self.params_.as_ref()
936    }
937
938    pub fn add_filter(&mut self, filter: QueryFilter) -> &mut Self {
939        self.item_.push(QueryFilterItem::Filter(filter));
940        self
941    }
942    pub(crate) fn eq_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
943        self.item_.push(QueryFilterItem::eq_(column, value));
944        self
945    }
946    pub fn eq_column<RC, VC>(&mut self, column: RC, value: VC) -> &mut Self
947    where
948        RdbcColumn: From<RC>,
949        RdbcColumn: From<VC>,
950    {
951        self.item_.push(QueryFilterItem::eq_column(
952            RdbcColumn::from(column),
953            RdbcColumn::from(value),
954        ));
955        self
956    }
957    pub(crate) fn ne_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
958        self.item_.push(QueryFilterItem::ne_(column, value));
959        self
960    }
961    pub(crate) fn ne_column(&mut self, column: RdbcColumn, value: RdbcColumn) -> &mut Self {
962        self.item_.push(QueryFilterItem::ne_column(column, value));
963        self
964    }
965    pub(crate) fn ge_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
966        self.item_.push(QueryFilterItem::ge_(column, value));
967        self
968    }
969    pub(crate) fn ge_column(&mut self, column: RdbcColumn, value: RdbcColumn) -> &mut Self {
970        self.item_.push(QueryFilterItem::ge_column(column, value));
971        self
972    }
973    pub(crate) fn gt_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
974        self.item_.push(QueryFilterItem::gt_(column, value));
975        self
976    }
977    pub(crate) fn gt_column(&mut self, column: RdbcColumn, value: RdbcColumn) -> &mut Self {
978        self.item_.push(QueryFilterItem::gt_column(column, value));
979        self
980    }
981    pub(crate) fn le_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
982        self.item_.push(QueryFilterItem::le_(column, value));
983        self
984    }
985    pub(crate) fn le_column(&mut self, column: RdbcColumn, value: RdbcColumn) -> &mut Self {
986        self.item_.push(QueryFilterItem::le_column(column, value));
987        self
988    }
989    pub(crate) fn lt_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
990        self.item_.push(QueryFilterItem::lt_(column, value));
991        self
992    }
993    pub(crate) fn lt_column(&mut self, column: RdbcColumn, value: RdbcColumn) -> &mut Self {
994        self.item_.push(QueryFilterItem::lt_column(column, value));
995        self
996    }
997    pub(crate) fn null_(&mut self, column: RdbcColumn) -> &mut Self {
998        self.item_.push(QueryFilterItem::null_(column));
999        self
1000    }
1001    pub(crate) fn not_null_(&mut self, column: RdbcColumn) -> &mut Self {
1002        self.item_.push(QueryFilterItem::not_null_(column));
1003        self
1004    }
1005    pub fn between_(
1006        &mut self,
1007        column: RdbcColumn,
1008        value_start: RdbcValue,
1009        value_end: RdbcValue,
1010    ) -> &mut Self {
1011        self.item_
1012            .push(QueryFilterItem::between_(column, value_start, value_end));
1013        self
1014    }
1015    pub fn not_between_(
1016        &mut self,
1017        column: RdbcColumn,
1018        value_start: RdbcValue,
1019        value_end: RdbcValue,
1020    ) -> &mut Self {
1021        self.item_.push(QueryFilterItem::not_between_(
1022            column,
1023            value_start,
1024            value_end,
1025        ));
1026        self
1027    }
1028    pub fn like_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
1029        self.item_.push(QueryFilterItem::like_(column, value));
1030        self
1031    }
1032    pub fn like_left_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
1033        self.item_.push(QueryFilterItem::like_left_(column, value));
1034        self
1035    }
1036    pub fn like_right_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
1037        self.item_.push(QueryFilterItem::like_right_(column, value));
1038        self
1039    }
1040    pub fn not_like_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
1041        self.item_.push(QueryFilterItem::not_like_(column, value));
1042        self
1043    }
1044    pub fn not_like_left_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
1045        self.item_
1046            .push(QueryFilterItem::not_like_left_(column, value));
1047        self
1048    }
1049    pub fn not_like_right_(&mut self, column: RdbcColumn, value: RdbcValue) -> &mut Self {
1050        self.item_
1051            .push(QueryFilterItem::not_like_right_(column, value));
1052        self
1053    }
1054    pub fn in_v_<RC, RV>(&mut self, column: RC, value: Vec<RV>) -> &mut Self
1055    where
1056        RdbcColumn: From<RC>,
1057        RdbcValue: From<RV>,
1058    {
1059        let rc = RdbcColumn::from(column);
1060        let rv: Vec<RdbcValue> = value.into_iter().map(|v| RdbcValue::from(v)).collect();
1061        self.item_.push(QueryFilterItem::in_v(rc, rv));
1062        self
1063    }
1064    pub fn in_v_s_<RC, RV>(&mut self, column: RC, value: &[RV]) -> &mut Self
1065    where
1066        RdbcColumn: From<RC>,
1067        RdbcValue: for<'a> From<&'a RV>,
1068    {
1069        let rc = RdbcColumn::from(column);
1070        let rv = value.into_iter().map(|v| RdbcValue::from(v)).collect();
1071        self.item_.push(QueryFilterItem::in_v(rc, rv));
1072        self
1073    }
1074    pub fn in_v(&mut self, column: RdbcColumn, value: Vec<RdbcValue>) -> &mut Self {
1075        self.item_.push(QueryFilterItem::in_v(column, value));
1076        self
1077    }
1078
1079    pub fn in_v_slice(&mut self, column: RdbcColumn, value: &[RdbcValue]) -> &mut Self {
1080        let rv: Vec<RdbcValue> = value.into_iter().map(|v| v.clone()).collect();
1081        self.item_.push(QueryFilterItem::in_v(column, rv));
1082        self
1083    }
1084    pub fn in_query(&mut self, column: RdbcColumn, value: QueryWrapper) -> &mut Self {
1085        self.item_.push(QueryFilterItem::in_query(column, value));
1086        self
1087    }
1088    pub fn not_in_v_<RC, RV>(&mut self, column: RC, value: Vec<RV>) -> &mut Self
1089    where
1090        RdbcColumn: From<RC>,
1091        RdbcValue: From<RV>,
1092    {
1093        let rc = RdbcColumn::from(column);
1094        let rv: Vec<RdbcValue> = value.into_iter().map(|v| RdbcValue::from(v)).collect();
1095        self.item_.push(QueryFilterItem::not_in_v(rc, rv));
1096        self
1097    }
1098    pub fn not_in_v_s_<RC, RV>(&mut self, column: RC, value: &[RV]) -> &mut Self
1099    where
1100        RdbcColumn: From<RC>,
1101        RdbcValue: for<'a> From<&'a RV>,
1102    {
1103        let rc = RdbcColumn::from(column);
1104        let rv: Vec<RdbcValue> = value.into_iter().map(|v| RdbcValue::from(v)).collect();
1105        self.item_.push(QueryFilterItem::not_in_v(rc, rv));
1106        self
1107    }
1108    pub fn not_in_v(&mut self, column: RdbcColumn, value: Vec<RdbcValue>) -> &mut Self {
1109        self.item_.push(QueryFilterItem::not_in_v(column, value));
1110        self
1111    }
1112
1113    pub fn not_in_v_slice(&mut self, column: RdbcColumn, value: &[RdbcValue]) -> &mut Self {
1114        let rv: Vec<RdbcValue> = value.into_iter().map(|v| v.clone()).collect();
1115        self.item_.push(QueryFilterItem::not_in_v(column, rv));
1116        self
1117    }
1118
1119    pub fn not_in_query(&mut self, column: RdbcColumn, value: QueryWrapper) -> &mut Self {
1120        self.item_
1121            .push(QueryFilterItem::not_in_query(column, value));
1122        self
1123    }
1124    pub fn exists_(&mut self, column: RdbcColumn, value: QueryWrapper) -> &mut Self {
1125        self.item_.push(QueryFilterItem::exists_(column, value));
1126        self
1127    }
1128    pub fn not_exists_(&mut self, column: RdbcColumn, value: QueryWrapper) -> &mut Self {
1129        self.item_.push(QueryFilterItem::not_exists_(column, value));
1130        self
1131    }
1132    pub fn new() -> QueryFilter {
1133        QueryFilter {
1134            concat_: RdbcConcatType::And,
1135            item_: vec![],
1136            params_: None,
1137        }
1138    }
1139    pub fn concat(concat: RdbcConcatType) -> QueryFilter {
1140        QueryFilter {
1141            concat_: concat,
1142            item_: vec![],
1143            params_: None,
1144        }
1145    }
1146    pub fn concat_with_filter(concat: RdbcConcatType, filter: QueryFilter) -> QueryFilter {
1147        QueryFilter {
1148            concat_: concat,
1149            item_: vec![QueryFilterItem::filter(filter)],
1150            params_: None,
1151        }
1152    }
1153}
1154
1155pub enum QueryFilterItem {
1156    Value(RdbcValueFilterItem),
1157    Column(RdbcColumnFilterItem),
1158    Filter(QueryFilter),
1159    Query(RdbcQueryFilterItem),
1160}
1161
1162impl QueryFilterItem {
1163    fn filter(filter: QueryFilter) -> QueryFilterItem {
1164        QueryFilterItem::Filter(filter)
1165    }
1166}
1167
1168impl QueryFilterItem {
1169    pub(crate) fn eq_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1170        QueryFilterItem::Value(RdbcValueFilterItem::eq_(column, value))
1171    }
1172    pub fn eq_column(column: RdbcColumn, value: RdbcColumn) -> QueryFilterItem {
1173        QueryFilterItem::Column(RdbcColumnFilterItem::eq_column(column, value))
1174    }
1175    pub(crate) fn ne_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1176        QueryFilterItem::Value(RdbcValueFilterItem::ne_(column, value))
1177    }
1178    pub fn ne_column(column: RdbcColumn, value: RdbcColumn) -> QueryFilterItem {
1179        QueryFilterItem::Column(RdbcColumnFilterItem::ne_column(column, value))
1180    }
1181    pub(crate) fn ge_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1182        QueryFilterItem::Value(RdbcValueFilterItem::ge_(column, value))
1183    }
1184    pub fn ge_column(column: RdbcColumn, value: RdbcColumn) -> QueryFilterItem {
1185        QueryFilterItem::Column(RdbcColumnFilterItem::ge_column(column, value))
1186    }
1187    pub(crate) fn gt_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1188        QueryFilterItem::Value(RdbcValueFilterItem::gt_(column, value))
1189    }
1190    pub fn gt_column(column: RdbcColumn, value: RdbcColumn) -> QueryFilterItem {
1191        QueryFilterItem::Column(RdbcColumnFilterItem::gt_column(column, value))
1192    }
1193    pub(crate) fn le_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1194        QueryFilterItem::Value(RdbcValueFilterItem::le_(column, value))
1195    }
1196    pub fn le_column(column: RdbcColumn, value: RdbcColumn) -> QueryFilterItem {
1197        QueryFilterItem::Column(RdbcColumnFilterItem::le_column(column, value))
1198    }
1199    pub(crate) fn lt_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1200        QueryFilterItem::Value(RdbcValueFilterItem::lt_(column, value))
1201    }
1202    pub fn lt_column(column: RdbcColumn, value: RdbcColumn) -> QueryFilterItem {
1203        QueryFilterItem::Column(RdbcColumnFilterItem::lt_column(column, value))
1204    }
1205
1206    pub fn null_(column: RdbcColumn) -> QueryFilterItem {
1207        QueryFilterItem::Column(RdbcColumnFilterItem::null_(column))
1208    }
1209    pub fn not_null_(column: RdbcColumn) -> QueryFilterItem {
1210        QueryFilterItem::Column(RdbcColumnFilterItem::not_null_(column))
1211    }
1212    pub fn like_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1213        QueryFilterItem::Value(RdbcValueFilterItem::like_(column, value))
1214    }
1215    pub fn like_left_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1216        QueryFilterItem::Value(RdbcValueFilterItem::like_left_(column, value))
1217    }
1218    pub fn like_right_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1219        QueryFilterItem::Value(RdbcValueFilterItem::like_right_(column, value))
1220    }
1221
1222    pub fn not_like_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1223        QueryFilterItem::Value(RdbcValueFilterItem::not_like_(column, value))
1224    }
1225    pub fn not_like_left_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1226        QueryFilterItem::Value(RdbcValueFilterItem::not_like_left_(column, value))
1227    }
1228    pub fn not_like_right_(column: RdbcColumn, value: RdbcValue) -> QueryFilterItem {
1229        QueryFilterItem::Value(RdbcValueFilterItem::not_like_right_(column, value))
1230    }
1231    pub(crate) fn between_(
1232        column: RdbcColumn,
1233        value_start: RdbcValue,
1234        value_end: RdbcValue,
1235    ) -> QueryFilterItem {
1236        QueryFilterItem::Value(RdbcValueFilterItem::between_(
1237            column,
1238            value_start,
1239            value_end,
1240        ))
1241    }
1242    pub(crate) fn not_between_(
1243        column: RdbcColumn,
1244        value_start: RdbcValue,
1245        value_end: RdbcValue,
1246    ) -> QueryFilterItem {
1247        QueryFilterItem::Value(RdbcValueFilterItem::not_between_(
1248            column,
1249            value_start,
1250            value_end,
1251        ))
1252    }
1253    pub fn in_v(column: RdbcColumn, value_vec: Vec<RdbcValue>) -> QueryFilterItem {
1254        QueryFilterItem::Value(RdbcValueFilterItem::in_v(column, value_vec))
1255    }
1256    pub fn in_query(column: RdbcColumn, query_wrapper: QueryWrapper) -> QueryFilterItem {
1257        QueryFilterItem::Query(RdbcQueryFilterItem::in_query(column, query_wrapper))
1258    }
1259    pub fn not_in_v(column: RdbcColumn, value_vec: Vec<RdbcValue>) -> QueryFilterItem {
1260        QueryFilterItem::Value(RdbcValueFilterItem::not_in_v(column, value_vec))
1261    }
1262    pub fn not_in_query(column: RdbcColumn, value: QueryWrapper) -> QueryFilterItem {
1263        QueryFilterItem::Query(RdbcQueryFilterItem::not_in_query(column, value))
1264    }
1265    pub fn exists_(column: RdbcColumn, value: QueryWrapper) -> QueryFilterItem {
1266        QueryFilterItem::Query(RdbcQueryFilterItem::exists_query(column, value))
1267    }
1268    pub fn not_exists_(column: RdbcColumn, value: QueryWrapper) -> QueryFilterItem {
1269        QueryFilterItem::Query(RdbcQueryFilterItem::not_exists_query(column, value))
1270    }
1271}
1272
1273pub struct RdbcValueFilterItem {
1274    column_: RdbcColumn,
1275    compare_: RdbcCompareType,
1276    value: Option<RdbcValue>,
1277    ignore_null: bool,
1278}
1279impl RdbcValueFilterItem {
1280    pub fn get_column(&self) -> &RdbcColumn {
1281        &self.column_
1282    }
1283    pub fn get_compare(&self) -> &RdbcCompareType {
1284        &self.compare_
1285    }
1286    pub fn get_value(&self) -> Option<&RdbcValue> {
1287        self.value.as_ref()
1288    }
1289    pub fn get_ignore_null(&self) -> bool {
1290        self.ignore_null
1291    }
1292}
1293impl RdbcValueFilterItem {
1294    pub fn eq_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1295        RdbcValueFilterItem {
1296            column_: column,
1297            compare_: RdbcCompareType::Eq,
1298            value: Some(value),
1299            ignore_null: false,
1300        }
1301    }
1302    pub fn ne_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1303        RdbcValueFilterItem {
1304            column_: column,
1305            compare_: RdbcCompareType::NotEq,
1306            value: Some(value),
1307            ignore_null: false,
1308        }
1309    }
1310    pub fn ge_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1311        RdbcValueFilterItem {
1312            column_: column,
1313            compare_: RdbcCompareType::GtEq,
1314            value: Some(value),
1315            ignore_null: false,
1316        }
1317    }
1318
1319    pub fn gt_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1320        RdbcValueFilterItem {
1321            column_: column,
1322            compare_: RdbcCompareType::Gt,
1323            value: Some(value),
1324            ignore_null: false,
1325        }
1326    }
1327
1328    pub fn le_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1329        RdbcValueFilterItem {
1330            column_: column,
1331            compare_: RdbcCompareType::LtEq,
1332            value: Some(value),
1333            ignore_null: false,
1334        }
1335    }
1336
1337    pub fn lt_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1338        RdbcValueFilterItem {
1339            column_: column,
1340            compare_: RdbcCompareType::Lt,
1341            value: Some(value),
1342            ignore_null: false,
1343        }
1344    }
1345    pub fn like_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1346        RdbcValueFilterItem {
1347            column_: column,
1348            compare_: RdbcCompareType::Like,
1349            value: Some(value),
1350            ignore_null: false,
1351        }
1352    }
1353    pub fn like_left_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1354        RdbcValueFilterItem {
1355            column_: column,
1356            compare_: RdbcCompareType::LikeLeft,
1357            value: Some(value),
1358            ignore_null: false,
1359        }
1360    }
1361    pub fn like_right_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1362        RdbcValueFilterItem {
1363            column_: column,
1364            compare_: RdbcCompareType::LikeRight,
1365            value: Some(value),
1366            ignore_null: false,
1367        }
1368    }
1369    pub fn not_like_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1370        RdbcValueFilterItem {
1371            column_: column,
1372            compare_: RdbcCompareType::NotLike,
1373            value: Some(value),
1374            ignore_null: false,
1375        }
1376    }
1377    pub fn not_like_left_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1378        RdbcValueFilterItem {
1379            column_: column,
1380            compare_: RdbcCompareType::NotLikeLeft,
1381            value: Some(value),
1382            ignore_null: false,
1383        }
1384    }
1385    pub fn not_like_right_(column: RdbcColumn, value: RdbcValue) -> RdbcValueFilterItem {
1386        RdbcValueFilterItem {
1387            column_: column,
1388            compare_: RdbcCompareType::NotLikeRight,
1389            value: Some(value),
1390            ignore_null: false,
1391        }
1392    }
1393    pub fn between_(
1394        column: RdbcColumn,
1395        value_start: RdbcValue,
1396        value_end: RdbcValue,
1397    ) -> RdbcValueFilterItem {
1398        let value = RdbcValue::Vec(vec![value_start, value_end]);
1399        RdbcValueFilterItem {
1400            column_: column,
1401            compare_: RdbcCompareType::Between,
1402            value: Some(value),
1403            ignore_null: false,
1404        }
1405    }
1406    pub fn not_between_(
1407        column: RdbcColumn,
1408        value_start: RdbcValue,
1409        value_end: RdbcValue,
1410    ) -> RdbcValueFilterItem {
1411        let value = RdbcValue::Vec(vec![value_start, value_end]);
1412        RdbcValueFilterItem {
1413            column_: column,
1414            compare_: RdbcCompareType::NotBetween,
1415            value: Some(value),
1416            ignore_null: false,
1417        }
1418    }
1419    pub fn in_v(column: RdbcColumn, value_vec: Vec<RdbcValue>) -> RdbcValueFilterItem {
1420        RdbcValueFilterItem {
1421            column_: RdbcColumn::from(column),
1422            compare_: RdbcCompareType::In,
1423            value: Some(RdbcValue::Vec(value_vec)),
1424            ignore_null: true,
1425        }
1426    }
1427    pub fn not_in_v(column: RdbcColumn, value_vec: Vec<RdbcValue>) -> RdbcValueFilterItem {
1428        RdbcValueFilterItem {
1429            column_: RdbcColumn::from(column),
1430            compare_: RdbcCompareType::NotIn,
1431            value: Some(RdbcValue::Vec(value_vec)),
1432            ignore_null: true,
1433        }
1434    }
1435}
1436
1437pub struct RdbcColumnFilterItem {
1438    column_: RdbcColumn,
1439    compare_: RdbcCompareType,
1440    value: Option<RdbcColumn>,
1441}
1442impl RdbcColumnFilterItem {
1443    pub fn get_column(&self) -> &RdbcColumn {
1444        &self.column_
1445    }
1446    pub fn get_compare(&self) -> &RdbcCompareType {
1447        &self.compare_
1448    }
1449    pub fn get_value(&self) -> Option<&RdbcColumn> {
1450        self.value.as_ref()
1451    }
1452}
1453impl RdbcColumnFilterItem {
1454    pub fn eq_column(column: RdbcColumn, value: RdbcColumn) -> RdbcColumnFilterItem {
1455        RdbcColumnFilterItem {
1456            column_: column,
1457            compare_: RdbcCompareType::Eq,
1458            value: Some(value),
1459        }
1460    }
1461    pub fn ne_column(column: RdbcColumn, value: RdbcColumn) -> RdbcColumnFilterItem {
1462        RdbcColumnFilterItem {
1463            column_: column,
1464            compare_: RdbcCompareType::NotEq,
1465            value: Some(value),
1466        }
1467    }
1468    pub fn ge_column(column: RdbcColumn, value: RdbcColumn) -> RdbcColumnFilterItem {
1469        RdbcColumnFilterItem {
1470            column_: column,
1471            compare_: RdbcCompareType::GtEq,
1472            value: Some(value),
1473        }
1474    }
1475    pub fn gt_column(column: RdbcColumn, value: RdbcColumn) -> RdbcColumnFilterItem {
1476        RdbcColumnFilterItem {
1477            column_: column,
1478            compare_: RdbcCompareType::Gt,
1479            value: Some(value),
1480        }
1481    }
1482    pub fn le_column(column: RdbcColumn, value: RdbcColumn) -> RdbcColumnFilterItem {
1483        RdbcColumnFilterItem {
1484            column_: column,
1485            compare_: RdbcCompareType::LtEq,
1486            value: Some(value),
1487        }
1488    }
1489    pub fn lt_column(column: RdbcColumn, value: RdbcColumn) -> RdbcColumnFilterItem {
1490        RdbcColumnFilterItem {
1491            column_: column,
1492            compare_: RdbcCompareType::Lt,
1493            value: Some(value),
1494        }
1495    }
1496    pub fn null_(column: RdbcColumn) -> RdbcColumnFilterItem {
1497        RdbcColumnFilterItem {
1498            column_: column,
1499            compare_: RdbcCompareType::IsNull,
1500            value: None,
1501        }
1502    }
1503    pub fn not_null_(column: RdbcColumn) -> RdbcColumnFilterItem {
1504        RdbcColumnFilterItem {
1505            column_: column,
1506            compare_: RdbcCompareType::IsNotNull,
1507            value: None,
1508        }
1509    }
1510}
1511
1512pub struct RdbcQueryFilterItem {
1513    column_: RdbcColumn,
1514    compare_: RdbcCompareType,
1515    value: Option<QueryWrapper>,
1516}
1517impl RdbcQueryFilterItem {
1518    pub fn get_column(&self) -> &RdbcColumn {
1519        &self.column_
1520    }
1521    pub fn get_compare(&self) -> &RdbcCompareType {
1522        &self.compare_
1523    }
1524    pub fn get_value(&self) -> Option<&QueryWrapper> {
1525        self.value.as_ref()
1526    }
1527}
1528impl RdbcQueryFilterItem {
1529    fn in_query(rdbc_column: RdbcColumn, query_wrapper: QueryWrapper) -> RdbcQueryFilterItem {
1530        RdbcQueryFilterItem {
1531            column_: rdbc_column,
1532            compare_: RdbcCompareType::In,
1533            value: Some(query_wrapper),
1534        }
1535    }
1536    fn not_in_query(rdbc_column: RdbcColumn, query_wrapper: QueryWrapper) -> RdbcQueryFilterItem {
1537        RdbcQueryFilterItem {
1538            column_: rdbc_column,
1539            compare_: RdbcCompareType::NotIn,
1540            value: Some(query_wrapper),
1541        }
1542    }
1543    fn exists_query(rdbc_column: RdbcColumn, query_wrapper: QueryWrapper) -> RdbcQueryFilterItem {
1544        RdbcQueryFilterItem {
1545            column_: rdbc_column,
1546            compare_: RdbcCompareType::Exists,
1547            value: Some(query_wrapper),
1548        }
1549    }
1550    fn not_exists_query(
1551        rdbc_column: RdbcColumn,
1552        query_wrapper: QueryWrapper,
1553    ) -> RdbcQueryFilterItem {
1554        RdbcQueryFilterItem {
1555            column_: rdbc_column,
1556            compare_: RdbcCompareType::NotExists,
1557            value: Some(query_wrapper),
1558        }
1559    }
1560}
1561
1562pub enum RdbcCompareType {
1563    Eq,
1564    NotEq,
1565    Gt,
1566    GtEq,
1567    Lt,
1568    LtEq,
1569    Like,
1570    LikeLeft,
1571    LikeRight,
1572    NotLike,
1573    NotLikeLeft,
1574    NotLikeRight,
1575    In,
1576    NotIn,
1577    IsNull,
1578    IsNotNull,
1579    Exists,
1580    NotExists,
1581    Between,
1582    NotBetween,
1583}
1584impl RdbcCompareType {
1585    pub fn name(&self) -> String {
1586        match self {
1587            RdbcCompareType::Eq => "=".to_string(),
1588            RdbcCompareType::NotEq => "<>".to_string(),
1589            RdbcCompareType::Gt => ">".to_string(),
1590            RdbcCompareType::GtEq => ">=".to_string(),
1591            RdbcCompareType::Lt => "<".to_string(),
1592            RdbcCompareType::LtEq => "<=".to_string(),
1593            RdbcCompareType::Like => "LIKE".to_string(),
1594            RdbcCompareType::LikeLeft => "LIKE".to_string(),
1595            RdbcCompareType::LikeRight => "LIKE".to_string(),
1596            RdbcCompareType::NotLike => "NOT LIKE".to_string(),
1597            RdbcCompareType::NotLikeLeft => "NOT LIKE".to_string(),
1598            RdbcCompareType::NotLikeRight => "NOT LIKE".to_string(),
1599            RdbcCompareType::In => "IN".to_string(),
1600            RdbcCompareType::NotIn => "NOT IN".to_string(),
1601            RdbcCompareType::IsNull => "IS NULL".to_string(),
1602            RdbcCompareType::IsNotNull => "IS NOT NULL".to_string(),
1603            RdbcCompareType::Exists => "EXISTS".to_string(),
1604            RdbcCompareType::NotExists => "NOT EXISTS".to_string(),
1605            RdbcCompareType::Between => "BETWEEN".to_string(),
1606            RdbcCompareType::NotBetween => "NOT BETWEEN".to_string(),
1607        }
1608    }
1609}
1610pub enum RdbcOrder {
1611    Column(RdbcColumnOrder),
1612}
1613
1614impl RdbcOrder {
1615    pub fn asc_<RC>(column: RC) -> RdbcOrder
1616    where
1617        RdbcColumn: From<RC>,
1618    {
1619        RdbcOrder::Column(RdbcColumnOrder::asc_(column))
1620    }
1621
1622    pub fn desc_<RC>(column: RC) -> RdbcOrder
1623    where
1624        RdbcColumn: From<RC>,
1625    {
1626        RdbcOrder::Column(RdbcColumnOrder::asc_(column))
1627    }
1628}
1629
1630pub struct RdbcColumnOrder {
1631    column: RdbcColumn,
1632    order: RdbcOrderType,
1633}
1634
1635impl RdbcColumnOrder {
1636    pub fn asc_<RC>(column: RC) -> RdbcColumnOrder
1637    where
1638        RdbcColumn: From<RC>,
1639    {
1640        RdbcColumnOrder {
1641            column: RdbcColumn::from(column),
1642            order: RdbcOrderType::Asc,
1643        }
1644    }
1645    pub fn desc_<RC>(column: RC) -> RdbcColumnOrder
1646    where
1647        RdbcColumn: From<RC>,
1648    {
1649        RdbcColumnOrder {
1650            column: RdbcColumn::from(column),
1651            order: RdbcOrderType::Desc,
1652        }
1653    }
1654
1655    pub fn get_column(&self) -> &RdbcColumn {
1656        &self.column
1657    }
1658    pub fn get_order(&self) -> &RdbcOrderType {
1659        &self.order
1660    }
1661}
1662
1663pub enum RdbcOrderType {
1664    Asc,
1665    Desc,
1666}
1667
1668pub enum RdbcDmlValue {
1669    VALUE(RdbcValue),
1670    COLUMN(RdbcColumn),
1671}
1672
1673impl RdbcDmlValue {
1674    pub fn is_value(&self) -> bool {
1675        match self {
1676            RdbcDmlValue::VALUE(_) => true,
1677            RdbcDmlValue::COLUMN(_) => false,
1678        }
1679    }
1680    pub fn is_column(&self) -> bool {
1681        match self {
1682            RdbcDmlValue::VALUE(_) => false,
1683            RdbcDmlValue::COLUMN(_) => true,
1684        }
1685    }
1686    pub fn get_value(&self) -> Option<&RdbcValue> {
1687        match self {
1688            RdbcDmlValue::VALUE(value) => Some(value),
1689            RdbcDmlValue::COLUMN(_) => None,
1690        }
1691    }
1692    pub fn get_column(&self) -> Option<&RdbcColumn> {
1693        match self {
1694            RdbcDmlValue::VALUE(_) => None,
1695            RdbcDmlValue::COLUMN(column) => Some(column),
1696        }
1697    }
1698}
1699
1700impl From<RdbcColumn> for RdbcDmlValue {
1701    fn from(value: RdbcColumn) -> Self {
1702        RdbcDmlValue::COLUMN(value)
1703    }
1704}
1705
1706impl<T> From<T> for RdbcDmlValue
1707where
1708    RdbcValue: From<T>,
1709{
1710    fn from(value: T) -> Self {
1711        RdbcDmlValue::VALUE(RdbcValue::from(value))
1712    }
1713}
1714
1715pub fn table<T>(table: T) -> RdbcTableInner
1716where
1717    T: ToString,
1718{
1719    RdbcTableInner::table(table)
1720}
1721
1722pub fn left_table<T>(table: T) -> RdbcTableInner
1723where
1724    T: ToString,
1725{
1726    RdbcTableInner::join_table(table, RdbcTableJoinType::Left)
1727}
1728
1729pub fn inner_table<T>(table: T) -> RdbcTableInner
1730where
1731    T: ToString,
1732{
1733    RdbcTableInner::join_table(table, RdbcTableJoinType::Inner)
1734}
1735
1736pub fn right_table<T>(table: T) -> RdbcTableInner
1737where
1738    T: ToString,
1739{
1740    RdbcTableInner::join_table(table, RdbcTableJoinType::Right)
1741}
1742
1743pub fn full_table<T>(table: T) -> RdbcTableInner
1744where
1745    T: ToString,
1746{
1747    RdbcTableInner::join_table(table, RdbcTableJoinType::Full)
1748}
1749
1750pub fn table_column<T, V>(table: T, column: V) -> RdbcTableColumn
1751where
1752    T: ToString,
1753    V: ToString,
1754{
1755    RdbcTableColumn::table_column(table, column)
1756}
1757
1758pub fn simple_column<T, V>(table: T, column: V) -> RdbcColumn
1759where
1760    T: ToString,
1761    V: ToString,
1762{
1763    RdbcColumn::table_column(table, column)
1764}
1765
1766pub fn value_column<V>(column: V) -> RdbcColumn
1767where
1768    V: ToString,
1769{
1770    RdbcColumn::rdbc_value(RdbcValue::String(column.to_string()))
1771}
bmbp_rdbc_sql/dsl/dsl_model.rs

bmbp_rdbc_sql/dsl/
dsl_model.rs
