English | 简体中文

api-docs / org.ktorm.entity / EntitySequence

EntitySequence

class EntitySequence<E : Any, T : BaseTable<E>> (source code)

Represents a sequence of entity objects. As the name implies, the style and use pattern of Ktorm’s entity sequence
APIs are highly similar to kotlin.sequences.Sequence and the extension functions in Kotlin standard lib, as it
provides many extension functions with the same names, such as filter, map, reduce, etc.

To create an EntitySequence, we can use the extension function sequenceOf:

val sequence = database.sequenceOf(Employees)

Now we got a default sequence, which can obtain all employees from the table. Please know that Ktorm doesn’t execute
the query right now. The sequence provides an iterator of type Iterator<Employee>, only when we iterate the
sequence using the iterator, the query is executed. The following code prints all employees using a for-each loop:

for (employee in sequence) {
println(employee)
}

This class wraps a Query object, and it’s iterator exactly wraps the query’s iterator. While an entity sequence is
iterated, its internal query is executed, and the entityExtractor function is applied to create an entity object
for each row. As for other properties in sequences (such as sql, rowSet, totalRecords, etc), all of them
delegates the callings to their internal query objects, and their usages are totally the same as the corresponding
properties in Query class.

Most of the entity sequence APIs are provided as extension functions, which can be divided into two groups:

  • Intermediate operations: these functions don’t execute the internal queries but return new-created sequence
    objects applying some modifications. For example, the filter function creates a new sequence object with the filter
    condition given by its parameter. The return types of intermediate operations are usually EntitySequence, so we
    can chaining call other sequence functions continuously.
  • Terminal operations: the return types of these functions are usually a collection or a computed result, as they execute the queries right now, obtain their results and perform some calculations on them. Eg. toList, reduce, etc.

For the list of sequence operations available, see the extension functions below.

Constructors

NameSummary

<init>

EntitySequence(
    database: Database,
    sourceTable: T,
    expression: SelectExpression,
    entityExtractor: (row: QueryRowSet) -> E)

Represents a sequence of entity objects. As the name implies, the style and use pattern of Ktorm's entity sequence APIs are highly similar to kotlin.sequences.Sequence and the extension functions in Kotlin standard lib, as it provides many extension functions with the same names, such as filter, map, reduce, etc.

Properties

NameSummary

database

val database: Database

The Database instance that the internal query is running on.

entityExtractor

val entityExtractor: (row: QueryRowSet) -> E

The function used to extract entity objects for each result row.

expression

val expression: SelectExpression

The SQL expression to be executed by this sequence when obtaining elements.

query

val query: Query

The internal query of this sequence to be executed, created by database and expression.

rowSet

val rowSet: QueryRowSet

The ResultSet object of the internal query, lazy initialized after first access, obtained from the database by executing the generated SQL.

sourceTable

val sourceTable: T

The source table from which elements are obtained.

sql

val sql: String

The executable SQL string of the internal query.

totalRecords

val totalRecords: Int

The total records count of this query ignoring the pagination params.

Functions

NameSummary

asKotlinSequence

fun asKotlinSequence(): Sequence<E>

Create a kotlin.sequences.Sequence instance that wraps this original entity sequence returning all the elements when being iterated.

iterator

operator fun iterator(): Iterator<E>

Return an iterator over the elements of this sequence.

withExpression

fun withExpression(
    expression: SelectExpression
): EntitySequence<E, T>

Return a copy of this EntitySequence with the expression modified.

Extension Functions

NameSummary

add

fun <E : Entity<E>, T : Table<E>> EntitySequence<E, T>.add(
    entity: E
): Int

Insert the given entity into this sequence and return the affected record number.

aggregateColumns

fun <E : Any, T : BaseTable<E>, C : Any> EntitySequence<E, T>.aggregateColumns(
    aggregationSelector: (T) -> ColumnDeclaring<C>
): C?

