chore: replace invocations of Array.toList with Array.asList to slightly reduce some copy overhead

An unnecessary `toList` conversion was removed instead of replaced.

Author: ShreckYe

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/OpBuilder.kt

@@ -658,13 +658,15 @@ fun <T> anyFrom(subQuery: AbstractQuery<*>): Op<T> = AllAnyFromSubQueryOp(true,
  * **Note** If [delegateType] is left `null`, the base column type associated with storing elements of type [T] will be
  * resolved according to the internal mapping of the element's type in [resolveColumnType].
  *
+ * @param array Wrapped in the resulting [Op] to improve performance. Do not mutate after passing to this function, otherwise pass the list converted using [Array.toList].
+ *
  * @throws IllegalStateException If no column type mapping is found and a [delegateType] is not provided.
  */
 inline fun <reified T : Any> anyFrom(array: Array<T>, delegateType: ColumnType<T>? = null): Op<T> {
     // emptyArray() without type info generates ARRAY[]
     @OptIn(InternalApi::class)
     val columnType = delegateType ?: resolveColumnType(T::class, if (array.isEmpty()) TextColumnType() else null)
-    return AllAnyFromArrayOp(true, array.toList(), columnType)
+    return AllAnyFromArrayOp(true, array.asList(), columnType)
 }
 
 /**
@@ -697,13 +699,15 @@ fun <T> allFrom(subQuery: AbstractQuery<*>): Op<T> = AllAnyFromSubQueryOp(false,
  * **Note** If [delegateType] is left `null`, the base column type associated with storing elements of type [T] will be
  * resolved according to the internal mapping of the element's type in [resolveColumnType].
  *
+ * @param array Wrapped in the resulting [Op] to improve performance. Do not mutate after passing to this function, otherwise pass the list converted using [Array.toList].
+ *
  * @throws IllegalStateException If no column type mapping is found and a [delegateType] is not provided.
  */
 inline fun <reified T : Any> allFrom(array: Array<T>, delegateType: ColumnType<T>? = null): Op<T> {
     // emptyArray() without type info generates ARRAY[]
     @OptIn(InternalApi::class)
     val columnType = delegateType ?: resolveColumnType(T::class, if (array.isEmpty()) TextColumnType() else null)
-    return AllAnyFromArrayOp(false, array.toList(), columnType)
+    return AllAnyFromArrayOp(false, array.asList(), columnType)
 }
 
 /**

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/SchemaUtilityApi.kt

@@ -553,7 +553,7 @@ abstract class SchemaUtilityApi {
 @InternalApi
 object TableUtils : SchemaUtilityApi() {
     /** Checks whether any of the [tables] have a sequence of foreign key constraints that cycle back to them. */
-    internal fun checkCycle(vararg tables: Table) = tables.toList().hasCycle()
+    internal fun checkCycle(vararg tables: Table) = tables.asList().hasCycle()
 
     /** Returns a list of [tables] sorted according to the targets of their foreign key constraints, if any exist. */
     fun sortTablesByReferences(tables: Iterable<Table>): List<Table> = tables.sortByReferences()

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/Table.kt

@@ -1520,7 +1520,7 @@ open class Table(name: String = "") : ColumnSet(), DdlAware {
     ) {
         _indices.add(
             Index(
-                columns.toList(),
+                columns.asList(),
                 isUnique,
                 customIndexName,
                 indexType,

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/BatchUpsertStatement.kt

@@ -54,7 +54,7 @@ open class BatchUpsertStatement(
     override fun prepareSQL(transaction: Transaction, prepared: Boolean): String {
         val dialect = transaction.db.dialect
         val functionProvider = UpsertBuilder.getFunctionProvider(dialect)
-        val keyColumns = if (functionProvider is MysqlFunctionProvider) keys.toList() else getKeyColumns(keys = keys)
+        val keyColumns = if (functionProvider is MysqlFunctionProvider) keys.asList() else getKeyColumns(keys = keys)
         val insertValues = arguments!!.first()
         val insertValuesSql = insertValues.toSqlString(prepared)
         val updateExcludeColumns = (onUpdateExclude ?: emptyList()) + if (dialect is OracleDialect) keyColumns else emptyList()

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/UpsertStatement.kt

@@ -46,7 +46,7 @@ open class UpsertStatement<Key : Any>(
     override fun prepareSQL(transaction: Transaction, prepared: Boolean): String {
         val dialect = transaction.db.dialect
         val functionProvider = UpsertBuilder.getFunctionProvider(dialect)
-        val keyColumns = if (functionProvider is MysqlFunctionProvider) keys.toList() else getKeyColumns(keys = keys)
+        val keyColumns = if (functionProvider is MysqlFunctionProvider) keys.asList() else getKeyColumns(keys = keys)
         val insertValues = arguments!!.first()
         val insertValuesSql = insertValues.toSqlString(prepared)
         val updateExcludeColumns = (onUpdateExclude ?: emptyList()) + if (dialect is OracleDialect) keyColumns else emptyList()
@@ -105,8 +105,9 @@ sealed interface UpsertBuilder {
 /** Returns the columns to be used in the conflict condition of an upsert statement. */
 internal fun UpsertBuilder.getKeyColumns(vararg keys: Column<*>): List<Column<*>> {
     this as InsertStatement<*>
-    return keys.toList().ifEmpty {
-        table.primaryKey?.columns?.toList() ?: table.indices.firstOrNull { it.unique }?.columns
+    return keys.asList().ifEmpty {
+        // TODO If it's needed to avoid changes from the underlying `columns`, revert to `toList`.
+        table.primaryKey?.columns?.asList() ?: table.indices.firstOrNull { it.unique }?.columns
     } ?: emptyList()
 }
 

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/vendors/SQLiteDialect.kt

@@ -34,9 +34,9 @@ internal object SQLiteFunctionProvider : FunctionProvider() {
 
     override fun concat(separator: String, queryBuilder: QueryBuilder, vararg expr: Expression<*>) = queryBuilder {
         if (separator == "") {
-            expr.toList().appendTo(this, separator = " || ") { +it }
+            expr.asList().appendTo(this, separator = " || ") { +it }
         } else {
-            expr.toList().appendTo(this, separator = " || '$separator' || ") { +it }
+            expr.asList().appendTo(this, separator = " || '$separator' || ") { +it }
         }
     }
 

exposed-dao/src/main/kotlin/org/jetbrains/exposed/v1/dao/References.kt

@@ -191,7 +191,7 @@ open class Referrers<ParentID : Any, in Parent : Entity<ParentID>, ChildID : Any
     infix fun orderBy(expression: Expression<*>) = orderBy(listOf(expression to SortOrder.ASC))
 
     /** Modifies this reference to sort entities based on multiple columns as specified in [order]. **/
-    fun orderBy(vararg order: Pair<Expression<*>, SortOrder>) = orderBy(order.toList())
+    fun orderBy(vararg order: Pair<Expression<*>, SortOrder>) = orderBy(order.asList())
 }
 
 /**
@@ -377,7 +377,7 @@ private fun <ID : Any> List<Entity<ID>>.preloadRelations(
     }
 
     if (directRelations.isNotEmpty() && relations.size != directRelations.size) {
-        val remainingRelations = relations.toList() - directRelations
+        val remainingRelations = relations.asList() - directRelations
         directRelations.map { relationProperty ->
             val relationsToLoad = this.flatMap {
                 when (val relation = (relationProperty as KProperty1<Entity<*>, *>).get(it)) {

exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/IterableEx.kt

@@ -66,7 +66,7 @@ class EmptySizedIterable<out T> : SizedIterable<T>, Iterator<T> {
 
 /** Represents a [SizedIterable] that defers to the specified [delegate] collection. */
 class SizedCollection<out T>(val delegate: Collection<T>) : SizedIterable<T> {
-    constructor(vararg values: T) : this(values.toList())
+    constructor(vararg values: T) : this(values.asList())
 
     override fun limit(count: Int): SizedIterable<T> = SizedCollection(delegate.take(count))
     override fun offset(start: Long): SizedIterable<T> = if (start >= Int.MAX_VALUE) {

exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/SchemaUtils.kt

@@ -21,14 +21,14 @@ object SchemaUtils : SchemaUtilityApi() {
     /** Checks whether any of the [tables] have a sequence of foreign key constraints that cycle back to them. */
     fun checkCycle(vararg tables: Table): Boolean {
         @OptIn(InternalApi::class)
-        return tables.toList().hasCycle()
+        return tables.asList().hasCycle()
     }
 
     /** Returns the SQL statements that create all [tables] that do not already exist. */
     fun createStatements(vararg tables: Table): List<String> {
         if (tables.isEmpty()) return emptyList()
 
-        val toCreate = sortTablesByReferences(tables.toList()).filterNot { it.exists() }
+        val toCreate = sortTablesByReferences(tables.asList()).filterNot { it.exists() }
         val alters = arrayListOf<String>()
 
         @OptIn(InternalApi::class)
@@ -441,7 +441,7 @@ object SchemaUtils : SchemaUtilityApi() {
     fun drop(vararg tables: Table, inBatch: Boolean = false) {
         if (tables.isEmpty()) return
         with(TransactionManager.current()) {
-            var tablesForDeletion = sortTablesByReferences(tables.toList()).reversed().filter { it in tables }
+            var tablesForDeletion = sortTablesByReferences(tables.asList()).reversed().filter { it in tables }
             if (!currentDialect.supportsIfNotExists) {
                 tablesForDeletion = tablesForDeletion.filter { it.exists() }
             }

exposed-r2dbc-tests/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/tests/shared/Assert.kt

@@ -23,15 +23,15 @@ fun <T> assertEqualCollections(actual: Collection<T>, expected: Collection<T>) {
 }
 
 fun <T> assertEqualCollections(actual: Collection<T>, vararg expected: T) {
-    assertEqualCollectionsImpl(actual, expected.toList())
+    assertEqualCollectionsImpl(actual, expected.asList())
 }
 
 suspend fun <T> assertEqualCollections(actual: Flow<T>, vararg expected: T) {
-    assertEqualCollectionsImpl(actual.toList(), expected.toList())
+    assertEqualCollectionsImpl(actual.toList(), expected.asList())
 }
 
 fun <T> assertEqualCollections(actual: Iterable<T>, vararg expected: T) {
-    assertEqualCollectionsImpl(actual.toList(), expected.toList())
+    assertEqualCollectionsImpl(actual.toList(), expected.asList())
 }
 
 fun <T> assertEqualCollections(actual: Iterable<T>, expected: Collection<T>) {
@@ -57,7 +57,7 @@ fun <T> assertEqualLists(actual: List<T>, expected: List<T>) {
 }
 
 fun <T> assertEqualLists(actual: List<T>, vararg expected: T) {
-    assertEqualLists(actual, expected.toList())
+    assertEqualLists(actual, expected.asList())
 }
 
 suspend fun <T> assertEqualLists(expected: Flow<T>, actual: List<T>) {