package com.czg.utils;

import cn.hutool.core.text.NamingCase;
import com.mybatisflex.core.constant.SqlConnector;
import com.mybatisflex.core.query.*;
import com.mybatisflex.core.table.TableInfo;
import com.mybatisflex.core.table.TableInfoFactory;
import com.mybatisflex.core.util.LambdaGetter;
import com.mybatisflex.core.util.StringUtil;
import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.Predicate;

@Slf4j
public class MyQueryWrapper extends QueryWrapper implements Serializable {

    public MyQueryWrapper selectAll(Class<?> clazz) {
        TableInfo tableInfo = TableInfoFactory.ofEntityClass(clazz);
        for (Method declaredMethod : clazz.getDeclaredMethods()) {
            String methodName = declaredMethod.getName();

            // 只处理 getter：getXxx() / isXxx()
            if ((methodName.startsWith("get") && methodName.length() > 3)
                    || (methodName.startsWith("is") && methodName.length() > 2)) {

                // 必须是无参方法
                if (declaredMethod.getParameterCount() == 0) {
                    String propertyName = StringUtil.methodToProperty(declaredMethod.getName());
                    select(new QueryColumn(tableInfo.getTableName(), NamingCase.toUnderlineCase(propertyName)));
                }
            }
        }
        return this;
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(QueryWrapper table, boolean when) {
        return super.join(table, when);
    }

    public MyQueryWrapper() {
        super();
    }

    @Override
    public boolean hasCondition() {
        return super.hasCondition();
    }

    @Override
    public <Q extends QueryWrapper> WithBuilder<Q> with(String name) {
        return super.with(name);
    }

    @Override
    public <Q extends QueryWrapper> WithBuilder<Q> with(String name, String... params) {
        return super.with(name, params);
    }

    @Override
    public <Q extends QueryWrapper> WithBuilder<Q> withRecursive(String name) {
        return super.withRecursive(name);
    }

    @Override
    public <Q extends QueryWrapper> WithBuilder<Q> withRecursive(String name, String... params) {
        return super.withRecursive(name, params);
    }

    @Override
    public QueryWrapper select() {
        return super.select();
    }

    @Override
    public QueryWrapper select(String... columns) {
        return super.select(columns);
    }

    @Override
    public <T> QueryWrapper select(LambdaGetter<T>... lambdaGetters) {
        return super.select(lambdaGetters);
    }

    @Override
    public QueryWrapper select(QueryColumn... queryColumns) {
        return super.select(queryColumns);
    }

    @Override
    public QueryWrapper select(Iterable<QueryColumn> queryColumns) {
        return super.select(queryColumns);
    }

    @Override
    public QueryWrapper select(QueryColumn[]... queryColumns) {
        return super.select(queryColumns);
    }

    @Override
    public QueryWrapper select(QueryColumn[] queryColumns, QueryColumn... queryColumns2) {
        return super.select(queryColumns, queryColumns2);
    }

    @Override
    public QueryWrapper from(Class<?>... entityClasses) {
        return super.from(entityClasses);
    }

    @Override
    public QueryWrapper from(String... tables) {
        return super.from(tables);
    }

    @Override
    public QueryWrapper from(QueryTable... tables) {
        return super.from(tables);
    }

    @Override
    public QueryWrapper from(QueryWrapper queryWrapper) {
        return super.from(queryWrapper);
    }

    @Override
    public QueryWrapper as(String alias) {
        return super.as(alias);
    }

    @Override
    public QueryWrapper where(QueryCondition queryCondition) {
        return super.where(queryCondition);
    }

    @Override
    public QueryWrapper where(String sql) {
        return super.where(sql);
    }

    @Override
    public QueryWrapper where(String sql, Object... params) {
        return super.where(sql, params);
    }

    @Override
    public QueryWrapper where(Map<String, Object> whereConditions) {
        return super.where(whereConditions);
    }

    @Override
    public QueryWrapper where(Map<String, Object> whereConditions, SqlOperators operators) {
        return super.where(whereConditions, operators);
    }

    @Override
    public <T> QueryConditionBuilder<? extends QueryWrapper> where(LambdaGetter<T> fn) {
        return super.where(fn);
    }

    @Override
    public QueryWrapper where(Consumer<QueryWrapper> consumer) {
        return super.where(consumer);
    }

    @Override
    public QueryWrapper and(QueryCondition queryCondition) {
        return super.and(queryCondition);
    }

    @Override
    public QueryWrapper and(String sql) {
        return super.and(sql);
    }

    @Override
    public QueryWrapper and(String sql, Object... params) {
        return super.and(sql, params);
    }

    @Override
    public <T> QueryConditionBuilder<? extends QueryWrapper> and(LambdaGetter<T> fn) {
        return super.and(fn);
    }

    @Override
    public QueryWrapper and(Consumer<QueryWrapper> consumer) {
        return super.and(consumer);
    }

    @Override
    public QueryWrapper and(Consumer<QueryWrapper> consumer, boolean condition) {
        return super.and(consumer, condition);
    }

    @Override
    public QueryWrapper and(Map<String, Object> whereConditions) {
        return super.and(whereConditions);
    }

    @Override
    public QueryWrapper and(Map<String, Object> whereConditions, SqlOperators operators) {
        return super.and(whereConditions, operators);
    }

    @Override
    public QueryWrapper and(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
        return super.and(whereConditions, operators, innerConnector);
    }

    @Override
    public QueryWrapper or(QueryCondition queryCondition) {
        return super.or(queryCondition);
    }

    @Override
    public QueryWrapper or(String sql) {
        return super.or(sql);
    }

    @Override
    public QueryWrapper or(String sql, Object... params) {
        return super.or(sql, params);
    }

    @Override
    public <T> QueryConditionBuilder<? extends QueryWrapper> or(LambdaGetter<T> fn) {
        return super.or(fn);
    }

    @Override
    public QueryWrapper or(Consumer<QueryWrapper> consumer) {
        return super.or(consumer);
    }

    @Override
    public QueryWrapper or(Consumer<QueryWrapper> consumer, boolean condition) {
        return super.or(consumer, condition);
    }

    @Override
    public QueryWrapper or(Map<String, Object> whereConditions) {
        return super.or(whereConditions);
    }

    @Override
    public QueryWrapper or(Map<String, Object> whereConditions, SqlOperators operators) {
        return super.or(whereConditions, operators);
    }

    @Override
    public QueryWrapper or(Map<String, Object> whereConditions, SqlOperators operators, SqlConnector innerConnector) {
        return super.or(whereConditions, operators, innerConnector);
    }

    @Override
    protected QueryWrapper connectMap(Map<String, Object> mapConditions, SqlOperators operators, SqlConnector outerConnector, SqlConnector innerConnector) {
        return super.connectMap(mapConditions, operators, outerConnector, innerConnector);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(QueryTable table) {
        return super.leftJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(String table) {
        return super.leftJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(String table, boolean when) {
        return super.leftJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(Class<?> entityClass) {
        return super.leftJoin(entityClass);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(Class<?> entityClass, boolean when) {
        return super.leftJoin(entityClass, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(QueryWrapper table) {
        return super.leftJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> leftJoin(QueryWrapper table, boolean when) {
        return super.leftJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(QueryTable table) {
        return super.rightJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(String table) {
        return super.rightJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(String table, boolean when) {
        return super.rightJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(Class<?> entityClass) {
        return super.rightJoin(entityClass);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(Class<?> entityClass, boolean when) {
        return super.rightJoin(entityClass, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(QueryWrapper table) {
        return super.rightJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> rightJoin(QueryWrapper table, boolean when) {
        return super.rightJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(QueryTable table) {
        return super.innerJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(String table) {
        return super.innerJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(String table, boolean when) {
        return super.innerJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(Class<?> entityClass) {
        return super.innerJoin(entityClass);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(Class<?> entityClass, boolean when) {
        return super.innerJoin(entityClass, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(QueryWrapper table) {
        return super.innerJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> innerJoin(QueryWrapper table, boolean when) {
        return super.innerJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(QueryTable table) {
        return super.fullJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(String table) {
        return super.fullJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(String table, boolean when) {
        return super.fullJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(Class<?> entityClass) {
        return super.fullJoin(entityClass);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(Class<?> entityClass, boolean when) {
        return super.fullJoin(entityClass, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(QueryWrapper table) {
        return super.fullJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> fullJoin(QueryWrapper table, boolean when) {
        return super.fullJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(QueryTable table) {
        return super.crossJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(String table) {
        return super.crossJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(String table, boolean when) {
        return super.crossJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(Class<?> entityClass) {
        return super.crossJoin(entityClass);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(Class<?> entityClass, boolean when) {
        return super.crossJoin(entityClass, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(QueryWrapper table) {
        return super.crossJoin(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> crossJoin(QueryWrapper table, boolean when) {
        return super.crossJoin(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(QueryTable table) {
        return super.join(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(String table) {
        return super.join(table);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(String table, boolean when) {
        return super.join(table, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(Class<?> entityClass) {
        return super.join(entityClass);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(Class<?> entityClass, boolean when) {
        return super.join(entityClass, when);
    }

    @Override
    public <Q extends QueryWrapper> Joiner<Q> join(QueryWrapper table) {
        return super.join(table);
    }

    @Override
    public QueryWrapper union(QueryWrapper unionQuery) {
        return super.union(unionQuery);
    }

    @Override
    public QueryWrapper unionAll(QueryWrapper unionQuery) {
        return super.unionAll(unionQuery);
    }

    @Override
    public QueryWrapper forUpdate() {
        return super.forUpdate();
    }

    @Override
    public QueryWrapper forUpdateNoWait() {
        return super.forUpdateNoWait();
    }

    @Override
    protected <T extends QueryWrapper> Joiner<T> joining(String type, QueryTable table, boolean when) {
        return super.joining(type, table, when);
    }

    @Override
    protected <T extends QueryWrapper> Joiner<T> joining(String type, Class<?> entityClass, boolean when) {
        return super.joining(type, entityClass, when);
    }

    @Override
    protected <T extends QueryWrapper> Joiner<T> joining(String type, QueryWrapper queryWrapper, boolean when) {
        return super.joining(type, queryWrapper, when);
    }

    @Override
    public QueryWrapper groupBy(String name) {
        return super.groupBy(name);
    }

    @Override
    public QueryWrapper groupBy(String... names) {
        return super.groupBy(names);
    }

    @Override
    public QueryWrapper groupBy(QueryColumn column) {
        return super.groupBy(column);
    }

    @Override
    public QueryWrapper groupBy(QueryColumn... columns) {
        return super.groupBy(columns);
    }

    @Override
    public <T> QueryWrapper groupBy(LambdaGetter<T> column) {
        return super.groupBy(column);
    }

    @Override
    public <T> QueryWrapper groupBy(LambdaGetter<T>... columns) {
        return super.groupBy(columns);
    }

    @Override
    public QueryWrapper having(QueryCondition queryCondition) {
        return super.having(queryCondition);
    }

    @Override
    public QueryWrapper orderBy(QueryColumn column, Boolean asc) {
        return super.orderBy(column, asc);
    }

    @Override
    public QueryWrapper orderBy(QueryOrderBy... orderBys) {
        return super.orderBy(orderBys);
    }

    @Override
    public <T> QueryWrapper orderBy(LambdaGetter<T> column, Boolean asc) {
        return super.orderBy(column, asc);
    }

    @Override
    public <T> QueryOrderByBuilder<? extends QueryWrapper> orderBy(LambdaGetter<T> getter) {
        return super.orderBy(getter);
    }

    @Override
    public QueryWrapper orderBy(String column, Boolean asc) {
        return super.orderBy(column, asc);
    }

    @Override
    public QueryWrapper orderBy(String... orderBys) {
        return super.orderBy(orderBys);
    }

    @Override
    public QueryWrapper orderByUnSafely(String... rawOrderBy) {
        return super.orderByUnSafely(rawOrderBy);
    }

    @Override
    public QueryWrapper limit(Number rows) {
        return super.limit(rows);
    }

    @Override
    public QueryWrapper offset(Number offset) {
        return super.offset(offset);
    }

    @Override
    public QueryWrapper limit(Number offset, Number rows) {
        return super.limit(offset, rows);
    }

    @Override
    public QueryWrapper datasource(String datasource) {
        return super.datasource(datasource);
    }

    @Override
    public QueryWrapper hint(String hint) {
        return super.hint(hint);
    }

    @Override
    public QueryWrapper eq(String column, Object value) {
        return super.eq(column, value);
    }

    @Override
    public <T> MyQueryWrapper eq(LambdaGetter<T> column, Object value) {
        super.eq(column, value);
        return this;
    }

    @Override
    public QueryWrapper eq(String column, Object value, boolean isEffective) {
        return super.eq(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper eq(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.eq(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper eq(String column, V value, Predicate<V> isEffective) {
        return super.eq(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper eq(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.eq(column, value, isEffective);
    }

    @Override
    public QueryWrapper ne(String column, Object value) {
        return super.ne(column, value);
    }

    @Override
    public <T> QueryWrapper ne(LambdaGetter<T> column, Object value) {
        return super.ne(column, value);
    }

    @Override
    public QueryWrapper ne(String column, Object value, boolean isEffective) {
        return super.ne(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper ne(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.ne(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper ne(String column, V value, Predicate<V> isEffective) {
        return super.ne(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper ne(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.ne(column, value, isEffective);
    }

    @Override
    public QueryWrapper gt(String column, Object value) {
        return super.gt(column, value);
    }

    @Override
    public <T> QueryWrapper gt(LambdaGetter<T> column, Object value) {
        return super.gt(column, value);
    }

    @Override
    public QueryWrapper gt(String column, Object value, boolean isEffective) {
        return super.gt(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper gt(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.gt(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper gt(String column, V value, Predicate<V> isEffective) {
        return super.gt(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper gt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.gt(column, value, isEffective);
    }

    @Override
    public QueryWrapper ge(String column, Object value) {
        return super.ge(column, value);
    }

    @Override
    public <T> QueryWrapper ge(LambdaGetter<T> column, Object value) {
        return super.ge(column, value);
    }

    @Override
    public QueryWrapper ge(String column, Object value, boolean isEffective) {
        return super.ge(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper ge(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.ge(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper ge(String column, V value, Predicate<V> isEffective) {
        return super.ge(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper ge(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.ge(column, value, isEffective);
    }

    @Override
    public QueryWrapper lt(String column, Object value) {
        return super.lt(column, value);
    }

    @Override
    public <T> QueryWrapper lt(LambdaGetter<T> column, Object value) {
        return super.lt(column, value);
    }

    @Override
    public QueryWrapper lt(String column, Object value, boolean isEffective) {
        return super.lt(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper lt(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.lt(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper lt(String column, V value, Predicate<V> isEffective) {
        return super.lt(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper lt(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.lt(column, value, isEffective);
    }

    @Override
    public QueryWrapper le(String column, Object value) {
        return super.le(column, value);
    }

    @Override
    public <T> QueryWrapper le(LambdaGetter<T> column, Object value) {
        return super.le(column, value);
    }

    @Override
    public QueryWrapper le(String column, Object value, boolean isEffective) {
        return super.le(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper le(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.le(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper le(String column, V value, Predicate<V> isEffective) {
        return super.le(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper le(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.le(column, value, isEffective);
    }

    @Override
    public QueryWrapper in(String column, Object... values) {
        return super.in(column, values);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, Object... values) {
        return super.in(column, values);
    }

    @Override
    public QueryWrapper in(String column, QueryWrapper queryWrapper) {
        return super.in(column, queryWrapper);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper) {
        return super.in(column, queryWrapper);
    }

    @Override
    public QueryWrapper in(String column, Collection<?> values) {
        return super.in(column, values);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, Collection<?> values) {
        return super.in(column, values);
    }

    @Override
    public QueryWrapper in(String column, Object[] values, boolean isEffective) {
        return super.in(column, values, isEffective);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, Object[] values, boolean isEffective) {
        return super.in(column, values, isEffective);
    }

    @Override
    public QueryWrapper in(String column, Collection<?> values, boolean isEffective) {
        return super.in(column, values, isEffective);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
        return super.in(column, values, isEffective);
    }

    @Override
    public QueryWrapper in(String column, QueryWrapper queryWrapper, boolean isEffective) {
        return super.in(column, queryWrapper, isEffective);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
        return super.in(column, queryWrapper, isEffective);
    }

    @Override
    public QueryWrapper in(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
        return super.in(column, queryWrapper, isEffective);
    }

    @Override
    public <T> QueryWrapper in(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
        return super.in(column, queryWrapper, isEffective);
    }

    @Override
    public QueryWrapper notIn(String column, Object... values) {
        return super.notIn(column, values);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, Object... values) {
        return super.notIn(column, values);
    }

    @Override
    public QueryWrapper notIn(String column, QueryWrapper queryWrapper) {
        return super.notIn(column, queryWrapper);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper) {
        return super.notIn(column, queryWrapper);
    }

    @Override
    public QueryWrapper notIn(String column, Collection<?> values) {
        return super.notIn(column, values);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, Collection<?> values) {
        return super.notIn(column, values);
    }

    @Override
    public QueryWrapper notIn(String column, Object[] values, boolean isEffective) {
        return super.notIn(column, values, isEffective);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, Object[] values, boolean isEffective) {
        return super.notIn(column, values, isEffective);
    }

    @Override
    public QueryWrapper notIn(String column, Collection<?> values, boolean isEffective) {
        return super.notIn(column, values, isEffective);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, Collection<?> values, boolean isEffective) {
        return super.notIn(column, values, isEffective);
    }

    @Override
    public QueryWrapper notIn(String column, QueryWrapper queryWrapper, boolean isEffective) {
        return super.notIn(column, queryWrapper, isEffective);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, boolean isEffective) {
        return super.notIn(column, queryWrapper, isEffective);
    }

    @Override
    public QueryWrapper notIn(String column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
        return super.notIn(column, queryWrapper, isEffective);
    }

    @Override
    public <T> QueryWrapper notIn(LambdaGetter<T> column, QueryWrapper queryWrapper, BooleanSupplier isEffective) {
        return super.notIn(column, queryWrapper, isEffective);
    }

    @Override
    public QueryWrapper between(String column, Object start, Object end) {
        return super.between(column, start, end);
    }

    @Override
    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end) {
        return super.between(column, start, end);
    }

    @Override
    public QueryWrapper between(String column, Object start, Object end, boolean isEffective) {
        return super.between(column, start, end, isEffective);
    }

    @Override
    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
        return super.between(column, start, end, isEffective);
    }

    @Override
    public QueryWrapper between(String column, Object start, Object end, BooleanSupplier isEffective) {
        return super.between(column, start, end, isEffective);
    }

    @Override
    public <T> QueryWrapper between(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
        return super.between(column, start, end, isEffective);
    }

    @Override
    public QueryWrapper notBetween(String column, Object start, Object end) {
        return super.notBetween(column, start, end);
    }

    @Override
    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end) {
        return super.notBetween(column, start, end);
    }

    @Override
    public QueryWrapper notBetween(String column, Object start, Object end, boolean isEffective) {
        return super.notBetween(column, start, end, isEffective);
    }

    @Override
    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end, boolean isEffective) {
        return super.notBetween(column, start, end, isEffective);
    }

    @Override
    public QueryWrapper notBetween(String column, Object start, Object end, BooleanSupplier isEffective) {
        return super.notBetween(column, start, end, isEffective);
    }

    @Override
    public <T> QueryWrapper notBetween(LambdaGetter<T> column, Object start, Object end, BooleanSupplier isEffective) {
        return super.notBetween(column, start, end, isEffective);
    }

    @Override
    public QueryWrapper like(String column, Object value) {
        return super.like(column, value);
    }

    @Override
    public <T> QueryWrapper like(LambdaGetter<T> column, Object value) {
        return super.like(column, value);
    }

    @Override
    public QueryWrapper like(String column, Object value, boolean isEffective) {
        return super.like(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper like(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.like(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper like(String column, V value, Predicate<V> isEffective) {
        return super.like(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper like(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.like(column, value, isEffective);
    }

    @Override
    public QueryWrapper likeLeft(String column, Object value) {
        return super.likeLeft(column, value);
    }

    @Override
    public <T> QueryWrapper likeLeft(LambdaGetter<T> column, Object value) {
        return super.likeLeft(column, value);
    }

    @Override
    public QueryWrapper likeLeft(String column, Object value, boolean isEffective) {
        return super.likeLeft(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper likeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.likeLeft(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper likeLeft(String column, V value, Predicate<V> isEffective) {
        return super.likeLeft(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper likeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.likeLeft(column, value, isEffective);
    }

    @Override
    public QueryWrapper likeRight(String column, Object value) {
        return super.likeRight(column, value);
    }

    @Override
    public <T> QueryWrapper likeRight(LambdaGetter<T> column, Object value) {
        return super.likeRight(column, value);
    }

    @Override
    public QueryWrapper likeRight(String column, Object value, boolean isEffective) {
        return super.likeRight(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper likeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.likeRight(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper likeRight(String column, V value, Predicate<V> isEffective) {
        return super.likeRight(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper likeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.likeRight(column, value, isEffective);
    }

    @Override
    public QueryWrapper notLike(String column, Object value) {
        return super.notLike(column, value);
    }

    @Override
    public <T> QueryWrapper notLike(LambdaGetter<T> column, Object value) {
        return super.notLike(column, value);
    }

    @Override
    public QueryWrapper notLike(String column, Object value, boolean isEffective) {
        return super.notLike(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper notLike(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.notLike(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper notLike(String column, V value, Predicate<V> isEffective) {
        return super.notLike(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper notLike(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.notLike(column, value, isEffective);
    }

    @Override
    public QueryWrapper notLikeLeft(String column, Object value) {
        return super.notLikeLeft(column, value);
    }

    @Override
    public <T> QueryWrapper notLikeLeft(LambdaGetter<T> column, Object value) {
        return super.notLikeLeft(column, value);
    }

    @Override
    public QueryWrapper notLikeLeft(String column, Object value, boolean isEffective) {
        return super.notLikeLeft(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper notLikeLeft(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.notLikeLeft(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper notLikeLeft(String column, V value, Predicate<V> isEffective) {
        return super.notLikeLeft(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper notLikeLeft(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.notLikeLeft(column, value, isEffective);
    }

    @Override
    public QueryWrapper notLikeRight(String column, Object value) {
        return super.notLikeRight(column, value);
    }

    @Override
    public <T> QueryWrapper notLikeRight(LambdaGetter<T> column, Object value) {
        return super.notLikeRight(column, value);
    }

    @Override
    public QueryWrapper notLikeRight(String column, Object value, boolean isEffective) {
        return super.notLikeRight(column, value, isEffective);
    }

    @Override
    public <T> QueryWrapper notLikeRight(LambdaGetter<T> column, Object value, boolean isEffective) {
        return super.notLikeRight(column, value, isEffective);
    }

    @Override
    public <V> QueryWrapper notLikeRight(String column, V value, Predicate<V> isEffective) {
        return super.notLikeRight(column, value, isEffective);
    }

    @Override
    public <T, V> QueryWrapper notLikeRight(LambdaGetter<T> column, V value, Predicate<V> isEffective) {
        return super.notLikeRight(column, value, isEffective);
    }

    @Override
    public QueryWrapper isNull(String column) {
        return super.isNull(column);
    }

    @Override
    public <T> QueryWrapper isNull(LambdaGetter<T> column) {
        return super.isNull(column);
    }

    @Override
    public QueryWrapper isNull(String column, boolean isEffective) {
        return super.isNull(column, isEffective);
    }

    @Override
    public <T> QueryWrapper isNull(LambdaGetter<T> column, boolean isEffective) {
        return super.isNull(column, isEffective);
    }

    @Override
    public QueryWrapper isNull(String column, BooleanSupplier isEffective) {
        return super.isNull(column, isEffective);
    }

    @Override
    public <T> QueryWrapper isNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
        return super.isNull(column, isEffective);
    }

    @Override
    public QueryWrapper isNotNull(String column) {
        return super.isNotNull(column);
    }

    @Override
    public <T> QueryWrapper isNotNull(LambdaGetter<T> column) {
        return super.isNotNull(column);
    }

    @Override
    public QueryWrapper isNotNull(String column, boolean isEffective) {
        return super.isNotNull(column, isEffective);
    }

    @Override
    public <T> QueryWrapper isNotNull(LambdaGetter<T> column, boolean isEffective) {
        return super.isNotNull(column, isEffective);
    }

    @Override
    public QueryWrapper isNotNull(String column, BooleanSupplier isEffective) {
        return super.isNotNull(column, isEffective);
    }

    @Override
    public <T> QueryWrapper isNotNull(LambdaGetter<T> column, BooleanSupplier isEffective) {
        return super.isNotNull(column, isEffective);
    }

    @Override
    public String toSQL() {
        return super.toSQL();
    }

    @Override
    public QueryWrapper clone() {
        return super.clone();
    }

    @Override
    public void clear() {
        super.clear();
    }

    @Override
    protected QueryWrapper addSelectColumn(QueryColumn queryColumn) {
        return super.addSelectColumn(queryColumn);
    }

    @Override
    protected QueryWrapper addJoin(Join join) {
        return super.addJoin(join);
    }

    @Override
    protected QueryWrapper setWhereQueryCondition(QueryCondition queryCondition) {
        return super.setWhereQueryCondition(queryCondition);
    }

    @Override
    protected QueryWrapper addWhereQueryCondition(QueryCondition queryCondition) {
        return super.addWhereQueryCondition(queryCondition);
    }

    @Override
    protected QueryWrapper addWhereQueryCondition(QueryCondition queryCondition, SqlConnector connector) {
        return super.addWhereQueryCondition(queryCondition, connector);
    }

    @Override
    protected QueryWrapper addGroupByColumns(QueryColumn queryColumn) {
        return super.addGroupByColumns(queryColumn);
    }

    @Override
    protected QueryWrapper addHavingQueryCondition(QueryCondition queryCondition, SqlConnector connector) {
        return super.addHavingQueryCondition(queryCondition, connector);
    }

    @Override
    protected QueryWrapper addOrderBy(QueryOrderBy queryOrderBy) {
        return super.addOrderBy(queryOrderBy);
    }

    @Override
    protected void addJoinTable(QueryTable queryTable) {
        super.addJoinTable(queryTable);
    }

    @Override
    protected void addEndFragment(String fragment) {
        super.addEndFragment(fragment);
    }

    @Override
    protected List<QueryTable> getQueryTables() {
        return super.getQueryTables();
    }

    @Override
    protected void setQueryTables(List<QueryTable> queryTables) {
        super.setQueryTables(queryTables);
    }

    @Override
    protected String getDataSource() {
        return super.getDataSource();
    }

    @Override
    protected void setDataSource(String dataSource) {
        super.setDataSource(dataSource);
    }

    @Override
    protected String getHint() {
        return super.getHint();
    }

    @Override
    protected void setHint(String hint) {
        super.setHint(hint);
    }

    @Override
    protected List<QueryColumn> getSelectColumns() {
        return super.getSelectColumns();
    }

    @Override
    protected void setSelectColumns(List<QueryColumn> selectColumns) {
        super.setSelectColumns(selectColumns);
    }

    @Override
    protected List<Join> getJoins() {
        return super.getJoins();
    }

    @Override
    protected void setJoins(List<Join> joins) {
        super.setJoins(joins);
    }

    @Override
    protected List<QueryTable> getJoinTables() {
        return super.getJoinTables();
    }

    @Override
    protected void setJoinTables(List<QueryTable> joinTables) {
        super.setJoinTables(joinTables);
    }

    @Override
    protected QueryCondition getWhereQueryCondition() {
        return super.getWhereQueryCondition();
    }

    @Override
    protected List<QueryColumn> getGroupByColumns() {
        return super.getGroupByColumns();
    }

    @Override
    protected void setGroupByColumns(List<QueryColumn> groupByColumns) {
        super.setGroupByColumns(groupByColumns);
    }

    @Override
    protected QueryCondition getHavingQueryCondition() {
        return super.getHavingQueryCondition();
    }

    @Override
    protected void setHavingQueryCondition(QueryCondition havingQueryCondition) {
        super.setHavingQueryCondition(havingQueryCondition);
    }

    @Override
    protected List<QueryOrderBy> getOrderBys() {
        return super.getOrderBys();
    }

    @Override
    protected void setOrderBys(List<QueryOrderBy> orderBys) {
        super.setOrderBys(orderBys);
    }

    @Override
    protected List<UnionWrapper> getUnions() {
        return super.getUnions();
    }

    @Override
    protected void setUnions(List<UnionWrapper> unions) {
        super.setUnions(unions);
    }

    @Override
    protected Long getLimitOffset() {
        return super.getLimitOffset();
    }

    @Override
    protected void setLimitOffset(Long limitOffset) {
        super.setLimitOffset(limitOffset);
    }

    @Override
    protected Long getLimitRows() {
        return super.getLimitRows();
    }

    @Override
    protected void setLimitRows(Long limitRows) {
        super.setLimitRows(limitRows);
    }

    @Override
    protected List<String> getEndFragments() {
        return super.getEndFragments();
    }

    @Override
    protected void setEndFragments(List<String> endFragments) {
        super.setEndFragments(endFragments);
    }

    @Override
    protected Map<String, Object> getContext() {
        return super.getContext();
    }

    @Override
    protected void setContext(Map<String, Object> context) {
        super.setContext(context);
    }

    @Override
    protected void putContext(String key, Object value) {
        super.putContext(key, value);
    }

    @Override
    protected <R> R getContext(String key) {
        return super.getContext(key);
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }

    @Override
    public String toString() {
        return super.toString();
    }

}
