A modern programming language that makes developers happier.

kotlinlang

So far, komapper seems very nice! (I started using it a new microservice...) I'm still wondering about a few seeming inconsistencies... like the `single()`  being called on the Query, whereas `toList()` is called on the flowQuery... also the presence of the lamba form of runQuery and flowQuery is a bit puzzling... it even only has an empty receiver object...

Thanks for using Komapper.
&gt; whereas toList() is called on the flowQuery
Which `toList()` is it?  `org.komapper.core.dsl.query.FlowQuery` doesn’t have the function of that name.
&gt; the presence of the lamba form of runQuery and flowQuery is a bit puzzling
They are just utility functions. You can write a more concise DSL if you wish:
```// define your extension function
fun &lt;ENTITY : Any, ID : Any, META : EntityMetamodel&lt;ENTITY, ID, META&gt;&gt; QueryScope.from(metamodel: META): SelectQueryBuilder&lt;ENTITY, ID, META&gt; {
    return QueryDsl.from(metamodel)
}```
Use the above extension function in the `runQuery`  lambda block:
```val a = Meta.address
val address = db.runQuery {
    from(a).where { a.addressId eq 1 }.first()
}```

I see. Why do you think the `Flow.toList()` is inconsistent? It is unrelated to Komapper’s API.

Compare:
```db.flowQuery(
            QueryDsl.from(oa).where { oa.deviceNo eq newDeviceNo }
        ).toList()
// To:
db.runQuery(QueryDsl.from(oa).where { oa.deviceNo eq deviceNo }.single())
// The single makes the user understand that he's actually recieving something even BEFORE the runQuery... the toList after the flowQuery makes it very clear that what's inside the flowQuery is JUST a query and NOT actually getting any result```

It was a bit confusing in the beginning... although now I understand it to a certain point... I think the naming is a bit unclear also... maybe `runFlowQuery` or maybe just an overload of `runQuery` might be a bit more consistent.

Than flowQuery... I guess that's really the reason that there's the difference in my original question :face_with_head_bandage:.

maybe `db.queryToFlow()` and `db.runQuery()` would make things MUCH clearer...

`flowQuery()` is a function to convert a Query to a Flow. `queryToFlow()` may be easier to understand than `flowQuery()`.

Yeah, after having tried to define the problem, I guess that's what bothered me from the beginning... :blush:

Or maybe even `queryFlow()` , or `toQueryFlow()` ...