Breaking Changes

0.60.0

In H2, the timestamp() column now maps to data type TIMESTAMP(9) instead of DATETIME(9).
The names of the CHECK constraints created for the ushort() and uinteger() columns have been modified for consistency. Check this pull request for details regarding this change.

0.59.0

val long = long("long_column").check { column ->
    fun typeOf(value: String) = object : ExpressionWithColumnType<String>() {
        override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder { append("typeof($value)") }
        override val columnType: IColumnType<String> = TextColumnType()
    }
    Expression.build { typeOf(column.name) eq stringLiteral("integer") }
}

val long = long("long_column").nullable().check { column ->
    fun typeOf(value: String) = object : ExpressionWithColumnType<String>() {
        override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder { append("typeof($value)") }
        override val columnType: IColumnType<String> = TextColumnType()
    }

    val typeCondition = Expression.build { typeOf(column.name) eq stringLiteral("integer") }
    column.isNull() or typeCondition
}

0.57.0

Insert, Upsert, and Replace statements will no longer implicitly send all default values (except for client-side default values) in every SQL request. This change will reduce the amount of data Exposed sends to the database and make Exposed rely more on the database's default values. However, this may uncover previously hidden issues related to actual database default values, which were masked by Exposed's insert/upsert statements. Also from InsertStatement was removed protected method isColumnValuePreferredFromResultSet() and method valuesAndDefaults() was marked as deprecated.
Let's say you have a table with columns that have default values, and you use an insert statement like this:
```
object TestTable : IntIdTable("test") {
  val number = integer("number").default(100)
  val expression = integer("exp")
      .defaultExpression(intLiteral(100) + intLiteral(200))
}

TestTable.insert { }
```
This insert statement would generate the following SQL in the H2 database:
```
-- For versions before 0.57.0
INSERT INTO TEST ("number", "exp") VALUES (100, (100 + 200))

-- Starting from version 0.57.0
INSERT INTO TEST DEFAULT VALUES
```
The OptionalReferrers class is now deprecated as it is a complete duplicate of the Referrers class; therefore, the latter should be used instead.

0.56.0

0.55.0

The DeleteStatement property table is now deprecated in favor of targetsSet, which holds a ColumnSet that may be a Table or Join. This enables the use of the new Join.delete() function, which performs a delete operation on a specific table from the join relation. The original statement class constructor has also been deprecated in favor of the constructor that accepts targetsSet, as well as another additional parameter targetTables (for specifying which table from the join relation, if applicable, to delete from).
The DeleteStatement property offset was not being used and is now deprecated, as are the extension functions that have an offset parameter. deleteWhere() and deleteIgnoreWhere(), as well as the original statement class constructor, no longer accept an argument for offset.
SizedIterable.limit(n, offset) is now deprecated in favor of 2 independent methods, limit() and offset(). In supporting databases, this allows the generation of an OFFSET clause in the SELECT statement without any LIMIT clause. Any custom implementations of the SizedIterable interface with a limit() override will now show a warning that the declaration overrides a deprecated member. This override should be split into an implementation of the 2 new members instead.
The original FunctionProvider.queryLimit() is also being deprecated in favor of queryLimitAndOffset(), which takes a nullable size parameter to allow exclusion of the LIMIT clause. This latter deprecation only affects extensions of the FunctionProvider class when creating a custom VendorDialect class.
In Oracle, the short column now maps to data type NUMBER(5) instead of SMALLINT because SMALLINT is stored as NUMBER(38) in the database and takes up unnecessary storage. In Oracle and SQLite, using the short column in a table now also creates a check constraint to ensure that no out-of-range values are inserted.
In Oracle, the byte column now maps to data type NUMBER(3) instead of SMALLINT because SMALLINT is stored as NUMBER(38) in the database and takes up unnecessary storage. In SQL Server, the byte column now maps to data type SMALLINT instead of TINYINT because TINYINT allows values from 0 to 255. In SQL Server, SQLite, Oracle, PostgreSQL, and H2 PostgreSQL, using the byte column in a table now also creates a check constraint to ensure that no out-of-range values are inserted.
The transformation of a nullable column (Column<Unwrapped?>.transform()) requires handling null values. This enables conversions from null to a non-nullable value, and vice versa.
In H2 the definition of json column with default value changed from myColumn JSON DEFAULT '{"key": "value"}' to myColumn JSON DEFAULT JSON '{"key": "value"}'

