11package me.liuwj.ktorm.dsl
22
3- import me.liuwj.ktorm.database.Database
4- import me.liuwj.ktorm.database.prepareStatement
5- import me.liuwj.ktorm.expression.*
3+ import me.liuwj.ktorm.entity.*
4+ import me.liuwj.ktorm.expression.AggregateExpression
5+ import me.liuwj.ktorm.expression.AggregateType
66import me.liuwj.ktorm.schema.ColumnDeclaring
77import me.liuwj.ktorm.schema.DoubleSqlType
88import me.liuwj.ktorm.schema.IntSqlType
@@ -40,142 +40,87 @@ fun <C : Number> sumDistinct(column: ColumnDeclaring<C>): AggregateExpression<C>
4040 return AggregateExpression (AggregateType .SUM , column.asExpression(), true , column.sqlType)
4141}
4242
43- fun < C : Any > count (column : ColumnDeclaring <C > ): AggregateExpression <Int > {
44- return AggregateExpression (AggregateType .COUNT , column.asExpression(), false , IntSqlType )
43+ fun count (column : ColumnDeclaring <* > ? = null ): AggregateExpression <Int > {
44+ return AggregateExpression (AggregateType .COUNT , column? .asExpression(), false , IntSqlType )
4545}
4646
47- fun < C : Any > countDistinct (column : ColumnDeclaring <C > ): AggregateExpression <Int > {
48- return AggregateExpression (AggregateType .COUNT , column.asExpression(), true , IntSqlType )
47+ fun countDistinct (column : ColumnDeclaring <* > ? = null ): AggregateExpression <Int > {
48+ return AggregateExpression (AggregateType .COUNT , column? .asExpression(), true , IntSqlType )
4949}
5050
5151/* *
5252 * 如果表中的所有行都符合指定条件，返回 true，否则 false
5353 */
54- fun <T : Table <* >> T.all (block : (T ) -> ScalarExpression <Boolean >): Boolean {
55- return none { ! block( this ) }
54+ inline fun <E : Entity < E >, T : Table <E >> T.all (predicate : (T ) -> ColumnDeclaring <Boolean >): Boolean {
55+ return asSequence().all(predicate)
5656}
5757
5858/* *
5959 * 如果表中有数据，返回 true，否则 false
6060 */
61- fun Table <* > .any (): Boolean {
62- return count() > 0
61+ fun < E : Entity < E >, T : Table <E >> T .any (): Boolean {
62+ return asSequence().any()
6363}
6464
6565/* *
6666 * 如果表中存在任何一条记录满足指定条件，返回 true，否则 false
6767 */
68- fun <T : Table <* >> T.any (block : (T ) -> ScalarExpression <Boolean >): Boolean {
69- return count(block) > 0
68+ inline fun <E : Entity < E >, T : Table <E >> T.any (predicate : (T ) -> ColumnDeclaring <Boolean >): Boolean {
69+ return asSequence().any(predicate)
7070}
7171
7272/* *
7373 * 如果表中没有数据，返回 true，否则 false
7474 */
75- fun Table <* > .none (): Boolean {
76- return count() == 0
75+ fun < E : Entity < E >, T : Table <E >> T .none (): Boolean {
76+ return asSequence().none()
7777}
7878
7979/* *
8080 * 如果表中所有记录都不满足指定条件，返回 true，否则 false
8181 */
82- fun <T : Table <* >> T.none (block : (T ) -> ScalarExpression <Boolean >): Boolean {
83- return count(block) == 0
82+ inline fun <E : Entity < E >, T : Table <E >> T.none (predicate : (T ) -> ColumnDeclaring <Boolean >): Boolean {
83+ return asSequence().none(predicate)
8484}
8585
8686/* *
8787 * 返回表中的记录数
8888 */
89- fun Table <* > .count (): Int {
90- return doCount( null )
89+ fun < E : Entity < E >, T : Table <E >> T .count (): Int {
90+ return asSequence().count( )
9191}
9292
9393/* *
9494 * 返回表中满足指定条件的记录数
9595 */
96- fun <T : Table <* >> T.count (block : (T ) -> ScalarExpression <Boolean >): Int {
97- return doCount(block)
98- }
99-
100- private fun <T : Table <* >> T.doCount (block : ((T ) -> ScalarExpression <Boolean >)? ): Int {
101- val expression = SelectExpression (
102- columns = listOf (
103- ColumnDeclaringExpression (
104- expression = AggregateExpression (
105- type = AggregateType .COUNT ,
106- argument = null ,
107- isDistinct = false ,
108- sqlType = IntSqlType
109- )
110- )
111- ),
112- from = this .asExpression(),
113- where = block?.invoke(this )
114- )
115-
116- expression.prepareStatement { statement, logger ->
117- statement.executeQuery().use { rs ->
118- if (rs.next()) {
119- return rs.getInt(1 ).also { logger.debug(" Count: {}"
120- } else {
121- val (sql, _) = Database .global.formatExpression(expression, beautifySql = true )
122- throw IllegalStateException (" No result return for sql: $sql "
123- }
124- }
125- }
96+ inline fun <E : Entity <E >, T : Table <E >> T.count (predicate : (T ) -> ColumnDeclaring <Boolean >): Int {
97+ return asSequence().count(predicate)
12698}
12799
128100/* *
129101 * 返回表中指定字段的和，若表中没有数据，返回 null
130102 */
131- fun <T : Table <* >, C : Number > T.sumBy (block : (T ) -> ColumnDeclaring <C >): C ? {
132- return doAggregation(sum(block( this )) )
103+ inline fun <E : Entity < E >, T : Table <E >, C : Number > T.sumBy (selector : (T ) -> ColumnDeclaring <C >): C ? {
104+ return asSequence().sumBy(selector )
133105}
134106
135107/* *
136108 * 返回表中指定字段的最大值，若表中没有数据，返回 null
137109 */
138- fun <T : Table <* >, C : Number > T.maxBy (block : (T ) -> ColumnDeclaring <C >): C ? {
139- return doAggregation(max(block( this )) )
110+ inline fun <E : Entity < E >, T : Table <E >, C : Number > T.maxBy (selector : (T ) -> ColumnDeclaring <C >): C ? {
111+ return asSequence().maxBy(selector )
140112}
141113
142114/* *
143115 * 返回表中指定字段的最小值，若表中没有数据，返回 null
144116 */
145- fun <T : Table <* >, C : Number > T.minBy (block : (T ) -> ColumnDeclaring <C >): C ? {
146- return doAggregation(min(block( this )) )
117+ inline fun <E : Entity < E >, T : Table <E >, C : Number > T.minBy (selector : (T ) -> ColumnDeclaring <C >): C ? {
118+ return asSequence().minBy(selector )
147119}
148120
149121/* *
150122 * 返回表中指定字段的平均值，若表中没有数据，返回 null
151123 */
152- fun <T : Table <* >> T.avgBy (block : (T ) -> ColumnDeclaring <out Number >): Double? {
153- return doAggregation(avg(block(this )))
154- }
155-
156- private fun <R : Number > Table <* >.doAggregation (aggregation : AggregateExpression <R >): R ? {
157- val expression = SelectExpression (
158- columns = listOf (
159- ColumnDeclaringExpression (
160- expression = aggregation.asExpression()
161- )
162- ),
163- from = this .asExpression()
164- )
165-
166- expression.prepareStatement { statement, logger ->
167- statement.executeQuery().use { rs ->
168- if (rs.next()) {
169- val result = aggregation.sqlType.getResult(rs, 1 )
170-
171- if (logger.isDebugEnabled) {
172- logger.debug(" {}: {}"
173- }
174-
175- return result
176- } else {
177- return null
178- }
179- }
180- }
124+ inline fun <E : Entity <E >, T : Table <E >> T.averageBy (selector : (T ) -> ColumnDeclaring <out Number >): Double? {
125+ return asSequence().averageBy(selector)
181126}
0 commit comments