mybatis多条件in查询的实现

select * from table where (sku_id,batch_no) in ((#{skuid},#{batchno}),...); 

lambdaquerychainwrapper<table> query = tableservice.lambdaquery();  
query.eq(table::getid, param.getid()); 

import com.baomidou.mybatisplus.core.conditions.abstractlambdawrapper;
import com.baomidou.mybatisplus.core.conditions.isqlsegment;
import com.baomidou.mybatisplus.core.conditions.segments.mergesegments;
import com.baomidou.mybatisplus.core.metadata.tablefieldinfo;
import com.baomidou.mybatisplus.core.toolkit.arrayutils;
import com.baomidou.mybatisplus.core.toolkit.stringpool;
import com.baomidou.mybatisplus.core.toolkit.tableinfohelper;
import com.baomidou.mybatisplus.core.toolkit.support.sfunction;
import io.vavr.tuple;
import org.springframework.util.assert;

import java.util.list;
import java.util.map;
import java.util.concurrent.atomic.atomicinteger;
import java.util.function.predicate;
import java.util.stream.collectors;

import static com.baomidou.mybatisplus.core.enums.sqlkeyword.in;
import static java.util.stream.collectors.joining;

public class combinationlambdaquerychainwrapper<t> extends abstractlambdawrapper<t, combinationlambdaquerychainwrapper<t>> {

    /**
     * 查询字段
     */
    private string sqlselect;

    public combinationlambdaquerychainwrapper() {
        this(null);
    }

    public combinationlambdaquerychainwrapper(t entity) {
        this.entity = entity;
        this.initentityclass();
        this.initneed();
    }

    combinationlambdaquerychainwrapper(t entity, class<t> entityclass, string sqlselect, atomicinteger paramnameseq, map<string, object> paramnamevaluepairs,
                                       mergesegments mergesegments) {
        this.entity = entity;
        this.paramnameseq = paramnameseq;
        this.paramnamevaluepairs = paramnamevaluepairs;
        this.expression = mergesegments;
        this.sqlselect = sqlselect;
        this.entityclass = entityclass;
    }

    /**
     * <p>
     * select 部分 sql 设置
     * </p>
     *
     * @param columns 查询字段
     */
    @safevarargs
    public final combinationlambdaquerychainwrapper<t> select(sfunction<t, ?>... columns) {
        if (arrayutils.isnotempty(columns)) {
            this.sqlselect = this.columnstostring(columns);
        }
        return typedthis;
    }

    public combinationlambdaquerychainwrapper<t> select(predicate<tablefieldinfo> predicate) {
        return select(entityclass, predicate);
    }

    /**
     * <p>
     * 过滤查询的字段信息(主键除外!)
     * </p>
     * <p>
     * 例1: 只要 java 字段名以 "test" 开头的              -> select(i -> i.getproperty().startswith("test"))
     * 例2: 只要 java 字段属性是 charsequence 类型的       -> select(tablefieldinfo::ischarsequence)
     * 例3: 只要 java 字段没有填充策略的                   -> select(i -> i.getfieldfill == fieldfill.default)
     * 例4: 要全部字段                                   -> select(i -> true)
     * 例5: 只要主键字段                                 -> select(i -> false)
     * </p>
     *
     * @param predicate 过滤方式
     * @return this
     */
    public combinationlambdaquerychainwrapper<t> select(class<t> entityclass, predicate<tablefieldinfo> predicate) {
        this.entityclass = entityclass;
        this.sqlselect = tableinfohelper.gettableinfo(getcheckentityclass()).chooseselect(predicate);
        return typedthis;
    }

    @override
    public string getsqlselect() {
        return sqlselect;
    }

    /**
     * <p>
     * 用于生成嵌套 sql
     * 故 sqlselect 不向下传递
     * </p>
     */
    @override
    protected combinationlambdaquerychainwrapper<t> instance(atomicinteger paramnameseq, map<string, object> paramnamevaluepairs) {
        return new combinationlambdaquerychainwrapper<>(entity, entityclass, null, paramnameseq, paramnamevaluepairs, new mergesegments());
    }

    /**
     * 组合in查询
     * 此处引入元组，需使用io.vavr包
     **/
    public combinationlambdaquerychainwrapper<t> combinationin(boolean condition, list<tuple> list, sfunction<t, ?>... columns) {
        assert.istrue(columns.length == list.get(0).arity(), "请检查组合in查询参数长度");
        return doit(condition,
                () -> stringpool.left_bracket + columnstostring(columns) + stringpool.right_bracket,
                in,
                inexpressionofparam(list));
    }


    private isqlsegment inexpressionofparam(list<tuple> list) {
        if (list.size() > 1000) {
            throw new runtimeexception("组合查询禁止超过1000条");
        }
        list<string> result = list.stream().map(m -> stringpool.left_bracket + m.toseq().asjava().stream()
                .map(n -> n instanceof string ? stringpool.single_quote + n + stringpool.single_quote : string.valueof(n)).collect(collectors.joining(stringpool.comma)) + stringpool.right_bracket).collect(collectors.tolist());
        return () -> result.stream()
                .collect(joining(stringpool.comma, stringpool.left_bracket, stringpool.right_bracket));
    }

}

productrelservice.list(new combinationlambdaquerychainwrapper<productrel>().select(productrel::getlevelid).eq(productrel::getlevelid, "gbz0555a0002").combinationin(true, arrays.aslist(tuple.of("91cf1c0f3b0bc46e0238dc33717dc88e", "gbz0555a0002")), productrel::getproductuuid, productrel::getlevelid));
productrelservice.list(new combinationlambdaquerychainwrapper<productrel>().combinationin(true, arrays.aslist(tuple.of(1l, "gbz0555a0002")), productrel::getid, productrel::getlevelid));