Question

While writing yet another class full of methods that access database tables to work, I started wondering how I may best write these methods in the case that the application may need to be run in a way that was the least load intensive on the server

For example, if I have the method foo which queries for and displays bars, I could write it like:

function foo (params) {
   this->query_db("select bar from bars where bar != foo");

   for all bars display bar
}

I was wondering if it may be better design to write something like

function foo(bars,params) {
   if(!bars) { bars = this->query_db("select bar from bars where bar != foo"); }

   for all bars display bar
}

In the second method bars is passed to the method foo as an array, this would allow for two things, a) if bars has already been queried in the same instance, a call to the database is avoided b) foo can now be used simply by passing an array in other instances you may want to use foo without using data from the database

Is this a good method of design for programs that use databases? Is there perhaps a software pattern out there that suggests similar design to this? Or…is this just silly? 😉

Answer 1

Point a) is potentially valid, as long as you’re aware of what you’re doing: implementing a cache in front of the database. That means you have to be thinking about all the usual considerations cache implementors worry about: tradeoff of cache size vs. memory consumption, how long to retain cached data, the possibility that the cache may no longer be valid if the underlying database has changed, etc. You might also want to consider using an object-relational mapping tool (such as Hibernate), which may take care of some of this kind of caching for you.

I think your point (b) is actually an anti-pattern.

A method that might be summarized as “query the the database and display the results, or display some data you pass it without doing a query” is begging to be refactored so it’s only doing one thing.