Design of PHP formatting class and improving performance and speed - php

Question

I work at a school and have been looking at a way to speed up and improve the way some of our database functions work.
We have a PHP formatting class that seems to be slowing things down now that the database is getting bigger and bigger and some of the queries longer.
The class does things like take a foreign key and find the value for that key in a lookup table.
For example a student class will use the formatting class for:
courseID = 114 and studentID are looked up to return Biology and John Doe each time using a mysql query.
My issue is there are classes that generate an array of objects for example and array of 500 student objects and each of these student classes accesses this formatter class and thus run several queries.
I am thinking this is slowing things down
Worst case
500 student objects x 10 lookups in the formatter class that means 5000 queries executed.
I am wondering the best way to deal with this.
Do I preload all the lookup data into arrays into that one formatter class?
Make that formatted class a one instance (singleton) so that the worst case scenario, one master class that generates a whole array of classes uses that one and only class.
Is it better to store all that lookup data already parsed in one array (cache issue?)
Some classes now have so many queries they no longer work.
edit 8/23/2013 below
To add further information.
I am not really concerned with a single lookup, those have no issues speed wise. Such as a teacher looking up one student's info. Having a formatter class run 10 queries is no issue.
The class which generate a huge listing of other objects, such as a teacher requesting to see all students, where there is 500 objects is the issue.
I have several of these type of classes, creating a Join for all of them is the probably the fastest but as someone pointed out a lot of work.
edit 1/30/2014
Wanted to thank Lorenz Meyer for the great start to my speed issues, been working on some of the suggestions!!!!
I do have a further related question.
For simpler lookups, say storing the values of 50 pairs of values, for example the teacherIds and the corresponding teacher names.
Option 1:
I have in some cases added a field to some tables and had a script pre-populate those fields with the value, such as the teachers name for the teacherIds in that row. At run time the field already has a value, I did this in some of the huge script and it dramatically cut the amount of queries.
With a Cron to run the script, it is a ok solution but I could see it becoming an issue adding fields just for rendered data to so many tables
Option 2:
I have been thinking of using the $_Session to store that pair data. Once a user logs in, an array of teacherIds and Full Names populate an array in the $_Session data. Any class that previously used a lookup to find a teachers name, could use the $_Session array and use that instead, with a fallback to query the lookup table just in case.
I don't have many concurrent users, 30 at most so it seems this would not be hugely taxing, and would limit it to some of the smaller lookup tables.
What are peoples thoughts on these two options, especially Option 2.

Answer 1

I see three solutions, I present them from the easiest to the heaviest, but most effective.
Caching, but limited to one request
This solution would be to include a static variable in this function and use this as a temporary store for the students and classes. This would result in fewer queries, because you query each student only once and each class only once.
Something like this
function format($studentid, $classid){
static $students = array();
static $classes = array();
if !isset($students[$studentid]) $students[$studentid] db_lookup($studentid);
if !isset($classes[$classid]) $classes[$classid] db_lookup($classid);
$student_name = $students[$studentid];
$class_name = $classes[$studentid];
(...)
instead of
function format($studentid, $classid){
$student_name = db_lookup($studentid);
$class_name = db_lookup($classid);
(...)
This solution is very easy to implement, but it caches the result only for one request, for instance if you display a table wich contains many times the same course.
Caching between requests
For caching between requests, you need to use a cache solution like for instance the PEAR package Cache_Lite. It allows to cache the result of a function call with a fixed value (e.g. db_lookup($studentid=123) ) and store the result in the cache. Cache_Lite implements a memory cache, a file cache and a database cache. I used it with memcache and it worked well.
This solution requires more work, and it will either use diskspace or memory.
Code refactoring
The most efficient solution, but the one that requires the most effort is to refactor your code. It does not make sense to query 500 times the database for one row each time. You should rewrite the code, so that the query gets all data, and then format the data for each row of your record set.