001/*
002 *  Copyright (c) 2022-2023, Mybatis-Flex (fuhai999@gmail.com).
003 *  <p>
004 *  Licensed under the Apache License, Version 2.0 (the "License");
005 *  you may not use this file except in compliance with the License.
006 *  You may obtain a copy of the License at
007 *  <p>
008 *  http://www.apache.org/licenses/LICENSE-2.0
009 *  <p>
010 *  Unless required by applicable law or agreed to in writing, software
011 *  distributed under the License is distributed on an "AS IS" BASIS,
012 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 *  See the License for the specific language governing permissions and
014 *  limitations under the License.
015 */
016package com.mybatisflex.core.query;
017
018import com.mybatisflex.core.constant.SqlConnector;
019import com.mybatisflex.core.table.TableDef;
020import com.mybatisflex.core.util.LambdaGetter;
021import com.mybatisflex.core.util.LambdaUtil;
022
023import java.util.Map;
024import java.util.function.Consumer;
025
026/**
027 * {@link QueryWrapper} 泛型适配器。
028 *
029 * @param <R> 返回值类型
030 * @author michael
031 * @author suomm
032 */
033@SuppressWarnings({"unchecked", "rawtypes"})
034public class QueryWrapperAdapter<R extends QueryWrapperAdapter<R>> extends QueryWrapper {
035
036    @Override
037    public WithBuilder<R> with(String name) {
038        return super.with(name);
039    }
040
041    @Override
042    public WithBuilder<R> with(String name, String... params) {
043        return super.with(name, params);
044    }
045
046    @Override
047    public WithBuilder<R> withRecursive(String name) {
048        return super.withRecursive(name);
049    }
050
051    @Override
052    public WithBuilder<R> withRecursive(String name, String... params) {
053        return super.withRecursive(name, params);
054    }
055
056    @Override
057    public R select() {
058        super.select();
059        return (R) this;
060    }
061
062    @Override
063    public R select(String... columns) {
064        super.select(columns);
065        return (R) this;
066    }
067
068    @Override
069    public <T> R select(LambdaGetter<T>... lambdaGetters) {
070        super.select(lambdaGetters);
071        return (R) this;
072    }
073
074    @Override
075    public R select(QueryColumn... queryColumns) {
076        super.select(queryColumns);
077        return (R) this;
078    }
079
080    @Override
081    public R select(QueryColumn[]... queryColumns) {
082        super.select(queryColumns);
083        return (R) this;
084    }
085
086    @Override
087    public R select(QueryColumn[] queryColumns, QueryColumn... queryColumns2) {
088        super.select(queryColumns,queryColumns2);
089        return (R) this;
090    }
091
092    @Override
093    public R from(TableDef... tableDefs) {
094        super.from(tableDefs);
095        return (R) this;
096    }
097
098    @Override
099    public R from(Class<?>... entityClasses) {
100        super.from(entityClasses);
101        return (R) this;
102    }
103
104    @Override
105    public R from(String... tables) {
106        super.from(tables);
107        return (R) this;
108    }
109
110    @Override
111    public R from(QueryTable... tables) {
112        super.from(tables);
113        return (R) this;
114    }
115
116    @Override
117    public R from(QueryWrapper queryWrapper) {
118        super.from(queryWrapper);
119        return (R) this;
120    }
121
122    @Override
123    public R as(String alias) {
124        super.as(alias);
125        return (R) this;
126    }
127
128    @Override
129    public R where(QueryCondition queryCondition) {
130        super.where(queryCondition);
131        return (R) this;
132    }
133
134    @Override
135    public R where(String sql) {
136        super.where(sql);
137        return (R) this;
138    }
139
140    @Override
141    public R where(String sql, Object... params) {
142        super.where(sql, params);
143        return (R) this;
144    }
145
146    @Override
147    public R where(Map<String, Object> whereConditions) {
148        super.where(whereConditions);
149        return (R) this;
150    }
151
152    @Override
153    public R where(Map<String, Object> whereConditions, SqlOperators operators) {
154        super.where(whereConditions, operators);
155        return (R) this;
156    }
157
158    @Override
159    public <T> QueryConditionBuilder<R> where(LambdaGetter<T> fn) {
160        return new QueryConditionBuilder<>((R) this, LambdaUtil.getQueryColumn(fn), SqlConnector.AND);
161    }
162
163    @Override
164    public R where(Consumer<QueryWrapper> consumer) {
165        return and(consumer);
166    }
167
168    @Override
169    public R and(QueryCondition queryCondition) {
170        super.and(queryCondition);
171        return (R) this;
172    }
173
174    @Override
175    public R and(String sql) {
176        super.and(sql);
177        return (R) this;
178    }
179
180    @Override
181    public R and(String sql, Object... params) {
182        super.and(sql, params);
183        return (R) this;
184    }
185
186    @Override
187    public <T> QueryConditionBuilder<R> and(LambdaGetter<T> fn) {
188        return new QueryConditionBuilder<>((R) this, LambdaUtil.getQueryColumn(fn), SqlConnector.AND);
189    }
190
191    @Override
192    public R and(Consumer<QueryWrapper> consumer) {
193        super.and(consumer);
194        return (R) this;
195    }
196
197    @Override
198    public R and(Map<String, Object> whereConditions) {
199        super.and(whereConditions);
200        return (R) this;
201    }
202
203    @Override
204    public R and(Map<String, Object> whereConditions, SqlOperators operators) {
205        super.and(whereConditions, operators);
206        return (R) this;
207    }
208
209    @Override
210    public R and(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
211        super.and(whereConditions, operators, innerConnector);
212        return (R) this;
213    }
214
215    @Override
216    public R or(QueryCondition queryCondition) {
217        super.or(queryCondition);
218        return (R) this;
219    }
220
221    @Override
222    public R or(String sql) {
223        super.or(sql);
224        return (R) this;
225    }
226
227    @Override
228    public R or(String sql, Object... params) {
229        super.or(sql, params);
230        return (R) this;
231    }
232
233    @Override
234    public <T> QueryConditionBuilder<R> or(LambdaGetter<T> fn) {
235        return new QueryConditionBuilder<>((R) this, LambdaUtil.getQueryColumn(fn), SqlConnector.OR);
236    }
237
238    @Override
239    public R or(Consumer<QueryWrapper> consumer) {
240        super.or(consumer);
241        return (R) this;
242    }
243
244    @Override
245    public R or(Map<String, Object> whereConditions) {
246        super.or(whereConditions);
247        return (R) this;
248    }
249
250    @Override
251    public R or(Map<String, Object> whereConditions, SqlOperators operators) {
252        super.or(whereConditions, operators);
253        return (R) this;
254    }
255
256    @Override
257    public R or(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
258        super.or(whereConditions, operators, innerConnector);
259        return (R) this;
260    }
261
262    @Override
263    public Joiner<R> leftJoin(String table) {
264        return super.leftJoin(table);
265    }
266
267    @Override
268    public Joiner<R> leftJoin(String table, boolean when) {
269        return super.leftJoin(table, when);
270    }
271
272    @Override
273    public Joiner<R> leftJoin(Class entityClass) {
274        return super.leftJoin(entityClass);
275    }
276
277    @Override
278    public Joiner<R> leftJoin(Class entityClass, boolean when) {
279        return super.leftJoin(entityClass, when);
280    }
281
282    @Override
283    public Joiner<R> leftJoin(TableDef table) {
284        return super.leftJoin(table);
285    }
286
287    @Override
288    public Joiner<R> leftJoin(TableDef table, boolean when) {
289        return super.leftJoin(table, when);
290    }
291
292    @Override
293    public Joiner<R> leftJoin(QueryWrapper table) {
294        return super.leftJoin(table);
295    }
296
297    @Override
298    public Joiner<R> leftJoin(QueryWrapper table, boolean when) {
299        return super.leftJoin(table, when);
300    }
301
302    @Override
303    public Joiner<R> rightJoin(String table) {
304        return super.rightJoin(table);
305    }
306
307    @Override
308    public Joiner<R> rightJoin(String table, boolean when) {
309        return super.rightJoin(table, when);
310    }
311
312    @Override
313    public Joiner<R> rightJoin(Class entityClass) {
314        return super.rightJoin(entityClass);
315    }
316
317    @Override
318    public Joiner<R> rightJoin(Class entityClass, boolean when) {
319        return super.rightJoin(entityClass, when);
320    }
321
322    @Override
323    public Joiner<R> rightJoin(TableDef table) {
324        return super.rightJoin(table);
325    }
326
327    @Override
328    public Joiner<R> rightJoin(TableDef table, boolean when) {
329        return super.rightJoin(table, when);
330    }
331
332    @Override
333    public Joiner<R> rightJoin(QueryWrapper table) {
334        return super.rightJoin(table);
335    }
336
337    @Override
338    public Joiner<R> rightJoin(QueryWrapper table, boolean when) {
339        return super.rightJoin(table, when);
340    }
341
342    @Override
343    public Joiner<R> innerJoin(String table) {
344        return super.innerJoin(table);
345    }
346
347    @Override
348    public Joiner<R> innerJoin(String table, boolean when) {
349        return super.innerJoin(table, when);
350    }
351
352    @Override
353    public Joiner<R> innerJoin(Class entityClass) {
354        return super.innerJoin(entityClass);
355    }
356
357    @Override
358    public Joiner<R> innerJoin(Class entityClass, boolean when) {
359        return super.innerJoin(entityClass, when);
360    }
361
362    @Override
363    public Joiner<R> innerJoin(TableDef table) {
364        return super.innerJoin(table);
365    }
366
367    @Override
368    public Joiner<R> innerJoin(TableDef table, boolean when) {
369        return super.innerJoin(table, when);
370    }
371
372    @Override
373    public Joiner<R> innerJoin(QueryWrapper table) {
374        return super.innerJoin(table);
375    }
376
377    @Override
378    public Joiner<R> innerJoin(QueryWrapper table, boolean when) {
379        return super.innerJoin(table, when);
380    }
381
382    @Override
383    public Joiner<R> fullJoin(String table) {
384        return super.fullJoin(table);
385    }
386
387    @Override
388    public Joiner<R> fullJoin(String table, boolean when) {
389        return super.fullJoin(table, when);
390    }
391
392    @Override
393    public Joiner<R> fullJoin(Class entityClass) {
394        return super.fullJoin(entityClass);
395    }
396
397    @Override
398    public Joiner<R> fullJoin(Class entityClass, boolean when) {
399        return super.fullJoin(entityClass, when);
400    }
401
402    @Override
403    public Joiner<R> fullJoin(TableDef table) {
404        return super.fullJoin(table);
405    }
406
407    @Override
408    public Joiner<R> fullJoin(TableDef table, boolean when) {
409        return super.fullJoin(table, when);
410    }
411
412    @Override
413    public Joiner<R> fullJoin(QueryWrapper table) {
414        return super.fullJoin(table);
415    }
416
417    @Override
418    public Joiner<R> fullJoin(QueryWrapper table, boolean when) {
419        return super.fullJoin(table, when);
420    }
421
422    @Override
423    public Joiner<R> crossJoin(String table) {
424        return super.crossJoin(table);
425    }
426
427    @Override
428    public Joiner<R> crossJoin(String table, boolean when) {
429        return super.crossJoin(table, when);
430    }
431
432    @Override
433    public Joiner<R> crossJoin(Class entityClass) {
434        return super.crossJoin(entityClass);
435    }
436
437    @Override
438    public Joiner<R> crossJoin(Class entityClass, boolean when) {
439        return super.crossJoin(entityClass, when);
440    }
441
442    @Override
443    public Joiner<R> crossJoin(TableDef table) {
444        return super.crossJoin(table);
445    }
446
447    @Override
448    public Joiner<R> crossJoin(TableDef table, boolean when) {
449        return super.crossJoin(table, when);
450    }
451
452    @Override
453    public Joiner<R> crossJoin(QueryWrapper table) {
454        return super.crossJoin(table);
455    }
456
457    @Override
458    public Joiner<R> crossJoin(QueryWrapper table, boolean when) {
459        return super.crossJoin(table, when);
460    }
461
462    @Override
463    public Joiner<R> join(String table) {
464        return super.join(table);
465    }
466
467    @Override
468    public Joiner<R> join(String table, boolean when) {
469        return super.join(table, when);
470    }
471
472    @Override
473    public Joiner<R> join(Class entityClass) {
474        return super.join(entityClass);
475    }
476
477    @Override
478    public Joiner<R> join(Class entityClass, boolean when) {
479        return super.join(entityClass, when);
480    }
481
482    @Override
483    public Joiner<R> join(TableDef table) {
484        return super.join(table);
485    }
486
487    @Override
488    public Joiner<R> join(TableDef table, boolean when) {
489        return super.join(table, when);
490    }
491
492    @Override
493    public Joiner<R> join(QueryWrapper table) {
494        return super.join(table);
495    }
496
497    @Override
498    public Joiner<R> join(QueryWrapper table, boolean when) {
499        return super.join(table, when);
500    }
501
502    @Override
503    public R union(QueryWrapper unionQuery) {
504        super.union(unionQuery);
505        return (R) this;
506    }
507
508    @Override
509    public R unionAll(QueryWrapper unionQuery) {
510        super.unionAll(unionQuery);
511        return (R) this;
512    }
513
514    @Override
515    public R forUpdate() {
516        super.forUpdate();
517        return (R) this;
518    }
519
520    @Override
521    public R forUpdateNoWait() {
522        super.forUpdateNoWait();
523        return (R) this;
524    }
525
526    @Override
527    public R groupBy(String name) {
528        super.groupBy(name);
529        return (R) this;
530    }
531
532    @Override
533    public R groupBy(String... names) {
534        super.groupBy(names);
535        return (R) this;
536    }
537
538    @Override
539    public R groupBy(QueryColumn column) {
540        super.groupBy(column);
541        return (R) this;
542    }
543
544    @Override
545    public R groupBy(QueryColumn... columns) {
546        super.groupBy(columns);
547        return (R) this;
548    }
549
550    @Override
551    public <T> R groupBy(LambdaGetter<T> column) {
552        super.groupBy(column);
553        return (R) this;
554    }
555
556    @Override
557    public <T> R groupBy(LambdaGetter<T>... columns) {
558        super.groupBy(columns);
559        return (R) this;
560    }
561
562    @Override
563    public R having(QueryCondition queryCondition) {
564        super.having(queryCondition);
565        return (R) this;
566    }
567
568    @Override
569    public R orderBy(QueryColumn column, Boolean asc) {
570        super.orderBy(column, asc);
571        return (R) this;
572    }
573
574    @Override
575    public R orderBy(QueryOrderBy... orderBys) {
576        super.orderBy(orderBys);
577        return (R) this;
578    }
579
580    @Override
581    public <T> R orderBy(LambdaGetter<T> column, Boolean asc) {
582        super.orderBy(column, asc);
583        return (R) this;
584    }
585
586    @Override
587    public <T> QueryOrderByBuilder<R> orderBy(LambdaGetter<T> getter) {
588        return (QueryOrderByBuilder<R>) super.orderBy(getter);
589    }
590
591    @Override
592    public R orderBy(String column, Boolean asc) {
593        super.orderBy(column, asc);
594        return (R) this;
595    }
596
597    @Override
598    public R orderBy(String... orderBys) {
599        super.orderBy(orderBys);
600        return (R) this;
601    }
602
603    @Override
604    public R limit(Number rows) {
605        super.limit(rows);
606        return (R) this;
607    }
608
609    @Override
610    public R offset(Number offset) {
611        super.offset(offset);
612        return (R) this;
613    }
614
615    @Override
616    public R limit(Number offset, Number rows) {
617        super.limit(offset, rows);
618        return (R) this;
619    }
620
621    @Override
622    public R datasource(String datasource) {
623        super.datasource(datasource);
624        return (R) this;
625    }
626
627    @Override
628    public R hint(String hint) {
629        super.hint(hint);
630        return (R) this;
631    }
632
633    @Override
634    public R clone() {
635        return (R) super.clone();
636    }
637
638}