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. When an entity sequence is
iterated, its internal query is executed, and the entityExtractor function is applied to create an entity object
for each row.

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 call other sequence functions continuously in chaining style.

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. E.g. toList, reduce, etc.

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

Constructors

Name Summary

Name	Summary
<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.

<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

Name	Summary
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.
totalRecordsInAllPages	`val totalRecordsInAllPages: Int` The total records count of this query ignoring the pagination params.

Functions

Name	Summary
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

Name	Summary
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 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 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.
eq	`infix fun <T : Any> T.eq( expr: ColumnDeclaring<T> ): BinaryExpression<Boolean>` Equal operator, translated to `=` in SQL.
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.
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 : Appendable> 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.
neq	`infix fun <T : Any> T.neq( expr: ColumnDeclaring<T> ): BinaryExpression<Boolean>` Not-equal operator, translated to `<>` in SQL.
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.
notEq	`infix fun <T : Any> T.notEq( expr: ColumnDeclaring<T> ): BinaryExpression<Boolean>` Not-equal operator, translated to `<>` in SQL.
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 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.
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.