对于主表中一条记录，对应明细表中的96条数据，每一条数据相隔15分钟，明细中没96条数据对应主表中的一个日期trade_date,并且每条明细中有一个字段start_time, 即明细中每96条数据中第一条数据中start_time为00:00，第二条为00:15,第三条为00:30，依次类推，直到23:45 ,现在要将明细表中的96条数据合并成24条，即第一条数据中start_time为00:00，第二条为01:00，第三条为02:00

 

sql:select max(de.bid_num) report_num,concat(to_char(to_timestamp(concat(ru.trade_date,' ',de.start_time), 'YYYY-MM-DD HH24:mi') :: TIMESTAMP WITHOUT TIME ZONE, 'HH24 '),':00') dd from quote_trade_rule ru LEFT JOIN quote_trade_rule_detail de on ru.trade_rule_id = de.trade_rule_id

WHERE

    1 = 1

AND ru.market_id ='a29c81ed-2baf-4c42-881a-f1e64a41e1b0'

AND to_char(ru.trade_date, 'YYYY-MM-DD') ='2018-10-17'

AND ru.rule_type ='2' GROUP BY dd ,trade_date ORDER BY dd,trade_date

 



将10条主表数据对应的960条明细数据合并成如下24条数据：

对于主表中一条记录，对应明细表中的96条数据，每一条数据相隔15分钟，明细中没96条数据对应主表中的一个日期trade_date,并且每条明细中有一个字段start_time, 即明细中每96条数据中第一条数据中start_time为00:00，

第二条为00:15,第三条为00:30，依次类推，直到23:45 ,现在要将明细表中的96条数据合并成24条，即第一条数据中start_time为00:00，第二条为01:00，第三条为02:00

1

2

3

4

5

6

sql:select max(de.bid_num) report_num,concat(to_char(to_timestamp(concat(ru.trade_date,' ',de.start_time), 'YYYY-MM-DD HH24:mi') :: TIMESTAMP WITHOUT TIME ZONE, 'HH24 '),':00') dd from quote_trade_rule ru LEFT JOIN quote_trade_rule_detail de on ru.trade_rule_id = de.trade_rule_id

WHERE

  1 = 1

AND ru.market_id ='a29c81ed-2baf-4c42-881a-f1e64a41e1b0'

AND to_char(ru.trade_date, 'YYYY-MM-DD') ='2018-10-17'

AND ru.rule_type ='2' GROUP BY dd ,trade_date ORDER BY dd,trade_date



将10条主表数据对应的960条明细数据合并成如下24条数据：

补充：Postgresql中执行计划的合并连接

Merge Join

通常情况下，散列连接的效果比合并连接好，但如果源数据上有索引，或者结果已经被排过序，在执行排序合并连接时，就不需要排序了，这时合并连接的性能会优于散列连接。

下面示例中，people的id字段和dept01的depto字段都有索引，且从索引扫描的数据已经排好序，可以直接走Merge Join：

1

2

3

4

5

6

7

8

highgo=# explain select people.id from people,dept01 where people.id=dept01.deptno;

                      QUERY PLAN

-------------------------------------------------------------------------------------------------

 Merge Join (cost=0.86..64873.59 rows=1048576 width=4)

  Merge Cond: (people.id = dept01.deptno)

  -> Index Only Scan using people_pkey on people (cost=0.44..303935.44 rows=10000000 width=4)

  -> Index Only Scan using idx_deptno on dept01 (cost=0.42..51764.54 rows=1048576 width=2)

(4 行记录)

删除dept01上的索引，会发现执行计划中先对dept01排序后在走Merge Join，示例如下：

1

2

3

4

5

6

7

8

9

10

11

highgo=# explain select people.id from people,dept01 where people.id=dept01.deptno;

                      QUERY PLAN

-------------------------------------------------------------------------------------------------

 Merge Join (cost=136112.80..154464.29 rows=1048576 width=4)

  Merge Cond: (people.id = dept01.deptno)

  -> Index Only Scan using people_pkey on people (cost=0.44..303935.44 rows=10000000 width=4)

  -> Materialize (cost=136112.36..141355.24 rows=1048576 width=2)

     -> Sort (cost=136112.36..138733.80 rows=1048576 width=2)

        Sort Key: dept01.deptno

        -> Seq Scan on dept01 (cost=0.00..16918.76 rows=1048576 width=2)

(7 行记录)

上面执行计划中，可看到“Sort Key: dept01.deptno”，这就是对表dept01的id字段进行排序。

以上为个人经验，希望能给大家一个参考

      最近在做项目中，有一个需求需要查询根据合同的状态去修改对应的业务单对应的状态，合同和业务单存在同一张表中，而且同一个业务A可能存在多条业务单的情况，需要一条SQL查询出每条业务对应的日期最新的那条业务单来操作。按自己平时的SQL习惯首先想到子查询实现：如下

