diff --git a/src/main/kotlin/org/jetbrains/exposed/dao/Entity.kt b/src/main/kotlin/org/jetbrains/exposed/dao/Entity.kt
index 1a1ff7672a..047f7600c9 100644
--- a/src/main/kotlin/org/jetbrains/exposed/dao/Entity.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/dao/Entity.kt
@@ -11,7 +11,7 @@ import kotlin.reflect.KProperty
 /**
  * @author max
  */
-class EntityID<T:Any>(id: T?, val table: IdTable<T>) {
+class EntityID<T:Comparable<T>>(id: T?, val table: IdTable<T>) : Comparable<EntityID<T>> {
     var _value: Any? = id
     val value: T get() {
         if (_value == null) {
@@ -32,6 +32,8 @@ class EntityID<T:Any>(id: T?, val table: IdTable<T>) {
 
         return other._value == _value && other.table == table
     }
+
+    override fun compareTo(other: EntityID<T>): Int = value.compareTo(other.value)
 }
 
 private fun <T:EntityID<*>?>checkReference(reference: Column<T>, factoryTable: IdTable<*>) {
@@ -42,33 +44,33 @@ private fun <T:EntityID<*>?>checkReference(reference: Column<T>, factoryTable: I
     }
 }
 
-class Reference<ID:Any, out Target : Entity<ID>> (val reference: Column<EntityID<ID>>, val factory: EntityClass<ID, Target>) {
+class Reference<ID:Comparable<ID>, out Target : Entity<ID>> (val reference: Column<EntityID<ID>>, val factory: EntityClass<ID, Target>) {
     init {
         checkReference(reference, factory.table)
     }
 }
 
-class OptionalReference<ID:Any, out Target: Entity<ID>> (val reference: Column<EntityID<ID>?>, val factory: EntityClass<ID, Target>) {
+class OptionalReference<ID:Comparable<ID>, out Target: Entity<ID>> (val reference: Column<EntityID<ID>?>, val factory: EntityClass<ID, Target>) {
     init {
         checkReference(reference, factory.table)
     }
 }
 
-class BackReference<ParentID:Any, out Parent:Entity<ParentID>, ChildID:Any, in Child:Entity<ChildID>>
+class BackReference<ParentID:Comparable<ParentID>, out Parent:Entity<ParentID>, ChildID:Comparable<ChildID>, in Child:Entity<ChildID>>
                     (reference: Column<EntityID<ChildID>>, factory: EntityClass<ParentID, Parent>) {
     private val delegate = Referrers(reference, factory, true)
 
     operator fun getValue(o: Child, desc: KProperty<*>) = delegate.getValue(o.apply { o.id.value }, desc).single() // flush entity before to don't miss newly created entities
 }
 
-class OptionalBackReference<ParentID:Any, out Parent:Entity<ParentID>, ChildID:Any, in Child:Entity<ChildID>>
+class OptionalBackReference<ParentID:Comparable<ParentID>, out Parent:Entity<ParentID>, ChildID:Comparable<ChildID>, in Child:Entity<ChildID>>
                     (reference: Column<EntityID<ChildID>?>, factory: EntityClass<ParentID, Parent>) {
     private val delegate = OptionalReferrers(reference, factory, true)
 
     operator fun getValue(o: Child, desc: KProperty<*>) = delegate.getValue(o.apply { o.id.value }, desc).singleOrNull()  // flush entity before to don't miss newly created entities
 }
 
-class Referrers<ParentID:Any, in Parent:Entity<ParentID>, ChildID:Any, out Child:Entity<ChildID>>
+class Referrers<ParentID:Comparable<ParentID>, in Parent:Entity<ParentID>, ChildID:Comparable<ChildID>, out Child:Entity<ChildID>>
     (val reference: Column<EntityID<ParentID>>, val factory: EntityClass<ChildID, Child>, val cache: Boolean) {
     init {
         reference.referee ?: error("Column $reference is not a reference")
@@ -85,7 +87,7 @@ class Referrers<ParentID:Any, in Parent:Entity<ParentID>, ChildID:Any, out Child
     }
 }
 
-class OptionalReferrers<ParentID:Any, in Parent:Entity<ParentID>, ChildID:Any, out Child:Entity<ChildID>>
+class OptionalReferrers<ParentID:Comparable<ParentID>, in Parent:Entity<ParentID>, ChildID:Comparable<ChildID>, out Child:Entity<ChildID>>
 (val reference: Column<EntityID<ParentID>?>, val factory: EntityClass<ChildID, Child>, val cache: Boolean) {
     init {
         reference.referee ?: error("Column $reference is not a reference")
@@ -116,7 +118,7 @@ class View<out Target: Entity<*>> (val op : Op<Boolean>, val factory: EntityClas
 }
 
 @Suppress("UNCHECKED_CAST")
-class InnerTableLink<ID:Any, Target: Entity<ID>>(val table: Table,
+class InnerTableLink<ID:Comparable<ID>, Target: Entity<ID>>(val table: Table,
                                      val target: EntityClass<ID, Target>) {
     private fun getSourceRefColumn(o: Entity<*>): Column<EntityID<*>> {
         val sourceRefColumn = table.columns.singleOrNull { it.referee == o.klass.table.id } as? Column<EntityID<*>> ?: error("Table does not reference source")
@@ -141,7 +143,7 @@ class InnerTableLink<ID:Any, Target: Entity<ID>>(val table: Table,
         return TransactionManager.current().entityCache.getOrPutReferrers(o.id, sourceRefColumn, query)
     }
 
-    operator fun<SrcID : Any> setValue(o: Entity<SrcID>, desc: KProperty<*>, value: SizedIterable<Target>) {
+    operator fun<SrcID : Comparable<SrcID>> setValue(o: Entity<SrcID>, desc: KProperty<*>, value: SizedIterable<Target>) {
         val sourceRefColumn = getSourceRefColumn(o)
         val targetRefColumn = getTargetRefColumn()
 
@@ -171,7 +173,7 @@ class InnerTableLink<ID:Any, Target: Entity<ID>>(val table: Table,
     }
 }
 
-open class Entity<ID:Any>(val id: EntityID<ID>) {
+open class Entity<ID:Comparable<ID>>(val id: EntityID<ID>) {
     var klass: EntityClass<ID, Entity<ID>> by Delegates.notNull()
 
     val writeValues = LinkedHashMap<Column<Any?>, Any?>()
@@ -183,20 +185,20 @@ open class Entity<ID:Any>(val id: EntityID<ID>) {
         _readValues!!
     }
 
-    operator fun <RID:Any, T: Entity<RID>> Reference<RID, T>.getValue(o: Entity<ID>, desc: KProperty<*>): T {
+    operator fun <RID:Comparable<RID>, T: Entity<RID>> Reference<RID, T>.getValue(o: Entity<ID>, desc: KProperty<*>): T {
         val id = reference.getValue(o, desc)
         return factory.findById(id) ?: error("Cannot find ${factory.table.tableName} WHERE id=$id")
     }
 
-    operator fun <RID:Any, T: Entity<RID>> Reference<RID, T>.setValue(o: Entity<ID>, desc: KProperty<*>, value: T) {
+    operator fun <RID:Comparable<RID>, T: Entity<RID>> Reference<RID, T>.setValue(o: Entity<ID>, desc: KProperty<*>, value: T) {
         value.id.value // flush before creating reference on it
         reference.setValue(o, desc, value.id)
     }
 
-    operator fun <RID:Any, T: Entity<RID>> OptionalReference<RID, T>.getValue(o: Entity<ID>, desc: KProperty<*>): T? =
+    operator fun <RID:Comparable<RID>, T: Entity<RID>> OptionalReference<RID, T>.getValue(o: Entity<ID>, desc: KProperty<*>): T? =
             reference.getValue(o, desc)?.let{factory.findById(it)}
 
-    operator fun <RID:Any, T: Entity<RID>> OptionalReference<RID, T>.setValue(o: Entity<ID>, desc: KProperty<*>, value: T?) {
+    operator fun <RID:Comparable<RID>, T: Entity<RID>> OptionalReference<RID, T>.setValue(o: Entity<ID>, desc: KProperty<*>, value: T?) {
         value?.id?.value // flush before creating reference on it
         reference.setValue(o, desc, value?.id)
     }
@@ -241,10 +243,10 @@ open class Entity<ID:Any>(val id: EntityID<ID>) {
         column.setValue(o, desc, toColumn(value))
     }
 
-    infix fun <ID:Any, Target:Entity<ID>> EntityClass<ID, Target>.via(table: Table): InnerTableLink<ID, Target> =
+    infix fun <ID:Comparable<ID>, Target:Entity<ID>> EntityClass<ID, Target>.via(table: Table): InnerTableLink<ID, Target> =
             InnerTableLink(table, this@via)
 
-    fun <T: Entity<*>> s(c: EntityClass<T, *>): EntityClass<T, *> = c
+    fun <T: Entity<*>> s(c: EntityClass<*, T>): EntityClass<*, T> = c
 
     open fun delete(){
         klass.removeFromCache(this)
@@ -253,7 +255,7 @@ open class Entity<ID:Any>(val id: EntityID<ID>) {
         EntityHook.registerChange(EntityChange(klass, id, EntityChangeType.Removed))
     }
 
-    open fun flush(batch: EntityBatchUpdate<ID>? = null): Boolean {
+    open fun flush(batch: EntityBatchUpdate? = null): Boolean {
         if (!writeValues.isEmpty()) {
             if (batch == null) {
                 val table = klass.table
@@ -293,37 +295,37 @@ open class Entity<ID:Any>(val id: EntityID<ID>) {
 
 @Suppress("UNCHECKED_CAST")
 class EntityCache {
-    val data = HashMap<IdTable<*>, MutableMap<Any, Entity<Any>>>()
-    val inserts = HashMap<IdTable<*>, MutableList<Entity<Any>>>()
+    val data = HashMap<IdTable<*>, MutableMap<Any, Entity<*>>>()
+    val inserts = HashMap<IdTable<*>, MutableList<Entity<*>>>()
     val referrers = HashMap<EntityID<*>, MutableMap<Column<*>, SizedIterable<*>>>()
 
-    private fun <ID:Any, T: Entity<ID>> getMap(f: EntityClass<ID, T>) : MutableMap<ID, T> = getMap(f.table)
+    private fun getMap(f: EntityClass<*, *>) : MutableMap<Any,  Entity<*>> = getMap(f.table)
 
-    private fun <ID:Any, T: Entity<ID>> getMap(table: IdTable<ID>) : MutableMap<ID, T> = data.getOrPut(table, {
+    private fun getMap(table: IdTable<*>) : MutableMap<Any, Entity<*>> = data.getOrPut(table, {
         HashMap()
-    }) as MutableMap<ID, T>
+    })
 
     fun <ID: Any, R: Entity<ID>> getOrPutReferrers(sourceId: EntityID<*>, key: Column<*>, refs: ()-> SizedIterable<R>): SizedIterable<R> =
             referrers.getOrPut(sourceId, {HashMap()}).getOrPut(key, {LazySizedCollection(refs())}) as SizedIterable<R>
 
-    fun <ID:Any, T: Entity<ID>> find(f: EntityClass<ID, T>, id: EntityID<ID>): T? = getMap(f)[id.value] ?: inserts[f.table]?.firstOrNull { it.id == id } as? T
+    fun <ID:Comparable<ID>, T: Entity<ID>> find(f: EntityClass<ID, T>, id: EntityID<ID>): T? = getMap(f)[id.value] as T? ?: inserts[f.table]?.firstOrNull { it.id == id } as? T
 
-    fun <ID:Any, T: Entity<ID>> findAll(f: EntityClass<ID, T>): Collection<T> = getMap(f).values
+    fun <ID:Comparable<ID>, T: Entity<ID>> findAll(f: EntityClass<ID, T>): Collection<T> = getMap(f).values as Collection<T>
 
-    fun <ID:Any, T: Entity<ID>> store(f: EntityClass<ID, T>, o: T) {
+    fun <ID:Comparable<ID>, T: Entity<ID>> store(f: EntityClass<ID, T>, o: T) {
         getMap(f).put(o.id.value, o)
     }
 
-    fun <ID:Any, T: Entity<ID>> store(o: T) {
+    fun store(o: Entity<*>) {
         getMap(o.klass.table).put(o.id.value, o)
     }
 
-    fun <ID:Any, T: Entity<ID>> remove(table: IdTable<ID>, o: T) {
-        getMap<ID, T>(table).remove(o.id.value)
+    fun <ID:Comparable<ID>, T: Entity<ID>> remove(table: IdTable<ID>, o: T) {
+        getMap(table).remove(o.id.value)
     }
 
-    fun <ID:Any, T: Entity<ID>> scheduleInsert(f: EntityClass<ID, T>, o: T) {
-        inserts.getOrPut(f.table) { arrayListOf() }.add(o as Entity<Any>)
+    fun <ID:Comparable<ID>, T: Entity<ID>> scheduleInsert(f: EntityClass<ID, T>, o: T) {
+        inserts.getOrPut(f.table) { arrayListOf() }.add(o as Entity<*>)
     }
 
     fun flush() {
@@ -343,7 +345,7 @@ class EntityCache {
                 if (map.isNotEmpty()) {
                     val updatedEntities = HashSet<Entity<*>>()
                     val batch = EntityBatchUpdate(map.values.first().klass)
-                    for ((i, entity) in map) {
+                    for ((_, entity) in map) {
                         if (entity.flush(batch)) {
                             if (entity.klass is ImmutableEntityClass<*,*>) {
                                 throw IllegalStateException("Update on immutable entity ${entity.javaClass.simpleName} ${entity.id}")
@@ -353,7 +355,7 @@ class EntityCache {
                     }
                     batch.execute(TransactionManager.current())
                     updatedEntities.forEach {
-                        EntityHook.registerChange(EntityChange(it.klass as EntityClass<Any, Entity<Any>>, it.id as EntityID<Any>, EntityChangeType.Updated))
+                        EntityHook.registerChange(EntityChange(it.klass, it.id, EntityChangeType.Updated))
                     }
                 }
             }
@@ -372,7 +374,7 @@ class EntityCache {
 
     internal fun flushInserts(table: IdTable<*>) {
         inserts.remove(table)?.let {
-            var toFlush: List<Entity<Any>> = it
+            var toFlush: List<Entity<*>> = it
             do {
                 val partition = toFlush.partition {
                     it.writeValues.none {
@@ -455,7 +457,7 @@ class EntityCache {
 }
 
 @Suppress("UNCHECKED_CAST")
-abstract class EntityClass<ID : Any, out T: Entity<ID>>(val table: IdTable<ID>, entityType: Class<T>? = null) {
+abstract class EntityClass<ID : Comparable<ID>, out T: Entity<ID>>(val table: IdTable<ID>, entityType: Class<T>? = null) {
     internal val klass: Class<*> = entityType ?: javaClass.enclosingClass as Class<T>
     private val ctor = klass.constructors[0]
 
@@ -503,7 +505,7 @@ abstract class EntityClass<ID : Any, out T: Entity<ID>>(val table: IdTable<ID>,
         }
 
         val toLoad = distinctIds - cached.map { it.id }
-        val loaded = wrapRows(searchQuery(Op.build { table.id inList (toLoad) }))
+        val loaded = wrapRows(searchQuery(Op.build { table.id inList toLoad }))
         if (cached.isEmpty()) {
             return loaded
         } else {
@@ -596,25 +598,25 @@ abstract class EntityClass<ID : Any, out T: Entity<ID>>(val table: IdTable<ID>,
 
     infix fun optionalReferencedOn(column: Column<EntityID<ID>?>) = registerRefRule(column) { OptionalReference(column, this) }
 
-    infix fun <TargetID: Any, Target:Entity<TargetID>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<EntityID<ID>>)
+    infix fun <TargetID: Comparable<TargetID>, Target:Entity<TargetID>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<EntityID<ID>>)
             = registerRefRule(column) { BackReference(column, this) }
 
     @JvmName("backReferencedOnOpt")
-    infix fun <TargetID: Any, Target:Entity<TargetID>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<EntityID<ID>?>)
+    infix fun <TargetID: Comparable<TargetID>, Target:Entity<TargetID>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<EntityID<ID>?>)
             = registerRefRule(column) { BackReference(column as Column<EntityID<ID>>, this) }
 
-    infix fun <TargetID: Any, Target:Entity<TargetID>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<EntityID<ID>>)
+    infix fun <TargetID: Comparable<TargetID>, Target:Entity<TargetID>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<EntityID<ID>>)
             = registerRefRule(column) { OptionalBackReference(column as Column<EntityID<ID>?>, this) }
 
     @JvmName("optionalBackReferencedOnOpt")
-    infix fun <TargetID: Any, Target:Entity<TargetID>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<EntityID<ID>?>)
+    infix fun <TargetID: Comparable<TargetID>, Target:Entity<TargetID>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<EntityID<ID>?>)
             = registerRefRule(column) { OptionalBackReference(column, this) }
 
-    infix fun <TargetID: Any> referrersOn(column: Column<EntityID<TargetID>>) = referrersOn(column, false)
+    infix fun <TargetID: Comparable<TargetID>> referrersOn(column: Column<EntityID<TargetID>>) = referrersOn(column, false)
 
-    fun <TargetID: Any> referrersOn(column: Column<EntityID<TargetID>>, cache: Boolean) = registerRefRule(column) { Referrers(column, this, cache) }
+    fun <TargetID: Comparable<TargetID>> referrersOn(column: Column<EntityID<TargetID>>, cache: Boolean) = registerRefRule(column) { Referrers(column, this, cache) }
 
-    fun <TargetID: Any> optionalReferrersOn(column: Column<EntityID<TargetID>?>, cache: Boolean = false) =  registerRefRule(column) { OptionalReferrers(column, this, cache) }
+    fun <TargetID: Comparable<TargetID>> optionalReferrersOn(column: Column<EntityID<TargetID>?>, cache: Boolean = false) =  registerRefRule(column) { OptionalReferrers(column, this, cache) }
 
     fun<TColumn: Any?,TReal: Any?> Column<TColumn>.transform(toColumn: (TReal) -> TColumn, toReal: (TColumn) -> TReal): ColumnWithTransform<TColumn, TReal> = ColumnWithTransform(this, toColumn, toReal)
 
@@ -663,10 +665,10 @@ abstract class EntityClass<ID : Any, out T: Entity<ID>>(val table: IdTable<ID>,
         return inCache.values.flatMap { it.toList() as List<T> } + loaded.orEmpty()
     }
 
-    fun <ID : Any, T: Entity<ID>> isAssignableTo(entityClass: EntityClass<ID, T>) = entityClass.klass.isAssignableFrom(klass)
+    fun <ID : Comparable<ID>, T: Entity<ID>> isAssignableTo(entityClass: EntityClass<ID, T>) = entityClass.klass.isAssignableFrom(klass)
 }
 
-abstract class ImmutableEntityClass<ID:Any, out T: Entity<ID>>(table: IdTable<ID>, entityType: Class<T>? = null) : EntityClass<ID, T>(table, entityType) {
+abstract class ImmutableEntityClass<ID:Comparable<ID>, out T: Entity<ID>>(table: IdTable<ID>, entityType: Class<T>? = null) : EntityClass<ID, T>(table, entityType) {
     open fun <T> forceUpdateEntity(entity: Entity<ID>, column: Column<T>, value: T) {
         table.update({ table.id eq entity.id }) {
             it[column] = value
@@ -674,10 +676,10 @@ abstract class ImmutableEntityClass<ID:Any, out T: Entity<ID>>(table: IdTable<ID
     }
 }
 
-abstract class ImmutableCachedEntityClass<ID:Any, out T: Entity<ID>>(table: IdTable<ID>, entityType: Class<T>? = null) : ImmutableEntityClass<ID, T>(table, entityType) {
+abstract class ImmutableCachedEntityClass<ID:Comparable<ID>, out T: Entity<ID>>(table: IdTable<ID>, entityType: Class<T>? = null) : ImmutableEntityClass<ID, T>(table, entityType) {
 
     private val cacheLoadingState = Key<Any>()
-    private var _cachedValues: MutableMap<Any, Entity<Any>>? = null
+    private var _cachedValues: MutableMap<Any, Entity<*>>? = null
 
     override fun invalidateEntityInCache(o: Entity<ID>) {
         warmCache()
diff --git a/src/main/kotlin/org/jetbrains/exposed/dao/EntityHook.kt b/src/main/kotlin/org/jetbrains/exposed/dao/EntityHook.kt
index b8f67855f9..5b18e4b749 100644
--- a/src/main/kotlin/org/jetbrains/exposed/dao/EntityHook.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/dao/EntityHook.kt
@@ -11,33 +11,33 @@ enum class EntityChangeType {
 }
 
 
-data class EntityChange<ID: Any>(val entityClass: EntityClass<ID, Entity<ID>>, val id: EntityID<ID>, var changeType: EntityChangeType)
+data class EntityChange(val entityClass: EntityClass<*, Entity<*>>, val id: EntityID<*>, var changeType: EntityChangeType)
 
-fun<ID: Any> EntityChange<ID>.toEntity() : Entity<ID>? = entityClass.findById(id)
+fun<ID: Comparable<ID>, T: Entity<ID>> EntityChange.toEntity() : T? = (entityClass as EntityClass<ID, T>).findById(id as EntityID<ID>)
 
-fun<ID: Any,T: Entity<ID>> EntityChange<*>.toEntity(klass: EntityClass<ID, T>) : T? {
+fun<ID: Comparable<ID>,T: Entity<ID>> EntityChange.toEntity(klass: EntityClass<ID, T>) : T? {
     if (!entityClass.isAssignableTo(klass)) return null
     @Suppress("UNCHECKED_CAST")
-    return toEntity() as? T
+    return toEntity<ID, T>()
 }
 
 object EntityHook {
-    private val entitySubscribers = CopyOnWriteArrayList<(EntityChange<*>) -> Unit>()
+    private val entitySubscribers = CopyOnWriteArrayList<(EntityChange) -> Unit>()
 
-    private val events by transactionScope { CopyOnWriteArrayList<EntityChange<*>>() }
+    private val events by transactionScope { CopyOnWriteArrayList<EntityChange>() }
 
-    val registeredEvents: List<EntityChange<*>> get() = events.toList()
+    val registeredEvents: List<EntityChange> get() = events.toList()
 
-    fun subscribe (action: (EntityChange<*>) -> Unit): (EntityChange<*>) -> Unit {
+    fun subscribe (action: (EntityChange) -> Unit): (EntityChange) -> Unit {
         entitySubscribers.add(action)
         return action
     }
 
-    fun unsubscribe (action: (EntityChange<*>) -> Unit) {
+    fun unsubscribe (action: (EntityChange) -> Unit) {
         entitySubscribers.remove(action)
     }
 
-    fun registerChange(change: EntityChange<*>) {
+    fun registerChange(change: EntityChange) {
         if (events.lastOrNull() != change) {
             events.add(change)
         }
@@ -53,7 +53,7 @@ object EntityHook {
     }
 }
 
-fun <T> withHook(action: (EntityChange<*>) -> Unit, body: ()->T): T {
+fun <T> withHook(action: (EntityChange) -> Unit, body: ()->T): T {
     EntityHook.subscribe(action)
     try {
         return body().apply {
diff --git a/src/main/kotlin/org/jetbrains/exposed/dao/IdTable.kt b/src/main/kotlin/org/jetbrains/exposed/dao/IdTable.kt
index f0f83cfbe6..32bf4c93b7 100644
--- a/src/main/kotlin/org/jetbrains/exposed/dao/IdTable.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/dao/IdTable.kt
@@ -3,7 +3,7 @@ package org.jetbrains.exposed.dao
 import org.jetbrains.exposed.sql.Column
 import org.jetbrains.exposed.sql.Table
 
-abstract class IdTable<T:Any>(name: String): Table(name) {
+abstract class IdTable<T:Comparable<T>>(name: String): Table(name) {
     abstract val id : Column<EntityID<T>>
 
 }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt
index 91c94f7a25..565f095a8f 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt
@@ -33,7 +33,7 @@ class Alias<out T:Table>(val delegate: T, val alias: String) : Table() {
 }
 
 
-class ExpressionAlias<out T: Any?>(val delegate: Expression<T>, val alias: String) : Expression<T>() {
+class ExpressionAlias<T>(val delegate: Expression<T>, val alias: String) : Expression<T>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "${delegate.toSQL(queryBuilder)} $alias"
 
     fun aliasOnlyExpression() = object: Expression<T>() {
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/ColumnType.kt b/src/main/kotlin/org/jetbrains/exposed/sql/ColumnType.kt
index cc5a7b7537..de4c8103a6 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/ColumnType.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/ColumnType.kt
@@ -80,7 +80,7 @@ val Column<*>.autoIncSeqName : String? get() {
             ?: (columnType as? EntityIDColumnType<*>)?.idColumn?.autoIncSeqName
 }
 
-class EntityIDColumnType<T:Any>(val idColumn: Column<T>) : ColumnType(false) {
+class EntityIDColumnType<T:Comparable<T>>(val idColumn: Column<T>) : ColumnType(false) {
 
     init {
         assert(idColumn.table is IdTable<*>){"EntityId supported only for IdTables"}
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Expression.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Expression.kt
index e30a449d1b..5aa3a446f2 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Expression.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Expression.kt
@@ -27,7 +27,7 @@ class QueryBuilder(val prepared: Boolean) {
     }
 }
 
-abstract class Expression<out T> {
+abstract class Expression<T> {
     private val _hashCode by lazy {
         toString().hashCode()
     }
@@ -46,7 +46,7 @@ abstract class Expression<out T> {
     }
 }
 
-abstract class ExpressionWithColumnType<out T> : Expression<T>() {
+abstract class ExpressionWithColumnType<T> : Expression<T>() {
     // used for operations with literals
     abstract val columnType: IColumnType
 }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Function.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Function.kt
index 6a193d86c6..7671b39e00 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Function.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Function.kt
@@ -4,7 +4,7 @@ import org.joda.time.DateTime
 import java.math.BigDecimal
 import java.util.*
 
-abstract class Function<out T> : ExpressionWithColumnType<T>()
+abstract class Function<T> : ExpressionWithColumnType<T>()
 
 class Count(val expr: Expression<*>, val distinct: Boolean = false): Function<Int>() {
     override fun toSQL(queryBuilder: QueryBuilder): String =
@@ -13,7 +13,7 @@ class Count(val expr: Expression<*>, val distinct: Boolean = false): Function<In
     override val columnType: IColumnType = IntegerColumnType()
 }
 
-class Date(val expr: Expression<DateTime?>): Function<DateTime>() {
+class Date<T:DateTime?>(val expr: Expression<T>): Function<DateTime>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "DATE(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DateColumnType(false)
@@ -24,80 +24,80 @@ class CurrentDateTime : Function<DateTime>() {
     override val columnType: IColumnType = DateColumnType(false)
 }
 
-class Month(val expr: Expression<DateTime?>): Function<DateTime>() {
+class Month<T:DateTime?>(val expr: Expression<T>): Function<DateTime>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "MONTH(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DateColumnType(false)
 }
 
-class LowerCase<out T: String?>(val expr: Expression<T>) : Function<T>() {
+class LowerCase<T: String?>(val expr: Expression<T>) : Function<T>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "LOWER(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = StringColumnType()
 }
 
-class UpperCase<out T: String?>(val expr: Expression<T>) : Function<T>() {
+class UpperCase<T: String?>(val expr: Expression<T>) : Function<T>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "UPPER(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = StringColumnType()
 }
 
-class Min<out T>(val expr: Expression<T>, _columnType: IColumnType): Function<T?>() {
+class Min<T:Comparable<T>, S:T?>(val expr: Expression<in S>, _columnType: IColumnType): Function<S?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "MIN(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = _columnType
 }
 
-class Max<out T>(val expr: Expression<T>, _columnType: IColumnType): Function<T?>() {
+class Max<T:Comparable<T>, S:T?>(val expr: Expression<in S>, _columnType: IColumnType): Function<S>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "MAX(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = _columnType
 }
 
-class Avg<out T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
+class Avg<T:Comparable<T>, in S:T?>(val expr: Expression<in S>, scale: Int): Function<BigDecimal?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "AVG(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DecimalColumnType(Int.MAX_VALUE, scale)
 }
 
-class StdDevPop<out T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
+class StdDevPop<T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "STDDEV_POP(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DecimalColumnType(Int.MAX_VALUE, scale)
 }
 
-class StdDevSamp<out T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
+class StdDevSamp<T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "STDDEV_SAMP(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DecimalColumnType(Int.MAX_VALUE, scale)
 }
 
-class VarPop<out T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
+class VarPop<T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "VAR_POP(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DecimalColumnType(Int.MAX_VALUE, scale)
 }
 
-class VarSamp<out T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
+class VarSamp<T>(val expr: Expression<T>, scale: Int): Function<BigDecimal?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "VAR_SAMP(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = DecimalColumnType(Int.MAX_VALUE, scale)
 }
 
-class Sum<out T>(val expr: Expression<T>, _columnType: IColumnType): Function<T?>() {
+class Sum<T>(val expr: Expression<T>, _columnType: IColumnType): Function<T?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "SUM(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = _columnType
 }
 
-class Coalesce<out T>(val expr: ExpressionWithColumnType<T?>, val alternate: ExpressionWithColumnType<out T>): Function<T>() {
+class Coalesce<out T, S:T?, R:T>(private val expr: ExpressionWithColumnType<S>, private val alternate: ExpressionWithColumnType<out T>): Function<R>() {
     override fun toSQL(queryBuilder: QueryBuilder): String =
             "COALESCE(${expr.toSQL(queryBuilder)}, ${alternate.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = alternate.columnType
 }
 
-class Substring(val expr: Expression<String?>, val start: ExpressionWithColumnType<Int>, val length: ExpressionWithColumnType<Int>): Function<String>() {
+class Substring<T:String?>(private val expr: Expression<T>, private val start: ExpressionWithColumnType<Int>, val length: ExpressionWithColumnType<Int>): Function<T>() {
     override fun toSQL(queryBuilder: QueryBuilder): String
             = currentDialect.functionProvider.substring(expr, start, length, queryBuilder)
 
@@ -112,12 +112,12 @@ class Random(val seed: Int? = null) : Function<BigDecimal>() {
     override val columnType: IColumnType = DecimalColumnType(38, 20)
 }
 
-class Cast<out T>(val expr: Expression<*>, override val columnType: IColumnType) : Function<T?>() {
+class Cast<T>(val expr: Expression<*>, override val columnType: IColumnType) : Function<T?>() {
     override fun toSQL(queryBuilder: QueryBuilder): String
             = currentDialect.functionProvider.cast(expr, columnType, queryBuilder)
 }
 
-class Trim(val expr: Expression<*>): Function<String>() {
+class Trim<T:String?>(val expr: Expression<T>): Function<T>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = "TRIM(${expr.toSQL(queryBuilder)})"
 
     override val columnType: IColumnType = StringColumnType()
@@ -129,17 +129,18 @@ class Case(val value: Expression<*>? = null) {
 }
 
 class CaseWhen<T> (val value: Expression<*>?) {
-    val cases: ArrayList<Pair<Expression<Boolean>, Expression<T>>> =  ArrayList()
+    val cases: ArrayList<Pair<Expression<Boolean>, Expression<out T>>> =  ArrayList()
 
-    fun When (cond: Expression<Boolean>, result: Expression<T>) : CaseWhen<T> {
+    @Suppress("UNCHECKED_CAST")
+    fun <R:T> When (cond: Expression<Boolean>, result: Expression<R>) : CaseWhen<R> {
         cases.add( cond to result )
-        return this
+        return this as CaseWhen<R>
     }
 
-    fun Else(e: Expression<T>) : Expression<T> = CaseWhenElse(this, e)
+    fun <R:T> Else(e: Expression<R>) : Expression<R> = CaseWhenElse(this, e)
 }
 
-class CaseWhenElse<T> (val caseWhen: CaseWhen<T>, val elseResult: Expression<T>) : Expression<T>() {
+class CaseWhenElse<T, R:T> (val caseWhen: CaseWhen<T>, val elseResult: Expression<R>) : Expression<R>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = buildString {
         append("CASE")
         if (caseWhen.value != null)
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt
index 8e8e49b9e1..2dda9e39c1 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt
@@ -3,7 +3,7 @@ package org.jetbrains.exposed.sql
 import org.jetbrains.exposed.dao.EntityID
 import org.joda.time.DateTime
 
-abstract class Op<out T> : Expression<T>() {
+abstract class Op<T> : Expression<T>() {
     companion object {
         inline fun <T> build(op: SqlExpressionBuilder.()-> Op<T>): Op<T> = SqlExpressionBuilder.op()
     }
@@ -21,7 +21,7 @@ class IsNotNullOp(val expr: Expression<*>): Op<Boolean>() {
     override fun toSQL(queryBuilder: QueryBuilder):String = "${expr.toSQL(queryBuilder)} IS NOT NULL"
 }
 
-class LiteralOp<out T>(override val columnType: IColumnType, val value: T): ExpressionWithColumnType<T>() {
+class LiteralOp<T>(override val columnType: IColumnType, val value: T): ExpressionWithColumnType<T>() {
     override fun toSQL(queryBuilder: QueryBuilder):String = columnType.valueToString(value)
 }
 
@@ -30,11 +30,11 @@ class Between(val expr: Expression<*>, val from: LiteralOp<*>, val to: LiteralOp
             "${expr.toSQL(queryBuilder)} BETWEEN ${from.toSQL(queryBuilder)} AND ${to.toSQL(queryBuilder)}"
 }
 
-class NoOpConversion<out T, out S>(val expr: Expression<T>, override val columnType: IColumnType): ExpressionWithColumnType<S>() {
+class NoOpConversion<T, S>(val expr: Expression<T>, override val columnType: IColumnType): ExpressionWithColumnType<S>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = expr.toSQL(queryBuilder)
 }
 
-class InListOrNotInListOp<out T>(val expr: ExpressionWithColumnType<T>, val list: Iterable<T>, val isInList: Boolean = true): Op<Boolean>() {
+class InListOrNotInListOp<T>(val expr: ExpressionWithColumnType<T>, val list: Iterable<T>, val isInList: Boolean = true): Op<Boolean>() {
 
     override fun toSQL(queryBuilder: QueryBuilder): String = buildString{
         list.iterator().let { i ->
@@ -66,11 +66,11 @@ class InListOrNotInListOp<out T>(val expr: ExpressionWithColumnType<T>, val list
     }
 }
 
-class QueryParameter<out T>(val value: T, val sqlType: IColumnType) : Expression<T>() {
+class QueryParameter<T>(val value: T, val sqlType: IColumnType) : Expression<T>() {
     override fun toSQL(queryBuilder: QueryBuilder): String = queryBuilder.registerArgument(sqlType, value)
 }
 
-fun <T:Any> idParam(value: EntityID<T>, column: Column<EntityID<T>>): Expression<EntityID<T>> = QueryParameter(value, EntityIDColumnType(column))
+fun <T:Comparable<T>> idParam(value: EntityID<T>, column: Column<EntityID<T>>): Expression<EntityID<T>> = QueryParameter(value, EntityIDColumnType(column))
 fun booleanParam(value: Boolean): Expression<Boolean> = QueryParameter(value, BooleanColumnType())
 fun intParam(value: Int): Expression<Int> = QueryParameter(value, IntegerColumnType())
 fun longParam(value: Long): Expression<Long> = QueryParameter(value, LongColumnType())
@@ -128,7 +128,7 @@ class AndOp(val expr1: Expression<Boolean>, val expr2: Expression<Boolean>): Op<
     }
 }
 
-class OrOp<out T>(val expr1: Expression<T>, val expr2: Expression<T>): Op<Boolean>() {
+class OrOp<T>(val expr1: Expression<T>, val expr2: Expression<T>): Op<Boolean>() {
     override fun toSQL(queryBuilder: QueryBuilder) = "(${expr1.toSQL(queryBuilder)}) OR (${expr2.toSQL(queryBuilder)})"
 }
 
@@ -140,19 +140,19 @@ class notExists(val query: Query) : Op<Boolean>() {
     override fun toSQL(queryBuilder: QueryBuilder) = "NOT EXISTS (${query.prepareSQL(queryBuilder)})"
 }
 
-class PlusOp<out T, out S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
+class PlusOp<T, S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
     override fun toSQL(queryBuilder: QueryBuilder) = "${expr1.toSQL(queryBuilder)}+${expr2.toSQL(queryBuilder)}"
 }
 
-class MinusOp<out T, out S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
+class MinusOp<T, S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
     override fun toSQL(queryBuilder: QueryBuilder) = "${expr1.toSQL(queryBuilder)}-${expr2.toSQL(queryBuilder)}"
 }
 
-class TimesOp<out T, out S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
+class TimesOp<T, S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
     override fun toSQL(queryBuilder: QueryBuilder):String = "(${expr1.toSQL(queryBuilder)}) * (${expr2.toSQL(queryBuilder)})"
 }
 
-class DivideOp<out T, out S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
+class DivideOp<T, S: T>(val expr1: Expression<T>, val expr2: Expression<S>, override val columnType: IColumnType): ExpressionWithColumnType<T>() {
     override fun toSQL(queryBuilder: QueryBuilder):String =
             "(${expr1.toSQL(queryBuilder)}) / (${expr2.toSQL(queryBuilder)})"
 }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt
index 587012b971..6b384ddcf6 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt
@@ -46,7 +46,7 @@ fun <T:Table> T.insert(body: T.(InsertStatement<Number>)->Unit): InsertStatement
 /**
  * @sample org.jetbrains.exposed.sql.tests.shared.DMLTests.testGeneratedKey03
  */
-fun <Key:Any, T: IdTable<Key>> T.insertAndGetId(ignore: Boolean = false, body: T.(InsertStatement<EntityID<Key>>)->Unit) =
+fun <Key:Comparable<Key>, T: IdTable<Key>> T.insertAndGetId(ignore: Boolean = false, body: T.(InsertStatement<EntityID<Key>>)->Unit) =
     InsertStatement<EntityID<Key>>(this, ignore).run {
         body(this)
         execute(TransactionManager.current())
@@ -97,7 +97,7 @@ fun <T:Table> T.insertIgnore(body: T.(UpdateBuilder<*>)->Unit): InsertStatement<
     execute(TransactionManager.current())
 }
 
-fun <Key:Any, T: IdTable<Key>> T.insertIgnoreAndGetId(body: T.(UpdateBuilder<*>)->Unit) = InsertStatement<EntityID<Key>>(this, isIgnore = true).run {
+fun <Key:Comparable<Key>, T: IdTable<Key>> T.insertIgnoreAndGetId(body: T.(UpdateBuilder<*>)->Unit) = InsertStatement<EntityID<Key>>(this, isIgnore = true).run {
     body(this)
     execute(TransactionManager.current())
     generatedKey
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Query.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Query.kt
index dbbe0f995c..c60934239b 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Query.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Query.kt
@@ -63,7 +63,7 @@ class ResultRow(size: Int, private val fieldIndex: Map<Expression<*>, Int>) {
         internal fun create(columns : List<Column<*>>): ResultRow =
             ResultRow(columns.size, columns.mapIndexed { i, c -> c to i }.toMap()).apply {
                 columns.forEach {
-                    this[it] = it.defaultValueFun?.invoke() ?: if (!it.columnType.nullable) NotInitializedValue else null
+                    this[it as Expression<Any?>] = it.defaultValueFun?.invoke() ?: if (!it.columnType.nullable) NotInitializedValue else null
                 }
             }
     }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt b/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt
index 8ec420baea..74f2a856c5 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt
@@ -1,3 +1,4 @@
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
 package org.jetbrains.exposed.sql
 
 import org.jetbrains.exposed.sql.vendors.FunctionProvider
@@ -5,19 +6,19 @@ import org.jetbrains.exposed.sql.vendors.currentDialect
 import org.joda.time.DateTime
 import java.math.BigDecimal
 
-fun Column<*>.count() = Count(this)
+fun Column<*>.count() : Function<Int> = Count(this)
 
 fun <T: DateTime?> Expression<T>.date() = Date(this)
 
 fun <T: DateTime?> Expression<T>.month() = Month(this)
 
-fun Column<*>.countDistinct() = Count(this, true)
+fun Column<*>.countDistinct() : Function<Int> = Count(this, true)
 
-fun<T:Any?> Column<T>.min() = Min(this, this.columnType)
+fun<T:Comparable<T>, S:T?> ExpressionWithColumnType<in S>.min() = Min<T, S>(this, this.columnType)
 
-fun<T:Any?> Column<T>.max() = Max(this, this.columnType)
+fun<T:Comparable<T>, S:T?> ExpressionWithColumnType<in S>.max() = Max<T, S>(this, this.columnType)
 
-fun<T:Any?> Column<T>.avg(scale: Int = 2) = Avg(this, scale)
+fun<T:Comparable<T>, S:T?> ExpressionWithColumnType<in S>.avg(scale: Int = 2) = Avg<T, S>(this, scale)
 
 fun<T:Any?> Column<T>.stdDevPop(scale: Int = 2) = StdDevPop(this, scale)
 
@@ -29,26 +30,26 @@ fun<T:Any?> Column<T>.varSamp(scale: Int = 2) = VarSamp(this, scale)
 
 fun<T:Any?> Column<T>.sum() = Sum(this, this.columnType)
 
-fun <R:Any> Expression<*>.castTo(columnType: IColumnType) = Cast<R>(this, columnType)
+fun<R:Any> Expression<*>.castTo(columnType: IColumnType) = Cast<R>(this, columnType)
 
-fun<T:String?> Expression<T>.substring(start: Int, length: Int): Substring =
+fun<T:String?> Expression<T>.substring(start: Int, length: Int) : Function<T> =
         Substring(this, LiteralOp(IntegerColumnType(), start), LiteralOp(IntegerColumnType(), length))
 
-fun<T:String?> Expression<T>.trim() =Trim(this)
+fun<T:String?> Expression<T>.trim() : Function<T> = Trim(this)
 
-fun <T:String?> Expression<T>.lowerCase() = LowerCase(this)
-fun <T:String?> Expression<T>.upperCase() = UpperCase(this)
+fun<T:String?> Expression<T>.lowerCase() : Function<T> = LowerCase(this)
+fun<T:String?> Expression<T>.upperCase() : Function<T> = UpperCase(this)
 
 fun <T:Any?> Column<T>.groupConcat(separator: String? = null, distinct: Boolean = false, vararg orderBy: Pair<Expression<*>,Boolean>): GroupConcat =
         GroupConcat(this, separator, distinct, *orderBy)
 
 object SqlExpressionBuilder {
-    fun <T:Any> coalesce(expr: ExpressionWithColumnType<T?>, alternate: ExpressionWithColumnType<T>): ExpressionWithColumnType<T> =
+    fun <T, S:T?, E:ExpressionWithColumnType<S>, R:T> coalesce(expr: E, alternate: ExpressionWithColumnType<out T>) : ExpressionWithColumnType<R> =
             Coalesce(expr, alternate)
 
     fun case(value: Expression<*>? = null) = Case(value)
 
-    fun<T> ExpressionWithColumnType<T>.wrap(value: T): Expression<T> = QueryParameter(value, columnType)
+    fun<T, S:T?> ExpressionWithColumnType<in S>.wrap(value: T): Expression<T> = QueryParameter(value, columnType)
 
     infix fun<T> ExpressionWithColumnType<T>.eq(t: T) : Op<Boolean> {
         if (t == null) {
@@ -57,9 +58,9 @@ object SqlExpressionBuilder {
         return EqOp(this, wrap(t))
     }
 
-    fun<T, S: T> Expression<T>.eq(other: Expression<S>) : Op<Boolean> = EqOp (this, other)
+    infix fun<T, S1: T?, S2: T?> Expression<S1>.eq(other: Expression<S2>) : Op<Boolean> = EqOp (this, other)
 
-    infix fun<T, S: T> ExpressionWithColumnType<T>.eq(other: Expression<S>) : Op<Boolean> = EqOp (this, other)
+//    infix fun<T, S: T> ExpressionWithColumnType<T>.eq(other: Expression<S>) : Op<Boolean> = EqOp (this, other)
 
     infix fun<T> ExpressionWithColumnType<T>.neq(other: T): Op<Boolean> {
         if (other == null) {
@@ -69,27 +70,27 @@ object SqlExpressionBuilder {
         return NeqOp(this, wrap(other))
     }
 
-    fun<T, S: T> ExpressionWithColumnType<T>.neq(other: Expression<S>) : Op<Boolean> = NeqOp (this, other)
+    fun<T, S: T?> ExpressionWithColumnType<S>.neq(other: Expression<S>) : Op<Boolean> = NeqOp (this, other)
 
     fun<T> ExpressionWithColumnType<T>.isNull(): Op<Boolean> = IsNullOp(this)
 
     fun<T> ExpressionWithColumnType<T>.isNotNull(): Op<Boolean> = IsNotNullOp(this)
 
-    infix fun<T> ExpressionWithColumnType<T>.less(t: T) : Op<Boolean> = LessOp(this, wrap(t))
+    infix fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.less(t: T) : Op<Boolean> = LessOp(this, wrap(t))
 
-    fun<T, S: T> ExpressionWithColumnType<T>.less(other: Expression<S>) : Op<Boolean> = LessOp (this, other)
+    fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.less(other: Expression<S>) = LessOp (this, other)
 
-    infix fun<T> ExpressionWithColumnType<T>.lessEq(t: T) : Op<Boolean> =LessEqOp(this, wrap(t))
+    infix fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.lessEq(t: T) : Op<Boolean> = LessEqOp(this, wrap(t))
 
-    fun<T, S: T> ExpressionWithColumnType<T>.lessEq(other: Expression<S>) : Op<Boolean> = LessEqOp(this, other)
+    fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.lessEq(other: Expression<S>) : Op<Boolean> = LessEqOp(this, other)
 
-    infix fun<T> ExpressionWithColumnType<T>.greater(t: T) : Op<Boolean> = GreaterOp(this, wrap(t))
+    infix fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.greater(t: T) : Op<Boolean> = GreaterOp(this, wrap(t))
 
-    fun<T, S: T> ExpressionWithColumnType<T>.greater(other: Expression<S>) : Op<Boolean> = GreaterOp (this, other)
+    fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.greater(other: Expression<S>) : Op<Boolean> = GreaterOp (this, other)
 
-    infix fun<T> ExpressionWithColumnType<T>.greaterEq(t: T) : Op<Boolean> = GreaterEqOp (this, wrap(t))
+    infix fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.greaterEq(t: T) : Op<Boolean> = GreaterEqOp (this, wrap(t))
 
-    fun<T, S: T> ExpressionWithColumnType<T>.greaterEq(other: Expression<S>) : Op<Boolean> = GreaterEqOp (this, other)
+    fun<T:Comparable<T>, S: T?> ExpressionWithColumnType<in S>.greaterEq(other: Expression<T>) : Op<Boolean> = GreaterEqOp (this, other)
 
     operator fun<T, S: T> ExpressionWithColumnType<T>.plus(other: Expression<S>) : ExpressionWithColumnType<T> = PlusOp (this, other, columnType)
 
@@ -120,16 +121,16 @@ object SqlExpressionBuilder {
     infix fun<T> ExpressionWithColumnType<T>.notInList(list: Iterable<T>): Op<Boolean> = InListOrNotInListOp(this, list, isInList = false)
 
     @Suppress("UNCHECKED_CAST")
-    fun<T, S: T> ExpressionWithColumnType<T>.asLiteral(value: S) = when (value) {
+    fun<T, S: T?> ExpressionWithColumnType<S>.asLiteral(value: T) = when (value) {
         is Boolean -> booleanLiteral(value)
         is Int -> intLiteral(value)
         is Long -> longLiteral(value)
         is String -> stringLiteral(value)
         is DateTime -> if ((columnType as DateColumnType).time) dateTimeLiteral(value) else dateLiteral(value)
-        else -> LiteralOp<T>(columnType, value)
+        else -> LiteralOp(columnType, value)
     } as LiteralOp<T>
 
-    fun<T, S: Any> ExpressionWithColumnType<T>.between(from: S, to: S): Op<Boolean> = Between(this, asLiteral(from), asLiteral(to))
+    fun<T, S: T?> ExpressionWithColumnType<S>.between(from: T, to: T): Op<Boolean> = Between(this, asLiteral(from), asLiteral(to))
 
     fun ExpressionWithColumnType<Int>.intToDecimal(): ExpressionWithColumnType<BigDecimal> = NoOpConversion(this, DecimalColumnType(15, 0))
 
@@ -139,5 +140,5 @@ object SqlExpressionBuilder {
         }
     }
 
-    infix fun <T : String?> ExpressionWithColumnType<T>.match(pattern: String): Op<Boolean> = match(pattern, null)
+    infix fun <T: String?> ExpressionWithColumnType<T>.match(pattern: String): Op<Boolean> = match(pattern, null)
 }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/Table.kt b/src/main/kotlin/org/jetbrains/exposed/sql/Table.kt
index 1b542752e8..9557625298 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/Table.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/Table.kt
@@ -187,15 +187,15 @@ open class Table(name: String = ""): ColumnSet(), DdlAware {
     }
 
     @Suppress("UNCHECKED_CAST")
-    fun <T:Any> Column<T>.entityId(): Column<EntityID<T>> = replaceColumn(this, Column<EntityID<T>>(table, name, EntityIDColumnType(this)).apply {
+    fun <T:Comparable<T>> Column<T>.entityId(): Column<EntityID<T>> = replaceColumn(this, Column<EntityID<T>>(table, name, EntityIDColumnType(this)).apply {
         this.indexInPK = this@entityId.indexInPK
         this.defaultValueFun = this@entityId.defaultValueFun?.let { { EntityID(it(), table as IdTable<T>) } }
     })
 
-    fun <ID:Any> entityId(name: String, table: IdTable<ID>) : Column<EntityID<ID>> {
+    fun <ID:Comparable<ID>> entityId(name: String, table: IdTable<ID>) : Column<EntityID<ID>> {
         val originalColumn = (table.id.columnType as EntityIDColumnType<*>).idColumn
         val columnTypeCopy = originalColumn.columnType.let { (it as? AutoIncColumnType)?.delegate ?: it }.clone()
-        val answer = Column<EntityID<ID>>(this, name, EntityIDColumnType(Column(table, name, columnTypeCopy)))
+        val answer = Column<EntityID<ID>>(this, name, EntityIDColumnType(Column<ID>(table, name, columnTypeCopy)))
         _columns.add(answer)
         return answer
     }
@@ -251,7 +251,7 @@ open class Table(name: String = ""): ColumnSet(), DdlAware {
     }
 
 
-    fun <N:Any> Column<EntityID<N>>.autoinc(idSeqName: String? = null): Column<EntityID<N>> = cloneWithAutoInc(idSeqName).apply {
+    fun <N:Comparable<N>> Column<EntityID<N>>.autoinc(idSeqName: String? = null): Column<EntityID<N>> = cloneWithAutoInc(idSeqName).apply {
         replaceColumn(this@autoinc, this)
     }
 
@@ -262,7 +262,7 @@ open class Table(name: String = ""): ColumnSet(), DdlAware {
 
     infix fun <T, S: T, C:Column<S>> C.references(ref: Column<T>): C = references(ref, null)
 
-    fun <T:Any> reference(name: String, foreign: IdTable<T>, onDelete: ReferenceOption? = null): Column<EntityID<T>> =
+    fun <T:Comparable<T>> reference(name: String, foreign: IdTable<T>, onDelete: ReferenceOption? = null): Column<EntityID<T>> =
             entityId(name, foreign).references(foreign.id, onDelete)
 
     fun<T> Table.reference(name: String, pkColumn: Column<T>): Column<T> {
@@ -271,7 +271,7 @@ open class Table(name: String = ""): ColumnSet(), DdlAware {
         return column
     }
 
-    fun <T:Any> optReference(name: String, foreign: IdTable<T>, onDelete: ReferenceOption? = null): Column<EntityID<T>?> =
+    fun <T:Comparable<T>> optReference(name: String, foreign: IdTable<T>, onDelete: ReferenceOption? = null): Column<EntityID<T>?> =
             entityId(name, foreign).references(foreign.id, onDelete).nullable()
 
     fun <T:Any> Column<T>.nullable(): Column<T?> {
@@ -279,7 +279,8 @@ open class Table(name: String = ""): ColumnSet(), DdlAware {
         newColumn.referee = referee
         newColumn.onDelete = onDelete
         newColumn.defaultValueFun = defaultValueFun
-        newColumn.dbDefaultValue = dbDefaultValue
+        @Suppress("UNCHECKED_CAST")
+        newColumn.dbDefaultValue = dbDefaultValue as Expression<T?>?
         newColumn.columnType.nullable = true
         return replaceColumn (this, newColumn)
     }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/statements/BatchUpdateStatement.kt b/src/main/kotlin/org/jetbrains/exposed/sql/statements/BatchUpdateStatement.kt
index 034550170f..985dfe9a42 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/statements/BatchUpdateStatement.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/statements/BatchUpdateStatement.kt
@@ -25,7 +25,7 @@ class BatchUpdateStatement(val table: IdTable<*>): UpdateStatement(table, null)
         }
     }
 
-    override fun <S> update(column: Column<S>, value: Expression<S>) = error("Expressions unsupported in batch update")
+    override fun <T, S:T?> update(column: Column<T>, value: Expression<S>) = error("Expressions unsupported in batch update")
 
     override fun prepareSQL(transaction: Transaction): String =
          "${super.prepareSQL(transaction)} WHERE ${transaction.identity(table.id)} = ?"
@@ -36,11 +36,12 @@ class BatchUpdateStatement(val table: IdTable<*>): UpdateStatement(table, null)
             = data.map { it.second.map { it.key.columnType to it.value } + (table.id.columnType to it.first) }
 }
 
-class EntityBatchUpdate<ID:Any>(val klass: EntityClass<in ID, Entity<in ID>>) {
+class EntityBatchUpdate(val klass: EntityClass<*, Entity<*>>) {
 
-    private val data = ArrayList<Pair<EntityID<ID>, SortedMap<Column<*>, Any?>>>()
+    private val data = ArrayList<Pair<EntityID<*>, SortedMap<Column<*>, Any?>>>()
 
-    fun addBatch(id: EntityID<ID>) {
+    fun addBatch(id: EntityID<*>) {
+        if (id.table != klass.table) error("Table from Entity ID ${id.table.tableName} differs from entity class ${klass.table.tableName}")
         data.add(id to TreeMap())
     }
 
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/statements/UpdateBuilder.kt b/src/main/kotlin/org/jetbrains/exposed/sql/statements/UpdateBuilder.kt
index ad22b6c034..628ef2b1f0 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/statements/UpdateBuilder.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/statements/UpdateBuilder.kt
@@ -22,7 +22,7 @@ abstract class UpdateBuilder<out T>(type: StatementType, targets: List<Table>):
         values[column] = value
     }
 
-    open fun <S> update(column: Column<S>, value: Expression<S>) {
+    open fun <T, S:T?> update(column: Column<T>, value: Expression<S>) {
         if (values.containsKey(column)) {
             error("$column is already initialized")
         }
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/vendors/Default.kt b/src/main/kotlin/org/jetbrains/exposed/sql/vendors/Default.kt
index 4818d56813..4a34f499d4 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/vendors/Default.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/vendors/Default.kt
@@ -43,7 +43,7 @@ open class DataTypeProvider {
 
 open class FunctionProvider {
 
-    open fun substring(expr: Expression<String?>, start: ExpressionWithColumnType<Int>, length: ExpressionWithColumnType<Int>, builder: QueryBuilder) : String =
+    open fun<T:String?> substring(expr: Expression<T>, start: ExpressionWithColumnType<Int>, length: ExpressionWithColumnType<Int>, builder: QueryBuilder) : String =
             "SUBSTRING(${expr.toSQL(builder)}, ${start.toSQL(builder)}, ${length.toSQL(builder)})"
 
     open fun random(seed: Int?): String = "RANDOM(${seed?.toString().orEmpty()})"
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/vendors/OracleDialect.kt b/src/main/kotlin/org/jetbrains/exposed/sql/vendors/OracleDialect.kt
index fd0e024a66..8cfad0284f 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/vendors/OracleDialect.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/vendors/OracleDialect.kt
@@ -44,7 +44,7 @@ internal object OracleDataTypeProvider : DataTypeProvider() {
 
 internal object OracleFunctionProvider : FunctionProvider() {
 
-    override fun substring(expr: Expression<String?>, start: ExpressionWithColumnType<Int>, length: ExpressionWithColumnType<Int>, builder: QueryBuilder): String =
+    override fun<T:String?> substring(expr: Expression<T>, start: ExpressionWithColumnType<Int>, length: ExpressionWithColumnType<Int>, builder: QueryBuilder): String =
             super.substring(expr, start, length, builder).replace("SUBSTRING", "SUBSTR")
 
     /* seed is ignored. You have to use dbms_random.seed function manually */
diff --git a/src/main/kotlin/org/jetbrains/exposed/sql/vendors/SQLiteDialect.kt b/src/main/kotlin/org/jetbrains/exposed/sql/vendors/SQLiteDialect.kt
index 67fd2d0751..d1711abc11 100644
--- a/src/main/kotlin/org/jetbrains/exposed/sql/vendors/SQLiteDialect.kt
+++ b/src/main/kotlin/org/jetbrains/exposed/sql/vendors/SQLiteDialect.kt
@@ -13,7 +13,7 @@ internal object SQLiteDataTypeProvider : DataTypeProvider() {
 }
 
 internal object SQLiteFunctionProvider : FunctionProvider() {
-    override fun substring(expr: Expression<String?>, start: ExpressionWithColumnType<Int>, length: ExpressionWithColumnType<Int>, builder: QueryBuilder): String =
+    override fun<T:String?> substring(expr: Expression<T>, start: ExpressionWithColumnType<Int>, length: ExpressionWithColumnType<Int>, builder: QueryBuilder): String =
             super.substring(expr, start, length, builder).replace("SUBSTRING", "substr")
 }
 
diff --git a/src/test/kotlin/org/jetbrains/exposed/sql/tests/DatabaseTestsBase.kt b/src/test/kotlin/org/jetbrains/exposed/sql/tests/DatabaseTestsBase.kt
index f76013476f..e1a0a351c4 100644
--- a/src/test/kotlin/org/jetbrains/exposed/sql/tests/DatabaseTestsBase.kt
+++ b/src/test/kotlin/org/jetbrains/exposed/sql/tests/DatabaseTestsBase.kt
@@ -53,8 +53,8 @@ enum class TestDB(val connection: String, val driver: String, val user: String =
                 }
                 Unit
             }),
-    SQLSERVER("jdbc:sqlserver://${System.getProperty("exposed.test.sqlserver.host", "localhost")}" +
-            ":${System.getProperty("exposed.test.sqlserver.port", "1433")}",
+    SQLSERVER("jdbc:sqlserver://${System.getProperty("exposed.test.sqlserver.host", "192.168.99.100")}" +
+            ":${System.getProperty("exposed.test.sqlserver.port", "32781")}",
             "com.microsoft.sqlserver.jdbc.SQLServerDriver", "SA", "yourStrong(!)Password");
 
     companion object {
diff --git a/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt b/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt
index 6efad02a60..a17a468d2c 100644
--- a/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt
+++ b/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DDLTests.kt
@@ -145,9 +145,9 @@ class DDLTests : DatabaseTestsBase() {
     @Test fun unnamedTableWithQuotesSQL() {
         withTables(UnnamedTable) {
             val q = db.identityQuoteString
-            val tableName = if (db.dialect.needsQuotesWhenSymbolsInNames) { "$q${"UnnamedTable$1".inProperCase()}$q" } else { "UnnamedTable$1".inProperCase() }
-            assertEquals("CREATE TABLE " + if (db.dialect.supportsIfNotExists) { "IF NOT EXISTS " } else { "" } + "$tableName " +
-                    "(${"id".inProperCase()} ${db.dialect.dataTypeProvider.shortType()} PRIMARY KEY, ${"name".inProperCase()} VARCHAR(42) NOT NULL)", UnnamedTable.ddl)
+            val tableName = if (currentDialect.needsQuotesWhenSymbolsInNames) { "$q${"UnnamedTable$1".inProperCase()}$q" } else { "UnnamedTable$1".inProperCase() }
+            assertEquals("CREATE TABLE " + if (currentDialect.supportsIfNotExists) { "IF NOT EXISTS " } else { "" } + "$tableName " +
+                    "(${"id".inProperCase()} ${currentDialect.dataTypeProvider.shortType()} PRIMARY KEY, ${"name".inProperCase()} VARCHAR(42) NOT NULL)", UnnamedTable.ddl)
         }
     }
 
@@ -157,6 +157,9 @@ class DDLTests : DatabaseTestsBase() {
 
         withDb (TestDB.H2 ) {
             assertEquals("CREATE TABLE IF NOT EXISTS ${"test_named_table".inProperCase()}", TestTable.ddl)
+            DMLTestsData.Users.select {
+                exists(DMLTestsData.UserData.select { DMLTestsData.Users.id eq DMLTestsData.UserData.user_id })
+            }
         }
     }
 
@@ -170,9 +173,9 @@ class DDLTests : DatabaseTestsBase() {
         }
 
          withTables(excludeSettings = listOf(TestDB.MYSQL, TestDB.ORACLE), tables = TestTable) {
-            assertEquals("CREATE TABLE " + if (db.dialect.supportsIfNotExists) { "IF NOT EXISTS " } else { "" } + "${"different_column_types".inProperCase()} " +
-                    "(${"id".inProperCase()} ${db.dialect.dataTypeProvider.shortAutoincType()} NOT NULL, ${"name".inProperCase()} VARCHAR(42) PRIMARY KEY, " +
-                    "${"age".inProperCase()} ${db.dialect.dataTypeProvider.shortType()} NULL)", TestTable.ddl)
+            assertEquals("CREATE TABLE " + if (currentDialect.supportsIfNotExists) { "IF NOT EXISTS " } else { "" } + "${"different_column_types".inProperCase()} " +
+                    "(${"id".inProperCase()} ${currentDialect.dataTypeProvider.shortAutoincType()} NOT NULL, ${"name".inProperCase()} VARCHAR(42) PRIMARY KEY, " +
+                    "${"age".inProperCase()} ${currentDialect.dataTypeProvider.shortType()} NULL)", TestTable.ddl)
         }
     }
 
@@ -184,8 +187,8 @@ class DDLTests : DatabaseTestsBase() {
         }
 
         withTables(excludeSettings = listOf(TestDB.MYSQL), tables = TestTable) {
-            assertEquals("CREATE TABLE " + if (db.dialect.supportsIfNotExists) { "IF NOT EXISTS " } else { "" } + "${"with_different_column_types".inProperCase()} " +
-                    "(${"id".inProperCase()} ${db.dialect.dataTypeProvider.shortType()}, ${"name".inProperCase()} VARCHAR(42), ${"age".inProperCase()} ${db.dialect.dataTypeProvider.shortType()} NULL, " +
+            assertEquals("CREATE TABLE " + if (currentDialect.supportsIfNotExists) { "IF NOT EXISTS " } else { "" } + "${"with_different_column_types".inProperCase()} " +
+                    "(${"id".inProperCase()} ${currentDialect.dataTypeProvider.shortType()}, ${"name".inProperCase()} VARCHAR(42), ${"age".inProperCase()} ${db.dialect.dataTypeProvider.shortType()} NULL, " +
                     "CONSTRAINT pk_with_different_column_types PRIMARY KEY (${"id".inProperCase()}, ${"name".inProperCase()}))", TestTable.ddl)
         }
     }
diff --git a/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DMLTests.kt b/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DMLTests.kt
index e1a0e0b128..b27c1ac78a 100644
--- a/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DMLTests.kt
+++ b/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/DMLTests.kt
@@ -2,8 +2,10 @@ package org.jetbrains.exposed.sql.tests.shared
 
 import org.hamcrest.Matchers.containsInAnyOrder
 import org.hamcrest.Matchers.not
+import org.jetbrains.exposed.dao.IdTable
 import org.jetbrains.exposed.dao.IntIdTable
 import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.Random
 import org.jetbrains.exposed.sql.statements.BatchDataInconsistentException
 import org.jetbrains.exposed.sql.statements.BatchInsertStatement
 import org.jetbrains.exposed.sql.tests.DatabaseTestsBase
@@ -12,6 +14,7 @@ import org.joda.time.DateTime
 import org.junit.Assert.assertThat
 import org.junit.Test
 import java.math.BigDecimal
+import java.util.*
 import kotlin.test.*
 
 object DMLTestsData {
@@ -413,7 +416,7 @@ class DMLTests : DatabaseTestsBase() {
 
     @Test fun testGroupBy06() {
         withCitiesAndUsers { cities, users, userData ->
-            val maxNullableId: Max<Int> = cities.id.max()
+            val maxNullableId = cities.id.max()
 
             cities.slice(maxNullableId).selectAll()
                     .map { it[maxNullableId] }.let { result ->
@@ -720,9 +723,23 @@ class DMLTests : DatabaseTestsBase() {
             }
 
             val row = tbl.selectAll().single()
+            tbl.select {
+                coalesce(tbl.dcn, intLiteral(0).intToDecimal()).isNull()
+//                tbl.tn.greaterEq(tbl.dcn)
+//                tbl.tn greater DateTime.now()!!
+            }
             tbl.checkRow(row, 42, null, date, null, time, null, DMLTestsData.E.ONE, null, DMLTestsData.E.ONE, null, "test", null, BigDecimal("239.42"), null)
         }
     }
+
+    fun <T:BigDecimal?> usdConversion(currencyAmount: ExpressionWithColumnType<T>): ExpressionWithColumnType<BigDecimal> {
+        return NoOpConversion(Expression.build {
+            val coalesce = coalesce(currencyAmount, intLiteral(0).intToDecimal())
+            coalesce / coalesce(DMLTestsData.Misc.t, intLiteral(1).intToDecimal())
+        }, DecimalColumnType(15, 2))
+    }
+
+
     @Test fun testInsert03() {
         val tbl = DMLTestsData.Misc
         val date = today
@@ -858,6 +875,21 @@ class DMLTests : DatabaseTestsBase() {
         }
     }
 
+    @Test fun testGeneratedKey04() {
+        val CharIdTable = object : IdTable<String>("charId") {
+            override val id = varchar("id", 50).primaryKey()
+                    .clientDefault { UUID.randomUUID().toString() }
+                    .entityId()
+            val foo = integer("foo")
+        }
+        withTables(CharIdTable){
+            val id = IntIdTestTable.insertAndGetId {
+                it[CharIdTable.foo] = 5
+            }
+            assertNotNull(id?.value)
+        }
+    }
+
 /*
     Test fun testInsert05() {
         val stringThatNeedsEscaping = "multi\r\nline"
@@ -954,6 +986,10 @@ class DMLTests : DatabaseTestsBase() {
 
             }
 
+            tbl.select {
+                tbl.nn.neq(tbl.nn)
+            }
+
             tbl.checkRow(tbl.select{tbl.nn.eq(42)}.single(), 42, 42, date, date, time, time, eOne, eOne, eOne, eOne, sTest, sTest, dec, dec)
             tbl.checkRow(tbl.select{tbl.nn neq null }.single(), 42, 42, date, date, time, time, eOne, eOne, eOne, eOne, sTest, sTest, dec, dec)