说明

高级查询是前面查询功能的进阶篇，这里将会介绍一些更为复杂的查询方式，按照复杂性依次为排序，分组，函数，视图，以及子查询等，接下来上一个比较复杂的json，而后进行全面说明，如下所示

{
    "rule": {
        "name": "group",
        "actions": [
            {
                "name": "test_group",
                "define":{
                    "viewParams":{"view.ZsTestView":["kkk","%3%"]},
                    "function":{
                        "sum":["sumSalary"],"substr":{"view.neibu.ZsTestPOView.test_field":["#","1","2"],"view.ZsTestView.test_field":["#","1","3"],
                        "[email protected]":["#","1","8"],"[email protected]":["#","1","5"]},
                        "decode":{"view.neibu.ZsTestPOView.name":["#","xxx","!!!!!!"]},"avg":["view.neibu.ZsTestPOView.qian"]
                    }
                },
                "get": {
                    "classes":["view.ZsTestView","view.neibu.ZsTestPOView"],
                    "relations": {"type":"left","main":"view.neibu.ZsTestPOView"},
                    "fields": ["view.ZsTestView.test_field","view.neibu.ZsTestPOView.test_field","substr->[email protected]","sum->sumSalary","avg->view.neibu.ZsTestPOView.qian"],
                    "order":{"view.neibu.ZsTestPOView.test_field":"asc","substr->view.neibu.ZsTestPOView.test_field":"desc"},
                    "group":{
                        "by":["substr->[email protected]","view.neibu.ZsTestPOView.test_field","view.ZsTestView.test_field"],
                        "having":{"in":{"view.neibu.ZsTestPOView.test_field":["tyu"]},"bracket":[{"equal":{"substr->[email protected]":["zzz","sss"]}}]},
                        "relation":"and"
                    }
                }
            }
        ]
    }
}

上面的json看着虽然很复杂，但是只要稍微梳理一下便能明白其中的含义，而在这里面有很多包的前缀，例如像view.neibu，这个是包的名字，并没有什么其它的含义

排序

排序使用order属性，key为字段，value为排序方式，这里后面的key使用了函数，意在说明排序时依然可以使用函数，而这主要取决于你的sql

分组

分组对应JSRuleGroups这个对象，目前只有3个属性，by、having和andOr属性

• by：顾名思义就是group by，按照哪些字段进行分组查询，这里不仅可以写字段，而且同样也是可以使用函数的，例如按照时间进行分组，每年每月每周，可以substr截取时间的字符串进行分组
• having：需要注意的是having这个属性的类型其实是JSRuleMatches，也就是前面查询功能篇所提到的查询条件这个对象模型，这里是复用了查询条件这个对象，因此里面的写法规则可以参照前面所说的
• andOr：表示逻辑关系符and或or。

生成的sql：

select suibian.test_field as "view_ZsTestView-test_field",zs_test_view_po.test_field as "view_neibu_ZsTestPOView-asddsa",substr(zs_test_view_po.test_field,'1','8') as "[email protected]",sum(sum1_salary) as "sum$lbv_salary",avg(zs_test_view_po.qian) as "avg$view_neibu_ZsTestPOView-qian" from (select * from zs_test) zs_test_view_po left join (select * from zs_test_son1 where oh_no='kkk' and id like '%3%') suibian on zs_test_view_po.id=suibian.zs_test_id group by substr(zs_test_view_po.test_field,'1','8'),zs_test_view_po.test_field,suibian.test_field having   zs_test_view_po.test_field in  ('tyu') and (  substr(suibian.test_field,'1','5')='zzz'  or  substr(suibian.test_field,'1','5')='sss') order by zs_test_view_po.test_field asc,substr(zs_test_view_po.test_field,'1','2') desc

对比json和sql可以更为有效的理解语法的含义

这里需要注意的是：不同的数据库有不同的语法，比如说mysql的group by 后面的having里如果要使用字段，譬如上面条件里的view.ZsTestView.test_field

