Is calling a Future method parameter "by-name" necessary? - scala

Question

I have something like the following for caching JSON responses in Redis for a Scala application using http4s, Argonaut, and Slick, and want to confirm that it is working how I expect is. The idea is if a Redis key was not found, then call the given fallback method to get the data from the original source (MySQL) and cache it for future requests, otherwise skip MySQL:
/** Get from MySQL */
def getThingsFromDatabase(matchingId: Int): Future[Seq[Thing]] = {
println("getThingsFromDatabase")
val query = things.filter(_.fieldId === matchingId)
db.run(query.result)
}
/** Get from Redis, else MySQL via `fallback` */
def getThingsFromRedisOrDatabase(key: String,
fallback: Future[Seq[Thing]]):
Future[argonaut.Json] = {
val stored = redis.get(key)
stored match {
// Data exists, return from redis
case Some(s) => {
Parse.parse(s) match { // convert string to Json
case Right(r) => Future { r } // Json => Future[argonaut.Json]
case Left(l) => println(l) // error
}
}
// Data does not exist, get from database and store
case None() => {
val data = fallback.map(_.toList.asJson)
data map { redis.set(key, _) }
data // Future[argonaut.Json]
}
}
}
// GET /things/12
Ok(getThingsFromRedisOrDatabase("things:12", getThingsFromDatabase(12)))
This works, however the above code will always print "getThingsFromDatabase" regardless of whether or not there is data in Redis because getThingsFromDatabase(12) executes when called as a parameter. The original database does not seem to be hit (no errors if it is shutdown) with data in Redis, as intended. I think this is because the fallback Future is not being used in this scenario so it does not complete even though the method was executed.
If fallback: Future[Seq[Thing]] is changed to be call-by-name (i.e. fallback: => Future[Seq[Thing]]), "getThingsFromDatabase" is only printed the first time when the cache is empty, as expected, since fallback is called only in the None() condition and not executed as a parameter.
While the latter is the intended functionality, would there be a difference between the original and the call-by-name version if there wasn't a println in the getThingsFromDatabase method? Both appear to meet the need of not going to MySQL if Redis has the desired data, with neither actually completing the Future even though the former executes the method.

Answer 1

There would be significant difference. As written, the db.run() will be invoked, and the database will execute the query; the results may be discarded but typically the server will do all the work.
If things is a big, unindexed table or if this code is frequently invoked, then yes, you could see significant performance degradation from the unnecessary calls. This example is a poster-child for the usefulness of call-by-name.