Perform an aggregation given by aggregationSelector for all elements in the sequence, and return the aggregate result.

all

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.all(
    predicate: (T) -> ColumnDeclaring<Boolean>
): Boolean

Return true if all elements match the given predicate.

any

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.any(): Boolean

Return true if the sequence has at lease one element.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.any(
    predicate: (T) -> ColumnDeclaring<Boolean>
): Boolean

Return true if at least one element matches the given predicate.

associate

fun <E : Any, K, V> EntitySequence<E, *>.associate(
    transform: (E) -> Pair<K, V>
): Map<K, V>

Return a Map containing key-value pairs provided by transform function applied to elements of the given sequence.

associateBy

fun <E : Any, K> EntitySequence<E, *>.associateBy(
    keySelector: (E) -> K
): Map<K, E>

Return a Map containing the elements from the given sequence indexed by the key returned from keySelector function applied to each element.

fun <E : Any, K, V> EntitySequence<E, *>.associateBy(
    keySelector: (E) -> K,
    valueTransform: (E) -> V
): Map<K, V>

Return a Map containing the values provided by valueTransform and indexed by keySelector functions applied to elements of the given sequence.

associateByTo

fun <E : Any, K, M : MutableMap<in K, in E>> EntitySequence<E, *>.associateByTo(
    destination: M,
    keySelector: (E) -> K
): M

Populate and return the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each element of the given sequence and value is the element itself.

fun <E : Any, K, V, M : MutableMap<in K, in V>> EntitySequence<E, *>.associateByTo(
    destination: M,
    keySelector: (E) -> K,
    valueTransform: (E) -> V
): M

Populate and return the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to elements of the given sequence.

associateTo

fun <E : Any, K, V, M : MutableMap<in K, in V>> EntitySequence<E, *>.associateTo(
    destination: M,
    transform: (E) -> Pair<K, V>
): M

Populate and return the destination mutable map with key-value pairs provided by transform function applied to each element of the given sequence.

associateWith

fun <K : Entity<K>, V> EntitySequence<K, *>.associateWith(
    valueSelector: (K) -> V
): Map<K, V>

Return a Map where keys are elements from the given sequence and values are produced by the valueSelector function applied to each element.

associateWithTo

fun <K : Entity<K>, V, M : MutableMap<in K, in V>> EntitySequence<K, *>.associateWithTo(
    destination: M,
    valueSelector: (K) -> V
): M

Populate and return the destination mutable map with key-value pairs for each element of the given sequence, where key is the element itself and value is provided by the valueSelector function applied to that key.

averageBy

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.averageBy(
    selector: (T) -> ColumnDeclaring<out Number>
): Double?

Return the average value of the column given by selector in this sequence.

clear

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.clear(): Int

Remove all of the elements of this sequence. The sequence will be empty after this function returns.

count

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.count(): Int

Return the number of elements in this sequence.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.count(
    predicate: (T) -> ColumnDeclaring<Boolean>
): Int

Return the number of elements matching the given predicate.

drop

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.drop(
    n: Int
): EntitySequence<E, T>

Returns a sequence containing all elements except first n elements.

elementAt

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.elementAt(
    index: Int
): E

Return an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this sequence.

elementAtOrElse

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.elementAtOrElse(
    index: Int,
    defaultValue: (Int) -> E
): E

Return an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this sequence.

elementAtOrNull

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.elementAtOrNull(
    index: Int
): E?

Return an element at the given index or null if the index is out of bounds of this sequence.

filter

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.filter(
    predicate: (T) -> ColumnDeclaring<Boolean>
): EntitySequence<E, T>

Return a sequence containing only elements matching the given predicate.

filterColumns

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.filterColumns(
    selector: (T) -> List<Column<*>>
): EntitySequence<E, T>

Return a sequence customizing the selected columns of the internal query.

filterNot

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.filterNot(
    predicate: (T) -> ColumnDeclaring<Boolean>
): EntitySequence<E, T>