"bracket":[{"equal":{"substr->[email protected]":["zzz","sss"]}}]

如果要使用这个字段，就必须要在select中存在这个字段（其它数据库没有这个问题），因此如果你用的是mysql数据库，那么上面json中的fields属性应该有view.ZsTestView.test_field字段，否则sql就会报错

除此之外，一些数据库的差异简单的罗列几个

1. 例如Postgresql的substr函数是从0开始计算的，而mysql是从1开始计算的
2. 同样的更新语句，在postgresql执行不通过，在其它数据库都可以，因为在Postgresql中更新语句后面的字段不能有前缀

update zs_test set zs_test.name='lkjhg' where   name='ccc'  or name='mmm' 

1. postgresql插入时没有对字符串进行自动转化其它类型的处理，因此在插入时会报错，不过这一点在框架里已经解决了，不需要开发者关注这一点，例如：salary这个字段是double类型，在json中写成双引号的字符串类型依然可以成功插入，后台会根据你Po中字段定义的类型进行转化
2. oracle数据库在使用pagehelper插件时会额外多返回PAGEHELPER_ROW_ID或ROW_ID字段

因此综上所述，不同的数据库需要不同的对待，可将sql先行打印出来再在数据库里执行一下，对比结果便不难得出结论

函数

这里再贴上一个新的示例，json如下：

{
    "rule": {
        "name": "function",
        "actions": [
            {
                "name": "test_function",
                "define":{
                    "viewParams":{"view.ZsTestView":["kkk","%1%"]},
                    "function":{
                        "ifnull":{"ZsTestPO.salary":["#","#name"]},
                        "length":["name"],"concat":{"ZsTestPO.name":["#","vnvn","kook"]},
                        "substr":{"ZsTestPO.name":["#","1","3"],"[email protected]":["#","1","5"],"view.ZsTestView.test_field":["#","1","3"],
                        "ZsTestPO.test_field":["#","1","4"],"[email protected]":["#substr->[email protected]","1","#length->name"]}
                    }
                },
                "get": {
                    "classes":["ZsTestPO","view.ZsTestView"],
                    "andOr":"or",
                    "matches":{
                        "bracket":[
                            {"bracket":[{"in":{"substr->ZsTestPO.name":["qqq"]},"like":{"substr->[email protected]":["%x%","%p%"]}}]},
                            {"bracket":[{"equal":{"substr->view.ZsTestView.test_field":["zzz"],"view.ZsTestView.test_field":["sss"]}}]}
                        ]
                    },
                    "fields": ["length->name","view.ZsTestView.test_field","substr->ZsTestPO.name","substr->[email protected]","substr->ZsTestPO.test_field",
                    "ifnull->ZsTestPO.salary","substr->[email protected]"]
                }
            }
        ]
    }
}

首先函数对应的顶级类为JSRuleFunctions，代码如下：

/**此类中的jackson注解可以控制其子类的相关jackson配置,如去掉ignoreUnknown,则同时影响当前以及子类的jackson装配*/
@JsonIgnoreProperties(ignoreUnknown=true)
public class JSRuleFunctions implements IJSRuleCustomModel{

    /**String为字段名,String[]为函数参数,无参类型为String[],有参类型为Map<String,String[]>*/
    public String[] length;
    public Map<String,String[]> substr;
    /**聚合函数*/
    public String[] sum;
    public String[] min;
    public String[] max;
    public String[] avg;
    public String[] count;
    
    public List<Field> getFunctions() {
        List<Field> fields = new ArrayList<Field>();
        for (Field f:ZSReflect.getFields(this.getClass(),JSRuleFunctions.class)) {
            try {
                if (ZSObject.sizeIsNotEmpty(f.get(this))) {
                    fields.add(f);
                }
            } catch (IllegalArgumentException | IllegalAccessException e) {
                throw new JSRuleException(e);
            }
        }
        return fields;
    }
}

这里定义了各个数据库共有的函数

