}        }    }    private String getInitProperty(Map props, String strName, String strDefault) {        Object o = props.get(strName);        if (o == null) {            return strDefault;        }        return (String) o;    }    private String buildNested(NestedExpression nestedExpression, StringBuffer sel, List values) {        sel.append("SELECT DISTINCT(");        // Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead        //sel.append(entryId);        sel.append(stepEntryId);        sel.append(") FROM ");        // Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead        // sel.append(entryTable);        sel.append(currentTable);        if (log.isDebugEnabled()) {            log.debug("Thus far, query is: " + sel.toString());        }        for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {            Expression expression = nestedExpression.getExpression(i);            if (i == 0) {                sel.append(" WHERE ");            } else {                if (nestedExpression.getExpressionOperator() == NestedExpression.AND) {                    sel.append(" AND ");                } else {                    sel.append(" OR ");                }            }            if (expression.isNegate()) {                sel.append(" NOT ");            }            // Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead            // sel.append(entryId);            sel.append(stepEntryId);            sel.append(" IN (");            if (expression.isNested()) {                this.buildNested((NestedExpression) nestedExpression.getExpression(i), sel, values);            } else {                FieldExpression sub = (FieldExpression) nestedExpression.getExpression(i);                this.buildSimple(sub, sel, values);            }            sel.append(')');        }        // Changed by Anthony on 2 June 2004, to query from OS_CURRENTSTEP instead        // return (entryId);        return (stepEntryId);    }    private String buildSimple(FieldExpression fieldExpression, StringBuffer sel, List values) {        String table;        String columnName;        if (fieldExpression.getContext() == FieldExpression.CURRENT_STEPS) {            table = currentTable;            columnName = stepEntryId;        } else if (fieldExpression.getContext() == FieldExpression.HISTORY_STEPS) {            table = historyTable;            columnName = stepEntryId;        } else {            table = entryTable;            columnName = entryId;        }        sel.append("SELECT DISTINCT(");        sel.append(columnName);        sel.append(") FROM ");        sel.append(table);        sel.append(" WHERE ");        queryComparison(fieldExpression, sel, values);        return columnName;    }    private List doExpressionQuery(String sel, String columnName, List values) throws StoreException {        if (log.isDebugEnabled()) {            log.debug(sel);        }        Connection conn = null;        PreparedStatement stmt = null;        ResultSet rs = null;        List results = new ArrayList();        try {            conn = getConnection();            stmt = conn.prepareStatement(sel);            if (!values.isEmpty()) {                for (int i = 1; i <= values.size(); i++) {                    stmt.setObject(i, values.get(i - 1));                }            }            rs = stmt.executeQuery();            while (rs.next()) {                // get entryIds and add to results list                Long id = new Long(rs.getLong(columnName));                results.add(id);            }            return results;        } catch (SQLException ex) {            throw new StoreException("SQL Exception in query: " + ex.getMessage());        } finally {            cleanup(conn, stmt, rs);        }    }    private static String escape(String s) {        StringBuffer sb = new StringBuffer(s);        char c;        char[] chars = s.toCharArray();        for (int i = 0; i < chars.length; i++) {            c = chars[i];            switch (c) {            case '\'':                sb.insert(i, '\'');                i++;                break;            case '\\':                sb.insert(i, '\\');                i++;            }        }        return sb.toString();    }    private String fieldName(int field) {        switch (field) {        case FieldExpression.ACTION: // actionId            return stepActionId;        case FieldExpression.CALLER:            return stepCaller;        case FieldExpression.FINISH_DATE:            return stepFinishDate;        case FieldExpression.OWNER:            return stepOwner;        case FieldExpression.START_DATE:            return stepStartDate;        case FieldExpression.STEP: // stepId            return stepStepId;        case FieldExpression.STATUS:            return stepStatus;        case FieldExpression.STATE:            return entryState;        case FieldExpression.NAME:            return entryName;        case FieldExpression.DUE_DATE:            return stepDueDate;        default:            return "1";        }    }    private Object lookup(String location) throws NamingException {        try {            InitialContext context = new InitialContext();            try {                return context.lookup(location);            } catch (NamingException e) {                //ok, couldn't find it, look in env                return context.lookup("java:comp/env/" + location);            }        } catch (NamingException e) {            throw e;        }    }    private String queryComparison(WorkflowQuery query) {        Object value = query.getValue();        int operator = query.getOperator();        int field = query.getField();        //int type = query.getType();        String oper;        switch (operator) {        case WorkflowQuery.EQUALS:            oper = " = ";            break;        case WorkflowQuery.NOT_EQUALS:            oper = " <> ";            break;        case WorkflowQuery.GT:            oper = " > ";            break;        case WorkflowQuery.LT:            oper = " < ";            break;        default:            oper = " = ";        }        String left = fieldName(field);        String right;        if (value != null) {            right = '\'' + escape(value.toString()) + '\'';        } else {            right = "null";        }        return left + oper + right;    }    /**     * Method queryComparison     *     * @param    expression          a  FieldExpression     * @param    sel                 a  StringBuffer     *     */    private void queryComparison(FieldExpression expression, StringBuffer sel, List values) {        Object value = expression.getValue();        int operator = expression.getOperator();        int field = expression.getField();        String oper;        switch (operator) {        case FieldExpression.EQUALS:            if (value == null) {                oper = " IS ";            } else {                oper = " = ";            }            break;        case FieldExpression.NOT_EQUALS:            if (value == null) {                oper = " IS NOT ";            } else {                oper = " <> ";            }            break;        case FieldExpression.GT:            oper = " > ";            break;        case FieldExpression.LT:            oper = " < ";            break;        default:            oper = " = ";        }        String left = fieldName(field);        String right = "?";        switch (field) {        case FieldExpression.FINISH_DATE:            values.add(new Timestamp(((Date) value).getTime()));            break;        case FieldExpression.START_DATE:            values.add(new Timestamp(((Date) value).getTime()));            break;        case FieldExpression.DUE_DATE:            values.add(new Timestamp(((Date) value).getTime()));            break;        default:            if (value == null) {                right = "null";            } else {                values.add(value);            }        }        sel.append(left);        sel.append(oper);        sel.append(right);    }    private String queryWhere(WorkflowQuery query) {        if (query.getLeft() == null) {            // leaf node            return queryComparison(query);        } else {            int operator = query.getOperator();            WorkflowQuery left = query.getLeft();            WorkflowQuery right = query.getRight();            switch (operator) {            case WorkflowQuery.AND:                return '(' + queryWhere(left) + " AND " + queryWhere(right) + ')';            case WorkflowQuery.OR:                return '(' + queryWhere(left) + " OR " + queryWhere(right) + ')';            case WorkflowQuery.XOR:                return '(' + queryWhere(left) + " XOR " + queryWhere(right) + ')';            }        }        return ""; // not sure if we should throw an exception or how this should be handled    }}