--其中serviceconstid代表一条业务A，每条业务对应的值不同
select M.*
  from CM_CONTRACT_INSTANCE M
 where M.createtime =
       (select max(t.createtime)
          from cm_contract_instance t
         where t.serviceconstid = M.serviceconstid);


但是如上发现一个问题，如果存在业务A下存在两条一模一样createtime的业务单，那这条SQL查出来的数据就会把对应的两条业务单都查出来，但是现在只想取其中一条来操作，这里就不满足需求了！

第二种查询方式如下

-- 结果准确，但是效率较差
SELECT B.*
  FROM (SELECT A.*,
               ROW_NUMBER() OVER(partition by A.serviceconstid order by A.createTime desc nulls last) rn
          FROM CM_CONTRACT_INSTANCE A) B
 WHERE RN = 1;


第三种方式，使用分组函数group by

select A.*
  from CM_CONTRACT_INSTANCE A,
       (select serviceconstid, max(createTime) createTime from CM_CONTRACT_INSTANCE group by serviceconstid) B
 where A.serviceconstid = B.serviceconstid
   and A.createTime = B.createTime
 order by A.serviceconstid;

第四中方式（和第三种类似）

 select A.*
   from CM_CONTRACT_INSTANCE A
  inner join (select serviceconstid, max(createTime) createTime from CM_CONTRACT_INSTANCE group by serviceconstid) B
     on A.serviceconstid = B.serviceconstid
    and A.createTime = B.createTime
  order by A.serviceconstid;

后面两种方式也会出现第一种那个问题，不过由于系统中数据量不大，执行效率差别不大，后续可以在观察一下！

如果创建时间非常规则，是不会出现相同的情况，所以上面四中方法都可以满足需求。

前端小白，在做浏览记录时，后台返回的数据是按照时间（年月日格式）排列的一维数组，前台需要处理后展示在页面上，选中删除后再返回对应条数的数据，追加到前台数据和页面上，本人在写小程序，所以用小程序代码做示例：
动图展示

数据示例
[   // 模拟后台传递过来的数据格式
      {
        createTime: "2020-12-06",
        id: "1",
      }, {
        createTime: "2020-12-06",
        id: "2",
      }, {
        createTime: "2020-12-05",
        id: "3",
      },
      ……
    ]

[	// 处理后的数据格式
      [
        { "createTime": "2020-12-06", "id": "1", "checked": false },
        { "createTime": "2020-12-06", "id": "2", "checked": false },
        { "createTime": "2020-12-06", "id": "3", "checked": false },
        { "createTime": "2020-12-06", "id": "4", "checked": false }
      ], [
        { "createTime": "2020-12-05", "id": "5", "checked": false },
        { "createTime": "2020-12-05", "id": "6", "checked": false },
        { "createTime": "2020-12-05", "id": "7", "checked": false },
        { "createTime": "2020-12-05", "id": "8", "checked": false },
        { "createTime": "2020-12-05", "id": "9", "checked": false }
      ]
    ]

整体思路


初始请求时 ，将请求到的数据保存到待处理的变量中；


第一次处理数据，将待处理数据的第一条数据放入二维数组中的第一个数组中，循环后续数据，通过每次判断当前数据的产生日期是否跟二维数组中的最后一项数组的最后一项数据的产生日期是否相等，来决定是否要在二维数组后面追加一个数组来存放不是同一天的数据，最后将数据追加到二维数组的最后一项数组的最后（刚才已经判断了是不是同一天的数据）；


点击切换选中状态，每个数据中有一个变量控制着该数据的选中状态，每次点击直接取反；


点击删除，遍历出要删除的数据项，记录下并向后台发送，后台删除几条返回几条，前台将未删除项通过一个数组接住；


返回数据做拼接，跟第2步中的第一次处理数据逻辑基本相同，循环数据判断是否不是同一天来追加数组，最后前台展示，依次类推；


函数方法介绍


处理数组的函数：首次处理和后续拼接处理通用，需判断前台显示的二维数组的长度；


点击选中的函数：获取到当前点击的数据，将数据的选中状态取反；