1. 要使用函数首先需要在类中定义函数类型，函数名为字段名，函数分为无参函数和有参函数，无参函数例如length(字段)，计算出字段值的字符长度，以及有参函数substr(字段,1,5)，截取字符长度，无参类型为String[]数组，可以同时在length函数中定义多个字段，有参类型为Map<String,String[]>

提示：属性中只存在String[]（单体参数）和Map<String,String[]>（多体参数），单体参数通常指的是参数只包含字段本身，比如length(字段名)，sum(字段名)，多体参数表示参数有多个，例如substr(字段名，0,3)

1. 接下来需要在json中定义函数变量，如上面的json中的

"function":{
    "ifnull":{"ZsTestPO.salary":["#","#name"]},
    "length":["name"],"concat":{"ZsTestPO.name":["#","vnvn","kook"]},
    "substr":{"ZsTestPO.name":["#","1","3"],
              "[email protected]":["#","1","5"],"view.ZsTestView.test_field":["#","1","3"],
              "ZsTestPO.test_field":["#","1","4"],"[email protected]":
              ["#substr->[email protected]","1","#length->name"]}
}

这里是定义本次action请求所可能用到的函数，也可能没有用到，所以多写几个也没关系，这里的"#"表示的就是前面key所对应的表的字段名，后面则是多个参数，有几个写几个，例如"substr":{"ZsTestPO.name":["#","1","3"]}，转换成sql就是substr(zs_test.name,'1','3')。

补充说明："ifnull":{"ZsTestPO.salary":["#","#name"]}，这里的#name是指字段名而不是字符串'name'，等同于ifnull(zs_test.salary,name)，另外如果你的函数是嵌套函数，同样可以用#开头，例如上面的"[email protected]":["#substr->[email protected]","1","#length->name"]，最终转化为substr(substr(zs_test.name,'1','5'),'1',length(name))，这个例子已经非常详细了，但需要注意的是嵌套函数引用的函数必须在它之前定义，因此这里的嵌套函数的例子写在了函数定义的最后

需要注意的是：ifnull函数是mysql的函数，decode函数是oracle的函数，不同的数据库需要集成不同的函数自定义类，他们分别是JSRuleMysqlFunctions，JSRulePostgresqlFunctions，JSRuleOracleFunctions，JSRuleKingbaseFunctions，这4个扩展函数类库继承了JSRuleFunctions，如果你需要自己定义自己的函数则对应的需要继承这些类，将类注册成spring bean，加@Component等注解即可，这个在后面的自定义开发中将会详细的说明

1. 最后在json主体中引用函数的定义，截取上面的json片段

"matches":{
    "bracket":[
        {"bracket":[{"in":{"substr->ZsTestPO.name":["qqq"]},"like":{"substr->[email protected]":["%x%","%p%"]}}]},
        {"bracket":[{"equal":{"substr->view.ZsTestView.test_field":["zzz"],"view.ZsTestView.test_field":["sss"]}}]}
    ]
},
"fields": ["length->name","view.ZsTestView.test_field","substr->ZsTestPO.name","substr->[email protected]","substr->ZsTestPO.test_field",
"ifnull->ZsTestPO.salary","substr->[email protected]"]

这里列举了两个示例，一个是查询条件里使用函数，一个是在查询字段上使用函数，它们的语法都是以函数名开头+指向箭头符号（->）+字段名，注意，substr所指向的ZsTestPO.name必须是在上面所示的json主体的function中定义的，如果没有定义则会提示报错

{
    "code": "6000",
    "msg": "操作失败",
    "result": null,
    "log": "未定义的表达式:substr->ZsTestPOa.name"
}

函数别名：由于多体参数的参数值有可能不同，因此如果当你的函数多次对同一个字段进行定义时，比如substr(name,1,3)，substr(name,1,5)，则可以使用别名，语法为加后缀符号@，参考"[email protected]":["#","1","5"]，此别名只针对多体参数的函数，单体函数不可能有不同的参数存在，因此用不到

