• 前端sql条件拼接js工具

    因为项目原因，需要前端写sql，所以弄了一套sql条件拼接的js工具

    1. ​
    2. /*常量
    3. LT : " < ",
    4. LE : " <= ",
    5. GT : " > ",
    6. GE : " >= ",
    7. NE : " != ",
    8. EQ : " = ",
    9. LIKE : " like ",
    10. OR : " or ",
    11. IN : " in ",
    12. */
    13.  
    14. let sqlUtil = {
    15.     // 拼接sql
    16.     buildSql : '',
    17.  
    18.     /*函数*/
    19.     lt: lessThan,
    20.     lte: lessThanOrEqual,
    21.     gt: greaterThan,
    22.     gte: greaterThanOrEqual,
    23.     ne: notEqual,
    24.     eq: equal,
    25.     toLike: sqlLike,
    26.     leftLike:leftLike,
    27.     rightLike:rightLike,
    28.     in: sqlIn,
    29.     notIn: notIn,
    30.     isNull: isNull,
    31.     isNotNull: isNotNull,
    32.     isEmpty: isEmpty,
    33.     isEmptyOrNull: isEmptyOrNull,
    34.     isNotEmpty:isNotEmpty,
    35.     isNotEmptyAndNotNull:isNotEmptyAndNotNull,
    36.     sor: simpleOr,
    37.     toBetween: between,
    38.     notBetween : notBetween,
    39.     sqlOr: sqlOr,
    40.     orderByDesc : orderByDesc,
    41.     orderByAsc: orderByAsc,
    42.     orderBy: orderBy,
    43.     notDelete : notDelete,
    44.     userDefined:userDefined,
    45.     toSql: toSql
    46. };
    47.  
    48. /**
    49.  * 小于 <
    50.  * sqlUtil.lt("field_name",fieldValue)
    51.  * @param fieldName 字段名
    52.  * @param fieldValue 字段值
    53.  * @param condition 判断条件是否成立
    54.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    55.  */
    56. function lessThan(fieldName,fieldValue,condition = true){
    57.     if(!condition){
    58.         return this;
    59.     }
    60.     if(fieldValue && fieldValue.trim() !== ''){
    61.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" < '"+fieldValue+"' ";
    62.     }
    63.     return this;
    64. }
    65.  
    66. /**
    67.  * 小于等于 <=
    68.  * sqlUtil.le("field_name",fieldValue)
    69.  * @param fieldName 字段名
    70.  * @param fieldValue 字段值
    71.  * @param condition 判断条件是否成立
    72.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    73.  */
    74. function lessThanOrEqual(fieldName,fieldValue,condition = true){
    75.     if(!condition){
    76.         return this;
    77.     }
    78.     if(fieldValue && fieldValue.trim() !== ''){
    79.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" <= '"+fieldValue+"' ";
    80.     }
    81.     return this;
    82. }
    83.  
    84. /**
    85.  * 大于 >
    86.  * sqlUtil.gt("field_name",fieldValue)
    87.  * @param fieldName 字段名
    88.  * @param fieldValue 字段值
    89.  * @param condition 判断条件是否成立
    90.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    91.  */
    92. function greaterThan(fieldName,fieldValue,condition = true){
    93.     if(!condition){
    94.         return this;
    95.     }
    96.     if(fieldValue && fieldValue.trim() !== ''){
    97.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" > '"+fieldValue+"' ";
    98.     }
    99.     return this;
    100. }
    101.  
    102.  
    103. /**
    104.  * 大于等于 >=
    105.  * sqlUtil.ge("field_name",fieldValue)
    106.  * @param fieldName 字段名
    107.  * @param fieldValue 字段值
    108.  * @param condition 判断条件是否成立
    109.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    110.  */
    111. function greaterThanOrEqual(fieldName,fieldValue,condition = true){
    112.     if(!condition){
    113.         return this;
    114.     }
    115.     if(fieldValue && fieldValue.trim() !== ''){
    116.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" >= '"+fieldValue+"' ";
    117.     }
    118.     return this;
    119. }
    120.  
    121.  
    122. /**
    123.  * 不等于 !=
    124.  * sqlUtil.ne("field_name",fieldValue)
    125.  * @param fieldName 字段名
    126.  * @param fieldValue 字段值
    127.  * @param condition 判断条件是否成立
    128.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    129.  */
    130. function notEqual(fieldName,fieldValue,condition = true){
    131.     if(!condition){
    132.         return this;
    133.     }
    134.     if(fieldValue && fieldValue.trim() !== ''){
    135.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" != '"+fieldValue+"' ";
    136.     }
    137.     return this;
    138. }
    139.  
    140. /**
    141.  * 等于 =
    142.  * sqlUtil.eq("field_name",fieldValue)
    143.  * @param fieldName 字段名
    144.  * @param fieldValue 字段值
    145.  * @param condition 判断条件是否成立
    146.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    147.  */
    148. function equal(fieldName,fieldValue,condition = true){
    149.     if(!condition){
    150.         return this;
    151.     }
    152.  
    153.     if(!fieldValue){
    154.         return this;
    155.     }
    156.  
    157.     if(typeof fieldValue === 'string' && fieldValue.trim() === ''){
    158.         return this;
    159.     }
    160.  
    161.     sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" = '"+fieldValue+"' ";
    162.     return this;
    163. }
    164.  
    165. /**
    166.  * 模糊搜索 like
    167.  * sqlUtil.like("field_name",fieldValue)
    168.  * @param fieldName 字段名
    169.  * @param fieldValue 字段值
    170.  * @param condition 判断条件是否成立
    171.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    172.  */
    173. function sqlLike(fieldName,fieldValue,condition = true){
    174.     if(!condition){
    175.         return this;
    176.     }
    177.     if(fieldValue && fieldValue.trim() !== ''){
    178.         fieldValue = fieldValue.replaceAll('%','\\%');
    179.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" like '%"+fieldValue+"%' ";
    180.     }
    181.     return this;
    182. }
    183.  
    184. /**
    185.  * 模糊搜索 左like
    186.  * sqlUtil.leftLike("field_name",fieldValue)
    187.  * @param fieldName 字段名
    188.  * @param fieldValue 字段值
    189.  * @param condition 判断条件是否成立
    190.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    191.  */
    192. function leftLike(fieldName,fieldValue,condition = true){
    193.     if(!condition){
    194.         return this;
    195.     }
    196.     if(fieldValue && fieldValue.trim() !== ''){
    197.         fieldValue = fieldValue.replaceAll('%','\\%');
    198.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" like '%"+fieldValue+"' ";
    199.     }
    200.     return this;
    201. }
    202.  
    203.  
    204.  
    205. /**
    206.  * 模糊搜索 右like
    207.  * sqlUtil.rightLike("field_name",fieldValue)
    208.  * @param fieldName 字段名
    209.  * @param fieldValue 字段值
    210.  * @param condition 判断条件是否成立
    211.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    212.  */
    213. function rightLike(fieldName,fieldValue,condition = true){
    214.     if(!condition){
    215.         return this;
    216.     }
    217.     if(fieldValue && fieldValue.trim() !== ''){
    218.         fieldValue = fieldValue.replaceAll('%','\\%');
    219.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" like '"+fieldValue+"%' ";
    220.     }
    221.     return this;
    222. }
    223.  
    224. /**
    225.  * in查询
    226.  * sqlUtil.in("field_name",fieldValueArray)
    227.  * @param fieldName 字段名
    228.  * @param fieldValueArray 字段值数组
    229.  * @param condition 判断条件是否成立
    230.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    231.  */
    232. function sqlIn(fieldName,fieldValueArray = [],condition = true){
    233.     if(!condition){
    234.         return this;
    235.     }
    236.     if (fieldValueArray.length === 0){
    237.         return this;
    238.     }
    239.  
    240.     sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" in ( ";
    241.     for (const fieldValue of fieldValueArray) {
    242.         if(typeof fieldValue === "string"){
    243.             sqlUtil.buildSql = sqlUtil.buildSql + "'" + fieldValue + "',";
    244.         }else{
    245.             sqlUtil.buildSql = sqlUtil.buildSql + fieldValue + ",";
    246.         }
    247.  
    248.     }
    249.  
    250.     sqlUtil.buildSql = sqlUtil.buildSql.substring(0,sqlUtil.buildSql.length-1) + ") ";
    251.     return this;
    252. }
    253.  
    254. /**
    255.  * not in查询
    256.  * sqlUtil.notIn("field_name",fieldValueArray)
    257.  * @param fieldName 字段名
    258.  * @param fieldValueArray 字段值数组
    259.  * @param condition 判断条件是否成立
    260.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    261.  */
    262. function notIn(fieldName,fieldValueArray = [],condition = true){
    263.     if(!condition){
    264.         return this;
    265.     }
    266.     if (fieldValueArray.length === 0){
    267.         return this;
    268.     }
    269.  
    270.     sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" not in ( ";
    271.     for (const fieldValue of fieldValueArray) {
    272.         sqlUtil.buildSql = sqlUtil.buildSql + fieldValue + " ,";
    273.     }
    274.  
    275.     sqlUtil.buildSql = sqlUtil.buildSql.substring(0,sqlUtil.buildSql.length-1) + " ) ";
    276.     return this;
    277. }
    278.  
    279.  
    280. /**
    281.  * is null
    282.  * sqlUtil.isNull("field_name",fieldValue)
    283.  * @param fieldName 字段名
    284.  * @param fieldValue 字段值
    285.  * @param condition 判断条件是否成立
    286.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    287.  */
    288. function isNull(fieldName,fieldValue,condition = true){
    289.     if(!condition){
    290.         return this;
    291.     }
    292.     if(fieldValue && fieldValue.trim() !== ''){
    293.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" is null '"+fieldValue+"%' ";
    294.     }
    295.     return this;
    296. }
    297.  
    298.  
    299. /**
    300.  * is not null
    301.  * sqlUtil.isNotNull("field_name",fieldValue)
    302.  * @param fieldName 字段名
    303.  * @param fieldValue 字段值
    304.  * @param condition 判断条件是否成立
    305.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    306.  */
    307. function isNotNull(fieldName,fieldValue,condition = true){
    308.     if(!condition){
    309.         return this;
    310.     }
    311.     if(fieldValue && fieldValue.trim() !== ''){
    312.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" is not null '"+fieldValue+"%' ";
    313.     }
    314.     return this;
    315. }
    316.  
    317.  
    318. /**
    319.  * 是否为空字符
    320.  * sqlUtil.isEmpty("field_name",fieldValue)
    321.  * @param fieldName 字段名
    322.  * @param condition 判断条件是否成立
    323.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    324.  */
    325. function isEmpty(fieldName,condition = true){
    326.     if(!condition){
    327.         return this;
    328.     }
    329.     if(fieldName){
    330.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" = '' ";
    331.     }
    332.     return this;
    333. }
    334.  
    335. /**
    336.  * 是否为 空字符或null
    337.  * sqlUtil.isEmpty("field_name",fieldValue)
    338.  * @param fieldName 字段名
    339.  * @param condition 判断条件是否成立
    340.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    341.  */
    342. function isEmptyOrNull(fieldName,condition = true){
    343.     if(!condition){
    344.         return this;
    345.     }
    346.     if(fieldName){
    347.         sqlUtil.buildSql = sqlUtil.buildSql + "and ("+fieldName+" = '' or  "+fieldName+" is null)";
    348.     }
    349.     return this;
    350. }
    351.  
    352. /**
    353.  * 是否为空字符
    354.  * sqlUtil.isNotEmpty("field_name",fieldValue)
    355.  * @param fieldName 字段名
    356.  * @param condition 判断条件是否成立
    357.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    358.  */
    359. function isNotEmpty(fieldName,condition = true){
    360.     if(!condition){
    361.         return this;
    362.     }
    363.     if(fieldName){
    364.         sqlUtil.buildSql = sqlUtil.buildSql + "and "+fieldName+" != '' ";
    365.     }
    366.     return this;
    367. }
    368.  
    369. /**
    370.  * 是否为空字符
    371.  * sqlUtil.isNotEmpty("field_name",fieldValue)
    372.  * @param fieldName 字段名
    373.  * @param condition 判断条件是否成立
    374.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    375.  */
    376. function isNotEmptyAndNotNull(fieldName,condition = true){
    377.     if(!condition){
    378.         return this;
    379.     }
    380.     if(fieldName){
    381.         sqlUtil.buildSql = sqlUtil.buildSql + "and ("+fieldName+" != '' or  "+fieldName+" is not null)";
    382.     }
    383.     return this;
    384. }
    385.  
    386. /**
    387.  * between("age", 20, 22);
    388.  * @param fieldName 字段名
    389.  * @param fieldValue1  第一个值
    390.  * @param fieldValue2 第二个值
    391.  * @param condition 判断条件是否成立
    392.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    393.  */
    394.  
    395. function between(fieldName,fieldValue1,fieldValue2,condition = true){
    396.     if(!condition){
    397.         return this;
    398.     }
    399.     if(!fieldValue1 || !fieldValue2){
    400.         return this;
    401.     }
    402.  
    403.     if(typeof fieldValue1 === 'string' && typeof fieldValue2  === 'string'){
    404.         //  有可能是日期
    405.         sqlUtil.buildSql = sqlUtil.buildSql + "and '"+fieldName+"' between '"+fieldValue1+"' and '"+fieldValue2+"' ";
    406.     }else{
    407.         sqlUtil.buildSql = sqlUtil.buildSql + "and '"+fieldName+"' between "+fieldValue1+" and "+fieldValue2+" ";
    408.     }
    409.  
    410.     return this;
    411. }
    412.  
    413. /**
    414.  * sqlUtil.notBetween("field_name",20,22)
    415.  * notBetween("age", 20, 22);
    416.  * @param fieldName 字段名
    417.  * @param fieldValue1  第一个值
    418.  * @param fieldValue2 第二个值
    419.  * @param condition 判断条件是否成立
    420.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    421.  */
    422.  
    423. function notBetween(fieldName,fieldValue1,fieldValue2,condition = true){
    424.     if(!condition){
    425.         return this;
    426.     }
    427.     if(fieldName){
    428.         sqlUtil.buildSql = sqlUtil.buildSql + "and '"+fieldName+"' not between "+fieldValue1+" and "+fieldValue2+" ";
    429.     }
    430.     return this;
    431. }
    432.  
    433. /**
    434.  * sqlUtil.orderByAsc("field_name") || sqlUtil.orderByAsc(["field_name1","field_name2"])
    435.  * "order by id asc"
    436.  * @param fieldName 字段名 || 数组
    437.  * @param condition 判断条件是否成立
    438.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    439.  */
    440. function orderByAsc(fieldName,condition = true){
    441.     if(!condition){
    442.         return this;
    443.     }
    444.     if(typeof fieldName === 'string'){
    445.         sqlUtil.buildSql = sqlUtil.buildSql +" order by "+fieldName+" asc"
    446.     }else{
    447.         sqlUtil.buildSql = sqlUtil.buildSql +" order by ";
    448.         for (const itemName of fieldName) {
    449.             sqlUtil.buildSql = sqlUtil.buildSql + itemName + " asc,";
    450.         }
    451.         sqlUtil.buildSql = sqlUtil.buildSql.substring(0,sqlUtil.buildSql.length-1) + " ";
    452.     }
    453.  
    454.     return this;
    455. }
    456.  
    457. /**
    458.  * sqlUtil.orderByDesc("field_name") || sqlUtil.orderByDesc(["field_name1","field_name2"])
    459.  * "order by id desc"
    460.  * @param fieldName 字段名 || 数组
    461.  * @param condition 判断条件是否成立
    462.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    463.  */
    464. function orderByDesc(fieldName,condition = true){
    465.     if(!condition){
    466.         return this;
    467.     }
    468.     if(typeof fieldName === 'string'){
    469.         sqlUtil.buildSql = sqlUtil.buildSql +" order by "+fieldName+" desc"
    470.     }else{
    471.         sqlUtil.buildSql = sqlUtil.buildSql +" order by ";
    472.         for (const itemName of fieldName) {
    473.             sqlUtil.buildSql = sqlUtil.buildSql + itemName + " desc,";
    474.         }
    475.         sqlUtil.buildSql = sqlUtil.buildSql.substring(0,sqlUtil.buildSql.length-1) + " ";
    476.     }
    477.  
    478.     return this;
    479. }
    480.  
    481. /**
    482.  * 自定义排序
    483.  * @param fieldList 字段名或数组[{fileName:'',order:''}],order的值为 desc|asc
    484.  * @param condition
    485.  * @returns {orderBy}
    486.  */
    487. function orderBy(fieldList,condition = true){
    488.     if(!condition){
    489.         return this;
    490.     }
    491.  
    492.     sqlUtil.buildSql = sqlUtil.buildSql +" order by ";
    493.     for (const item of fieldList) {
    494.         sqlUtil.buildSql = sqlUtil.buildSql + item.fileName +" "+item.order +",";
    495.     }
    496.     sqlUtil.buildSql = sqlUtil.buildSql.substring(0,sqlUtil.buildSql.length-1) + " ";
    497.  
    498.     return this;
    499. }
    500.  
    501.  
    502.  
    503. /**
    504.  * 简单的或条件 or
    505.  * const paramMap =  new Map([
    506.  *   ["field_name1",fieldValue1],
    507.  *   ["field_name2",fieldValue2],
    508.  *   ["field_name3",fieldValue3],
    509.  * ])
    510.  *
    511.  * sqlUtil.sor(paramMap)
    512.  * @param paramMap  参数集
    513.  *
    514.  * @param condition
    515.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    516.  */
    517. function simpleOr(paramMap,condition = true){
    518.     if(!condition){
    519.         return this;
    520.     }
    521.     if(! paramMap){
    522.         return this;
    523.     }
    524.  
    525.     sqlUtil.buildSql += "and ( ";
    526.     for(let [index,field] of paramMap.entries()){
    527.         sqlUtil.buildSql = sqlUtil.buildSql + field[0]+" = '"+field[1]+"' or ";
    528.     }
    529.     sqlUtil.buildSql = sqlUtil.buildSql.substring(0, sqlUtil.buildSql.length - 4) +  ") ";
    530.  
    531.     return this;
    532. }
    533.  
    534.  
    535. /**
    536.  * 或条件 or
    537.  *
    538.  * sqlUtil.OR(paramMap)
    539.  * @param paramSqlList  sql集
    540.  * @param condition
    541.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    542.  */
    543. function sqlOr(paramSqlList= [],condition = true){
    544.     if(!condition){
    545.         return this;
    546.     }
    547.  
    548.     if(paramSqlList.length === 0){
    549.         return this;
    550.     }
    551.  
    552.     sqlUtil.buildSql = sqlUtil.buildSql +" and (";
    553.     for (const paramSql of paramSqlList) {
    554.         sqlUtil.buildSql = sqlUtil.buildSql + " or "
    555.     }
    556.     sqlUtil.buildSql = sqlUtil.buildSql.substring(0,sqlUtil.buildSql.length - 3) + ") "
    557.  
    558.     return this;
    559. }
    560.  
    561. /**
    562.  * 查询没有被逻辑删除的
    563.  * @returns {{sqlUtil}} 拼接后的sqlUtil
    564.  */
    565. function notDelete(){
    566.     sqlUtil.buildSql += "and is_delete = '0' "
    567.     return this;
    568. }
    569.  
    570. /**
    571.  * 自定义sql,
    572.  * @param paramSql  'and {condition}'
    573.  * @param condition  条件
    574.  */
    575. function userDefined(paramSql,condition = true){
    576.     if(!condition){
    577.         return this;
    578.     }
    579.     sqlUtil.buildSql += paramSql;
    580.     return this;
    581.  
    582. }
    583.  
    584. /**
    585.  * 获取拼装后的sql
    586.  * @returns {string}
    587.  */
    588. function toSql(){
    589.     let sql = '';
    590.     //判断有没有orderBy
    591.     if(sqlUtil.buildSql.indexOf("order by") != -1){
    592.        let arr = sqlUtil.buildSql.split("order by");
    593.        sql = arr[0] + " and is_delete = '0' "+"order by"+arr[1];
    594.     }else{
    595.         sql =  sqlUtil.notDelete()["buildSql"];
    596.     }
    597.     // sqlUtil.notDelete().buildSql
    598.  
    599.     sqlUtil.buildSql = '';
    600.     console.log("sql:"+sql);
    601.     return sql;
    602. }
    603.  
    604. export default sqlUtil;
    605.  
    606. ​

    或许某些场景，例如用户自定义条件的场景才用得到吧？这篇文章如能提供到帮助，方便的话请在评论下留言，我也想知道还能用到什么地方。

    使用方式参考如下（使用userDefined方法可以利用sql函数，并进行条件拼接）：

    1. return sqlUtil
    2.           .toLike("discussion_title",searchParam.discussionTitle)
    3.           .eq("division_code",searchParam.divisionCode)
    4.           .eq("party_grid_deliberation_id",searchParam.partyGridDeliberationId)
    5.           .userDefined(" and (DATE_FORMAT(discussion_time_start, '%Y-%m') = '"+this.searchParam.discussionYearMonth+"' or DATE_FORMAT(discussion_time_end, '%Y-%m') = '"+this.searchParam.discussionYearMonth+"') ",this.searchParam.discussionYearMonth)
    6.           .orderByDesc("discussion_time_start")
    7.           .toSql();

    另外进阶版，可以结合jq的extend，进一步封装，像后端开发那样，把业务代码写到前端来。如图：

    fwptPost(表名，提交的json对象)。

    这样做当然是有缺陷，需要解决事务一致性的问题，要考虑如何联表，要考虑性能。

  • 相关阅读:
    l8-d15 IO多路复用select函数
    前端算法：链表，逆置，递归的写法
    《创业者必学的搞流量营销课》负责百万到年入千万，500W+粉丝操盘经验
    EMQX +计算巢：构建云上物联网平台，轻松实现百万级设备连接
    如何定位el-tree中的树节点当父元素滚动时如何定位子元素
    微服务链路追踪-SkyWalking
    【简单dp】舔狗舔到最后一无所有
    【小程序】使用WXSS编写样式介绍以及与CSS的区别
    Java集合01：
    Maven依赖仲裁
  • 原文地址：https://blog.csdn.net/hunwanjie/article/details/136306232