Quarkus - 使用Ktorm

class KtOrmConfiguration {
    @ConfigProperty(name = "quarkus.datasource.jdbc.url")
    lateinit var url: String

    @ConfigProperty(name = "quarkus.datasource.username")
    lateinit var username: String

    @ConfigProperty(name = "quarkus.datasource.password")
    lateinit var password: String

    @ApplicationScoped
    fun database(): Database {
        // 如不需要数据源可直接返回
        // return  Database.connect(url,"com.mysql.jdbc.Driver",username,password)

        val config = HikariConfig()
        config.jdbcUrl = url
        config.username = username
        config.password = password
        config.maxLifetime = 120000
        return Database.connect(HikariDataSource(config))
    }
}

object Employees : Table<Nothing>("t_employee") {
    val id = int("id").primaryKey()
    val name = varchar("name")
    val job = varchar("job")
    val managerId = int("manager_id")
    val hireDate = date("hire_date")
    val salary = long("salary")
    val departmentId = int("department_id")
}

@Inject
lateinit var database: Database

func test(){
  for (row in database.from(Employees).select()) {
    println(row[Employees.name])
  }
}

// 实体类建议采用interface
// 更多信息可查看https://www.ktorm.org/zh-cn/entities-and-column-binding.html
interface User : Entity<User> {
    companion object : Entity.Factory<User>()

    var id: Long
    var avatarUrl: String
    var nickName: String
}

object Users : Table<User>("user") {
    val id = long("id").primaryKey().bindTo { it.id }
    val avatarUrl = varchar("avatar_url").bindTo { it.avatarUrl }
    val nickName = varchar("nick_name").bindTo { it.nickName }
}

// 查询出来为List<User>
val userList = database.sequenceOf(Users).toList()

/**
 * Created by vince on Jun 15, 2022.
 */
abstract class BaseService<E : Entity<E>, T : Table<E>>(private val tableObject: T) {
    @Inject
    protected lateinit var database: Database

    /**
     * Insert the given entity into the table and return the effected record number.
     */
    open fun add(entity: E): Int {
        return database.sequenceOf(tableObject).add(entity)
    }

    /**
     * Update properties of the given entity to the table and return the effected record number.
     */
    open fun update(entity: E): Int {
        return database.sequenceOf(tableObject).update(entity)
    }

    /**
     * Delete records that satisfy the given [predicate].
     */
    open fun deleteIf(predicate: (T) -> ColumnDeclaring<Boolean>): Int {
        return database.sequenceOf(tableObject).removeIf(predicate)
    }

    /**
     * Return true if all records match the given [predicate].
     */
    open fun allMatched(predicate: (T) -> ColumnDeclaring<Boolean>): Boolean {
        return database.sequenceOf(tableObject).all(predicate)
    }

    /**
     * Return true if at least one record match the given [predicate].
     */
    open fun anyMatched(predicate: (T) -> ColumnDeclaring<Boolean>): Boolean {
        return database.sequenceOf(tableObject).any(predicate)
    }

    /**
     * Return true if no records match the given [predicate].
     */
    open fun noneMatched(predicate: (T) -> ColumnDeclaring<Boolean>): Boolean {
        return database.sequenceOf(tableObject).none(predicate)
    }

    /**
     * Return the number of records in the table.
     */
    open fun count(): Int {
        return database.sequenceOf(tableObject).count()
    }

    /**
     * Return the number of records matching the given [predicate] in the table.
     */
    open fun count(predicate: (T) -> ColumnDeclaring<Boolean>): Int {
        return database.sequenceOf(tableObject).count(predicate)
    }

    /**
     * Return an entity object matching the given [predicate].
     */
    open fun findOne(predicate: (T) -> ColumnDeclaring<Boolean>): E? {
        return database.sequenceOf(tableObject).find(predicate)
    }

    /**
     * Return a list of entities matching the given [predicate].
     */
    open fun findList(predicate: (T) -> ColumnDeclaring<Boolean>): List<E> {
        return database.sequenceOf(tableObject).filter(predicate).toList()
    }

    /**
     * Return all entities in the table.
     */
    open fun findAll(): List<E> {
        return database.sequenceOf(tableObject).toList()
    }
}

@ApplicationScoped
class UserService : BaseService<User, Users>(Users) {
}

@Path("/user")
class UserResource {
    @Inject
    lateinit var userService: UserService

    @GET
    fun getOne(): User? {
        return userService.findOne { Users.id eq 1 }
    }
}