Efficiency - How to load what you need.

Question

Hello,
I am pondering the scenario of using object oriented programming and filling a report efficiently. I am hoping someone could provide insight or direct me to existing patterns.
Let's say I want to create a report of all employees. Great, my first thought is have a Employee class and Employee Container. Load all the employee objects and all the n attributes. Loop through to display.
What about if I only wanted a select few of the employees in the report. I could loop through all as above looking for the correct criteria, however, I would much rather let the database do that. So what is a good way to specify criteria to load the employees.
Another is what if I only want 2 of the n attributes. How can I get around loading all the attributes of the Employee? Keeping in mind that I don't want to know anything about the database at the business object level.
This is really only part of the problem. I'm sure everyone goes through it so there must be best practices and/or patterns to help.
Thanks,
Tom

Answer 1

Note, I didn't actually run this in a database to verify that it worked. Only verification I did was to print out on the console what the SQL statement was.
bash-2.03$ java Example
SELECT * person WHERE name = bob AND age >= 21
(You may want to modify it to put a ';' at the end of the query if necessary.)
This is the interface that defines the key to the Map
package db;
public interface Attribute {
        String getField();
        String getOperator();
        String construct(String value);
        int hashCode();
        boolean equals(Object o);
}Very flexible implementation of an attribute--should be able to apply to whatever you want.
package db;
public class GenericAttribute implements Attribute {
        private String field;
        private String operator;
        public GenericAttribute(String field) {
                this(field, "=");
        public GenericAttribute(String field, String operator) {
                this.field = field;
                this.operator = operator;
        public String getField() {
                return this.field;
        public String getOperator() {
                return this.operator;
        public String construct(String value) {
                return this.field + " " + this.operator + " " + value;
        public int hashCode() {
                return field.hashCode() + operator.hashCode();
        public boolean equals(Object o) {
                if(o instanceof GenericAttribute) {
                        GenericAttribute attrib = (GenericAttribute) o;
                        return (this.field.equals(attrib.getField()) && this.operator.equals(attrib.getOperator()));
                return false;
}Pieces all of the parts together.
package db;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.sql.ResultSet;
import java.sql.SQLException;
public abstract class SQLComposer {
        protected abstract String getTable();
        protected String getFields() {
                return "*";
        protected abstract Collection getResults(ResultSet rs) throws SQLException;
        public String compose(Map attributes) {
                StringBuffer sb = new StringBuffer("SELECT ");
                sb.append(getFields() + " " + getTable());
                Iterator iter = attributes.keySet().iterator();
                boolean first = true;
                while(iter.hasNext()) {
                        Attribute attrib = (Attribute) iter.next();
                        if(first) {
                                sb.append(" WHERE ");
                                first = false;
                        } else {
                                sb.append(" AND ");
                        sb.append(attrib.construct((String) attributes.get(attrib)));
                return sb.toString();
}Example code using the composer and the attribute
import db.Attribute;
import db.GenericAttribute;
import db.SQLComposer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.SQLException;
import java.sql.ResultSet;
public class Example extends SQLComposer {
        public static final Attribute NAME = new GenericAttribute("name", "=");
        public static final Attribute AGE = new GenericAttribute("age" , ">=");
        public static final Attribute TITLE = new GenericAttribute("title", "LIKE");
        private String table = null;
        public Example(String table) {
                this.table = table;
        protected String getTable() {
                return this.table;
        public Connection getConnection() {
                // do JDBC direct connection or DataSource lookup
                return null;
        public Collection process(Map attributes) throws SQLException {
                Connection conn = getConnection();
                Statement s = conn.createStatement();
                return getResults(s.executeQuery(compose(attributes)));
        protected Collection getResults(ResultSet rs) throws SQLException {
                Collection results = new ArrayList();
                while(rs.next()) {
                        // parse out info and append to collection
                return results;
        public static void main(String[] args) {
                Example e = new Example("person");
                Map map = new HashMap();
                map.put(Example.NAME, "bob");
                map.put(Example.AGE, "21");
                try {
                        e.process(map);
                } catch(SQLException sqle) {
                        sqle.printStackTrace();
                        System.exit(1);