Return a sequence containing only elements not matching the given predicate.

filterNotTo

fun <E : Any, T : BaseTable<E>, C : MutableCollection<in E>> EntitySequence<E, T>.filterNotTo(
    destination: C,
    predicate: (T) -> ColumnDeclaring<Boolean>
): C

Append all elements not matching the given predicate to the given destination.

filterTo

fun <E : Any, T : BaseTable<E>, C : MutableCollection<in E>> EntitySequence<E, T>.filterTo(
    destination: C,
    predicate: (T) -> ColumnDeclaring<Boolean>
): C

Append all elements matching the given predicate to the given destination.

find

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.find(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E?

Return the first element matching the given predicate, or null if no such element was found.

findLast

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.findLast(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E?

Return the last element matching the given predicate, or null if no such element was found.

first

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.first(): E

Return the first element, or throws NoSuchElementException if the sequence is empty.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.first(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E

Return the first element matching the given predicate, or throws NoSuchElementException if element was not found.

firstOrNull

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.firstOrNull(): E?

Return the first element, or null if the sequence is empty.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.firstOrNull(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E?

Return the first element matching the given predicate, or null if element was not found.

flatMap

fun <E : Any, R> EntitySequence<E, *>.flatMap(
    transform: (E) -> Iterable<R>
): List<R>

Return a single list of all elements yielded from results of transform function being invoked on each element of original sequence.

flatMapIndexed

fun <E : Any, R> EntitySequence<E, *>.flatMapIndexed(
    transform: (index: Int, E) -> Iterable<R>
): List<R>

Return a single list of all elements yielded from results of transform function being invoked on each element and its index in the original sequence.

flatMapIndexedTo

fun <E : Any, R, C : MutableCollection<in R>> EntitySequence<E, *>.flatMapIndexedTo(
    destination: C,
    transform: (index: Int, E) -> Iterable<R>
): C

Append all elements yielded from results of transform function being invoked on each element and its index in the original sequence, to the given destination.

flatMapTo

fun <E : Any, R, C : MutableCollection<in R>> EntitySequence<E, *>.flatMapTo(
    destination: C,
    transform: (E) -> Iterable<R>
): C

Append all elements yielded from results of transform function being invoked on each element of original sequence, to the given destination.

fold

fun <E : Any, R> EntitySequence<E, *>.fold(
    initial: R,
    operation: (acc: R, E) -> R
): R

Accumulate value starting with initial value and applying operation from left to right to current accumulator value and each element.

foldIndexed

fun <E : Any, R> EntitySequence<E, *>.foldIndexed(
    initial: R,
    operation: (index: Int, acc: R, E) -> R
): R

Accumulate value starting with initial value and applying operation from left to right to current accumulator value and each element with its index in the original sequence.

forEach

fun <E : Any> EntitySequence<E, *>.forEach(
    action: (E) -> Unit
): Unit

Perform the given action on each element.

forEachIndexed

fun <E : Any> EntitySequence<E, *>.forEachIndexed(
    action: (index: Int, E) -> Unit
): Unit

Perform the given action on each element, providing sequential index with the element.

forUpdate

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.forUpdate(): EntitySequence<E, T>

Indicate that this query should acquire the record-lock, the generated SQL would be select ... for update.

groupBy

fun <E : Any, K> EntitySequence<E, *>.groupBy(
    keySelector: (E) -> K
): Map<K, List<E>>

Group elements of the original sequence by the key returned by the given keySelector function applied to each element and return a map where each group key is associated with a list of corresponding elements.

fun <E : Any, K, V> EntitySequence<E, *>.groupBy(
    keySelector: (E) -> K,
    valueTransform: (E) -> V
): Map<K, List<V>>

Group values returned by the valueTransform function applied to each element of the original sequence by the key returned by the given keySelector function applied to the element and returns a map where each group key is associated with a list of corresponding values.

groupByTo

fun <E : Any, K, M : MutableMap<in K, MutableList<E>>> EntitySequence<E, *>.groupByTo(
    destination: M,
    keySelector: (E) -> K
): M

Group elements of the original sequence by the key returned by the given keySelector function applied to each element and put to the destination map each group key associated with a list of corresponding elements.

fun <E : Any, K, V, M : MutableMap<in K, MutableList<V>>> EntitySequence<E, *>.groupByTo(
    destination: M,
    keySelector: (E) -> K,
    valueTransform: (E) -> V
): M

Group values returned by the valueTransform function applied to each element of the original sequence by the key returned by the given keySelector function applied to the element and put to the destination map each group key associated with a list of corresponding values.

groupingBy

fun <E : Any, T : BaseTable<E>, K : Any> EntitySequence<E, T>.groupingBy(
    keySelector: (T) -> ColumnDeclaring<K>
): EntityGrouping<E, T, K>

Create an EntityGrouping from the sequence to be used later with one of group-and-fold operations.

isEmpty

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.isEmpty(): Boolean

Return true if the sequence has no elements.

isNotEmpty

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.isNotEmpty(): Boolean

Return true if the sequence has at lease one element.

joinTo

fun <E : Any, A> EntitySequence<E, *>.joinTo(
    buffer: A,
    separator: CharSequence = ", ",
    prefix: CharSequence = "",
    postfix: CharSequence = "",
    limit: Int = -1,
    truncated: CharSequence = "...",
    transform: ((E) -> CharSequence)? = null
): A

Append the string from all the elements separated using separator and using the given prefix and postfix.

joinToString

fun <E : Any> EntitySequence<E, *>.joinToString(
    separator: CharSequence = ", ",
    prefix: CharSequence = "",
    postfix: CharSequence = "",
    limit: Int = -1,
    truncated: CharSequence = "...",
    transform: ((E) -> CharSequence)? = null
): String

Create a string from all the elements separated using separator and using the given prefix and postfix.

last

fun <E : Any> EntitySequence<E, *>.last(): E

Return the last element, or throws NoSuchElementException if the sequence is empty.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.last(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E

Return the last element matching the given predicate, or throws NoSuchElementException if no such element found.

lastOrNull

fun <E : Any> EntitySequence<E, *>.lastOrNull(): E?

Return the last element, or null if the sequence is empty.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.lastOrNull(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E?

Return the last element matching the given predicate, or null if no such element was found.

locking

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.locking(
    mode: LockingMode,
    tables: List<BaseTable<*>> = emptyList(),
    wait: LockingWait = WAIT
): EntitySequence<E, T>

Specify the locking clause of this query, an example generated SQL could be:

locking

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.locking(
    mode: LockingMode,
    tables: List<BaseTable<*>> = emptyList(),
    wait: LockingWait = WAIT
): EntitySequence<E, T>

Specify the locking clause of this query, an example generated SQL could be:

map

fun <E : Any, R> EntitySequence<E, *>.map(
    transform: (E) -> R
): List<R>

Return a List containing the results of applying the given transform function to each element in the original sequence.

mapColumns

fun <E : Any, T : BaseTable<E>, C : Any> EntitySequence<E, T>.mapColumns(
    isDistinct: Boolean = false,
    columnSelector: (T) -> ColumnDeclaring<C>
): List<C?>

Customize the selected columns of the internal query by the given columnSelector function, and return a List containing the query results.

mapColumnsNotNull

fun <E : Any, T : BaseTable<E>, C : Any> EntitySequence<E, T>.mapColumnsNotNull(
    isDistinct: Boolean = false,
    columnSelector: (T) -> ColumnDeclaring<C>
): List<C>

Customize the selected columns of the internal query by the given columnSelector function, and return a List containing the non-null results.

mapColumnsNotNullTo

fun <E : Any, T : BaseTable<E>, C : Any, R : MutableCollection<in C>> EntitySequence<E, T>.mapColumnsNotNullTo(
    destination: R,
    isDistinct: Boolean = false,
    columnSelector: (T) -> ColumnDeclaring<C>
): R

Customize the selected columns of the internal query by the given columnSelector function, and append non-null results to the given destination.

mapColumnsTo

fun <E : Any, T : BaseTable<E>, C : Any, R : MutableCollection<in C?>> EntitySequence<E, T>.mapColumnsTo(
    destination: R,
    isDistinct: Boolean = false,
    columnSelector: (T) -> ColumnDeclaring<C>
): R

Customize the selected columns of the internal query by the given columnSelector function, and append the query results to the given destination.

mapIndexed

fun <E : Any, R> EntitySequence<E, *>.mapIndexed(
    transform: (index: Int, E) -> R
): List<R>

Return a List containing the results of applying the given transform function to each element and its index in the original sequence.

mapIndexedNotNull

fun <E : Any, R : Any> EntitySequence<E, *>.mapIndexedNotNull(
    transform: (index: Int, E) -> R?
): List<R>

Return a List containing only the non-null results of applying the given transform function to each element and its index in the original sequence.

mapIndexedNotNullTo

fun <E : Any, R : Any, C : MutableCollection<in R>> EntitySequence<E, *>.mapIndexedNotNullTo(
    destination: C,
    transform: (index: Int, E) -> R?
): C

Apply the given transform function to each element and its index in the original sequence and append only the non-null results to the given destination.

mapIndexedTo

fun <E : Any, R, C : MutableCollection<in R>> EntitySequence<E, *>.mapIndexedTo(
    destination: C,
    transform: (index: Int, E) -> R
): C

Apply the given transform function to each element and its index in the original sequence and append the results to the given destination.

mapNotNull

fun <E : Any, R : Any> EntitySequence<E, *>.mapNotNull(
    transform: (E) -> R?
): List<R>

Return a List containing only the non-null results of applying the given transform function to each element in the original sequence.

mapNotNullTo

fun <E : Any, R : Any, C : MutableCollection<in R>> EntitySequence<E, *>.mapNotNullTo(
    destination: C,
    transform: (E) -> R?
): C

Apply the given transform function to each element in the original sequence and append only the non-null results to the given destination.

mapTo

fun <E : Any, R, C : MutableCollection<in R>> EntitySequence<E, *>.mapTo(
    destination: C,
    transform: (E) -> R
): C

Apply the given transform function to each element of the original sequence and append the results to the given destination.

maxBy

fun <E : Any, T : BaseTable<E>, C : Comparable<C>> EntitySequence<E, T>.maxBy(
    selector: (T) -> ColumnDeclaring<C>
): C?

Return the max value of the column given by selector in this sequence.

minBy

fun <E : Any, T : BaseTable<E>, C : Comparable<C>> EntitySequence<E, T>.minBy(
    selector: (T) -> ColumnDeclaring<C>
): C?

Return the min value of the column given by selector in this sequence.

none

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.none(): Boolean

Return true if the sequence has no elements.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.none(
    predicate: (T) -> ColumnDeclaring<Boolean>
): Boolean

Return true if no elements match the given predicate.

reduce

fun <E : Any> EntitySequence<E, *>.reduce(
    operation: (acc: E, E) -> E
): E

Accumulate value starting with the first element and applying operation from left to right to current accumulator value and each element.

reduceIndexed

fun <E : Any> EntitySequence<E, *>.reduceIndexed(
    operation: (index: Int, acc: E, E) -> E
): E

Accumulate value starting with the first element and applying operation from left to right to current accumulator value and each element with its index in the original sequence.

reduceIndexedOrNull

fun <E : Any> EntitySequence<E, *>.reduceIndexedOrNull(
    operation: (index: Int, acc: E, E) -> E
): E?

Accumulate value starting with the first element and applying operation from left to right to current accumulator value and each element with its index in the original sequence.

reduceOrNull

fun <E : Any> EntitySequence<E, *>.reduceOrNull(
    operation: (acc: E, E) -> E
): E?

Accumulate value starting with the first element and applying operation from left to right to current accumulator value and each element.

removeIf

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.removeIf(
    predicate: (T) -> ColumnDeclaring<Boolean>
): Int

Remove all of the elements of this sequence that satisfy the given predicate.

single

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.single(): E

Return the single element, or throws an exception if the sequence is empty or has more than one element.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.single(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E

Return the single element matching the given predicate, or throws exception if there is no or more than one matching element.

singleOrNull

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.singleOrNull(): E?

Return single element, or null if the sequence is empty or has more than one element.

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.singleOrNull(
    predicate: (T) -> ColumnDeclaring<Boolean>
): E?

Return the single element matching the given predicate, or null if element was not found or more than one element was found.

sorted

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.sorted(
    selector: (T) -> List<OrderByExpression>
): EntitySequence<E, T>

Return a sequence customizing the order by clause of the internal query.

sortedBy

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.sortedBy(
    vararg selectors: (T) -> OrderByExpression
): EntitySequence<E, T>

Return a sequence sorting elements by multiple columns, in ascending or descending order. For example, sortedBy({ it.col1.asc() }, { it.col2.desc() }).

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.sortedBy(
    selector: (T) -> OrderByExpression
): EntitySequence<E, T>

Return a sequence sorting elements by a column, in ascending or descending order. For example, sortedBy { it.col.asc() }

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.sortedBy(
    selector: (T) -> ColumnDeclaring<*>
): EntitySequence<E, T>

Return a sequence sorting elements by the specific column in ascending order.

sortedByDescending

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.sortedByDescending(
    selector: (T) -> ColumnDeclaring<*>
): EntitySequence<E, T>

Return a sequence sorting elements by the specific column in descending order.

sumBy

fun <E : Any, T : BaseTable<E>, C : Number> EntitySequence<E, T>.sumBy(
    selector: (T) -> ColumnDeclaring<C>
): C?

Return the sum of the column given by selector in this sequence.

take

fun <E : Any, T : BaseTable<E>> EntitySequence<E, T>.take(
    n: Int
): EntitySequence<E, T>

Returns a sequence containing first n elements.

toCollection

fun <E : Any, C : MutableCollection<in E>> EntitySequence<E, *>.toCollection(
    destination: C
): C

Append all elements to the given destination collection.

toHashSet

fun <E : Any> EntitySequence<E, *>.toHashSet(): HashSet<E>

Return a HashSet containing all the elements of this sequence.

toList

fun <E : Any> EntitySequence<E, *>.toList(): List<E>

Return a List containing all the elements of this sequence.

toMutableList

fun <E : Any> EntitySequence<E, *>.toMutableList(): MutableList<E>

Return a MutableList containing all the elements of this sequence.

toMutableSet

fun <E : Any> EntitySequence<E, *>.toMutableSet(): MutableSet<E>

Return a MutableSet containing all the elements of this sequence.

toSet

fun <E : Any> EntitySequence<E, *>.toSet(): Set<E>

Return a Set containing all the elements of this sequence.

toSortedSet

fun <E> EntitySequence<E, *>.toSortedSet(): SortedSet<E> where E : Any, E : Comparable<E>

fun <E> EntitySequence<E, *>.toSortedSet(
    comparator: Comparator<in E>
): SortedSet<E> where E : Any, E : Comparable<E>

Return a SortedSet containing all the elements of this sequence.

update

fun <E : Entity<E>, T : Table<E>> EntitySequence<E, T>.update(
    entity: E
): Int

Update properties of the given entity to the database and return the affected record number.

withIndex

fun <E : Any> EntitySequence<E, *>.withIndex(): Sequence<IndexedValue<E>>

Return a lazy Sequence that wraps each element of the original sequence into an IndexedValue containing the index of that element and the element itself.