Changing my blocking play / scala /slick algorithm not to block - scala

Question

Here is a relatively simple problem, I'm sure I'm missing something basic.
I'm using Slick to query a DB.
I know that it gives me back a sequence which is going to have missing values...
so I want to add them in ... but I don't know the values in advance.
Then ultimately generate a csv file for someone else to consume...
def annualAtomTesting(peril: String , region: String) = Action {
val theResult: Future[Seq[SingleEventYear]] = db.run(filterAnnualPerilAndRegionFillGaps(peril, region).result)
val years = theResult.map { list => list.map(s => s.year).toSet}
val allYear = (1 to 10000) toSet
val dbYears = Await.result( years , Duration.Inf )
val theDifference = allYear.diff( dbYears )
val whatsMissing = theDifference.map(s => new SingleEventYear(region, peril, 0 ,0 , s, 0))
val intermediate: String = Await.result( theResult.map(result => header + result.mkString("\n") + "\n"
+ whatsMissing.mkString("\r\n") ), Duration.Inf )
Ok(intermediate)
}
So from a potential series of 1,2,3,4,5 , i might get 2, 4, 5 from the DB query. This code adds in 1 and 3... but my understanding is it will block everything, which is kind of naughty.
For all that I tried, I could not future out how to get the .diff method (which looks like the cleanest strategy) to operate in a 'Future', non-blocking context.
Am I missing something?

Answer 1

Here you have only one Future and you don't need to make several Await.result.
You can get rid of all your Await.result(...) calls by switching to Action.async:
Action.async {
val allYear = (1 to 10000).toSet
val intermediate:Future[String] = for (
res <- db.run(filterAnnualPerilAndRegionFillGaps(peril, region).result)
) yield (
header + res.mkString("\n") + "\n" +
allYear.diff(res.map (s => s.year).toSet).map(s => new SingleEventYear(region, peril, 0 ,0 , s, 0)).mkString("\r\n")
)
intermediate.map(item => Ok(item))
}

Answer 2

Here is another example of how to do this:
def annualAtomTesting(peril: String, region: String) = Action.async {
for {
results <- db.run(filterAnnualPerilAndRegionFillGaps(peril, region).result)
years = results.map(_.year).toSet
allYears = (1 to 10000).toSet
differences = allYears diff years
missing = differences.map(new SingleEventYear(region, peril, 0, 0, _, 0))
intermediate = header + results.mkString("\n") + "\n" + missing.mkString("\r\n")
} yield Ok(intermediate)
}
You should not use Await in production code. Play allows you to use async actions that require you to return Future[Result] instead of Result.
If you really want to think about your code with await you can use scala async like this:
import scala.async.Async._
def annualAtomTesting(peril: String, region: String) = Action.async {
async {
val results: Seq[SingleEventYear] = await(db.run(filterAnnualPerilAndRegionFillGaps(peril, region).result))
val years = results.map(_.year).toSet
val allYears = (1 to 10000).toSet
val differences = allYears diff years
val missing = differences.map(new SingleEventYear(region, peril, 0, 0, _, 0))
val intermediate = header + results.mkString("\n") + "\n" + missing.mkString("\r\n")
Ok(intermediate)
}
}
You can call await on any Future in async block and it will return the result, maybe that approach might seem easier, but it has limitations. It will be changed using macros to flatMaps. The async { Ok("res") } is an expression of type Future[Result]. This allows you to put it inside Action.async {} and keep your code asynchronous.