From b8d50bd61c657f5977419f8b2af60b41bcae26b7 Mon Sep 17 00:00:00 2001
From: Jack Stratton <jack@phroa.net>
Date: Sat, 12 Dec 2015 16:49:11 -0800
Subject: [PATCH] Update to Kotlin 1.0.0-beta-3595

---
 build.gradle                                  |   4 +-
 gradle.properties                             |   1 +
 .../kotlin/kotlinx/nosql/mongodb/MongoDB.kt   |  28 +--
 .../kotlinx/nosql/mongodb/MongoDBSession.kt   | 167 ++++++++----------
 .../kotlinx/nosql/mongodb/test/MongoDBSpek.kt |   3 -
 .../kotlin/kotlinx/nosql/AbstractColumn.kt    |  33 ++--
 .../kotlin/kotlinx/nosql/AbstractSchema.kt    |  42 +----
 .../kotlinx/nosql/ColumnQueryWrapper.kt       | 128 +++++++-------
 src/main/kotlin/kotlinx/nosql/Database.kt     |   6 +-
 .../nosql/DocumentSchemaIdQueryWrapper.kt     |   2 +-
 .../nosql/KeyValueDocumentSchemaOperations.kt |   2 -
 src/main/kotlin/kotlinx/nosql/Session.kt      |   2 -
 src/main/kotlin/kotlinx/nosql/TableSchema.kt  |  17 +-
 .../TableSchemaProjectionQueryWrapper.kt      |   2 +-
 .../kotlin/kotlinx/nosql/util/SchemaUtils.kt  |  12 +-
 15 files changed, 191 insertions(+), 258 deletions(-)
 create mode 100644 gradle.properties

diff --git a/build.gradle b/build.gradle
index 8327ae43..7663bc6a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -11,7 +11,7 @@ buildscript {
         }
     }
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:0.1-SNAPSHOT"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
     }
 }
 
