davinci sql 组装where 部分的思路

 

SqlFilter  条件组装类：

 

sqlType ==datatype  字段类型

这里有OR

 

operator    between 类型比较

 

Type   本身过滤条件中也可设置oR   and主要用于between  or 还没有试用代码（可以自己实现成本身的or 一个属性多个或）

filter---该字段属于过滤条件

relation

and

or

 

ViewExecuteParam  传入条件信息

    formatColumn ---别名控制

   Criterion  每个条件的操作信息（由ViewExecuteParam部分条件参数完成）

 

 

所有的where 后面部分的条件组合都可适用，需要不同where的组合可在模板固定where 1=1 然后就是分部的条件块，不能像原始的模板where 和一个条件块固定在一起

 

sql：

 

子查询内部的条件在原sql写好

 

SELECT m.*, s.event_property_code,s.event_property_value FROM cms.daily_new_client88_master m LEFT JOIN cms.daily_new_client88_slave s on m.event_id= s.event_id 

 

模板：

 

querySqlAndOrms(nativeQuery, groups, aggregators, filters, orders, sql, keywordPrefix, keywordSuffix,filterAndFlag,eventCode)

::=<<

<if(!groups && !aggregators && !filters && !orders)>

<sql>

<else>

SELECT

<if(!groups && !aggregators)>

 *

<endif>

<if(groups)>

 <groups:{group|<if(keywordPrefix && keywordSuffix)><keywordPrefix><group><keywordSuffix><else><group><endif>}; separator=",">

<endif>

<if(groups && aggregators)>,<endif>

<if(aggregators)>

<if(nativeQuery)>

 <aggregators:{agg|<if(agg)><if(keywordPrefix && keywordSuffix)><keywordPrefix><agg.column><keywordSuffix><else><agg.column><endif><endif>}; separator=",">

<else>

 <aggregators:{agg|<if(agg)><agg><endif>}; separator=",">

<endif>

<endif>

FROM (<sql>) T

<if(eventCode)>

WHERE <eventCode>

<endif>

<if(!eventCode)>

WHERE 1=1

<endif>

<if(filters && filterAndFlag)>

 AND ( <filters:{filter|<if(filter)><filter><endif>}; separator=" AND "> )

<endif>

<if(filters && !filterAndFlag)>

AND ( <filters:{filter|<if(filter)><filter><endif>}; separator=" OR "> )

<endif>

<if(groups)>

<if(!nativeQuery)>

GROUP BY <groups:{group|<if(keywordPrefix && keywordSuffix)><keywordPrefix><group><keywordSuffix><else><group><endif>}; separator=",">

<endif>

<endif>

<if(orders)>

ORDER BY <orders:{order|<if(order)><order.column> <order.direction><endif>}; separator=", ">

<endif>

<endif>