点击删除函数：循环用于前台显示的二维数组，选出被选中的保存到待删除的数组中，未被选中的放到另一个新数组中用于替换掉删除前的数据
上代码


 
Page({
  data: {
    toDealList: [],   // 等待去处理的数组
    originalList: [   // 模拟首次加载的数据
      {
        createTime: "2020-12-06",
        id: "1",
      }, {
        createTime: "2020-12-06",
        id: "2",
      }, {
        createTime: "2020-12-06",
        id: "3",
      }, {
        createTime: "2020-12-06",
        id: "4",
      }, {
        createTime: "2020-12-05",
        id: "5",
      }, {
        createTime: "2020-12-05",
        id: "6",
      }, {
        createTime: "2020-12-05",
        id: "7",
      }, {
        createTime: "2020-12-05",
        id: "8",
      }, {
        createTime: "2020-12-05",
        id: "9",
      },
    ],
    backList: [       // 后续的数据 删多少条返回多少条 直到这个数组中没有数据
      {
        createTime: "2020-12-05",
        id: "10",
      }, {
        createTime: "2020-12-05",
        id: "11",
      }, {
        createTime: "2020-12-05",
        id: "12",
      }, {
        createTime: "2020-12-04",
        id: "13",
      }, {
        createTime: "2020-12-04",
        id: "14",
      }, {
        createTime: "2020-12-04",
        id: "15",
      }, {
        createTime: "2020-12-03",
        id: "16",
      }, {
        createTime: "2020-12-03",
        id: "17",
      }, {
        createTime: "2020-12-03",
        id: "18",
      },
    ],
    list: [[]],            // 经过处理的 显示在前端的数据
  },

  // 处理数组的函数
  dealFun() {
    let list = this.data.list
    let toDealList = this.data.toDealList
    console.log(toDealList, '待处理数组')
    // 需保证后台返回的数组长度大于一
    if (toDealList.length > 0) {
      // 将第一个数据放到第一个数组中
      // 如果是第一次处理 数组中的第一个数组会没有数据 需要将第一个待处理数据放到里面 并且从第二个开始循环
      let isFirst = false
      if (list[0].length == 0) {
        isFirst = true
        list[0][0] = toDealList[0]
        toDealList[0].checked = false
      }
      // 如果是第一次处理 数组中的第一个数组会没有数据 需要将第一个待处理数据放到里面 并且从第二个开始循环
      for (let index = (isFirst ? 1 : 0); index < toDealList.length; index++) {
        toDealList[index].checked = false
        // 如果当前的日期 不等于前台展示的数组中的最后一个日期了 就代表当前循环项是前一天的数据了
        // console.log(list[list.length - 1][list[list.length - 1].length - 1])
        if (toDealList[index].createTime != list[list.length - 1][list[list.length - 1].length - 1].createTime) {
          // 重新添加一个空数组 放前的一天的数据
          list.push([])
        }
        // 直接将循环项放到 前端展示的数组中的最后一个数组的最后
        list[list.length - 1].push(toDealList[index])
      }
      console.log(list, '循环完成后的数组')
    }
    this.setData({
      list,
    })
  },

  // 点击选中函数
  choose(e) {
    let indexs = e.target.dataset.indexs
    let index = e.target.dataset.index
    if (index !== undefined) {
      let item = this.data.list[indexs][index]
      item.checked = !item.checked
      // console.log(item)
      this.setData({
        // [`this.data.list[${indexs}][${index}]`]: this.data.list[indexs][index],  // 这样修改 数据已经发生改变 但却不会触发页面更改  是为什么呢
        list: this.data.list,
      })
    }
  },

  // 点击删除
  delete() {
    let list = this.data.list
    let newArr = []
    let delArr = []   // 用于记录当前删除的条数  并可用于向后台发送要删除的数据的id
    // 遍历时直接改变当前遍历的数组 会造成逻辑混乱
    // 所以此处用另外一个数组接住（newArr）
    list.forEach(item => {
      let arr = []      // 定义数组 一会存放每一天的记录
      item.forEach(i => {
        if (i.checked) {
          //  选中的代表要删除的  他的id放到待删除的id的数组中
          delArr.push(i.id)
        } else {
          //  没有被选中的就正常放到新定义的存放每一天的数组中（而不是直接在这截取删除掉该数据 是因为在遍历时直接改变当前遍历的数组会造成逻辑混乱）
          arr.push(i)
        }
      })
      // 此处是为了判断防止把某一天的所有数据都删除掉
      if (arr.length > 0) {
        newArr.push(arr)
      }
    })
    console.log(newArr, '删除完之后的数组（因为是数组（引用型数），打印出来会跟删除完之后处理完的数组是一样的）')
    this.data.list = newArr
    // 模拟后台在删除之后返回数据 将返回数据存贮到待处理函数中
    let backList = this.data.backList.splice(0, delArr.length)
    this.data.toDealList = backList
    this.dealFun()
  },

  onLoad: function () {
    // 模拟后台第一次返回数据 将返回数据存贮到待处理函数中
    this.data.toDealList = this.data.originalList
    this.dealFun()
  },
})


GitHub地址：https://github.com/noiceli/DeleteBrowsingHistory
半路出家的前端小白，仅以此文章作为成长记录，如若有任何逻辑或代码可优化方法，欢迎评论交流！