yeah, I see. Would be interesting to make a sample for #ktor with some embedded db (#relational-sql or not) that support async calls.

Also in my spare time I’m working on a Kotlin SQL DSL library without an ORM (but with object mapping), thinking about an API for async calls. For JDBC it would be of course just a thread pool (unitl async JDBC lands), but then could use native pg async libs.

hehe 🙂

hehe? 🙂

@orangy Your spare time? 😂 Between 3am and 5am?

yeah I know this issue too well 🙂

Indeed, hehe 🙂

@orangy look at http://requery.io It's a pretty easy to use sql DSL that's type safe and works with Rx.

@kenkyee thanks, will take a look. However I wonder how rx and stream would work, given that JDBC drivers are normally non-reactive. I suppose though not sure, that most JDBC drivers load entire resultset in memory before handing it to client.

Another issue is "N+1 problem", because without loading entire master dataset, one cannot efficiently issue query for details dataset.

Like in “Relationships” example, if I have a list of

AbstractPerson

and want to inspect their groups, I’d better avoid roundtrips for every person and make a more complex query to fetch all groups for all persons in a single resultset.

I think it uses a cursor so no need to load entire dataset

For that case, you're better off doing a custom query...orms can get pretty ugly for that...

I don’t really like ORMs in general. I was thinking about something like ViewModel mapping instead, and implemented a prototype thanks to @andrewoma with his graph-fetching idea. It still needs some graph optimizations, but in general it issues as much queries, as there are references in the graph.

Like, if there is Team entity, and each team has list of Person entities (members), and then each Person has a list of Contact entities, entire graph can be fetched with just 3 queries, regardless of number of Teams fetched by initial query.

If you are interested, here is it: https://github.com/orangy/squash/ Not released anywhere yet, so would need local maven install or jitpack.

That looks interesting, the table definitions look similar to Exposed’s?

Yes, squash was started as a refactoring of Exposed to clean up DSL, make it more dialect-friendly and optimize query building, but later it branched off too far to be considered a refactoring 🙂

@orangy I'm using vertx-mysql-postgresql-client and a few kotlin interfaces on top

its wrapping async driver that was made for play framework

As for interface, https://www.playframework.com/documentation/2.5.x/ScalaAnorm is one of the best , and its "parser" pattern helps alot. But anorm itself isn't async

I may publish my attempt on it for Kotlin when it'll have enough good use-cases

@hackerham: thanks, I will take a look

Huh, any ideas on how to break a dead loop, when ktor or wasabi are not considered "production ready", and thus have few brave souls using them, not getting a lot of feedback and then not moving fast towards production-ready?

in my experiment it looks like this:

val updLongParser = UpdateParser<Long> { arr -> arr.getLong(0) }

    fun add_point(point: Point): Future<Long?> =
            asyncVx<Long?> {
                await(conn.query("SELECT id FROM Point WHERE lat = ? AND lng = ?",
                        listOf(point.lat, point.lng),
                        longParser::parseAsync)) ?:
                        await(conn.update("INSERT INTO Point (lat, lng) VALUES (?, ?) RETURNING id",
                                listOf(point.lat, point.lng),
                                updLongParser::parseAsync))
            }

Yeah, I know "crossing the chasm", but still

@orangy Web Framework may be considered awesome if someone ports java stuff on it, python stuff, nodejs stuff

"project X was ported from python 1:1 and then optimized , code size reduced by Y% and now its non-blocking"

Wasabi looks like nodejs express

pseudo-compatibility with node and python is the key