最后附上此json最后生成的sql语句：

select length(name) as "length$name",suibian.test_field as "view_ZsTestView-test_field",substr(zs_test.name,'1','3') as "substr$ZsTestPO-name",substr(zs_test.name,'1','5') as "[email protected]",substr(zs_test.test_field,'1','4') as "substr$ZsTestPO-sum_test_field",ifnull(zs_test.salary,name) as "ifnull$ZsTestPO-salary",substr(substr(zs_test.name,'1','5'),'1',length(name)) as "[email protected]" from zs_test,(select * from zs_test_son1 where oh_no='kkk' and id like '%1%') suibian where   zs_test.id=suibian.zs_test_id and (((  substr(zs_test.name,'1','3') in  ('qqq')   or  substr(zs_test.name,'1','5') like '%x%'   or  substr(zs_test.name,'1','5') like '%p%' ) and (  substr(suibian.test_field,'1','3')='zzz'  or  suibian.test_field='sss')))

总结：函数表达式可作用于查询字段、查询条件、分组、排序等。

视图

视图说通俗一点就是一个sql语句而并非是一个表，它可能是由一个表组成也可能是由多个表组成，总之就是一个查询结果集

说明：

配置视图需要在Po类上进行配置，如

@JSRuleRelationTable(tableName="suibian",view="select # from zs_test_son1 where oh_no=? and id like ?")
public class ZsTestView {

    @JSRuleRelationField(pk=true)
    public String id;
    @JSRuleRelationField(fieldName= "zs_test_id",fk="ZsTestPO")
    public String zs_test_id;
    @JSRuleRelationField(fieldName= "zs_test_id",fk="view.neibu.ZsTestPOView")
    public String zs_test_id2;
    @JSRuleRelationField(fieldName= "oh_no")
    public String ohNo;
    public Double qian;
    public String test_field;
    @JSRuleRelationField(fieldName= "zs_test_son2_id")
    public String zs_test_son2_id;
}

这里我们只看上面的@JSRuleRelationTable注解，这里的tableName是为视图起的别名（如果不是视图这里需要写表的名字），后面的view是视图的查询sql，可以单表也可以多个表，里面的#符号表示字段动态传参，参数取决于json上action中的定义对象JSRuleDefinition里的viewParams和viewFields，如果你不需要动态传参，这里直接写sql原语法select xx或* from table就可以了，系统会把这个sql作为这个对象ZsTestView进行关联处理，对应的sql含义进行对比，如下：
表：select * from tableName
视图：select * from (select * from xx) suibian
后面的?符号表示的是查询参数动态传参，参数取决于json，这里也可以直接写死参数是什么。
接下来是一个足够复杂的json主体

{
    "rule": {
        "name": "view",
        "actions": [
            {
                "name": "poAction",
                "get": {
                    "classes":["ZsTestPO"],
                    "isExecute":false,
                    "fields":["test_field"]
                }
            },
            {
                "define":{
                    "viewParams":{"view.ZsTestView":["kkk","%1%"]},
                    "viewFields":{"view.ZsTestView":[],"view.ZSTestUpdateSon":[],"view.neibu.ZsTestPOView":["name"]}
                },
                "name": "test_view_left",
                "get": {
                    "classes":["view.ZSTestUpdateSon","ZsTestPO","view.ZsTestView"],
                    "relations": {"type":"left","main":"ZsTestPO"},
                    "andOr":"or",
                    "fields":[],
                    "matches":{
                        "in":{"ZsTestPO.name":"view->view.neibu.ZsTestPOView",
                        "ZsTestPO.test_field":"action->poAction"}
                    },
                    "order":{"ZsTestPO.id":"asc"},
                    "page":{"pageNum":"1","pageSize":"10"}
                }
            }
        ]
    }
}

上面提到的动态传参，这里对应的地方是