@@ -35,7 +35,7 @@ allprojects {
 
     dependencies {
         compile 'joda-time:joda-time:2.3'
-        compile group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: '0.1-SNAPSHOT', changing: true
+        compile group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: kotlinVersion, changing: true
         testCompile group: 'org.jetbrains.spek', name: 'spek', version: '0.1-SNAPSHOT', changing: true
     }
 
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 00000000..04643e61
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1 @@
+kotlinVersion=1.0.0-beta-3595
\ No newline at end of file
diff --git a/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDB.kt b/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDB.kt
index b93adf60..aaf65e54 100644
--- a/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDB.kt
+++ b/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDB.kt
@@ -1,34 +1,20 @@
 package kotlinx.nosql.mongodb
 
-import kotlinx.nosql.Database
-import kotlinx.nosql.Session
-import com.mongodb.MongoClient
-import kotlinx.nosql.AbstractColumn
-import kotlinx.nosql.util.*
-import java.util.concurrent.ConcurrentHashMap
-import com.mongodb.ServerAddress
-import com.mongodb.MongoClientOptions
-import com.mongodb.MongoClientURI
-import kotlinx.nosql.SchemaGenerationAction
-import kotlinx.nosql.Create
-import kotlinx.nosql.CreateDrop
-import kotlinx.nosql.Validate
-import kotlinx.nosql.Update
-import kotlinx.nosql.AbstractSchema
-import com.mongodb.MongoCredential
+import com.mongodb.*
+import kotlinx.nosql.*
 
 fun MongoDB(uri: MongoClientURI, schemas: Array<out AbstractSchema>, initialization: SchemaGenerationAction<MongoDBSession> = Validate()): MongoDB {
-    val seeds: Array<ServerAddress> = uri.getHosts()!!.map { host ->
+    val seeds: Array<ServerAddress> = uri.hosts!!.map { host ->
         if (host.indexOf(':') > 0) {
             val tokens = host.split(':')
             ServerAddress(tokens[0], tokens[1].toInt())
         } else
             ServerAddress(host)
     }.toTypedArray()
-    val database: String = if (uri.getDatabase() != null) uri.getDatabase()!! else "test"
-    val options: MongoClientOptions = uri.getOptions()!!
-    val credentials = if (uri.getUsername() != null)
-      arrayOf(MongoCredential.createMongoCRCredential(uri.getUsername(), database, uri.getPassword())!!)
+    val database: String = if (uri.database != null) uri.database!! else "test"
+    val options: MongoClientOptions = uri.options!!
+    val credentials = if (uri.username != null)
+      arrayOf(MongoCredential.createMongoCRCredential(uri.username, database, uri.password)!!)
     else arrayOf()
   return MongoDB(seeds, database, credentials, options, schemas, initialization)
 }
diff --git a/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDBSession.kt b/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDBSession.kt
index db8f0f4f..88ebb4a9 100644
--- a/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDBSession.kt
+++ b/kotlin-nosql-mongodb/src/main/kotlin/kotlinx/nosql/mongodb/MongoDBSession.kt
@@ -1,26 +1,15 @@
 package kotlinx.nosql.mongodb
 
-import com.mongodb.DB
-import com.mongodb.BasicDBObject
-import java.lang.reflect.Field
-import java.util.ArrayList
-import java.util.HashMap
-import com.mongodb.DBObject
-import java.util.Arrays
-import org.bson.types.ObjectId
-import com.mongodb.BasicDBList
+import com.mongodb.*
 import kotlinx.nosql.*
+import kotlinx.nosql.query.*
 import kotlinx.nosql.util.*
-import java.util.regex.Pattern
-import java.util.Date
-import java.util.concurrent.atomic.AtomicReference
+import org.bson.types.ObjectId
 import org.joda.time.DateTime
-import org.joda.time.format.ISODateTimeFormat
 import org.joda.time.LocalDate
 import org.joda.time.LocalTime
-import com.mongodb.DBCollection
-import com.mongodb.DBCursor
-import kotlinx.nosql.query.*
+import java.util.*
+import java.util.regex.Pattern
 
 class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchemaOperations, IndexOperations {
     override fun <T : Number> incr(schema: KeyValueSchema, column: AbstractColumn<out Any?, out AbstractSchema, T>, value: T): T {
@@ -34,7 +23,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
 
     init {
         val results = db.command("buildInfo")
-        dbVersion = results!!.get("version")!!.toString()
+        dbVersion = results!!["version"]!!.toString()
         val versions = dbVersion.split('.')
         searchOperatorSupported = versions[0].toInt() >= 2 && versions[1].toInt() >= 6
     }
@@ -72,15 +61,15 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val doc = getDBObject(v, this)
         if (discriminator != null) {
             var dominatorValue: Any? = null
-            for (entry in kotlinx.nosql.DocumentSchema.discriminatorClasses.entrySet()) {
+            for (entry in kotlinx.nosql.DocumentSchema.discriminatorClasses.entries) {
                 if (entry.value.java.equals(v.javaClass)) {
                     dominatorValue = entry.key.value
                 }
             }
-            doc.set(this.discriminator!!.column.name, dominatorValue!!)
+            doc.set(this.discriminator.column.name, dominatorValue!!)
         }
         collection.insert(doc)
-        return Id<P, T>(doc.get("_id").toString() as P)
+        return Id(doc["_id"].toString() as P)
     }
 
     private fun getDBObject(o: Any, schema: Any): BasicDBObject {
@@ -90,10 +79,10 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         var sc: Class<out Any?>? = null
         var s: AbstractSchema? = null
         if (schema is kotlinx.nosql.DocumentSchema<*, *> && schema.discriminator != null) {
-            for (entry in kotlinx.nosql.DocumentSchema.discriminatorClasses.entrySet()) {
+            for (entry in kotlinx.nosql.DocumentSchema.discriminatorClasses.entries) {
                 if (entry.value.java.equals(o.javaClass)) {
-                    sc = kotlinx.nosql.DocumentSchema.discriminatorSchemaClasses.get(entry.key)!!
-                    s = kotlinx.nosql.DocumentSchema.discriminatorSchemas.get(entry.key)!!
+                    sc = kotlinx.nosql.DocumentSchema.discriminatorSchemaClasses[entry.key]!!
+                    s = kotlinx.nosql.DocumentSchema.discriminatorSchemas[entry.key]!!
                 }
             }
         }
@@ -101,10 +90,10 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val objectSchema: Any = if (schema is kotlinx.nosql.DocumentSchema<*, *> && schema.discriminator != null) s!! else schema
         val schemaFields = getAllFieldsMap(schemaClass as Class<in Any>, { f -> f.isColumn })
         for (field in fields) {
-            val schemaField = schemaFields.get(field.getName()!!.toLowerCase())
+            val schemaField = schemaFields[field.getName()!!.toLowerCase()]
             if (schemaField != null && schemaField.isColumn) {
-                field.setAccessible(true)
-                schemaField.setAccessible(true)
+                field.isAccessible = true
+                schemaField.isAccessible = true
                 val column = schemaField.asColumn(objectSchema)
                 val value = field.get(o)
                 if (value != null) {
@@ -129,8 +118,8 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
     }
 
     override fun <T : kotlinx.nosql.DocumentSchema<P, C>, P: Any, C: Any> find(params: DocumentSchemaQueryParams<T, P, C>): Iterator<C> {
-        if (params.query != null && !searchOperatorSupported && params.query!!.usesSearch())
-          return params.schema.runCommandText(params.query!!)
+        if (params.query != null && !searchOperatorSupported && params.query.usesSearch())
+          return params.schema.runCommandText(params.query)
         else
           return object : Iterator<C> {
             var cursor: DBCursor? = null
@@ -138,15 +127,15 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             override fun next(): C {
               if (cursor == null) {
                 val collection = db.getCollection(params.schema.schemaName)
-                val query = if (params.query != null) getQuery(params.query!!) else BasicDBObject()
+                val query = if (params.query != null) getQuery(params.query) else BasicDBObject()
                 cursor = collection!!.find(query)!!
                 if (params.skip != null) {
                   cursor!!.skip(params.skip!!)
                 }
               }
-              val value = getObject(cursor!!.next(), params.schema) as C
+              val value = getObject(cursor!!.next(), params.schema)
               pos++
-              if (!cursor!!.hasNext() || (params.take != null && pos == params.take!!)) {
+              if (!cursor!!.hasNext() || (params.take != null && pos == params.take)) {
                 cursor!!.close()
                 pos = -1
               }
@@ -155,7 +144,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             override fun hasNext(): Boolean {
               if (cursor == null) {
                 val collection = db.getCollection(params.schema.schemaName)
-                val query = if (params.query != null) getQuery(params.query!!) else BasicDBObject()
+                val query = if (params.query != null) getQuery(params.query) else BasicDBObject()
                 cursor = collection!!.find(query)!!
                 if (params.skip != null) {
                   cursor!!.skip(params.skip!!)
@@ -172,7 +161,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
       // TODO: Only supports text(...) and other condition
       searchCmd.append("search", when (op) {
         is TextQuery -> op.search
-        is AndQuery -> if (op.expr1 is TextQuery) (op.expr1 as TextQuery).search else throw UnsupportedOperationException()
+        is AndQuery -> if (op.expr1 is TextQuery) op.expr1.search else throw UnsupportedOperationException()
         else -> throw UnsupportedOperationException()
       })
       val schema = this
@@ -182,7 +171,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
       val result = db.command(searchCmd)!!
 
       val objects = ArrayList<C>()
-      for (doc in result.get("results") as BasicDBList) {
+      for (doc in result["results"] as BasicDBList) {
         objects.add(getObject((doc as DBObject).get("obj") as DBObject, schema))
       }
 
@@ -200,7 +189,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
                     params.projection.forEach {
                         fields.append(it.fullName, "1")
                     }
-                    val query = if (params.query != null) getQuery(params.query!!) else BasicDBObject()
+                    val query = if (params.query != null) getQuery(params.query) else BasicDBObject()
                     cursor = collection!!.find(query, fields)!!
                     if (params.skip != null) {
                         cursor!!.skip(params.skip!!)
@@ -238,7 +227,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
                     params.projection.forEach {
                         fields.append(it.fullName, "1")
                     }
-                    val query = if (params.query != null) getQuery(params.query!!) else BasicDBObject()
+                    val query = if (params.query != null) getQuery(params.query) else BasicDBObject()
                     cursor = collection!!.find(query, fields)!!
                     if (params.skip != null) {
                         cursor!!.skip(params.skip!!)
@@ -264,21 +253,21 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is EqualQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr1 as AbstractColumn<*, *, *>).columnType.primitive) {
-                            if ((op.expr1 as AbstractColumn<*, *, *>).columnType.id) {
-                                query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, ObjectId((op.expr2 as LiteralExpression).value.toString()))
+                        if (op.expr1.columnType.primitive) {
+                            if (op.expr1.columnType.id) {
+                                query.append(op.expr1.fullName, ObjectId(op.expr2.value.toString()))
                             } else {
-                                var columnName = (op.expr1 as AbstractColumn<*, *, *>).fullName
+                                var columnName = op.expr1.fullName
                                 if (removePrefix.isNotEmpty() && columnName.startsWith(removePrefix)) {
-                                    columnName = columnName.substring(removePrefix.length() + 1)
+                                    columnName = columnName.substring(removePrefix.length + 1)
                                 }
-                                query.append( columnName, (op.expr2 as LiteralExpression).value)
+                                query.append( columnName, op.expr2.value)
                             }
                         } else {
                             throw UnsupportedOperationException()
                         }
                     } else if (op.expr2 is AbstractColumn<*, *, *>) {
-                        query.append("\$where", "this.${(op.expr1 as AbstractColumn<*, *, *>).fullName} == this.${(op.expr2 as AbstractColumn<*, *, *>).fullName}")
+                        query.append("\$where", "this.${op.expr1.fullName} == this.${op.expr2.fullName}")
                     } else {
                         throw UnsupportedOperationException()
                     }
@@ -289,8 +278,8 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is MatchesQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is Pattern) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$regex", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is Pattern) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$regex", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
@@ -304,17 +293,17 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is NotEqualQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is String || (op.expr2 as LiteralExpression).value is Int) {
-                            if ((op.expr1 as AbstractColumn<*, *, *>).columnType.id) {
-                                query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$ne", ObjectId((op.expr2 as LiteralExpression).value.toString())))
+                        if (op.expr2.value is String || op.expr2.value is Int) {
+                            if (op.expr1.columnType.id) {
+                                query.append(op.expr1.fullName, BasicDBObject().append("\$ne", ObjectId(op.expr2.value.toString())))
                             } else {
-                                query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$ne", (op.expr2 as LiteralExpression).value))
+                                query.append(op.expr1.fullName, BasicDBObject().append("\$ne", op.expr2.value))
                             }
                         } else {
                             throw UnsupportedOperationException()
                         }
                     } else if (op.expr2 is AbstractColumn<*, *, *>) {
-                        query.append("\$where", "this.${(op.expr1 as AbstractColumn<*, *, *>).fullName} != this.${(op.expr2 as AbstractColumn<*, *, *>).fullName}")
+                        query.append("\$where", "this.${op.expr1.fullName} != this.${op.expr2.fullName}")
                     } else {
                         throw UnsupportedOperationException()
                     }
@@ -325,13 +314,13 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is GreaterQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is String || (op.expr2 as LiteralExpression).value is Int) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$gt", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is String || op.expr2.value is Int) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$gt", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
                     } else if (op.expr2 is AbstractColumn<*, *, *>) {
-                        query.append("\$where", "this.${(op.expr1 as AbstractColumn<*, *, *>).fullName} > this.${(op.expr2 as AbstractColumn<*, *, *>).fullName}")
+                        query.append("\$where", "this.${op.expr1.fullName} > this.${op.expr2.fullName}")
                     } else {
                         throw UnsupportedOperationException()
                     }
@@ -342,13 +331,13 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is LessQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is String || (op.expr2 as LiteralExpression).value is Int) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$lt", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is String || op.expr2.value is Int) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$lt", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
                     } else if (op.expr2 is AbstractColumn<*, *, *>) {
-                        query.append("\$where", "this.${(op.expr1 as AbstractColumn<*, *, *>).fullName} < this.${(op.expr2 as AbstractColumn<*, *, *>).fullName}")
+                        query.append("\$where", "this.${op.expr1.fullName} < this.${op.expr2.fullName}")
                     } else {
                         throw UnsupportedOperationException()
                     }
@@ -359,13 +348,13 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is GreaterEqualQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is String || (op.expr2 as LiteralExpression).value is Int) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$gte", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is String || op.expr2.value is Int) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$gte", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
                     } else if (op.expr2 is AbstractColumn<*, *, *>) {
-                        query.append("\$where", "this.${(op.expr1 as AbstractColumn<*, *, *>).fullName} >= this.${(op.expr2 as AbstractColumn<*, *, *>).fullName}")
+                        query.append("\$where", "this.${op.expr1.fullName} >= this.${op.expr2.fullName}")
                     } else {
                         throw UnsupportedOperationException()
                     }
@@ -376,13 +365,13 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is LessEqualQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is String || (op.expr2 as LiteralExpression).value is Int) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$lte", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is String || op.expr2.value is Int) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$lte", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
                     } else if (op.expr2 is AbstractColumn<*, *, *>) {
-                        query.append("\$where", "this.${(op.expr1 as AbstractColumn<*, *, *>).fullName} <= this.${(op.expr2 as AbstractColumn<*, *, *>).fullName}")
+                        query.append("\$where", "this.${op.expr1.fullName} <= this.${op.expr2.fullName}")
                     } else {
                         throw UnsupportedOperationException()
                     }
@@ -393,8 +382,8 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is MemberOfQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is List<*> || (op.expr2 as LiteralExpression).value is Array<*>) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$in", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is List<*> || op.expr2.value is Array<*>) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$in", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
@@ -408,8 +397,8 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is NotMemberOfQuery -> {
                 if (op.expr1 is AbstractColumn<*, *, *>) {
                     if (op.expr2 is LiteralExpression) {
-                        if ((op.expr2 as LiteralExpression).value is List<*> || (op.expr2 as LiteralExpression).value is Array<*>) {
-                            query.append((op.expr1 as AbstractColumn<*, *, *>).fullName, BasicDBObject().append("\$nin", (op.expr2 as LiteralExpression).value))
+                        if (op.expr2.value is List<*> || op.expr2.value is Array<*>) {
+                            query.append(op.expr1.fullName, BasicDBObject().append("\$nin", op.expr2.value))
                         } else {
                             throw UnsupportedOperationException()
                         }
@@ -424,10 +413,10 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
             is AndQuery -> {
                 val query1 = getQuery(op.expr1)
                 val query2 = getQuery(op.expr2)
-                for (entry in query1.entrySet()) {
+                for (entry in query1.entries) {
                     query.append(entry.key, entry.value)
                 }
-                for (entry in query2.entrySet()) {
+                for (entry in query2.entries) {
                     query.append(entry.key, entry.value)
                 }
                 return query
@@ -452,11 +441,11 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         var s: AbstractSchema? = null
         val valueInstance: Any = if (schema is kotlinx.nosql.DocumentSchema<*, *> && schema.discriminator != null) {
             var instance: Any? = null
-            val discriminatorValue = doc.get(schema.discriminator!!.column.name)
-            for (discriminator in kotlinx.nosql.DocumentSchema.tableDiscriminators.get(schema.schemaName)!!) {
-                if (discriminator.value!!.equals(discriminatorValue)) {
-                    instance = newInstance(kotlinx.nosql.DocumentSchema.discriminatorClasses.get(discriminator)!!.java)
-                    s = kotlinx.nosql.DocumentSchema.discriminatorSchemas.get(discriminator)!!
+            val discriminatorValue = doc.get(schema.discriminator.column.name)
+            for (discriminator in kotlinx.nosql.DocumentSchema.tableDiscriminators[schema.schemaName]!!) {
+                if (discriminator.value.equals(discriminatorValue)) {
+                    instance = newInstance(kotlinx.nosql.DocumentSchema.discriminatorClasses[discriminator]!!.java)
+                    s = kotlinx.nosql.DocumentSchema.discriminatorSchemas[discriminator]!!
                     break
                 }
             }
@@ -469,12 +458,12 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val schemaFields = getAllFields(schemaClass as Class<in Any?>)
         val valueFields = getAllFieldsMap(valueInstance.javaClass as Class<in Any?>)
         for (schemaField in schemaFields) {
-            if (AbstractColumn::class.java.isAssignableFrom(schemaField.getType()!!)) {
-                val valueField = valueFields.get(if (schemaField.getName()!!.equals("pk")) "id" else schemaField.getName()!!.toLowerCase())
+            if (AbstractColumn::class.java.isAssignableFrom(schemaField.type!!)) {
+                val valueField = valueFields[if (schemaField.getName()!!.equals("pk")) "id" else schemaField.getName()!!.toLowerCase()]
                 if (valueField != null) {
-                    schemaField.setAccessible(true)
-                    valueField.setAccessible(true)
-                    val column = schemaField.asColumn(s!!)
+                    schemaField.isAccessible = true
+                    valueField.isAccessible = true
+                    val column = schemaField.asColumn(s)
                     val value = doc.get(column.name)
                     val columnValue: Any? = if (value == null) {
                         null
@@ -521,12 +510,12 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val valueFields = getAllFieldsMap(valueInstance.javaClass as Class<in Any?>)
         for (columnField in columnFields) {
             if (columnField.isColumn) {
-                val valueField = valueFields.get(columnField.getName()!!.toLowerCase())
+                val valueField = valueFields[columnField.getName()!!.toLowerCase()]
                 if (valueField != null) {
                     columnField.setAccessible(true)
-                    valueField.setAccessible(true)
+                    valueField.isAccessible = true
                     val column = columnField.asColumn(column)
-                    val columnValue: Any? = if (column.columnType.id && !column.columnType.iterable) Id<String, TableSchema<String>>(doc.get(column.name).toString())
+                    val columnValue: Any? = if (column.columnType.id && !column.columnType.iterable) Id(doc.get(column.name).toString())
                     else if (column.columnType.primitive) doc.get(column.name)
                     else if (column.columnType.list && !column.columnType.custom) (doc.get(column.name) as BasicDBList).toList()
                     else if (column.columnType.set && !column.columnType.custom && !column.columnType.id) (doc.get(column.name) as BasicDBList).toSet()
@@ -560,7 +549,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
     override fun <T : AbstractSchema> delete(table: T, op: Query): Int {
         val collection = db.getCollection(table.schemaName)!!
         val query = getQuery(op)
-        return collection.remove(query)!!.getN()
+        return collection.remove(query)!!.n
     }
 
     override fun update(schema: AbstractSchema, columnValues: Array<Pair<AbstractColumn<*, *, *>, *>>, op: Query): Int {
@@ -570,7 +559,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         for ((column, value) in columnValues) {
             statement.append(column.fullName, getDBValue(value, column))
         }
-        return collection.update(getQuery(op), doc)!!.getN()
+        return collection.update(getQuery(op), doc)!!.n
     }
 
     override fun <T> addAll(schema: AbstractSchema, column: AbstractColumn<Collection<T>, *, *>, values: Collection<T>, op: Query): Int {
@@ -578,7 +567,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val statement = BasicDBObject()
         val doc = BasicDBObject().append("\$pushAll", statement)
         statement.append(column.fullName, getDBValue(values, column))
-        return collection.update(getQuery(op), doc)!!.getN()
+        return collection.update(getQuery(op), doc)!!.n
     }
 
     override fun <T> removeAll(schema: AbstractSchema, column: AbstractColumn<Collection<T>, *, *>, values: Collection<T>, op: Query): Int {
@@ -586,7 +575,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val statement = BasicDBObject()
         val doc = BasicDBObject().append("\$pullAll", statement)
         statement.append(column.fullName, getDBValue(values, column))
-        return collection.update(getQuery(op), doc)!!.getN()
+        return collection.update(getQuery(op), doc)!!.n
     }
 
     override fun <T> removeAll(schema: AbstractSchema, column: AbstractColumn<Collection<T>, *, *>, removeOp: Query, op: Query): Int {
@@ -594,7 +583,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
         val statement = BasicDBObject()
         val doc = BasicDBObject().append("\$pull", statement)
         statement.append(column.fullName, getQuery(removeOp, column.fullName))
-        return collection.update(getQuery(op), doc)!!.getN()
+        return collection.update(getQuery(op), doc)!!.n
     }
 
     private fun getDBValue(value: Any?, column: AbstractColumn<*, *, *>, withinIterable: Boolean = false): Any? {
@@ -620,7 +609,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
     private fun getColumnObject(doc: DBObject, column: AbstractColumn<*, *, *>): Any? {
         val columnObject = parse(doc, column.fullName.split(".").toTypedArray())
         return if (column.columnType.id && !column.columnType.iterable) {
-            Id<String, TableSchema<String>>(columnObject.toString())
+            Id(columnObject.toString())
         } else if (column.columnType.primitive && !column.columnType.iterable) when (column.columnType) {
             ColumnType.DATE -> LocalDate.parse(columnObject.toString())
             ColumnType.TIME -> LocalTime.parse(columnObject.toString())
@@ -647,7 +636,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
 
     private fun parse(doc: DBObject, path: Array<String>, position: Int = 0): Any? {
         val value = doc.get(path[position])
-        if (position < path.size() - 1) {
+        if (position < path.size - 1) {
             return parse(value as DBObject, path, position + 1)
         } else {
             return value
@@ -655,7 +644,7 @@ class MongoDBSession(val db: DB) : Session, DocumentSchemaOperations, TableSchem
     }
 
     override fun <T: kotlinx.nosql.DocumentSchema<P, C>, P: Any, C: Any> T.find(query: T.() -> Query): DocumentSchemaQueryWrapper<T, P, C> {
-        val params = DocumentSchemaQueryParams<T, P, C>(this, query())
+        val params = DocumentSchemaQueryParams(this, query())
         return DocumentSchemaQueryWrapper(params)
     }
 }
diff --git a/kotlin-nosql-mongodb/src/test/kotlin/kotlinx/nosql/mongodb/test/MongoDBSpek.kt b/kotlin-nosql-mongodb/src/test/kotlin/kotlinx/nosql/mongodb/test/MongoDBSpek.kt
index f6a285b9..b5188297 100644
--- a/kotlin-nosql-mongodb/src/test/kotlin/kotlinx/nosql/mongodb/test/MongoDBSpek.kt
+++ b/kotlin-nosql-mongodb/src/test/kotlin/kotlinx/nosql/mongodb/test/MongoDBSpek.kt
@@ -1,14 +1,11 @@
 package kotlinx.nosql.mongodb.test
 
-import kotlin.test.assertEquals
 import kotlinx.nosql.*
 import kotlinx.nosql.mongodb.*
 import kotlinx.nosql.mongodb.DocumentSchema
 import org.joda.time.LocalDate
-import org.jetbrains.spek.api.Spek
 import java.util.regex.Pattern
 import kotlin.reflect.KClass
-import kotlin.test.assertTrue
 
 class MongoDBSpek : Spek() {
     open class ProductSchema<D: Any, S : DocumentSchema<D>>(klass: KClass<D>, discriminator: String) : DocumentSchema<D>("products",
diff --git a/src/main/kotlin/kotlinx/nosql/AbstractColumn.kt b/src/main/kotlin/kotlinx/nosql/AbstractColumn.kt
index c75e22ec..e4493893 100644
--- a/src/main/kotlin/kotlinx/nosql/AbstractColumn.kt
+++ b/src/main/kotlin/kotlinx/nosql/AbstractColumn.kt
@@ -1,8 +1,7 @@
 package kotlinx.nosql
 
-import java.util.ArrayList
-import java.util.regex.Pattern
 import kotlinx.nosql.query.*
+import java.util.regex.Pattern
 import kotlin.reflect.KClass
 
 open class AbstractColumn<C, T : AbstractSchema, S: Any>(val name: String, val valueClass: KClass<S>, val columnType: ColumnType) : ColumnQueryWrapper<C>(), Expression<C> {
@@ -22,7 +21,7 @@ open class AbstractColumn<C, T : AbstractSchema, S: Any>(val name: String, val v
     }
 
     operator fun <C2> plus(c: AbstractColumn<C2, T, *>): ColumnPair<T, C, C2> {
-        return ColumnPair(this, c) as ColumnPair<T, C, C2>
+        return ColumnPair(this, c)
     }
 }
 
@@ -32,53 +31,53 @@ fun<C, T: AbstractSchema> AbstractColumn<C, T, *>.get(): C {
 }
 */
 
-fun <C, T: AbstractSchema> AbstractColumn<C, T, *>.update(value: C): Int {
+fun <C, T: AbstractSchema> update(value: C): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to value),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to value),
             wrapper.params.query!!)
 }
 
-fun <C, S: Collection<C>> AbstractColumn<S, *, *>.addAll(values: S): Int {
+fun <C, S: Collection<C>> addAll(values: S): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
     return Session.current<Session>().addAll(wrapper.params.table,
-            wrapper.params.projection.get(0)
+            wrapper.params.projection[0]
                     as AbstractColumn<Collection<C>, out AbstractSchema, out Any>, values,
             wrapper.params.query!!)
 }
 
-fun <C, S: Collection<C>> AbstractColumn<S, *, *>.add(value: C): Int {
+fun <C, S: Collection<C>> add(value: C): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    val values: Collection<C> = if (wrapper.params.projection.get(0).columnType.list) listOf(value) else setOf(value)
+    val values: Collection<C> = if (wrapper.params.projection[0].columnType.list) listOf(value) else setOf(value)
     return Session.current<Session>().addAll(wrapper.params.table,
-                    wrapper.params.projection.get(0)
+                    wrapper.params.projection[0]
                             as AbstractColumn<Collection<C>, out AbstractSchema, out Any>, values,
                     wrapper.params.query!!)
 }
 
-fun <C, S: Collection<C>> AbstractColumn<S, *, *>.removeAll(values: S): Int {
+fun <C, S: Collection<C>> removeAll(values: S): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
     return Session.current<Session>().removeAll(wrapper.params.table,
-            wrapper.params.projection.get(0)
+            wrapper.params.projection[0]
                     as AbstractColumn<Collection<C>, out AbstractSchema, out Any>, values,
             wrapper.params.query!!)
 }
 
-fun <C> AbstractColumn<out Collection<C>, *, *>.remove(value: C): Int {
+fun <C> remove(value: C): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    val values: Collection<C> = if (wrapper.params.projection.get(0).columnType.list) listOf(value) else setOf(value)
+    val values: Collection<C> = if (wrapper.params.projection[0].columnType.list) listOf(value) else setOf(value)
     return Session.current<Session>().removeAll(wrapper.params.table,
-            wrapper.params.projection.get(0)
+            wrapper.params.projection[0]
                     as AbstractColumn<Collection<C>, out AbstractSchema, out Any>, values,
             wrapper.params.query!!)
 }
 
 fun <C: AbstractColumn<out Collection<*>, *, *>> C.remove(removeOp: C.() -> Query): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-        val removeOpValue = with (wrapper.params.projection.get(0)) {
+        val removeOpValue = with (wrapper.params.projection[0]) {
             removeOp()
         }
     return Session.current<Session>().removeAll(wrapper.params.table,
-            wrapper.params.projection.get(0)
+            wrapper.params.projection[0]
                     as AbstractColumn<Collection<C>, out AbstractSchema, out Any>, removeOpValue,
             wrapper.params.query!!)
 }
diff --git a/src/main/kotlin/kotlinx/nosql/AbstractSchema.kt b/src/main/kotlin/kotlinx/nosql/AbstractSchema.kt
index 79e056f8..889ec5f2 100644
--- a/src/main/kotlin/kotlinx/nosql/AbstractSchema.kt
+++ b/src/main/kotlin/kotlinx/nosql/AbstractSchema.kt
@@ -1,12 +1,10 @@
 package kotlinx.nosql
 
-import java.util.ArrayList
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.CopyOnWriteArrayList
+import kotlinx.nosql.query.TextQuery
+import org.joda.time.DateTime
 import org.joda.time.LocalDate
 import org.joda.time.LocalTime
-import org.joda.time.DateTime
-import kotlinx.nosql.query.TextQuery
+import java.util.*
 
 abstract class AbstractSchema(val schemaName: String) {
     // TODO TODO TODO
@@ -37,79 +35,53 @@ fun text(search: String): Query {
 // Extension functions
 
 fun <S : AbstractSchema> string(name: String): AbstractColumn<String, S, String> = AbstractColumn(name, String::class, ColumnType.STRING)
-fun <S : AbstractSchema> S.string(name: String): AbstractColumn<String, S, String> = AbstractColumn(name, String::class, ColumnType.STRING)
 
 fun <S : AbstractSchema> boolean(name: String): AbstractColumn<Boolean, S, Boolean> = AbstractColumn(name, Boolean::class, ColumnType.BOOLEAN)
-fun <S : AbstractSchema> S.boolean(name: String): AbstractColumn<Boolean, S, Boolean> = AbstractColumn(name, Boolean::class, ColumnType.BOOLEAN)
 
 fun <S : AbstractSchema> date(name: String): AbstractColumn<LocalDate, S, LocalDate> = AbstractColumn(name, LocalDate::class, ColumnType.DATE)
-fun <S : AbstractSchema> S.date(name: String): AbstractColumn<LocalDate, S, LocalDate> = AbstractColumn(name, LocalDate::class, ColumnType.DATE)
 
 fun <S : AbstractSchema> time(name: String): AbstractColumn<LocalTime, S, LocalTime> = AbstractColumn(name, LocalTime::class, ColumnType.TIME)
-fun <S : AbstractSchema> S.time(name: String): AbstractColumn<LocalTime, S, LocalTime> = AbstractColumn(name, LocalTime::class, ColumnType.TIME)
 
 fun <S : AbstractSchema> dateTime(name: String): AbstractColumn<DateTime, S, DateTime> = AbstractColumn(name, DateTime::class, ColumnType.DATE_TIME)
-fun <S : AbstractSchema> S.dateTime(name: String): AbstractColumn<DateTime, S, DateTime> = AbstractColumn(name, DateTime::class, ColumnType.DATE_TIME)
 
 fun <S : AbstractSchema> double(name: String): AbstractColumn<Double, S, Double> = AbstractColumn(name, Double::class, ColumnType.DOUBLE)
-fun <S : AbstractSchema> S.double(name: String): AbstractColumn<Double, S, Double> = AbstractColumn(name, Double::class, ColumnType.DOUBLE)
 
 fun <S : AbstractSchema> integer(name: String): AbstractColumn<Int, S, Int> = AbstractColumn(name, Int::class, ColumnType.INTEGER)
-fun <S : AbstractSchema> S.integer(name: String): AbstractColumn<Int, S, Int> = AbstractColumn(name, Int::class, ColumnType.INTEGER)
 
 fun <S : AbstractSchema> float(name: String): AbstractColumn<Float, S, Float> = AbstractColumn(name, Float::class, ColumnType.FLOAT)
-fun <S : AbstractSchema> S.float(name: String): AbstractColumn<Float, S, Float> = AbstractColumn(name, Float::class, ColumnType.FLOAT)
 
 fun <S : AbstractSchema> long(name: String): AbstractColumn<Long, S, Long> = AbstractColumn(name, Long::class, ColumnType.LONG)
-fun <S : AbstractSchema> S.long(name: String): AbstractColumn<Long, S, Long> = AbstractColumn(name, Long::class, ColumnType.LONG)
 
 fun <S : AbstractSchema> short(name: String): AbstractColumn<Short, S, Short> = AbstractColumn(name, Short::class, ColumnType.SHORT)
-fun <S : AbstractSchema> S.short(name: String): AbstractColumn<Short, S, Short> = AbstractColumn(name, Short::class, ColumnType.SHORT)
 
 fun <S : AbstractSchema> byte(name: String): AbstractColumn<Byte, S, Byte> = AbstractColumn(name, Byte::class, ColumnType.BYTE)
-fun <S : AbstractSchema> S.byte(name: String): AbstractColumn<Byte, S, Byte> = AbstractColumn(name, Byte::class, ColumnType.BYTE)
 
 fun <S : AbstractSchema> nullableString(name: String): NullableColumn<String, S> = NullableColumn(name, String::class, ColumnType.STRING)
-fun <S : AbstractSchema> S.nullableString(name: String): NullableColumn<String, S> = NullableColumn(name, String::class, ColumnType.STRING)
 
 fun <S : AbstractSchema> nullableInteger(name: String): NullableColumn<Int, S> = NullableColumn(name, Int::class, ColumnType.INTEGER)
-fun <S : AbstractSchema> S.nullableInteger(name: String): NullableColumn<Int, S> = NullableColumn(name, Int::class, ColumnType.INTEGER)
 
 fun <S : AbstractSchema> nullableBoolean(name: String): NullableColumn<Boolean, S> = NullableColumn(name, Boolean::class, ColumnType.BOOLEAN)
-fun <S : AbstractSchema> S.nullableBoolean(name: String): NullableColumn<Boolean, S> = NullableColumn(name, Boolean::class, ColumnType.BOOLEAN)
 
 fun <S : AbstractSchema> nullableDate(name: String): NullableColumn<LocalDate, S> = NullableColumn(name, LocalDate::class, ColumnType.DATE)
-fun <S : AbstractSchema> S.nullableDate(name: String): NullableColumn<LocalDate, S> = NullableColumn(name, LocalDate::class, ColumnType.DATE)
 
 fun <S : AbstractSchema> nullableTime(name: String): NullableColumn<LocalTime, S> = NullableColumn(name, LocalTime::class, ColumnType.TIME)
-fun <S : AbstractSchema> S.nullableTime(name: String): NullableColumn<LocalTime, S> = NullableColumn(name, LocalTime::class, ColumnType.TIME)
 
 fun <S : AbstractSchema> nullableDateTime(name: String): NullableColumn<DateTime, S> = NullableColumn(name, DateTime::class, ColumnType.DATE_TIME)
-fun <S : AbstractSchema> S.nullableDateTime(name: String): NullableColumn<DateTime, S> = NullableColumn(name, DateTime::class, ColumnType.DATE_TIME)
 
 fun <S : AbstractSchema> nullableDouble(name: String): NullableColumn<Double, S> = NullableColumn(name, Double::class, ColumnType.DOUBLE)
-fun <S : AbstractSchema> S.nullableDouble(name: String): NullableColumn<Double, S> = NullableColumn(name, Double::class, ColumnType.DOUBLE)
 
 fun <S : AbstractSchema> nullableFloat(name: String): NullableColumn<Float, S> = NullableColumn(name, Float::class, ColumnType.FLOAT)
-fun <S : AbstractSchema> S.nullableFloat(name: String): NullableColumn<Float, S> = NullableColumn(name, Float::class, ColumnType.FLOAT)
 
 fun <S : AbstractSchema> nullableLong(name: String): NullableColumn<Long, S> = NullableColumn(name, Long::class, ColumnType.LONG)
-fun <S : AbstractSchema> S.nullableLong(name: String): NullableColumn<Long, S> = NullableColumn(name, Long::class, ColumnType.LONG)
 
 fun <S : AbstractSchema> nullableShort(name: String): NullableColumn<Short, S> = NullableColumn(name, Short::class, ColumnType.SHORT)
-fun <S : AbstractSchema> S.nullableShort(name: String): NullableColumn<Short, S> = NullableColumn(name, Short::class, ColumnType.SHORT)
 
 fun <S : AbstractSchema> nullableByte(name: String): NullableColumn<Byte, S> = NullableColumn(name, Byte::class, ColumnType.BYTE)
-fun <S : AbstractSchema> S.nullableByte(name: String): NullableColumn<Byte, S> = NullableColumn(name, Byte::class, ColumnType.BYTE)
 
-fun <S : AbstractSchema> setOfString(name: String): AbstractColumn<Set<String>, S, String> = AbstractColumn<Set<String>, S, String>(name, String::class, ColumnType.STRING_SET)
-fun <S : AbstractSchema> S.setOfString(name: String): AbstractColumn<Set<String>, S, String> = AbstractColumn<Set<String>, S, String>(name, String::class, ColumnType.STRING_SET)
+fun <S : AbstractSchema> setOfString(name: String): AbstractColumn<Set<String>, S, String> = AbstractColumn(name, String::class, ColumnType.STRING_SET)
 
-fun <S : AbstractSchema> setOfInteger(name: String): AbstractColumn<Set<Int>, S, Int> = AbstractColumn<Set<Int>, S, Int>(name, Int::class, ColumnType.INTEGER_SET)
-fun <S : AbstractSchema> S.setOfInteger(name: String): AbstractColumn<Set<Int>, S, Int> = AbstractColumn<Set<Int>, S, Int>(name, Int::class, ColumnType.INTEGER_SET)
+fun <S : AbstractSchema> setOfInteger(name: String): AbstractColumn<Set<Int>, S, Int> = AbstractColumn(name, Int::class, ColumnType.INTEGER_SET)
 
-fun <S : AbstractSchema> listOfString(name: String): AbstractColumn<List<String>, S, String> = AbstractColumn<List<String>, S, String>(name, String::class, ColumnType.STRING_LIST)
-fun <S : AbstractSchema> S.listOfString(name: String): AbstractColumn<List<String>, S, String> = AbstractColumn<List<String>, S, String>(name, String::class, ColumnType.STRING_LIST)
+fun <S : AbstractSchema> listOfString(name: String): AbstractColumn<List<String>, S, String> = AbstractColumn(name, String::class, ColumnType.STRING_LIST)
 
-fun <S : AbstractSchema> listOfInteger(name: String): AbstractColumn<List<Int>, S, Int> = AbstractColumn<List<Int>, S, Int>(name, Int::class, ColumnType.INTEGER_LIST)
-fun <S : AbstractSchema> S.listOfInteger(name: String): AbstractColumn<List<Int>, S, Int> = AbstractColumn<List<Int>, S, Int>(name, Int::class, ColumnType.INTEGER_LIST)
+fun <S : AbstractSchema> listOfInteger(name: String): AbstractColumn<List<Int>, S, Int> = AbstractColumn(name, Int::class, ColumnType.INTEGER_LIST)
diff --git a/src/main/kotlin/kotlinx/nosql/ColumnQueryWrapper.kt b/src/main/kotlin/kotlinx/nosql/ColumnQueryWrapper.kt
index 55dbeb8c..d1fd4369 100644
--- a/src/main/kotlin/kotlinx/nosql/ColumnQueryWrapper.kt
+++ b/src/main/kotlin/kotlinx/nosql/ColumnQueryWrapper.kt
@@ -1,5 +1,7 @@
 package kotlinx.nosql
 
+import jdk.internal.util.xml.impl.Pair
+
 abstract class ColumnQueryWrapper<C> : Iterable<C> {
     override fun iterator(): Iterator<C> {
         val wrapper = TableSchemaProjectionQueryWrapper.get()
@@ -7,101 +9,101 @@ abstract class ColumnQueryWrapper<C> : Iterable<C> {
     }
 }
 
-fun <A, B> ColumnQueryWrapper<Pair<A, B>>.update(a: A, b: B): Int {
+fun <A, B> update(a: A, b: B): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b),
             wrapper.params.query!!)
 }
 
-fun <A, B, C> ColumnQueryWrapper<Triple<A, B, C>>.update(a: A, b: B, c: C): Int {
+fun <A, B, C> update(a: A, b: B, c: C): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D> ColumnQueryWrapper<Quadruple<A, B, C, D>>.update(a: A, b: B, c: C, d: D): Int {
+fun <A, B, C, D> update(a: A, b: B, c: C, d: D): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D, E> ColumnQueryWrapper<Quintuple<A, B, C, D, E>>.update(a: A, b: B, c: C, d: D, e: E): Int {
+fun <A, B, C, D, E> update(a: A, b: B, c: C, d: D, e: E): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d,
-            wrapper.params.projection.get(4) to e),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d,
+            wrapper.params.projection[4] to e),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D, E, F> ColumnQueryWrapper<Sextuple<A, B, C, D, E, F>>.update(a: A, b: B, c: C, d: D, e: E, f: F): Int {
+fun <A, B, C, D, E, F> update(a: A, b: B, c: C, d: D, e: E, f: F): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d,
-            wrapper.params.projection.get(4) to e,
-            wrapper.params.projection.get(5) to f),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d,
+            wrapper.params.projection[4] to e,
+            wrapper.params.projection[5] to f),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D, E, F, G> ColumnQueryWrapper<Septuple<A, B, C, D, E, F, G>>.update(a: A, b: B, c: C, d: D, e: E, f: F, g: G): Int {
+fun <A, B, C, D, E, F, G> update(a: A, b: B, c: C, d: D, e: E, f: F, g: G): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d,
-            wrapper.params.projection.get(4) to e,
-            wrapper.params.projection.get(5) to f,
-            wrapper.params.projection.get(6) to g),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d,
+            wrapper.params.projection[4] to e,
+            wrapper.params.projection[5] to f,
+            wrapper.params.projection[6] to g),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D, E, F, G, H> ColumnQueryWrapper<Octuple<A, B, C, D, E, F, G, H>>.update(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): Int {
+fun <A, B, C, D, E, F, G, H> update(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d,
-            wrapper.params.projection.get(4) to e,
-            wrapper.params.projection.get(5) to f,
-            wrapper.params.projection.get(6) to g,
-            wrapper.params.projection.get(7) to h),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d,
+            wrapper.params.projection[4] to e,
+            wrapper.params.projection[5] to f,
+            wrapper.params.projection[6] to g,
+            wrapper.params.projection[7] to h),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D, E, F, G, H, J> ColumnQueryWrapper<Nonuple<A, B, C, D, E, F, G, H, J>>.update(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, j: J): Int {
+fun <A, B, C, D, E, F, G, H, J> update(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, j: J): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d,
-            wrapper.params.projection.get(4) to e,
-            wrapper.params.projection.get(5) to f,
-            wrapper.params.projection.get(6) to g,
-            wrapper.params.projection.get(7) to h,
-            wrapper.params.projection.get(8) to j),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d,
+            wrapper.params.projection[4] to e,
+            wrapper.params.projection[5] to f,
+            wrapper.params.projection[6] to g,
+            wrapper.params.projection[7] to h,
+            wrapper.params.projection[8] to j),
             wrapper.params.query!!)
 }
 
-fun <A, B, C, D, E, F, G, H, J, K> ColumnQueryWrapper<Decuple<A, B, C, D, E, F, G, H, J, K>>.update(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, j: J, k: K): Int {
+fun <A, B, C, D, E, F, G, H, J, K> update(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, j: J, k: K): Int {
     val wrapper = TableSchemaProjectionQueryWrapper.get()
-    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection.get(0) to a,
-            wrapper.params.projection.get(1) to b,
-            wrapper.params.projection.get(2) to c,
-            wrapper.params.projection.get(3) to d,
-            wrapper.params.projection.get(4) to e,
-            wrapper.params.projection.get(5) to f,
-            wrapper.params.projection.get(6) to g,
-            wrapper.params.projection.get(7) to h,
-            wrapper.params.projection.get(8) to j,
-            wrapper.params.projection.get(9) to k),
+    return Session.current<Session>().update(wrapper.params.table, arrayOf(wrapper.params.projection[0] to a,
+            wrapper.params.projection[1] to b,
+            wrapper.params.projection[2] to c,
+            wrapper.params.projection[3] to d,
+            wrapper.params.projection[4] to e,
+            wrapper.params.projection[5] to f,
+            wrapper.params.projection[6] to g,
+            wrapper.params.projection[7] to h,
+            wrapper.params.projection[8] to j,
+            wrapper.params.projection[9] to k),
             wrapper.params.query!!)
 }
\ No newline at end of file
diff --git a/src/main/kotlin/kotlinx/nosql/Database.kt b/src/main/kotlin/kotlinx/nosql/Database.kt
index 4afce2e0..d1ba35fa 100644
--- a/src/main/kotlin/kotlinx/nosql/Database.kt
+++ b/src/main/kotlin/kotlinx/nosql/Database.kt
@@ -34,9 +34,9 @@ abstract class Database<S: Session>(val schemas: Array<out AbstractSchema>, val
         }
         withSession {
             if (action is Create) {
-                action.onCreate()
+                (action.onCreate)()
             } else if (action is CreateDrop) {
-                action.onCreate()
+                (action.onCreate)()
             }
         }
     }
@@ -61,5 +61,5 @@ abstract class Database<S: Session>(val schemas: Array<out AbstractSchema>, val
 
 val AbstractColumn<*, *, *>.fullName: String
     get() {
-        return Database.fullColumnNames.get(this)!!
+        return Database.fullColumnNames[this]!!
     }
diff --git a/src/main/kotlin/kotlinx/nosql/DocumentSchemaIdQueryWrapper.kt b/src/main/kotlin/kotlinx/nosql/DocumentSchemaIdQueryWrapper.kt
index e712d659..f11cd335 100644
--- a/src/main/kotlin/kotlinx/nosql/DocumentSchemaIdQueryWrapper.kt
+++ b/src/main/kotlin/kotlinx/nosql/DocumentSchemaIdQueryWrapper.kt
@@ -3,7 +3,7 @@ package kotlinx.nosql
 import java.util.ArrayList
 
 class DocumentSchemaIdQueryWrapper<T : DocumentSchema<P, C>, P: Any, C: Any>(val schema: T, val id: Id<P, T>): DocumentSchemaQueryWrapper<T, P, C>(DocumentSchemaQueryParams(schema,
-        schema.id.equal(id))
+        schema.getId().equal(id))
 ) {
     fun get(): C {
         return single()
diff --git a/src/main/kotlin/kotlinx/nosql/KeyValueDocumentSchemaOperations.kt b/src/main/kotlin/kotlinx/nosql/KeyValueDocumentSchemaOperations.kt
index 0da55eb3..9472e5a0 100644
--- a/src/main/kotlin/kotlinx/nosql/KeyValueDocumentSchemaOperations.kt
+++ b/src/main/kotlin/kotlinx/nosql/KeyValueDocumentSchemaOperations.kt
@@ -1,7 +1,5 @@
 package kotlinx.nosql
 
-import kotlinx.nosql.query.NoQuery
-
 interface KeyValueDocumentSchemaOperations {
   fun <T : DocumentSchema<P, V>, P: Any, V: Any> T.insert(v: V): Id<P, T>
   operator fun <T: DocumentSchema<P, C>, P: Any, C: Any> T.get(id: Id<P, T>): C?
diff --git a/src/main/kotlin/kotlinx/nosql/Session.kt b/src/main/kotlin/kotlinx/nosql/Session.kt
index 73d272f5..ee46c111 100644
--- a/src/main/kotlin/kotlinx/nosql/Session.kt
+++ b/src/main/kotlin/kotlinx/nosql/Session.kt
@@ -1,7 +1,5 @@
 package kotlinx.nosql
 
-import java.util.ArrayList
-
 interface Session {
     fun <T : AbstractSchema>T.create()
 
diff --git a/src/main/kotlin/kotlinx/nosql/TableSchema.kt b/src/main/kotlin/kotlinx/nosql/TableSchema.kt
index 204a2161..daffcb80 100644
--- a/src/main/kotlin/kotlinx/nosql/TableSchema.kt
+++ b/src/main/kotlin/kotlinx/nosql/TableSchema.kt
@@ -6,19 +6,12 @@ abstract class TableSchema<I: Any>(tableName: String, primaryKey: AbstractColumn
 
 // Extension functions
 
-val <C: Any, T : TableSchema<C>> T.id: AbstractColumn<Id<C, T>, T, C>
-    get () {
-        return pk as AbstractColumn<Id<C, T>, T, C>
-    }
+fun <C: Any, T : TableSchema<C>> T.getId(): AbstractColumn<Id<C, T>, T, C> = pk as AbstractColumn<Id<C, T>, T, C>
 
-fun <S : AbstractSchema, R: TableSchema<P>, P: Any> id(name: String, refSchema: R): AbstractColumn<Id<P, R>, S, P> = AbstractColumn(name, refSchema.id.valueClass, ColumnType.FOREIGN_ID)
-fun <S : AbstractSchema, R: TableSchema<P>, P: Any> S.id(name: String, refSchema: R): AbstractColumn<Id<P, R>, S, P> = AbstractColumn(name, refSchema.id.valueClass, ColumnType.FOREIGN_ID)
+fun <S : AbstractSchema, R: TableSchema<P>, P: Any> id(name: String, refSchema: R): AbstractColumn<Id<P, R>, S, P> = AbstractColumn(name, refSchema.getId().valueClass , ColumnType.FOREIGN_ID)
 
-fun <S : TableSchema<P>, R: TableSchema<P>, P: Any>  listOfId(name: String, refSchema: R): IdListColumn<S, R, P> = IdListColumn(name, refSchema)
-fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> S.listOfId(name: String, refSchema: R): IdListColumn<S, R, P> = IdListColumn(name, refSchema)
+fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> listOfId(name: String, refSchema: R): IdListColumn<S, R, P> = IdListColumn(name, refSchema)
 
-fun <S : TableSchema<P>, R: TableSchema<P>, P: Any>  setOfId(name: String, refSchema: R): IdSetColumn<S, R, P> = IdSetColumn(name, refSchema)
-fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> S.setOfId(name: String, refSchema: R): IdSetColumn<S, R, P> = IdSetColumn(name, refSchema)
+fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> setOfId(name: String, refSchema: R): IdSetColumn<S, R, P> = IdSetColumn(name, refSchema)
 
-fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> nullableId(name: String, refSchema: R): NullableIdColumn<P, S, R> = NullableIdColumn(name, refSchema.id.valueClass, ColumnType.FOREIGN_ID)
-fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> S.nullableId(name: String, refSchema: R): NullableIdColumn<P, S, R> = NullableIdColumn(name, refSchema.id.valueClass, ColumnType.FOREIGN_ID)
+fun <S : TableSchema<P>, R: TableSchema<P>, P: Any> nullableId(name: String, refSchema: R): NullableIdColumn<P, S, R> = NullableIdColumn(name, refSchema.getId().valueClass, ColumnType.FOREIGN_ID)
diff --git a/src/main/kotlin/kotlinx/nosql/TableSchemaProjectionQueryWrapper.kt b/src/main/kotlin/kotlinx/nosql/TableSchemaProjectionQueryWrapper.kt
index 2bbec9e3..d0426748 100644
--- a/src/main/kotlin/kotlinx/nosql/TableSchemaProjectionQueryWrapper.kt
+++ b/src/main/kotlin/kotlinx/nosql/TableSchemaProjectionQueryWrapper.kt
@@ -19,7 +19,7 @@ class TableSchemaProjectionQueryWrapper<T : TableSchema<P>, P: Any, V: Any>(val
         val threadLocal = ThreadLocal<TableSchemaProjectionQueryWrapper<out TableSchema<*>, *, *>>()
 
         fun get(): TableSchemaProjectionQueryWrapper<out TableSchema<*>, *, *> {
-            return threadLocal.get()!! as TableSchemaProjectionQueryWrapper<out TableSchema<*>, *, *>
+            return threadLocal.get()!!
         }
 
         fun set(value: TableSchemaProjectionQueryWrapper<out TableSchema<*>, *, *>) {
diff --git a/src/main/kotlin/kotlinx/nosql/util/SchemaUtils.kt b/src/main/kotlin/kotlinx/nosql/util/SchemaUtils.kt
index d94a15c8..d9c8dffb 100644
--- a/src/main/kotlin/kotlinx/nosql/util/SchemaUtils.kt
+++ b/src/main/kotlin/kotlinx/nosql/util/SchemaUtils.kt
@@ -1,13 +1,11 @@
 package kotlinx.nosql.util
 
-import java.lang.reflect.Field
-import java.util.ArrayList
-import java.util.HashMap
 import kotlinx.nosql.AbstractColumn
-import kotlinx.nosql.AbstractSchema
+import org.joda.time.DateTime
 import org.joda.time.LocalDate
 import org.joda.time.LocalTime
-import org.joda.time.DateTime
+import java.lang.reflect.Field
+import java.util.*
 
 fun getAllFields(_type: Class<in Any>, condition: (Field) -> Boolean = { f -> true },
                  fields: MutableList<Field> = ArrayList()): MutableList<Field> {
@@ -15,7 +13,7 @@ fun getAllFields(_type: Class<in Any>, condition: (Field) -> Boolean = { f -> tr
         if (condition(field)) fields.add(field)
     }
     if (_type.superclass != null) {
-        getAllFields(_type.superclass!!, condition, fields)
+        getAllFields(_type.superclass, condition, fields)
     }
     return fields
 }
@@ -44,7 +42,7 @@ fun Field.asColumn(schema: Any): AbstractColumn<*, *, *> {
 fun newInstance(clazz: Class<out Any?>): Any {
   val constructor = clazz.constructors!![0]
   val constructorParamTypes = constructor.parameterTypes!!
-  val constructorParamValues = Array<Any?>(constructor.parameterTypes!!.size(), { index ->
+  val constructorParamValues = Array<Any?>(constructor.parameterTypes!!.size, { index ->
     when (constructorParamTypes[index].name) {
       "int" -> 0
       "java.lang.String" -> ""