Provide DslMapper To simplify Kotlin code

[huicunjun]

Provide DslMapper
To simplify Kotlin code

Refer to the exposed https://github.com/JetBrains/Exposed

   class PersonTable : SqlTable("Person") {
        val id = column<Int>(name = "id", jdbcType = JDBCType.INTEGER, javaProperty = "id")
        val firstName = column<String>(name = "first_name", jdbcType = JDBCType.VARCHAR, javaProperty = "firstName")
        val lastName = column<LastName>(
            name = "last_name",
            jdbcType = JDBCType.VARCHAR,
            typeHandler = "examples.kotlin.mybatis3.canonical.LastNameTypeHandler",
            javaProperty = "lastName"
        )
        val birthDate = column<Date>(name = "birth_date", jdbcType = JDBCType.DATE, javaProperty = "birthDate")
        val employed = column<Boolean>(
            name = "employed",
            JDBCType.VARCHAR,
            typeHandler = "examples.kotlin.mybatis3.canonical.YesNoTypeHandler",
            javaProperty = "employed"
        )
        val occupation = column<String>(name = "occupation", jdbcType = JDBCType.VARCHAR, javaProperty = "occupation")
        val addressId = column<Int>(name = "address_id", jdbcType = JDBCType.INTEGER, javaProperty = "addressId")
    }

interface DslMapper <Table,Entiy>{
}


@Mapper
interface PersonMapper :  DslMapper<PersonTable,PersonRecord>{}



val personMapper:PersonMapper

personMapper.insert{
 it[PersonTable.lastName] = "hello"
}

personMapper.insert(PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1))

personMapper.delete{
 it[PersonTable.id] = 1
}

personMapper.updateById(PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1))
personMapper.update(where = { PersonTable.id eq "alex" }) {
            it[name] = "Alexey"
  }

[huicunjun]

If possible, I would be happy to contribute to the relevant implementation

[jeffgbutler]

First, thank you for the contribution and the idea. I'm commenting here rather than on your pull request because there is a larger discussion and it deserves some time and thought.

I think there are really two ideas here:

1. Having SqlTable keep track of the columns associated with the table
2. Updating the DSL to make it possible to write more generic mappers

For the first idea, it's probably a bit more complex than what you might imagine. We would need to think about it to make sure all the corner cases are covered. For example, we now recommend usage of AliasableSqlTable rather then SqlTable. But some of the methods on AliasableSqlTable will create new instances - we would need to make sure that new instances also copied the column list.

I have resisted adding this idea of a column list to SqlTable because so many methods in the library create new instances of SqlColumn and it would be very difficult to know when to use the originally configured column versus the instance created in a statement (for example, if a column alias is applied).

But if we did add this capability, we could potentially write some more generic mappers - at least for some statements.

For the second idea, I understand the motivation to make more generic mappers. Many people have tried it. But there are some limitations in MyBatis that make it difficult - especially for select statements. MyBatis currently has no method for providing a dynamic result map, insert statements get tricky when there are generated keys, etc.

You mentioned JetBrains' Exposed framework. I am not super familiar with it, but I do know that the statements seem to be configured as extensions on a TABLE object rather than on something like a MyBatis session. I have been thinking about something like that. My idea is dependent on Kotlin's experimental "context parameters" capability, but I think this has some promise here. For example, we could write extension functions like this:

context(mapper: CommonDeleteMapper)
fun SqlTable.delete(completer: DeleteCompleter): Int =
    deleteFrom(mapper::delete, this, completer )

context(mapper: CommonCountMapper)
fun SqlTable.count(completer: CountCompleter): Long =
    countFrom(mapper::count, this, completer)

And then write code like this:

@Test
fun testDeleteNewDsl() {
    newSession().use { session ->
        with(session.getMapper(PersonMapper::class.java)) {
            val rows = person.delete { where { occupation.isNull()} }
            assertThat(rows).isEqualTo(2)
        }
    }
}

@Test
fun testCountNewDsl() {
    newSession().use { session ->
        with(session.getMapper(PersonMapper::class.java)) {
            val rows = person.count { where { occupation.isNull() } }
            assertThat(rows).isEqualTo(2L)
        }
    }
}

(This code will work now if you enable context parameters with the -Xcontext-parameters compiler argument)

I think this looks cool.

I'll leave this issue open - I'm very interested in feedback from anyone about this.