toQueryColumns()可以不加toTypedArray()，返回List<QueryColumn>即可

```
val <E : Any> KClass<E>.baseMapper: BaseMapper<E>
    get() = Mappers.ofEntityClass(java)

val <E : Any> KClass<E>.baseMapperOrNull: BaseMapper<E>?
    get() = try {
        Mappers.ofEntityClass(java)
    } catch (_: Exception) {
        null
    }

val <E : Any> KClass<E>.tableInfo: TableInfo
    get() = requireNotNull(tableInfoOrNull) {
        "The class TableInfo cannot be found through $this" +
                " because the entity class corresponding to the generic used by this interface to inherit from BaseMapper cannot be found."
    }

val <E : Any> KClass<E>.tableInfoOrNull: TableInfo?
    get() = if (isSubclassOf(BaseMapper::class)) TableInfoFactory.ofMapperClass(java)
    else TableInfoFactory.ofEntityClass(java)

//    query-----------
/**
 * 通过条件查询一条数据
 * @param columns 查询的列
 * @param init 查询作用域初始化函数
 */
inline fun <reified T : Any> queryOne(
    columns: Collection<QueryColumn> = emptyList(),
    init: QueryScope.() -> Unit
): T? = T::class.baseMapperOrNull?.run {
    val scope = QueryScope().apply(init)
    if (!scope.hasSelect() && columns.isNotEmpty()) scope.select(columns)
    selectOneByQuery(scope)
} ?: T::class.tableInfo.run {
    queryRow(schema, tableName, columns) {
        init()
        // 如果未调用select方法，则默认查询所有列
        if (hasSelect().not()) select(T::class.allColumns)
    }?.toEntity(T::class.java)
}

/**
 * 通过条件查询多条数据
 * @param columns 查询的列
 * @param init 查询作用域初始化函数
 */
inline fun <reified T : Any> query(
    columns: Collection<QueryColumn>,
    init: QueryScope.() -> Unit
): List<T> = try {
    T::class.baseMapper.selectListByQuery(queryScope(columns, init))
} catch (e: MybatisFlexException) {
    T::class.tableInfo.run {
        queryRows(schema, tableName, columns) {
            init()
            // 如果未调用select方法，则默认查询所有列
            if (hasSelect().not()) select(T::class.defaultColumns)
        }.toEntities()
    }
}

/**
 * 通过条件查询一条数据
 * @param columns 查询的列
 * @param init 查询作用域初始化函数
 */
inline fun queryRow(
    schema: String? = null,
    tableName: String? = null,
    columns: Collection<QueryColumn>,
    init: QueryScope.() -> Unit
): Row? = selectOneByQuery(
    schema,
    tableName,
    queryScope(columns, init)
)

inline fun queryScope(columns: Collection<QueryColumn>, init: QueryScope.() -> Unit = {}): QueryWrapper =
    QueryScope().apply(init).apply { if (columns.isNotEmpty() && !hasSelect()) select(columns) }

/**
 * 通过条件查询多条数据
 * @param columns 查询的列
 * @param init 查询作用域初始化函数
 */
inline fun queryRows(
    schema: String? = null,
    tableName: String? = null,
    columns: Collection<QueryColumn>,
    init: QueryScope.() -> Unit
): List<Row> = selectListByQuery(schema, tableName, queryScope(columns, init))

//    filter-----------
/**
 * 通过条件查询多条数据
 * @param columns 查询的列
 * @param queryCondition 查询条件
 */
inline fun <reified E : Any> filter(
    columns: Collection<QueryColumn> = emptyList(),
    queryCondition: QueryCondition = QueryCondition.createEmpty()
): List<E> = query(columns = columns) { and(queryCondition) }

val KClass<*>.defaultColumns: List<QueryColumn> get() = tableInfo.defaultQueryColumn

/**
 * 通过条件查询多条数据
 * @param columns 查询的列
 * @param condition 查询条件
 */
inline fun <reified E : Any> filterColumn(
    columns: Collection<QueryColumn> = E::class.defaultColumns,
    condition: () -> QueryCondition
): List<E> = filter(columns = columns, queryCondition = condition())

/**
 * 通过条件查询一条数据
 * @param columns 查询的列
 * @param condition 查询条件
 * @since 1.0.5
 */
inline fun <reified E : Any> filterOne(
    columns: Collection<KProperty1<E, *>> = emptyList(),
    condition: () -> QueryCondition
): E? = queryOne {
    if (columns.isNotEmpty()) select(columns.toQueryColumns())
    and(condition())
}

inline fun <reified E : Any, T : KProperty1<E, *>> Iterable<T>.toQueryColumns(): List<QueryColumn> =
    map { it.column() }

/**
 * 通过条件查询一条数据
 * @param columns 查询的列
 * @param condition 查询条件
 * @since 1.0.5
 */
inline fun <reified E : Any> filterOneColumn(
    columns: Iterable<QueryColumn> = E::class.defaultColumns,
    condition: () -> QueryCondition
): E? = queryOne { select(columns).and(condition()) }

/**
 * 通过条件查询多条数据
 * @param columns 查询的列
 * @param condition 查询条件
 */
inline fun <reified E : Any> filter(
    columns: Iterable<KProperty1<E, *>> = emptyList(),
    condition: () -> QueryCondition
): List<E> = filterColumn(columns.toQueryColumns(), condition)
```

MyBatis-Flex/MyBatis-Flex-Kotlin

内容风险标识

评论 (6)