ktorm-core/org.ktorm.schema/BaseTable

BaseTable

abstract class BaseTable<E : Any>(tableName: String, alias: String? = null, catalog: String? = null, schema: String? = null, entityClass: KClass<E>? = null) : TypeReference<E> (source)

Base class of Ktorm's table objects, represents relational tables in the database.

This class provides the basic ability of table and column definition but doesn't support any binding mechanisms. If you need the binding support to Entity interfaces, use Table instead.

There is an abstract function doCreateEntity. Subclasses should implement this function, creating an entity object from the result set returned by a query, using the binding rules defined by themselves. Here, the type of the entity object could be an interface extending from Entity, or a data class, POJO, or any kind of classes.

Here is an example defining an entity as data class. The full documentation can be found at: https://www.ktorm.org/en/define-entities-as-any-kind-of-classes.html

data class Staff(
    val id: Int,
    val name: String,
    val job: String,
    val hireDate: LocalDate
)
object Staffs : BaseTable<Staff>("t_employee") {
    val id = int("id").primaryKey()
    val name = varchar("name")
    val job = varchar("job")
    val hireDate = date("hire_date")
    override fun doCreateEntity(row: QueryRowSet, withReferences: Boolean) = Staff(
        id = row[id] ?: 0,
        name = row[name].orEmpty(),
        job = row[job].orEmpty(),
        hireDate = row[hireDate] ?: LocalDate.now()
    )
}

Since

2.5

Inheritors

Table

Constructors

BaseTable

constructor(tableName: String, alias: String? = null, catalog: String? = null, schema: String? = null, entityClass: KClass<E>? = null)

Properties

alias

val alias: String?

The table's alias.

catalog

val catalog: String?

The table's catalog.

columns

val columns: List<Column<*>>

Return all columns of the table.

entityClass

val entityClass: KClass<E>?

The entity class this table is bound to.

primaryKeys

val primaryKeys: List<Column<*>>

The primary key columns of this table.

referencedKotlinType

val referencedKotlinType: KType

The actual kotlin type argument of subclass without erased.

referencedType

val referencedType: Type

The actual type argument of subclass without erased.

schema

val schema: String?

The table's schema.

tableName

val tableName: String

The table's name.

Functions

aliased

open fun aliased(alias: String): BaseTable<E>

Return a new-created table object with all properties (including the table name and columns and so on) being copied from this table, but applying a new alias given by the parameter.

asExpression

open fun asExpression(): TableExpression

Convert this table to a TableExpression.

blob

fun BaseTable<*>.blob(name: String): Column<ByteArray>

Define a column typed of BlobSqlType.

boolean

fun BaseTable<*>.boolean(name: String): Column<Boolean>

Define a column typed of BooleanSqlType.

bytes

fun BaseTable<*>.bytes(name: String): Column<ByteArray>

Define a column typed of BytesSqlType.

createEntity

fun createEntity(row: QueryRowSet, withReferences: Boolean = true): E

Create an entity object from the specific row of query results. This function uses the binding configurations of the table, filling column values into corresponding properties of the returned entity.

date

fun BaseTable<*>.date(name: String): Column<LocalDate>

Define a column typed of LocalDateSqlType.

datetime

fun BaseTable<*>.datetime(name: String): Column<LocalDateTime>

Define a column typed of LocalDateTimeSqlType.

decimal

fun BaseTable<*>.decimal(name: String): Column<BigDecimal>

Define a column typed of DecimalSqlType.

double

fun BaseTable<*>.double(name: String): Column<Double>

Define a column typed of DoubleSqlType.

enum

inline fun <C : Enum<C>> BaseTable<*>.enum(name: String): Column<C>

Define a column typed of EnumSqlType.

equals

operator override fun equals(other: Any?): Boolean

Indicates whether some other object is "equal to" this table. Two tables are equal only if they are the same instance.

float

fun BaseTable<*>.float(name: String): Column<Float>

Define a column typed of FloatSqlType.

get

operator fun get(name: String): Column<*>

Obtain a column from this table by the name.

hashCode

override fun hashCode(): Int

Return a hash code value for this table.

int

fun BaseTable<*>.int(name: String): Column<Int>

Define a column typed of IntSqlType.

jdbcDate

fun BaseTable<*>.jdbcDate(name: String): Column<Date>

Define a column typed of DateSqlType.

jdbcTime

fun BaseTable<*>.jdbcTime(name: String): Column<Time>

Define a column typed of TimeSqlType.

jdbcTimestamp

fun BaseTable<*>.jdbcTimestamp(name: String): Column<Timestamp>

Define a column typed of TimestampSqlType.

long

fun BaseTable<*>.long(name: String): Column<Long>

Define a column typed of LongSqlType.

monthDay

fun BaseTable<*>.monthDay(name: String): Column<MonthDay>

Define a column typed of MonthDaySqlType, instances of MonthDay are saved as strings in format MM-dd.

primaryKey

fun <C : Any> Column<C>.primaryKey(): Column<C>

Mark the registered column as a primary key.

registerColumn

fun <C : Any> registerColumn(name: String, sqlType: SqlType<C>): Column<C>

short

fun BaseTable<*>.short(name: String): Column<Short>

Define a column typed of ShortSqlType.

text

fun BaseTable<*>.text(name: String): Column<String>

Define a column typed of TextSqlType.

time

fun BaseTable<*>.time(name: String): Column<LocalTime>

Define a column typed of LocalTimeSqlType.

timestamp

fun BaseTable<*>.timestamp(name: String): Column<Instant>

Define a column typed of InstantSqlType.

toString

open override fun toString(): String

Return a string representation of this table.

transform

fun <C : Any, R : Any> Column<C>.transform(fromUnderlyingValue: (C) -> R, toUnderlyingValue: (R) -> C): Column<R>

Transform the registered column's SqlType to another. The transformed SqlType has the same typeCode and typeName as the underlying one, and performs the specific transformations on column values.

uuid

fun BaseTable<*>.uuid(name: String): Column<UUID>

Define a column typed of UuidSqlType.

varchar

fun BaseTable<*>.varchar(name: String): Column<String>

Define a column typed of VarcharSqlType.

year

fun BaseTable<*>.year(name: String): Column<Year>

Define a column typed of YearSqlType, instances of Year are saved as integers.

yearMonth

fun BaseTable<*>.yearMonth(name: String): Column<YearMonth>

Define a column typed of YearMonthSqlType, instances of YearMonth are saved as strings in format yyyy-MM.