静态编程语言暴露求和条件（CaseWhenElse）

Question

我有一个数据结构如下的表：

id    type   cityName   regDate
1249     0   City1      2019-10-01

我想得到独特的城市的结果输出，以及每月在其中注册的数量，作为数据类对象的列表

data class NewClientsNumberCityMonth(
    val cityName: String = "",
    val januaryNewClientsNumber :Int = 0,
    val februaryNewClientsNumber :Int = 0,
    val marchNewClientsNumber :Int = 0,
    val aprilNewClientsNumber :Int = 0,
    val mayNewClientsNumber :Int = 0,
    val juneNewClientsNumber :Int = 0,
    val julyNewClientsNumber :Int = 0,
    val augustNewClientsNumber :Int = 0,
    val septemberNewClientsNumber :Int = 0,
    val octoberNewClientsNumber :Int = 0,
    val novemberNewClientsNumber :Int = 0,
    val decemberNewClientsNumber :Int = 0
    val total :Int = 0
)

并使用此对象作为字符串来填充表格（我们不知道唯一城市的数量），结果应该是这样的：

City1     5    8    3    1    2    1    4    1    2    1    0    0 
City2    69   23    7    5    3   10   24   14   12   23   25   10
...

我正在尝试这个

val tempMutList = mutableListOf<NewClientsNumberCityMonthModel>()

transaction(Connection.TRANSACTION_SERIALIZABLE, 2) {
                        addLogger(StdOutSqlLogger)


                        ClientsDataExposed
                            .slice(ClientsDataExposed.cityName)
                            .selectAll()
                            .groupBy(ClientsDataExposed.cityName)
                            .map { it[ClientsDataExposed.cityName] }
                            .toList().forEach {

                              val regsInCity = ClientsDataExposed
                                .slice(
                                        ClientsDataExposed.id,
                                        ClientsDataExposed.cityName,
                                        ClientsDataExposed.type,
                                        ClientsDataExposed.regDate,
                                        ClientsDataExposed.regDate.month()

                                    )
                                    .selectAll()
                                    .andWhere { ClientsDataExposed.cityName.eq(it) }
                                    .andWhere {
                                        ClientsDataExposed.regDate.between(
                                            Date.valueOf("2019-01-01".toString()),
                                            Date.valueOf("2020-01-01".toString())
                                        )
                                    }
                                    .andWhere {
                                        (ClientsDataExposed.type.inList(contracterTypeSelectedCheckboxes.filterValues { it }.keys.toList())) and (ClientsDataExposed.cityName.inList(
                                            citiesSelectedChekboxes.filterValues { it }.keys.toList()
                                        ))
                                    }
                                    .map { it[ClientsDataExposed.regDate.month()] }
                                    .toList()

                        val cityClientsPerMonth = NewClientsNumberCityMonthModel(
                            it,
                            regsInCity.count { it == 1 },
                            regsInCity.count { it == 2 },
                            regsInCity.count { it == 3 },
                            regsInCity.count { it == 4 },
                            regsInCity.count { it == 5 },
                            regsInCity.count { it == 6 },
                            regsInCity.count { it == 7 },
                            regsInCity.count { it == 8 },
                            regsInCity.count { it == 9 },
                            regsInCity.count { it == 10 },
                            regsInCity.count { it == 11 },
                            regsInCity.count { it == 12 },
                            regsInCity.count()
                            )
                               tempMutList.add(cityClientsPerMonth)    

                                //obj of dataclass
                            }

               viewTableTabOfnewClientsNumberCityMonth.value = tempMutList.map { it }
}

我知道，我应该使用Sum（）和CaseWhenElse，就像这里一样，检查ClientsDataExposed。注册日期。month（）它给出了一个月数（1-12），用于将sum（）结果分配给我的数据类属性，但我找不到任何CaseWhenElse语法的示例，我自己也无法理解，或者是否有其他方法可以不使用CaseWhenElse来获取它？

Answer 1

请检查该代码：

    val monthExpr = ClientsDataExposed.regDate.month()

    fun sumByMonth(monthNum: Int) = Expression.build { 
        val caseExpr = case().
            When(monthExpr eq intLiteral(monthNum), intLiteral(1)).
            Else(intLiteral(0))
        Sum(caseExpr, IntegerColumnType())
    }

    val janSumExp = sumByMonth(1)
    val febSumExp = sumByMonth(2)
    ClientsDataExposed.
        slice(ClientsDataExposed.cityName, janSumExp, febSumExp).
        selectAll().
        groupBy(ClientsDataExposed.id).map { 
          val janSum = it[janSumExp]
          val febSum = it[febSumExp]
          ...
        }