精华内容
下载资源
问答
  • mybatis中数组空值查询条件

    千次阅读 2015-11-04 14:03:27
    原: and  open="(" separator=" or " close=")">  p. BK_RT_RMK like '%'||...传过来可能是一个数组payOrdVo.bkRtRmkArr[] ,有值为payOrdVo.bkRtRmkArr[0] =" ",所以条件仍然符合 现: and  open="(" separa

    原:<if test="payOrdVo.bkRtRmkArr != null and payOrdVo.bkRtRmkArr != ' ' ">

    and 
    <foreach item="item" index="index" collection="payOrdVo.bkRtRmkArr"
    open="(" separator=" or " close=")">
     p. BK_RT_RMK like '%'||#{item}||'%'
     </foreach>
    </if> 

    传过来的可能是一个数组payOrdVo.bkRtRmkArr[] ,有值为payOrdVo.bkRtRmkArr[0] =" ",条件仍然符合


    现:<if test="payOrdVo.bkRtRmkArr != null and payOrdVo.bkRtRmkArr != '' and payOrdVo.bkRtRmkArr[0] !=' '  " >

    and 
    <foreach item="item" index="index" collection="payOrdVo.bkRtRmkArr"
    open="(" separator=" or " close=")">
    p. BK_RT_RMK like '%'||#{item}||'%'
    </foreach>
    </if> 
    展开全文
  • 但在做时候type字段就会发送空,查询时就等于 board='BMW'AND year="2013" AND type='' 我要实现 不选择字段IS NOT NULL就是BMW和2013所有车型, board='BMW'AND year="2013" AND type is not null ...
  • 例如Filter Query Missing已在es5以后版本废除,简单点就是以前我们可以在kibana这样查数学成绩为空数量: GET /student/doc/_search { "query": { "bool": { "must": [ {"match": { "...

    现在es已经更新至6.5版本,有些用法已经被抛弃,不在使用。例如Filter Query Missing已在es5以后的版本废除,简单点就是以前我们可以在kibana这样查数学成绩为空的数量:

    GET /student/doc/_search
    {
      "query": {
        "bool": {
          "must": [
            {"match": {
              "subject": "数学"
            }},
            {"constant_score": {
              "filter": 
                  {"missing": {
                    "field": "grade"
              }},
              "boost": 1.2
            }}
          ]
        }
      }
    }

    但结果是:

    抛弃了Filter Query Missing的用法,是因为官方觉得用exists就足够解决这个问题,例如上面的查询可以修改为:

    GET /student/doc/_search
    {
      "query": {
        "bool": {
          "must": [
            {"match": {
              "subject": "数学"
            }}
          ],"must_not": [
            {"exists": {"field": "grate"}}
          ]
        }
      }
    }

    那么现在问题来了!

    但我要查询空值为非必要条件是该怎么查询呢?例如上面的查询如果我要查数学成绩为空或者数学成绩在60以下的数量该怎么查询以前还可以用should包含missing和range查询,为了这个问题我是焦头烂耳,网上的资源大多没有及时更新。终于我在官网看文档中找到了解决方法!!

    废话少说,直奔主题。

    通过上图我们知道可以missing虽然在Query中被抛弃,但在Aggregation中仍然可以使用,解决办法:

    GET /student/doc/_search
    {
      "query": {
        "bool": {
          "must": [
            {"match": {
              "subject": "数学"
            }}
          ]
        }
      },"aggs": {
        "missGrate": {
          "missing": {
            "field": "grade"
          }
        },
        "filter":{
          "filter": {
            "range": {
              "grade": {
                "lte": 60
              }
            }
          }
        }
      }
    }

    通过聚合我就可以去查询空值为非必要条件的查询,但仍然有个缺陷就是无法获取具体详细信息,虽然我只要求获取数量。希望厉害的大神能够补充。具体API实现我就不贴了,也不难。

    本篇文章为小弟第一次写博客,如有不正确的请通知,及时改正。


    更新:如果不用聚合的query查询的话,使用

    {
      "query": {
        "bool": {
          "must": [
            {"bool": {"must_not": [
              {"exists": {"field": "your_field"}}
            ]}}
          ]
        }
      }}

     

    展开全文
  • 在之前做的一个基于java的web项目中,有很多多条件查询,每个条件都需要判断下是不是空,然后再拼起来,做组合查询,觉得很烦,就想能不能自己封装一套高层的api,自动忽略空值的条件,自动实现统计总数,自动翻页,...

        在之前做的一个基于java的web项目中,有很多多条件查询,每个条件都需要判断下是不是空,然后再拼起来,做组合查询,觉得很烦,就想能不能自己封装一套高层的api,自动忽略空值的条件,自动实现统计总数,自动翻页,等功能;后来又加上了条件优先级,如果某个字段不是空,则其他某个字段不参与查询(就是条件优先级,比如如果条件2不是空,则条件1不生效),这样我就自己写了一个符合这个要求的实现。我觉得这个东西有价值,跟大家分享一下。

        访问数据库我用的hibernate,我的这套api跟hibernate的critical查询比较像,不过我是基于hql拼条件的思路做的,下面看例子:

    原来多条件查询的例子:

     1     @Override
     2     @Transactional(readOnly = true, rollbackFor = Exception.class )
     3     public Page<Dictionary> findByPage(int pageNo, String table, String name,Dictionary pareDict) {
     4         Page<Dictionary> page = new Page<Dictionary>();
     5         page.setAutoCount(true);
     6         page.setPageNo(pageNo);
     7         page.setPageSize(5);
     8         
     9         if(name==null || name.equals("")){//判断输入条件的空值
    10             if(pareDict!=null){
    11                 Query query = getQueryForFind(pareDict.getId(), table);
    12                 int count = query.list().size();
    13                 List<Dictionary> list = query.setMaxResults(5).setFirstResult((pageNo - 1) * 5).list();
    14                 page.setRows(list);
    15                 page.setTotal(count);
    16                 return page;
    17             }else{
    18                 return dictionaryDao.findByCriteria(page,Restrictions.eq("tableName", table));
    19             }
    20             
    21         }else{
    22             if(pareDict!=null){//判断输入条件空值
    23return dictionaryDao.findByCriteria(page,Restrictions.eq("tableName", table),
    24 Restrictions.like("name", "%"+name+"%"),Restrictions.eq("parentTable", pareDict));
    25             }else{
    26                 return dictionaryDao.findByCriteria(page,Restrictions.eq("tableName", table),
    27                         Restrictions.like("name", "%"+name+"%"));
    28             }
    29         }
    30 
    31     }

    这个例子逻辑看不懂没有关系,只要能看出来原来是怎么根据多个条件进行判断的就好了,相信很多做过java的人都会有这方面的经验。

        以下是使用我写的api查询的例子:

        private List<Well> find(Integer jobid, String state, List<String> wellNames) throws Exception {
            
            Page<WellJob> page = new Page<WellJob>();//初始化一个分页查询结果对象,用于接收查询结果
            page.setPageSize(rows.size());//设置一页大小
            PageQuery<WellJob> query = new PageQuery<WellJob>(page);//用page对象构造查询对象
            query.setCount(false);//设定是否自动获取总数,如果获取的话,只会统计一次
            query.addTable(WellJob.class, null);//addtable可以多次调用,用于联合查询,第二个参数是表别名,null的话表示用默认值
            query.addConditon("jobType.id", OP.eq, jobid).and("state", OP.eq, state).and("well.wellNum", OP.in, wellNames);
    //addCondition 这个方法表示设置条件的开始,只能调用一次,如果第三个参数是null,则忽略这次方法调用
    //add 与条件,如果第三个参数是null,忽略这次方法调用
    //query 对象上基本每个api的返回值都是自身,api可以连续调用,编码更流畅
    this.pageQueryService.getNextPage(query);//获取下一页,如果page参数从页面上传回来,这个方法就是翻页了 //this.pageQueryService 对象是全局对象,基本上就是个壳,不用关心,主要功能都是在query对象里边实现的

    //以下代码都是分析结果的,于查询api关系不大 Set<Long> wellNumSet = new HashSet<Long>(); for (WellJob wj : page.getRows()) { wellNumSet.add(wj.getWell().getId()); } List<Well> result = new ArrayList<Well>(rows.size() - wellNumSet.size()); for (Well w : rows) { if (!wellNumSet.contains(w.getId())) { result.add(w); } } return result; }

        查询对象的主要api:

    package com.secneo.common;
    
    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Locale;
    import java.util.Map;
    
    import org.apache.commons.lang.xwork.StringUtils;
    import org.hibernate.Query;
    import org.hibernate.classic.Session;
    import org.secneo.framework.orm.hibernate.Page;
    
    /**
     * 分页查询 工具, 原理类似hibernate 的critical工具,但用法上不同, 可以与pageQueryService 配合,在 action中直接使用,
     * 本质上该工具是对hql的封装, 封装后
     * 目的是提供简易的分页查询接口,可以设定为自动计算总条目数。
     * 可以设定条件的替换规则,如 第二个条件不为空时 ,第一个条件则不生效,
     * 
     * @author ZDCIN
     *
     */
    public class PageQuery<T> {
        
        private Page<T> page;
    //    private List<String> tables = new ArrayList<String>();
        private String where = "";
        private Map<Integer, CondTuple> conditionMap = new HashMap<Integer, CondTuple>();
        private String orderBy = "";
        
        private int conditionIndex = 0;
        private boolean isCount = true;
        
        /**
         * 查看是否计算总数, 默认true, 计算总数的条件是 isCount = true
         * @return
         */
        public boolean isCount() {
            return isCount;
        }
        /**
         * 设置是否计算总数, 默认true
         * @return
         */
        public void setCount(boolean isCount) {
            this.isCount = isCount;
        }
        /**
         * 设定page对象,和返回类型T
         * @param page
         */
        public PageQuery(Page<T> page) {
            this.page = page;
        }
    
        private String selectSql = "";
    
        /**
         * 当获取字段不是一个标准bean或者不是一个bean的全部字段的时候使用, 默认不用调用该方法
         * @param selectSql
         * @return
         */
        public PageQuery<T> setSelectSql(String selectSql) {
            this.selectSql = selectSql;
            return this;
        }
        private String countSql;
        
        /**
         * 当count语句不能从select简易变化过来的时候使用。 比如有distinct限制的时候
         * @param countSql
         * @return
         */
        public PageQuery<T> setCountSql(String countSql) {
            this.countSql = countSql;
            return this;
        }
    
        private String fromSql;
        
        /**
         * 添加要查询的表,并设定别名, 该方法可以多次调用,作为多表联合查询。
         * @param tableClass
         * @param alias  可以为空,表示没有别名
         * @return
         */
        @SuppressWarnings("rawtypes")
        public PageQuery<T> addTable(Class tableClass, String alias) {
           。。。。。
        }
    
        /**
         * 添加条件, 该方法只能调用一次,且必须在and 或者or之前调用
         * @param filedName 字段名, 别名和字段的组合形式,
         * @param op 字段上的条件操作, 如等于, 大于, in like等,
         * @param value  如果value为空,则该条件不生效,  但当op是 innotnull或者isnull的时候例外,该条件会生效
         * @return
         */
        public PageQuery<T> addConditon(String filedName, OP op, Object value) {
           。。。。
        }
    
    
        /**
         *  addConditon(String filedName, OP op, Object value) 的简写形式, op 是eq
         * @param filedName
         * @param value
         * @return
         */
        public PageQuery<T> addConditon(String filedName, Object value) {
            return this.addConditon(filedName, OP.eq, value);
        }
    
        private static enum LogicOp {
            and, or;
        }
    
        private PageQuery<T> and_AND_or(LogicOp logicOP, String filedName, OP op, Object value,
                String replaceWhich) {
            。。。。
        }
    
        /**
         * 添加and条件, where中的条件都是平级的,如果有括号,则用逻辑运算规则拉平
         * 
         * @param filedName  与addConditon中意义相同
         * @param op  与addConditon中意义相同
         * @param value  与addConditon中意义相同
         * @param replaceWhich  替换列表, 如果该方法中value不为空,则替换列表中的字段,如“1,2” 
         * 
         * @return
         */
        public PageQuery<T> and(String filedName, OP op, Object value, String replaceWhich) {
            return this.and_AND_or(LogicOp.and,  filedName, op, value, replaceWhich);
        }
    
        /**
         * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
         * @param filedName
         * @param op
         * @param value
         * @return
         */
        public PageQuery<T> and(String filedName, OP op, Object value) {
            return this.and_AND_or(LogicOp.and,  filedName, op, value, null);
        }
    
        /**
         * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
         * @param filedName
         * @param value
         * @return
         */
        public PageQuery<T> and(String filedName, Object value) {
            return this.and_AND_or(LogicOp.and,  filedName, OP.eq, value, null);
        }
    
        /**
         * 添加or条件, where中的条件都是平级的,如果有括号,则用逻辑运算规则拉平
         * 
         * @param filedName  与addConditon中意义相同
         * @param op  与addConditon中意义相同
         * @param value  与addConditon中意义相同
         * @param replaceWhich  替换列表, 如果该方法中value不为空,则替换列表中的字段,如“1,2” 
         * 
         * @return
         */
        public PageQuery<T> or(String filedName, OP op, Object value, String replaceWhich) {
            return this.and_AND_or(LogicOp.or,  filedName, op, value, replaceWhich);
        }
    
    
        /**
         * 同  or(String filedName, OP op, Object value, String replaceWhich)
         * @param filedName
         * @param op
         * @param value
         * @return
         */
        public PageQuery<T> or(String filedName, OP op, Object value) {
            return this.and_AND_or(LogicOp.or, filedName, op, value, null);
        }
    
        /**
         * 同  or(String filedName, OP op, Object value, String replaceWhich)
         * @param filedName
         * @param value
         * @return
         */
        public PageQuery<T> or(String filedName, Object value) {
            return this.and_AND_or(LogicOp.or, filedName, OP.eq, value, null);
        }
        
        /**
         * 添加排序, 可调用多次
         * @param filedName  与addConditon中意义相同
         * @param orderType OrderType.ASC, OrderType.DESC
         * @return
         */
        public PageQuery<T> addOrderBy(String filedName, OrderType orderType) {
            。。。。
        }
        
        
        /**
         * 执行查询, 在pageQueryService中调用, service可以提供hibernate session对象
         * @param currentSession
         * @return
         */
        public Page<T> excuteQuery(Session currentSession) {
            。。。。
        }
    }

     

       page对象api:

    public class Page<T> {public Page() {
        }
        public Page(Integer pageSize, boolean autoCount) {
        }
        /**
         * 每页的记录数量,默认值 15.
         */
        public Integer getPageSize() {
        }
        public boolean isPageSizeSetted() {
        }
        public void setPageSize(Integer pageSize) {
        }
        /**
         * 当前页的页号,序号从1开始.
         */
        public Integer getPageNo() {
        }
        public void setPageNo(Integer pageNo) {
        }
        /**
         * 第一条记录在结果集中的位置,序号从0开始.
         */
        public Integer getFirst() {
        }
        public boolean isFirstSetted() {
        }
        public boolean isOrderBySetted() {
        }
        /**
         * 是否自动获取总页数,默认为false,query by HQL时本属性无效.
         */
        public boolean isAutoCount() {
        }
        public void setAutoCount(boolean autoCount) {
        }
        /**
         * 页内的数据列表.
         */
        public List<T> getRows() {
        }
        public void setRows(List<T> result) {
        }
        /**
         * 总记录数.
         */
        public Integer getTotal() {
        }
        public void setTotal(Integer totalCount) {
        }
        /**
         * 计算总页数.
         */
        public Integer getTotalPages() {
        }
        /**
         * 是否还有下一页.
         */
        public boolean isHasNext() {
        }
    
        /**
         * 返回下页的页号,序号从1开始.
         */
        public Integer getNextPage() {
        }
        /**
         * 是否还有上一页.
         */
        public boolean isHasPre() {
        }
        /**
         * 返回上页的页号,序号从1开始.
         */
        public Integer getPrePage() {
        }
        /**
         * 得到分页条件仅支持like查询
         */
        public Map<String, Object> getCondition() {
        }
        public void setCondition(Map<String, Object> condition) {
        }
        /**
         * 多排序条件
         * 
         * @return
         */
        public String[][] getOrderByArr() {
        }
        public void setOrderByArr(String[][] orderByArr) {
        }
        public String getMemo() {
        }
        public void setMemo(String memo) {
        }
    }

    page对象功能比较直观,但因为大部分代码都不是我写的,page的源码我就不提供了。

     

        这个api就是为了解决多个条件任意组合的联合查询的问题,省去if判断空值,省去写额外的统计总数代码,还提供条件优先级的功能。

        我的这个代码不会那么容易跑起来,我觉得比代码更重要的是,提供一种简化问题、解决问题的思路。如果读者您对这个问题跟我一样感兴趣,欢迎讨论。

      以下是query对象和queryService对象的的全部源码:

      1 import java.math.BigDecimal;
      2 import java.math.BigInteger;
      3 import java.util.ArrayList;
      4 import java.util.Date;
      5 import java.util.HashMap;
      6 import java.util.List;
      7 import java.util.Locale;
      8 import java.util.Map;
      9 
     10 import org.apache.commons.lang.xwork.StringUtils;
     11 import org.hibernate.Query;
     12 import org.hibernate.classic.Session;
     13 import org.secneo.framework.orm.hibernate.Page;
     14 
     15 /**
     16  * 分页查询 工具, 原理类似hibernate 的critical工具,但用法上不同, 可以与pageQueryService 配合,在 action中直接使用,
     17  * 本质上该工具是对hql的封装, 封装后
     18  * 目的是提供简易的分页查询接口,可以设定为自动计算总条目数。
     19  * 可以设定条件的替换规则,如 第二个条件不为空时 ,第一个条件则不生效,
     20  * 
     21  * @author ZDCIN
     22  *
     23  */
     24 public class PageQuery<T> {
     25     
     26     private Page<T> page;
     27 //    private List<String> tables = new ArrayList<String>();
     28     private String where = "";
     29     private Map<Integer, CondTuple> conditionMap = new HashMap<Integer, CondTuple>();
     30     private String orderBy = "";
     31     
     32     private int conditionIndex = 0;
     33     private boolean isCount = true;
     34     
     35     /**
     36      * 查看是否计算总数, 默认true, 计算总数的条件是 isCount = true
     37      * @return
     38      */
     39     public boolean isCount() {
     40         return isCount;
     41     }
     42     /**
     43      * 设置是否计算总数, 默认true
     44      * @return
     45      */
     46     public void setCount(boolean isCount) {
     47         this.isCount = isCount;
     48     }
     49     /**
     50      * 设定page对象,和返回类型T
     51      * @param page
     52      */
     53     public PageQuery(Page<T> page) {
     54         this.page = page;
     55     }
     56 
     57     private String selectSql = "";
     58 
     59     /**
     60      * 当获取字段不是一个标准bean或者不是一个bean的全部字段的时候使用, 默认不用调用该方法
     61      * @param selectSql
     62      * @return
     63      */
     64     public PageQuery<T> setSelectSql(String selectSql) {
     65         this.selectSql = selectSql;
     66         return this;
     67     }
     68     private String countSql;
     69     
     70     /**
     71      * 当count语句不能从select简易变化过来的时候使用。 比如有distinct限制的时候
     72      * @param countSql
     73      * @return
     74      */
     75     public PageQuery<T> setCountSql(String countSql) {
     76         this.countSql = countSql;
     77         return this;
     78     }
     79 
     80     private String fromSql;
     81     
     82     /**
     83      * 添加要查询的表,并设定别名, 该方法可以多次调用,作为多表联合查询。
     84      * @param tableClass
     85      * @param alias  可以为空,表示没有别名
     86      * @return
     87      */
     88     @SuppressWarnings("rawtypes")
     89     public PageQuery<T> addTable(Class tableClass, String alias) {
     90         if (StringUtils.isBlank(this.fromSql)) {
     91             this.fromSql = " FROM ";
     92         } else {
     93             this.fromSql += ", ";
     94         }
     95         if (StringUtils.isNotBlank(alias)) {
     96             this.fromSql += tableClass.getSimpleName() + " AS " + alias;
     97         } else {
     98             this.fromSql += tableClass.getSimpleName() + " ";
     99         }
    100         return this;
    101     }
    102 
    103     /**
    104      * 添加条件, 该方法只能调用一次,且必须在and 或者or之前调用
    105      * @param filedName 字段名, 别名和字段的组合形式,
    106      * @param op 字段上的条件操作, 如等于, 大于, in like等,
    107      * @param value  如果value为空,则该条件不生效,  但当op是 innotnull或者isnull的时候例外,该条件会生效
    108      * @return
    109      */
    110     public PageQuery<T> addConditon(String filedName, OP op, Object value) {
    111         CondTuple tuple = new CondTuple(null, filedName, op, value, null);
    112         this.conditionMap.put(this.conditionIndex ++, tuple);
    113         return this;
    114 //        if (value == null) {
    115 //            return this;
    116 //        }
    117 //        //String filedFullName = this.filedName(tableIndex, filedName);
    118 //        this.condition = " WHERE " + filedName + op.v() + ":" + filedName;
    119 //        this.conditionMap.put(filedName, value);
    120 //        return this;
    121     }
    122 
    123 
    124     /**
    125      *  addConditon(String filedName, OP op, Object value) 的简写形式, op 是eq
    126      * @param filedName
    127      * @param value
    128      * @return
    129      */
    130     public PageQuery<T> addConditon(String filedName, Object value) {
    131         return this.addConditon(filedName, OP.eq, value);
    132     }
    133 
    134     private static enum LogicOp {
    135         and, or;
    136     }
    137 
    138     private PageQuery<T> and_AND_or(LogicOp logicOP, String filedName, OP op, Object value,
    139             String replaceWhich) {
    140         CondTuple tuple = new CondTuple(logicOP, filedName, op, value, replaceWhich);
    141         this.conditionMap.put(this.conditionIndex ++, tuple);
    142         return this;
    143 //        if (value == null) {
    144 //            return this;
    145 //        }
    146 //        if (StringUtils.isBlank(this.condition)) {
    147 //            this.condition = " WHERE ";
    148 //        } else {
    149 //            this.condition += " " + logicOP.name() + " ";
    150 //        }
    151 //        //String filedFullName = this.filedName(tableIndex, filedName);
    152 //        this.condition += filedName + op.v() + ":" + filedName;
    153 //        this.conditionMap.put(filedName, value);
    154 //        return this;
    155     }
    156 
    157     /**
    158      * 添加and条件, where中的条件都是平级的,如果有括号,则用逻辑运算规则拉平
    159      * 
    160      * @param filedName  与addConditon中意义相同
    161      * @param op  与addConditon中意义相同
    162      * @param value  与addConditon中意义相同
    163      * @param replaceWhich  替换列表, 如果该方法中value不为空,则替换列表中的字段,如“1,2” 
    164      * 
    165      * @return
    166      */
    167     public PageQuery<T> and(String filedName, OP op, Object value, String replaceWhich) {
    168         return this.and_AND_or(LogicOp.and,  filedName, op, value, replaceWhich);
    169     }
    170 
    171     /**
    172      * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
    173      * @param filedName
    174      * @param op
    175      * @param value
    176      * @return
    177      */
    178     public PageQuery<T> and(String filedName, OP op, Object value) {
    179         return this.and_AND_or(LogicOp.and,  filedName, op, value, null);
    180     }
    181 
    182     /**
    183      * and(String filedName, OP op, Object value, String replaceWhich) 的简写形式
    184      * @param filedName
    185      * @param value
    186      * @return
    187      */
    188     public PageQuery<T> and(String filedName, Object value) {
    189         return this.and_AND_or(LogicOp.and,  filedName, OP.eq, value, null);
    190     }
    191 
    192     /**
    193      * 添加or条件, where中的条件都是平级的,如果有括号,则用逻辑运算规则拉平
    194      * 
    195      * @param filedName  与addConditon中意义相同
    196      * @param op  与addConditon中意义相同
    197      * @param value  与addConditon中意义相同
    198      * @param replaceWhich  替换列表, 如果该方法中value不为空,则替换列表中的字段,如“1,2” 
    199      * 
    200      * @return
    201      */
    202     public PageQuery<T> or(String filedName, OP op, Object value, String replaceWhich) {
    203         return this.and_AND_or(LogicOp.or,  filedName, op, value, replaceWhich);
    204     }
    205 
    206 
    207     /**
    208      * 同  or(String filedName, OP op, Object value, String replaceWhich)
    209      * @param filedName
    210      * @param op
    211      * @param value
    212      * @return
    213      */
    214     public PageQuery<T> or(String filedName, OP op, Object value) {
    215         return this.and_AND_or(LogicOp.or, filedName, op, value, null);
    216     }
    217 
    218     /**
    219      * 同  or(String filedName, OP op, Object value, String replaceWhich)
    220      * @param filedName
    221      * @param value
    222      * @return
    223      */
    224     public PageQuery<T> or(String filedName, Object value) {
    225         return this.and_AND_or(LogicOp.or, filedName, OP.eq, value, null);
    226     }
    227     
    228     /**
    229      * 添加排序, 可调用多次
    230      * @param filedName  与addConditon中意义相同
    231      * @param orderType OrderType.ASC, OrderType.DESC
    232      * @return
    233      */
    234     public PageQuery<T> addOrderBy(String filedName, OrderType orderType) {
    235         if (StringUtils.isBlank(filedName)) {
    236             return this;
    237         }
    238         if (StringUtils.isBlank(this.orderBy)) {
    239             this.orderBy = " ORDER BY ";
    240         } else {
    241             this.orderBy += ",";
    242         }
    243         this.orderBy += filedName + " " + orderType.name();
    244         return this;
    245     }
    246     
    247     
    248     /**
    249      * 执行查询, 在pageQueryService中调用, service可以提供hibernate session对象
    250      * @param currentSession
    251      * @return
    252      */
    253     public Page<T> excuteQuery(Session currentSession) {
    254         List<Integer> replaceList = this.getReplaceList();
    255         this.buildWhereStatementInSql(replaceList);
    256        
    257         if (page.getTotal() == -1) {
    258             String countHql = "SELECT " + (StringUtils.isBlank(this.countSql) ? " COUNT(*) " : this.countSql)
    259                     + this.fromSql + this.where;
    260 
    261             Query hquery = currentSession.createQuery(countHql);
    262             this.buildHibernateQuery(replaceList, hquery);
    263             Long totalCol = (Long) hquery.uniqueResult();
    264 
    265             page.setTotal(totalCol.intValue());
    266             // page.setPageNo(1);//肯定是从第一页开始
    267         }
    268         String hql = this.selectSql + this.fromSql + this.where + this.orderBy;
    269         System.out.println("query sql is:" + hql);
    270         Query hquery = currentSession.createQuery(hql);
    271         this.buildHibernateQuery(replaceList, hquery);
    272         @SuppressWarnings("unchecked")
    273         List<T> resultSet= hquery.setFirstResult(this.page.getFirst()).setMaxResults(this.page.getPageSize()).list();
    274         this.page.setRows(resultSet);
    275         return this.page;
    276     }
    277     
    278     private void buildHibernateQuery(List<Integer> replaceList, Query hquery) {
    279         for (int i = 0; i < this.conditionIndex; i++) {
    280             CondTuple tuple = this.conditionMap.get(i);
    281             if (replaceList.contains(i)) {
    282                 continue;
    283             }
    284             if (tuple.value != null && !tuple.op.equals(OP.in)) {
    285                 this.putObjectToHql(hquery, tuple.valueNameInHql + i, tuple.value);
    286             }
    287         }
    288     }
    289 
    290     private void putObjectToHql(Query hquery, String valueNameInHql, Object value) {
    291 //        valueNameInHql = valueNameInHql.replace('.', '_');
    292       //valueName 是hql中的冒号后边的单词,用于hql执行时用变量替换,里边不能含有下列字符
    293 //        String valueNameInHql =  valueNameInHql;
    294         valueNameInHql = valueNameInHql.replace('.', '_');
    295         valueNameInHql = valueNameInHql.replaceAll(" ", "");
    296         valueNameInHql = valueNameInHql.replaceAll("-", "");
    297         valueNameInHql = valueNameInHql.replaceAll("\\(", "");
    298         valueNameInHql = valueNameInHql.replaceAll("\\)", "");
    299         if (value instanceof Long) {
    300             hquery.setLong(valueNameInHql, (Long) value);
    301         } else if (value instanceof String) {
    302             hquery.setString(valueNameInHql, (String) value);
    303         } else if (value instanceof Date) {
    304             hquery.setTimestamp(valueNameInHql, (Date) value);
    305         } else if (value instanceof BigDecimal) {
    306             hquery.setBigDecimal(valueNameInHql, (BigDecimal) value);
    307         } else if (value instanceof Integer) {
    308             hquery.setInteger(valueNameInHql, (Integer) value);
    309         } else if (value instanceof Double) {
    310             hquery.setDouble(valueNameInHql, (Double) value);
    311         } else if (value instanceof Float) {
    312             hquery.setFloat(valueNameInHql, (Float) value);
    313         } else if (value instanceof Boolean) {
    314             hquery.setBoolean(valueNameInHql, (Boolean) value);
    315         } else if (value instanceof byte[]) {
    316             hquery.setBinary(valueNameInHql, (byte[]) value);
    317         } else if (value instanceof Locale) {
    318             hquery.setLocale(valueNameInHql, (Locale) value);
    319         } else if (value instanceof BigInteger) {
    320             hquery.setBigInteger(valueNameInHql, (BigInteger) value);
    321         } else {
    322             throw new RuntimeException("不支持的value类型:" + value.getClass());
    323         }
    324         // 下面这些不常用,且麻烦,不支持
    325         // setText(String, String)
    326         // setSerializable(String, Serializable)
    327         // setDate(String, Date)
    328         // setTime(String, Date)
    329         // setCalendar(String, Calendar)
    330         // setCalendarDate(String, Calendar)
    331         // setCharacter(String, char)
    332         // setByte(String, byte)
    333         // setShort(String, short)
    334     }
    335 
    336     private void buildWhereStatementInSql(List<Integer> replaceList) {
    337         for (int i = 0; i < this.conditionIndex; i++) {
    338             CondTuple tuple = this.conditionMap.get(i);
    339             if (replaceList.contains(i)) {
    340                 continue;
    341             }
    342             if (tuple.value != null) {
    343                 //in 查询特殊处理
    344                 if (tuple.op.equals(OP.in)) {
    345                     List value = (List)tuple.value;
    346                     String temp = "";
    347                     if (value == null || value.size() == 0) {
    348                         break;
    349                     }
    350                     if (value.get(0) instanceof String) {
    351                         temp = "('";
    352                         for (String subv : (List<String>)value) {
    353                             temp += subv + "','";
    354                         }
    355                         temp += "')";
    356                         temp = temp.replace(",')", "')");
    357                     } else if (value.get(0) instanceof Long){
    358                         temp = "(";
    359                         for (Long subv : (List<Long>)value) {
    360                             temp += subv.longValue() + ",";
    361                         }
    362                         temp += ")";
    363                         temp = temp.replace(",)", ")");
    364                     }else {
    365                         temp = "(";
    366                         for (Integer subv : (List<Integer>)value) {
    367                             temp += subv.intValue() + ",";
    368                         }
    369                         temp += ")";
    370                         temp = temp.replace(",)", ")");
    371                     }
    372                     this.where += (tuple.logicOp == null ? "" : tuple.logicOp.name()) + " " +  tuple.valueNameInHql + tuple.op.v()
    373                             + temp + " ";
    374                 } else {
    375                     //valueName 是hql中的冒号后边的单词,用于hql执行时用变量替换,里边不能含有下列字符
    376                     String valueName =  tuple.valueNameInHql + i;
    377                     valueName = valueName.replace('.', '_');
    378                     valueName = valueName.replaceAll(" ", "");
    379                     valueName = valueName.replaceAll("-", "");
    380                     valueName = valueName.replaceAll("\\(", "");
    381                     valueName = valueName.replaceAll("\\)", "");
    382                     this.where += (tuple.logicOp == null ? "" : tuple.logicOp.name()) + " " + tuple.valueNameInHql
    383                             + tuple.op.v() + ":" + valueName + " ";
    384                 }
    385             } else {
    386                 if (tuple.op.equals(OP.isNull) || tuple.op.equals(OP.isNotNull)) {
    387                     this.where += (tuple.logicOp == null ? "" : tuple.logicOp.name()) + " " + tuple.valueNameInHql
    388                             + tuple.op.v()  + " ";
    389                 }
    390             }
    391         }
    392         if (StringUtils.isNotBlank(this.where)) {
    393             this.where = " WHERE " + this.where;
    394             if (this.where.contains("WHERE and")) {
    395                 this.where.replace("WHERE and", "WHERE ");
    396             } else if (this.where.contains("WHERE or")) {
    397                 this.where.replace("WHERE or", "WHERE ");
    398             }
    399         }
    400     }
    401     private List<Integer> getReplaceList() {
    402         List<Integer> result = new ArrayList<Integer>();
    403         String replaceString = "";
    404         for (int i = 0; i < this.conditionIndex; i++) {
    405             CondTuple tuple = this.conditionMap.get(i);
    406             if (tuple.value != null && StringUtils.isNotBlank(tuple.replaceString)) {
    407                 replaceString += tuple.replaceString;
    408             }
    409         }
    410         String[] temp = replaceString.split(",");
    411         if (temp == null || temp.length == 0) {
    412             return result;
    413         }
    414         for (String t : temp) {
    415             if (StringUtils.isBlank(t)) {
    416                 continue;
    417             }
    418             if (!result.contains(t)) {
    419                 result.add(Integer.parseInt(t));
    420             }
    421         }
    422         return result;
    423     }
    424     
    425     
    426 
    427     /**条件组合对象*/
    428     private static class CondTuple {
    429         CondTuple(LogicOp logicOp, String valueNameInHql, OP op, Object value, String replaceString) {
    430             this.logicOp = logicOp;
    431             this.valueNameInHql = valueNameInHql;
    432             this.op = op;
    433             this.value = value;
    434             this.replaceString = replaceString;
    435         }
    436 
    437         LogicOp logicOp;
    438         String valueNameInHql;
    439         OP op;
    440         Object value;
    441         String replaceString;
    442     }
    443     public static enum OrderType {
    444         ASC,DESC;
    445     }
    446     public static enum OP {
    447         eq {
    448             {
    449                 value = "=";
    450             }
    451         },
    452         neq {
    453             {
    454                 value = "<>";
    455             }
    456         },
    457         gt {
    458             {
    459                 value = ">";
    460             }
    461         },
    462         lt {
    463             {
    464                 value = "<";
    465             }
    466         },
    467         ge {
    468             {
    469                 value = ">=";
    470             }
    471         },
    472         le {
    473             {
    474                 value = "<=";
    475             }
    476         },
    477         like {
    478             {
    479                 value = " like ";
    480             }
    481         },
    482         in {
    483             {
    484                 value = " in ";
    485             }
    486         }, 
    487         isNotNull {
    488             {
    489                 value = " is not null ";
    490             }
    491         },
    492         isNull {
    493             {
    494                 value = " is null ";
    495             }
    496         };
    497         protected String value = null;
    498 
    499         public String v() {
    500             return value;
    501         }
    502     }
    503 
    504     
    505 }
    View Code
     1 @Service("pageQueryService")
     2 public class PageQueryService {
     3     
     4     private SessionFactory sessionFactory;
     5 
     6     @Resource(name = "sessionFactory")
     7     public void setSessionFactory(SessionFactory sessionFactory) {
     8         this.sessionFactory = sessionFactory;
     9     }
    10 
    11     public <T> Page<T> getNextPage(PageQuery<T> pageQuery) {
    12         Page<T> result = pageQuery.excuteQuery(this.sessionFactory.getCurrentSession());
    13         return result;
    14     }
    15 }
    View Code

     

    原文地址:http://www.cnblogs.com/zdcin/p/3152668.html

    转载于:https://www.cnblogs.com/zdcin/p/3152668.html

    展开全文
  • –带条件的查询 –select 列 –from 表 –where 条件查询年龄小于30 select *from Student select *from Student where age<30 –查询年龄在25-30之间男学生 select *from Student where age>=25 and ...

    –带条件的查询
    –select 列
    –from 表
    –where 条件

    –查询年龄小于30的
    select *from Student
    select *from Student where age<30
    –查询年龄在25-30之间的男学生
    select *from Student where age>=25 and age<=30 and gender=‘男’
    select *from Student where age between 25 and 30and gender=‘男’ --(between 包含25和包含30,同上)
    –查询ID是3,4,5的,推荐使用第三种写法
    select *from Student where id=3 or id=4 or id =5
    select *from Student where id in(3,4,5)
    select *from Student where id>=3 and id<=5


    –模糊查询
    –通配符: _ % [] ^
    表示任意的单个字符
    select *from Student where name like '张
    ’–两个字的名字
    select *from Student where name like ‘张__’–三个字的名字
    – %表示任意多个字符
    –无视姓名字数,只要第一个字符是’张’的就查询出来
    select *from Student where name like ‘张%’
    –[]表示筛选,范围
    select *from Student where name like ‘张[0-9]机’
    select *from student where name like ‘张[0-9a-z]机’
    –^表示取反,不包含a-z
    select *from student where name like ‘张[^a-z]机’

    –替换语句 将gender中的男,替换成女
    update Student set gender =replace(gender,‘男’,‘女’)
    select *from Student

    –查出姓名中带& 特殊字符的人
    –通配符放到[]中就不是通配符了
    select *from Student where name like ‘%[%]%’


    –空值处理
    –查询detail是NULL的信息
    –null值无法使用=或<>来进行比较
    select *from Orders where detail =null --无法查出空值
    select *from Orders where detail <>null --无法查出空值

    –判断null值必须用is null或者 is null null
    select *from Orders where detail is null
    select *from orders where detail is not null


    -----通过order by 语句进行排序
    –1.降序order by 列名 desc
    –2.升序order by 列名 asc
    –3.order by语句必须一定要放在整个sql语句的最后来执行。
    select *from Student
    where…
    group by …
    having…
    order by…

    –4.根据多列进行排序,先根据英语成绩排序,再根据数学成绩排序(英语成绩相同时,再按照数学成绩排序)
    select *from Score order by english desc ,math desc
    select * --3
    from Score --1
    where englishi>60 and math >60 --2
    order by englishi desc,math desc --4

    –5.按照平均分来排序
    select *
    平均分=(math+englishi)*1.0/2
    from Score
    order by 平均分 desc

    展开全文
  • sql server查询空值

    2019-12-09 13:57:47
    今天同事在工作想找出shop id为空sku id但是查不...然后他写代码的查询结果: 一开始我也纳闷怎么回事,后面知道了,因为这个空值不是null而是'' 所以修改代码将where 条件改写=’‘即可: ...
  • /* 条件查询 */ /* 查询课程注册表中 学年为2016所有信息 */ SELECT * FROM 课程注册 where 学年='2016' GO /* 比较运算符查询 */ /* 查询课程注册表中成绩不低于80分所有信息 */ SELECT * FROM 课程注册 where...
  • /* 条件查询 */ /* 1、查询学生表中班级代码为“15wljs301”同班同学学号、姓名和性别信息。 */ SELECT 学号,姓名,性别 FROM 学生 where 班级代码='15wljs301' GO /* 比较运算符查询 */ /* 2、查询课程注册表中...
  • 正常情况下我们都是按有值方式去搜索,但是有时候有一些字段为null,solr中就没有存储进去,我们怎么获取这个字段不存在为条件...查询空值数据 字符串类型 可以通过下面这种查询方式找到所有描述description为空...
  • oracle查询空值问题?

    2013-03-15 15:01:34
    两表用join的方式,根据某个字段相等a=b条件查询,当a和b都是空值时查询结果中是不出现的,如何能在查询时把空值的情况也当做相等的条件一起查出来?
  • solr查询空值、null、不存在字段方法--转载 正常情况下我们都是按有值方式去搜索,但是有时候有一些字段为null,solr中就没有存储进去,我们怎么获取这个字段不存在为条件的搜索结果了,我们只需要在搜索字段前...
  • 前两天工作过程中,遇到...2.加个 o.lat = n.lat 的条件查询出来的结果是15586 3.现在我们将条件改成 o.lat != n.lat,查出来的结果是不是应该显示 25053-15586的差值呢? 我们发现结果并不是预想的那样,而是...
  • 查询缺少考试成绩学生学号和相应课程号。 select sno,cno from sc where grade is null 这里“is” 不能用等号 = 来代替。 例22:查询所有有成绩学生学号和课程号 select sno,cno from sc where ...
  • 查询(集合查询、基于派生表的查询)、数据更新、空值处理、视图一、查询...查询的删除语句三、空值的处理1、空值的产生2、空值的判断3、空值的约束条件4、空值的算术运算、比较运算和逻辑运算四、视图1、定义视图(1)...
  • 在表单中输入查询条件,处理后,在Action中通过request.setAttribute(“form”,form1)返回jsp页面填充查询条件后,无法重置表单的查询条件为初始空值,通过js重置过程中清空后又填充了
  • 通过条件查询学生,返回 List 条件:学生状态 <> 退学 第一次逻辑 List<Student> mappings = mappingService.query() .eq(Student::getSex, Sex) .ne(Student::getStatus,"退学") .list(); 发现...
  • 条件查询常用运算符: 多重条件查询运算符(Not、And、Or)优先级: 范围查询(between-and)实例: 集合查询(In)实例: 部分匹配(模糊)查询常用通配符: 模糊查询实例: ...
  • oracle 中left join on条件中如果字段可能存在空值查询结果记录数可能会不等于左表,这种情况下,可以在取字段值时单独用select from表语句
  • 8、 IS NULL:空值查询

    2020-10-14 10:41:22
    如果字段值是空值,则满足查询条件,该记录将被查询出来。如果字段值不是空值,则不满足查询条件。 使用 IS NULL 基本语法格式如下: IS [NOT] NULL 其中,“NOT”是可选参数,表示字段值不是空值时满足条件...
  • 上次我在子查询中用多行操作符(not in)进行数据查询时出现过此种情况,数据是空,为了验证一下结果,我用in 查询了该表数据,发现查询出来结果数据并没有等于该表总数据,所以not in一定是会存在数据,...
  • Blob字段为空值的查询问题

    千次阅读 2011-09-07 16:06:09
    想以Blob字段为空进行条件查询 select * from mytable where pic is null 这个语句在pic字段是空时可以查到,但如果pic字段不是空,但长度是0是又查不到。这时用 select * from mytable where length
  • * 因为state=2,是确实没有记录,而group by是要求要有记录才行,否则显示空值,就是如上图所示。而我期待结果为BOOK_TICKET_ITEM_ID=113 , CANCEL_BOOK_NUMBER=0 这样一条结果记录。哪位大神帮告诉下解决方案,...
  • 类似于超市里面文件柜,按照一定规律去存储物品。 数据库也是一样,按照一定规律去存储数据。 2 关系性数据库概念 说人话关系库数据库就是: 关系性数据库是以二维表形式去存储数据,同时表与表之间 存在...
  • --带条件查询 select 列名 from 数据源(表名,子查询的结果,视图) where 条件(筛选一些行) 1--查询MyStudents数学成绩不及格学生 select * from MyStudents select FId as 学号,FMath as ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 692
精华内容 276
关键字:

查询空值的条件