0.54.0

// before
TestTable.upsert(
    onUpdate = listOf(Words.count to Words.count.plus(1))
) {
    it[word] = "Kotlin"
    it[count] = 3
}

// after
TestTable.upsert(
    onUpdate = {
        it[Words.count] = Words.count + 1
    }
) {
    it[word] = "Kotlin"
    it[count] = 3
}

// after - with new value from insert used in update expression
TestTable.upsert(
    onUpdate = {
        it[Words.count] = Words.count + insertValue(Words.count)
    }
) {
    it[word] = "Kotlin"
    it[count] = 3
}

0.53.0

DAO Entity Transformation Changes

Parameter Renaming: transform() and memoizedTransform() now use wrap and unwrap instead of toColumn and toReal.

// Old:
var name by EmployeeTable.name.transform(toColumn = { it.uppercase() }, toReal = { it.lowercase() })
// New:
var name by EmployeeTable.name.transform(wrap = { it.uppercase() }, unwrap = { it.lowercase() })

Class Renaming: ColumnWithTransform is now EntityFieldWithTransform, consolidating properties into a single transformer.

EntityFieldWithTransform(column, object : ColumnTransformer<String, Int> {
        override fun unwrap(value: Int): String = value.toString()
        override fun wrap(value: String): Int = value.toInt()
    })

Entity transformation via DAO is deprecated and should be replaced with DSL transformation.

val tester = object : Table() {
        val value = integer("value")
            .transform(wrap = { ... }, unwrap = { ... })
    }

0.51.0

0.50.0

0.49.0

0.48.0

0.47.0

0.46.0

object TestTable : Table("table") {
    val col = integer("select")
}

// default behavior (preserveKeywordCasing is by default set to true)
// H2 generates SQL -> CREATE TABLE IF NOT EXISTS "table" ("select" INT NOT NULL)

// with opt-out
Database.connect(
    url = "jdbc:h2:mem:test",
    driver = "org.h2.Driver",
    databaseConfig = DatabaseConfig {
        @OptIn(ExperimentalKeywordApi::class)
        preserveKeywordCasing = false
    }
)
// H2 generates SQL -> CREATE TABLE IF NOT EXISTS "TABLE" ("SELECT" INT NOT NULL)

0.44.0

object TestTable : Table("table") {
    val col = integer("select")
}

// without opt-in (default set to false)
// H2 generates SQL -> CREATE TABLE IF NOT EXISTS "TABLE" ("SELECT" INT NOT NULL)

// with opt-in
Database.connect(
    url = "jdbc:h2:mem:test",
    driver = "org.h2.Driver",
    databaseConfig = DatabaseConfig {
        @OptIn(ExperimentalKeywordApi::class)
        preserveKeywordCasing = true
    }
)
// H2 generates SQL -> CREATE TABLE IF NOT EXISTS "table" ("select" INT NOT NULL)

0.43.0

byte("number").check { it.between(0, Byte.MAX_VALUE) }
// OR
byte("number").check { (it greaterEq 0) and (it lessEq Byte.MAX_VALUE) }

integer("number").check { it.between(0, Int.MAX_VALUE) }
// OR
integer("number").check { (it greaterEq 0) and (it lessEq Int.MAX_VALUE) }

0.42.0

// before
transaction(Connection.TRANSACTION_READ_COMMITTED, repetitionAttempts = 10) {
    // statements
}

// after
transaction(Connection.TRANSACTION_READ_COMMITTED) {
    repetitionAttempts = 10
    // statements
}

short("number").check { it.between(0, Short.MAX_VALUE) }
// OR
short("number").check { (it greaterEq 0) and (it lessEq Short.MAX_VALUE) }

Breaking Changes﻿

0.60.0﻿

0.59.0﻿

0.57.0﻿

0.56.0﻿

0.55.0﻿

0.54.0﻿

0.53.0﻿

0.51.0﻿

0.50.0﻿

0.49.0﻿

0.48.0﻿

0.47.0﻿

0.46.0﻿

note

0.44.0﻿