query.js 查询示例

目录

一. Query使用示例

1. 通过单个字段查询，model默认为“LK”，模糊查询，如果model值为EQ表示精确查询

2. 通过两个字段AND查询

3. 通过两个字段OR查询（三种方式）

4. 通过IN查询

5. 排序查询

6. 分页查询

7. 过滤查询字段

8.复杂查询

9.左（右）连表查询，ON后面添加过滤条件

10.query.js代码

---

一. Query使用示例

    Query页面测试可在“系统工具-Query”页面上进行使用测试，下面列举了常用的几种查询使用示例。

1. 通过单个字段查询，model默认为“LK”，模糊查询，如果model值为EQ表示精确查询

2. 通过两个字段AND查询

3. 通过两个字段OR查询（三种方式）

第一种方式，如果是username = ? or mob = ?，且seq不设置排序，那么必须是顺序添加；如果设置了seq，那么可以不按顺序添加

第二种方式，通过第二个type进行OR查询，内部实现原理不一样，后面复杂查询可以会进行区分

 

第三种方式，每个字段之间通过分隔符(",")或者("__")进行分割，这边也展示了name设值之后sql的变化

4. 通过IN查询

5. 排序查询

type默认为ASC

6. 分页查询

count默认为0，如果count = 1，那么分页查询，不查总数

7. 过滤查询字段

可以精确某几个字段查询，多个字段通过(",")分割

8.复杂查询

9.左（右）连表查询，ON后面添加过滤条件

  ON查询更多的偏向于后端，如果前端开发不熟悉，可以让后端直接开新接口

/**
     * t_test_a 左连接 t_test_b
     */
    @Link(  print = false, printRm = false,
            ones = { @OneToOne(leftColumn = "b_id", rightClass = TestBVo.class, joinType = JoinType.LEFT, onArgName = "abOn") })
    List<TestADto> listTestALtTestB(@Param(Constants.WRAPPER) Wrapper<TestAVo> wrapper);

 

 

10.query.js代码

const query = {}

/**
 * w （已经弃用，请使用R）过滤条件
 * r 过滤条件
 * o 排序
 * j 左连接、右连接 ON 后面过滤条件，主要面向后端开发人员
 * p 分页条件
 * s 过滤字段
 */
query.new = () => {
  return {
    'w': [],
    'r': [],
    'o': [],
    'j': [],
    'p': {},
    's': {}
  }
}

/**
 * 数组过滤条件
 * @param {query} q
 * @param {array} arrKv 数组：key/value
 * @param {array} arrKm 数组：key/mode
 */
query.toF = (q, arrKv, arrKm) => {
  for (var i in arrKv) {
    query.toR(q, i, arrKv[i], arrKm[i])
  }
  return q
}

/**
 * 过滤条件
 * @param {query} q
 * @param {key} k
 * @param {value} v
 * @param {mode} m 默认值（LK）非必填
 * @param {name} n 默认值（a1）非必填
 * @param {type} t 默认值（and）非必填
 * @param {type} t1 默认值（and）非必填
 * @param {seq} s 默认值（0）非必填
 */
query.toR = (q, k, v, m, t1, s, n, t) => {
  if (v === '') {
    return q
  }
  if (m === 'IS' || m === 'NIS') {
  } else {
    if (v === null) {
      return q
    }
  }
  if (typeof m === 'undefined') {
    m = 'LK'
  }
  if (typeof n === 'undefined') {
    n = 'a1'
  }
  if (typeof t === 'undefined') {
    t = 'and'
  }
  if (typeof t1 === 'undefined') {
    t1 = 'and'
  }
  if (typeof s === 'undefined') {
    s = 0
  }
  let rObj = null
  q.r.forEach(function (val, i) {
    if (val.n === n) {
      rObj = val
    }
  })
  if (rObj) {
    rObj.w.push({
      'k': k,
      'v': v,
      'm': m,
      't': t1,
      's': s
    })
  } else {
    q.r.push({
      'n': n,
      't': t,
      'w': [{
        'k': k,
        'v': v,
        'm': m,
        't': t1,
        's': s
      }]
    })
  }
  return q
}

/**
 * 过滤条件（已经弃用，请使用toR方法）
 * @param {query} q
 * @param {key} k
 * @param {value} v
 * @param {mode} m 默认值（LK）非必填
 * @param {type} t1 默认值（and）非必填
 * @param {seq} s 默认值（0）非必填
 */