>>

 

 

 

 

 public List<String> convertFilters(List<String> filterStrs, Source source){-----每一部分完成每一部分的所有组装（除了sql关键字）------------把所有的filter组装成完整的where过滤条件

        List<String> whereClauses = new ArrayList<>();

        List<SqlFilter> filters = new ArrayList<>();

        try{

            if(null == filterStrs || filterStrs.isEmpty()){

                return null;

            }

 

            for(String str : filterStrs){----所有的过滤字段

                SqlFilter obj = JSON.parseObject(str, SqlFilter.class);---------

                if(!StringUtils.isEmpty(obj.getName())){

                    obj.setName(ViewExecuteParam.getField(obj.getName(), source.getJdbcUrl(), source.getDbVersion()));----判断是否需要前后缀

                }

                filters.add(obj);

            }

            filters.forEach(filter -> whereClauses.add(SqlFilter.dealFilter(filter)));--------------经过dealFilter就把每个filter中组装成where条件后的完整过滤语句

 

        }catch (Exception e){

            log.error("convertFilters error . filterStrs = {}, source = {}, filters = {} , whereClauses = {} ",

                    JSON.toJSON(filterStrs), JSON.toJSON(source), JSON.toJSON(filters), JSON.toJSON(whereClauses));

            throw e;

        }

        return whereClauses;

    }

 

 

 

 

 

   public static String dealFilter(SqlFilter filter){

        StringBuilder condition = new StringBuilder();

        String type = filter.getType();

 

        if(Type.filter.equalsIgnoreCase(type)){-----条件类的（字段的对比操作信息）

            condition.append(dealOperator(filter));

        }

 

        if(Type.relation.equalsIgnoreCase(type)){

            List<SqlFilter> childs = filter.getChildren();

            condition.append(Consts.PARENTHESES_START);

            for(int i=0; i<childs.size(); i++){

                condition.append(i == 0 ? dealFilter(childs.get(i))

 

                        : Consts.SPACE + filter.getValue().toString() + Consts.SPACE + dealFilter(childs.get(i)));

            }

            condition.append(Consts.PARENTHESES_END);

        }

 

        return condition.toString();

    }

 

 

    private static String dealOperator(SqlFilter filter){

        String name     = filter.getName();

        Object value    = filter.getValue();

        String operator = filter.getOperator();

        String sqlType  = filter.getSqlType();

 

        Criterion criterion;

        if(SqlOperatorEnum.BETWEEN.getValue().equalsIgnoreCase(operator)){

            JSONArray values = (JSONArray) value;

            criterion = new Criterion(name, operator, values.get(0), values.get(1), sqlType);----对一个字段的对比操作信息

        }else{

            criterion = new Criterion(name, operator, value, sqlType);

        }

 

        return generator(criterion);

    }

 

 

 

 

 

private static String generator(Criterion criterion){----正真生成每个条件的对比操作信息---每一个条件完成一个条件的完整操作的信息

        StringBuilder whereClause = new StringBuilder();

        if(criterion.isSingleValue()){---单值操作

            //column='value'

            String value = criterion.getValue().toString();

            whereClause.append(criterion.getColumn() + Consts.SPACE + criterion.getOperator() + Consts.SPACE);

            if(criterion.isNeedApostrophe() && !Pattern.matches(pattern, value)){

                whereClause.append(Consts.APOSTROPHE + value + Consts.APOSTROPHE);

            }else{

                whereClause.append(value);

            }

 

        }else if(criterion.isBetweenValue()){ ---- between

            //column>='' and column<=''

            String value1 = criterion.getValue().toString();

            whereClause.append(Consts.PARENTHESES_START);

            whereClause.append(criterion.getColumn()+ Consts.SPACE + SqlOperatorEnum.GREATERTHANEQUALS.getValue() + Consts.SPACE);

            if(criterion.isNeedApostrophe() && !Pattern.matches(pattern, value1)){

                whereClause.append(Consts.APOSTROPHE + value1 + Consts.APOSTROPHE);

            }else{

                whereClause.append(value1);

            }

            whereClause.append(Consts.SPACE + SqlFilter.Type.and + Consts.SPACE);

            whereClause.append(criterion.getColumn()+ Consts.SPACE + SqlOperatorEnum.MINORTHANEQUALS.getValue() + Consts.SPACE);

            String value2 = criterion.getSecondValue().toString();

            if(criterion.isNeedApostrophe() && !Pattern.matches(pattern, value2)){

                whereClause.append(Consts.APOSTROPHE + value2 + Consts.APOSTROPHE);

            }else{

                whereClause.append(value2);

            }

            whereClause.append(Consts.PARENTHESES_END);

 

        }else if(criterion.isListValue()){  -----in

            List values = (List) criterion.getValue();

            //column in ()

            whereClause.append(criterion.getColumn() + Consts.SPACE + criterion.getOperator() + Consts.SPACE);

            whereClause.append(Consts.PARENTHESES_START);

            if(criterion.isNeedApostrophe() && !Pattern.matches(pattern, values.get(0).toString())){

                whereClause.append(Consts.APOSTROPHE +

                        StringUtils.join(values,Consts.APOSTROPHE + Consts.COMMA + Consts.APOSTROPHE) +

                        Consts.APOSTROPHE);

            }else{

                whereClause.append(StringUtils.join(values, Consts.COMMA));

            }

            whereClause.append(Consts.PARENTHESES_END);

        }

        return whereClause.toString();

    }