"define":{
    "viewParams":{"view.ZsTestView":["kkk","%1%"]},
    "viewFields":{"view.ZsTestView":[],"view.ZSTestUpdateSon":[],"view.neibu.ZsTestPOView":["name"]}
}

viewParams对应的是?符号，里面的参数个数应该与视图中?符号的个数相同，按照顺序进行赋值
viewFields对应的是#符号，如果没有定义对应视图的动态字段数组，或字段数组是个空[]数组，则表示的动态字段是所有字段
这里值得注意的是：view.neibu.ZsTestPOView并没有出现在classes中，但在in查询的时候却用到了这个动态视图，因此说明viewParams属性中定义的并非仅仅是classes中的类，而是所有通过po类配置过的视图类，这个in所用到的->指向符号表达的含义是指向性操作，也就是sql语法 in (view.neibu.ZsTestPOView对应的视图sql，也可以理解为一个子查询)，这样一个in (子查询)就完成了。
生成的sql：

select zs_test_son1_son1.zs_test_id as "view_ZSTestUpdateSon-zs_test_id",zs_test_son1_son1.zs_test_son1_id as "view_ZSTestUpdateSon-zs_test_son1_id2",zs_test_son1_son1.zs_test_son1_id as "view_ZSTestUpdateSon-zs_test_son1_id",zs_test_son1_son1.oh_oh_no as "view_ZSTestUpdateSon-wolegequ",zs_test_son1_son1.id as "view_ZSTestUpdateSon-id",zs_test_son1_son1.zs_test_id as "view_ZSTestUpdateSon-id2_dawangba",zs_test.remark as "ZsTestPO-remark",zs_test.test_field as "ZsTestPO-sum_test_field",zs_test.birth_day as "ZsTestPO-birthDay",zs_test.id as "ZsTestPO-id",zs_test.bonus as "ZsTestPO-bonus",zs_test.name as "ZsTestPO-name",zs_test.salary as "ZsTestPO-salary",zs_test.qian as "ZsTestPO-qian",zs_test.create_date as "ZsTestPO-create_date",zs_test.sum1_salary as "ZsTestPO-lbv_salary",suibian.zs_test_id as "view_ZsTestView-zs_test_id",suibian.oh_no as "view_ZsTestView-ohNo",suibian.zs_test_id as "view_ZsTestView-zs_test_id2",suibian.id as "view_ZsTestView-id",suibian.qian as "view_ZsTestView-qian",suibian.test_field as "view_ZsTestView-test_field",suibian.zs_test_son2_id as "view_ZsTestView-zs_test_son2_id" from zs_test left join (select * from zs_test_son1_son1) zs_test_son1_son1 on zs_test.id=zs_test_son1_son1.zs_test_id left join (select * from zs_test_son1 where oh_no='kkk' and id like '%1%') suibian on zs_test.id=suibian.zs_test_id where   zs_test.name in (select name from zs_test)  or zs_test.test_field in (select test_field as "sum_test_field" from zs_test)  order by zs_test.id asc

生成的sql有点长，因为没有指定查询字段fields属性的缘故，默认就是查询所有字段

指向性查询

还是上面的json，我们先来看看第一个action，这个action非常简单就是从zs_test表中查询test_field字段，这里的属性"isExecute":false，表示这个action并不需要执行，它只为第二个action的子查询sql，因此虽然是两个action，但却只执行了第二个。
我们再看下面的json片段

"matches":{
    "in":{"ZsTestPO.name":"view->view.neibu.ZsTestPOView",
    "ZsTestPO.test_field":"action->poAction"}
}

这里第二行表达式action->poAction指向了上面第一个action的名字，也就是将第一个action查询的sql作为子查询放进了in的参数里，这与先前的in (视图) 子查询其实是一个意思，指向性操作目前只有view以及action两种方式

注意：作为子查询的action一定要写在前面

---

总结：高级查询其实可以满足绝大部分应用场景了，如果有极个别的特殊需求也可以通过扩展接口来变相实现，这些自定义开发规则将在后面的介绍中详细说明