query.toW = (q, k, v, m, t1, s) => {
  if (v === '') {
    return q
  }
  if (m === 'IS' || m === 'NIS') {
  } else {
    if (v === null) {
      return q
    }
  }
  if (typeof m === 'undefined') {
    m = 'LK'
  }
  if (typeof t1 === 'undefined') {
    t1 = 'and'
  }
  if (typeof s === 'undefined') {
    s = 0
  }
  q.w.push({
    'k': k,
    'v': v,
    'm': m,
    't': t1,
    's': s
  })
  return q
}

/**
 * 过滤条件（已经弃用，请使用toR方法）
 * @param {query} q
 * @param {key} k
 */
query.toWNull = (q, k) => {
  q.w.push({
    'k': k,
    'v': null,
    'm': 'IS'
  })
  return q
}

/**
 * 左连接、右连接 ON 后面过滤条件
 * @param {query} q
 * @param {key} k
 * @param {value} v
 * @param {mode} m 默认值（LK）非必填
 * @param {name} n 设置联表查询时，ON的参数名
 * @param {type} t1 默认值（and）非必填
 * @param {seq} s 默认值（0）非必填
 */
query.toJ = (q, k, v, m, n, t1, s) => {
  if (v === null || v === '') {
    return q
  }
  if (typeof m === 'undefined') {
    m = 'LK'
  }
  if (typeof t1 === 'undefined') {
    t1 = 'and'
  }
  if (typeof s === 'undefined') {
    s = 0
  }
  let rObj = null
  q.j.forEach(function (val, i) {
    if (val.n === n) {
      rObj = val
    }
  })
  console.log(rObj)
  if (rObj) {
    rObj.r[0].w.push({
      'k': k,
      'v': v,
      'm': m,
      't': t1,
      's': s
    })
  } else {
    q.j.push({
      'n': n,
      'r': [{
        't': 'and',
        'w': [{
          'k': k,
          'v': v,
          'm': m,
          't': t1,
          's': s
        }]
      }]
    })
  }
  return q
}

/**
 * 排序
 * @param {query} q
 * @param {key} k 排序字段
 * @param {type} t 升序还是降序 asc or desc
 */
query.toO = (q, k, t) => {
  if (typeof k === 'undefined' || k === '') {
    return q
  }
  if (typeof t === 'undefined') {
    t = 'desc'
  }
  q.o.push({
    'k': k,
    't': t
  })
  return q
}

/**
 * 分页条件
 * @param {query} q
 * @param {pageNo} n 第几页
 * @param {pageSize} s 每页条数
 * @param {count} c 是否查询总数，非必填，如果设置为1，则不会查询总数
 */
query.toP = (q, n, s, c) => {
  if (typeof c === 'undefined' || c === '') {
    c = 0
  }
  q.p = {
    'n': n,
    's': s,
    'c': c
  }
  return q
}

/**
 * 过滤字段
 * @param {query} q
 * @param {value} v 过滤字段，支持String类型多个字段(",")逗号隔开，如："username,mob"，或者进行数组赋值，如：["username", "mob"]
 */
query.toS = (q, v) => {
  q.s = {
    'v': v
  }
  return q
}

/**
 * query对象转string
 */
query.toJsonStr = (q) => {
  return JSON.stringify(q)
}

/**
 * 查询条件url编码
 */
query.toEncode = (q) => {
  return encodeURIComponent(JSON.stringify(q))
}

/**
 * 查询条件频接
 */
query.toQ = (q) => {
  return '?query=' + encodeURIComponent(JSON.stringify(q))
}

export default query

    EQ(" = ", "等于"), 
    NE(" <> ", "不等于"), 
    LK(" like ", "包含"), 
    LLK(" like ", "左包含"), 
    RLK(" like ", "右包含"), 
    NLK(" not like ", "不包含"), 
    IN(" in ", "在..中"), 
    NIN(" not in ", "不在..中"),
    LT(" < ", "小于"), 
    LE(" <= ", "小于等于"), 
    GT(" > ", "大于"), 
    GE(" >= ", "大于等于"), 
    BT(" between ", "位于..和..之间"),
    IS(" is ", "是"),
    NIS(" is not ", "不是"),
    ASC(" asc ", "升序"),
    DESC(" desc ", "降序"),
    AND("and", "and"),
    OR("or", "or"),