Style updates and simplification

Author: jeffgbutler

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/model/ModelBuilderFunctions.kt

@@ -66,21 +66,21 @@ fun deleteFrom(table: SqlTable, tableAlias: String, completer: DeleteCompleter):
     KotlinDeleteBuilder(SqlBuilder.deleteFrom(table, tableAlias)).apply(completer).build()
 
 fun <T> insert(row: T & Any, completer: KotlinInsertCompleter<T>): InsertModel<T> {
-    val f : KotlinInsertBuilder<T> = KotlinInsertBuilder(row)
-    return f.apply(completer).build()
+    val builder : KotlinInsertBuilder<T> = KotlinInsertBuilder(row)
+    return builder.apply(completer).build()
 }
 
 fun <T> insertBatch(rows: Collection<T & Any>, completer: KotlinBatchInsertCompleter<T>): BatchInsertModel<T> {
-    val f: KotlinBatchInsertBuilder<T> = KotlinBatchInsertBuilder(rows)
-    return f.apply(completer).build()
+    val builder: KotlinBatchInsertBuilder<T> = KotlinBatchInsertBuilder(rows)
+    return builder.apply(completer).build()
 }
 
 fun insertInto(table: SqlTable, completer: GeneralInsertCompleter): GeneralInsertModel =
     KotlinGeneralInsertBuilder(table).apply(completer).build()
 
 fun <T> insertMultiple(rows: Collection<T & Any>, completer: KotlinMultiRowInsertCompleter<T>): MultiRowInsertModel<T> {
-    val f: KotlinMultiRowInsertBuilder<T> = KotlinMultiRowInsertBuilder(rows)
-    return f.apply(completer).build()
+    val builder: KotlinMultiRowInsertBuilder<T> = KotlinMultiRowInsertBuilder(rows)
+    return builder.apply(completer).build()
 }
 
 fun insertSelect(table: SqlTable, completer: InsertSelectCompleter): InsertSelectModel =

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/mybatis3/MapperSupportFunctions.kt

@@ -42,41 +42,38 @@ fun count(
     table: SqlTable,
     completer: CountCompleter
 ): Long =
-    count(column) {
+    mapper(count(column) {
         from(table)
         run(completer)
-    }.run(mapper)
+    })
 
 fun countDistinct(
     mapper: (SelectStatementProvider) -> Long,
     column: BasicColumn,
     table: SqlTable,
     completer: CountCompleter
 ): Long =
-    countDistinct(column) {
+    mapper(countDistinct(column) {
         from(table)
         run(completer)
-    }.run(mapper)
+    })
 
 fun countFrom(mapper: (SelectStatementProvider) -> Long, table: SqlTable, completer: CountCompleter): Long =
-    countFrom(table, completer).run(mapper)
+    mapper(countFrom(table, completer))
 
 fun deleteFrom(mapper: (DeleteStatementProvider) -> Int, table: SqlTable, completer: DeleteCompleter): Int =
-    deleteFrom(table, completer).run(mapper)
+    mapper(deleteFrom(table, completer))
 
 fun <T> insert(
     mapper: (InsertStatementProvider<T>) -> Int,
     row: T & Any,
     table: SqlTable,
     completer: KotlinInsertCompleter<T>
-): Int {
-    val f : InsertStatementProvider<T> = insert(row) {
+): Int =
+    mapper(insert(row) {
         into(table)
         run(completer)
-    }
-
-    return f.run(mapper)
-}
+    })
 
 /**
  * This function simply inserts all rows using the supplied mapper. It is up
@@ -91,90 +88,85 @@ fun <T> insertBatch(
     table: SqlTable,
     completer: KotlinBatchInsertCompleter<T>
 ): List<Int> {
-    val f: BatchInsert<T> = insertBatch(records) {
+    val batchInsert: BatchInsert<T> = insertBatch(records) {
         into(table)
         run(completer)
     }
 
-    return f.insertStatements().map(mapper)
+    return batchInsert.insertStatements().map(mapper)
 }
 
 fun insertInto(
     mapper: (GeneralInsertStatementProvider) -> Int,
     table: SqlTable,
     completer: GeneralInsertCompleter
 ): Int =
-    insertInto(table, completer).run(mapper)
+    mapper(insertInto(table, completer))
 
 fun <T> insertMultiple(
     mapper: (MultiRowInsertStatementProvider<T>) -> Int,
     records: Collection<T & Any>,
     table: SqlTable,
     completer: KotlinMultiRowInsertCompleter<T>
-): Int {
-    val f: MultiRowInsertStatementProvider<T> = insertMultiple(records) {
+): Int =
+    mapper(insertMultiple(records) {
         into(table)
         run(completer)
-    }
-
-    return f.run(mapper)
-}
+    })
 
 fun <T> insertMultipleWithGeneratedKeys(
     mapper: (String, List<T>) -> Int,
     records: Collection<T & Any>,
     table: SqlTable,
     completer: KotlinMultiRowInsertCompleter<T>
 ): Int {
-    val f: MultiRowInsertStatementProvider<T> = insertMultiple(records) {
+    val provider: MultiRowInsertStatementProvider<T> = insertMultiple(records) {
         into(table)
         run(completer)
     }
 
-    return f.run {
-        mapper(insertStatement, this.records)
-    }
+    return mapper(provider.insertStatement, provider.records)
 }
 
 fun insertSelect(
     mapper: (InsertSelectStatementProvider) -> Int,
     table: SqlTable,
     completer: InsertSelectCompleter
 ): Int =
-    insertSelect(table, completer).run(mapper)
+    mapper(insertSelect(table, completer))
 
 fun <T> selectDistinct(
     mapper: (SelectStatementProvider) -> List<T>,
     selectList: List<BasicColumn>,
     table: SqlTable,
     completer: SelectCompleter
 ): List<T> =
-    selectDistinct(selectList) {
+    mapper(selectDistinct(selectList) {
         from(table)
         run(completer)
-    }.run(mapper)
+    })
 
 fun <T> selectList(
     mapper: (SelectStatementProvider) -> List<T>,
     selectList: List<BasicColumn>,
     table: SqlTable,
     completer: SelectCompleter
 ): List<T> =
-    select(selectList) {
+    mapper(select(selectList) {
         from(table)
         run(completer)
-    }.run(mapper)
+    })
 
 fun <T> selectOne(
     mapper: (SelectStatementProvider) -> T?,
     selectList: List<BasicColumn>,
     table: SqlTable,
     completer: SelectCompleter
 ): T? =
-    select(selectList) {
+    mapper(select(selectList) {
         from(table)
         run(completer)
-    }.run(mapper)
+    })
 
 fun update(mapper: (UpdateStatementProvider) -> Int, table: SqlTable, completer: UpdateCompleter): Int =
-    update(table, completer).run(mapper)
+    mapper(update(table, completer))