package org.apache.torque.util;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.OrderedMap;
import org.apache.commons.collections.map.ListOrderedMap;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.torque.Torque;
import org.apache.torque.TorqueException;
import org.apache.torque.adapter.DB;
import org.apache.torque.om.DateKey;
import org.apache.torque.om.ObjectKey;
/**
* This is a utility class that is used for retrieving different types
* of values from a hashtable based on a simple name string. This
* class is meant to minimize the amount of casting that needs to be
* done when working with Hashtables.
*
* NOTE: other methods will be added as needed and as time permits.
*
* @author <a href="mailto:frank.kim@clearink.com">Frank Y. Kim</a>
* @author <a href="mailto:jmcnally@collab.net">John D. McNally</a>
* @author <a href="mailto:bmclaugh@algx.net">Brett McLaughlin</a>
* @author <a href="mailto:eric@dobbse.net">Eric Dobbs</a>
* @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
* @author <a href="mailto:sam@neurogrid.com">Sam Joseph</a>
* @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
* @author <a href="mailto:fischer@seitenbau.de">Thomas Fischer</a>
* @author <a href="mailto:seade@backstagetech.com.au">Scott Eade</a>
* @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
* @version $Id: Criteria.java 591648 2007-11-03 16:34:00Z tfischer $
*/
public class Criteria extends Hashtable
{
/** Serial version. */
private static final long serialVersionUID = -9001666575933085601L;
/** Comparison type. */
public static final SqlEnum EQUAL = SqlEnum.EQUAL;
/** Comparison type. */
public static final SqlEnum NOT_EQUAL = SqlEnum.NOT_EQUAL;
/** Comparison type. */
public static final SqlEnum ALT_NOT_EQUAL = SqlEnum.ALT_NOT_EQUAL;
/** Comparison type. */
public static final SqlEnum GREATER_THAN = SqlEnum.GREATER_THAN;
/** Comparison type. */
public static final SqlEnum LESS_THAN = SqlEnum.LESS_THAN;
/** Comparison type. */
public static final SqlEnum GREATER_EQUAL = SqlEnum.GREATER_EQUAL;
/** Comparison type. */
public static final SqlEnum LESS_EQUAL = SqlEnum.LESS_EQUAL;
/** Comparison type. */
public static final SqlEnum LIKE = SqlEnum.LIKE;
/** Comparison type. */
public static final SqlEnum NOT_LIKE = SqlEnum.NOT_LIKE;
/** Comparison type. */
public static final SqlEnum ILIKE = SqlEnum.ILIKE;
/** Comparison type. */
public static final SqlEnum NOT_ILIKE = SqlEnum.NOT_ILIKE;
/** Comparison type. */
public static final SqlEnum CUSTOM = SqlEnum.CUSTOM;
/** Comparison type. */
public static final SqlEnum DISTINCT = SqlEnum.DISTINCT;
/** Comparison type. */
public static final SqlEnum IN = SqlEnum.IN;
/** Comparison type. */
public static final SqlEnum NOT_IN = SqlEnum.NOT_IN;
/** Comparison type. */
public static final SqlEnum ALL = SqlEnum.ALL;
/** Comparison type. */
public static final SqlEnum JOIN = SqlEnum.JOIN;
/** "Order by" qualifier - ascending */
private static final SqlEnum ASC = SqlEnum.ASC;
/** "Order by" qualifier - descending */
private static final SqlEnum DESC = SqlEnum.DESC;
/** "IS NULL" null comparison */
public static final SqlEnum ISNULL = SqlEnum.ISNULL;
/** "IS NOT NULL" null comparison */
public static final SqlEnum ISNOTNULL = SqlEnum.ISNOTNULL;
/** "CURRENT_DATE" ANSI SQL function */
public static final SqlEnum CURRENT_DATE = SqlEnum.CURRENT_DATE;
/** "CURRENT_TIME" ANSI SQL function */
public static final SqlEnum CURRENT_TIME = SqlEnum.CURRENT_TIME;
/** "LEFT JOIN" SQL statement */
public static final SqlEnum LEFT_JOIN = SqlEnum.LEFT_JOIN;
/** "RIGHT JOIN" SQL statement */
public static final SqlEnum RIGHT_JOIN = SqlEnum.RIGHT_JOIN;
/** "INNER JOIN" SQL statement */
public static final SqlEnum INNER_JOIN = SqlEnum.INNER_JOIN;
private static final int DEFAULT_CAPACITY = 10;
private boolean ignoreCase = false;
private boolean singleRecord = false;
private boolean cascade = false;
private UniqueList selectModifiers = new UniqueList();
private UniqueList selectColumns = new UniqueList();
private UniqueList orderByColumns = new UniqueList();
private UniqueList groupByColumns = new UniqueList();
private Criterion having = null;
private OrderedMap asColumns = ListOrderedMap.decorate(new HashMap());
private transient List joins = new ArrayList(3);
/** The name of the database. */
private String dbName;
/** The name of the database as given in the contructor. */
private String originalDbName;
/**
* To limit the number of rows to return. <code>-1</code> means return all
* rows.
*/
private int limit = -1;
/** To start the results at a row other than the first one. */
private int offset = 0;
private HashMap aliases = new HashMap(8);
private boolean useTransaction = false;
/** the log. */
private static Log log = LogFactory.getLog(Criteria.class);
/**
* Creates a new instance with the default capacity.
*/
public Criteria()
{
this(DEFAULT_CAPACITY);
}
/**
* Creates a new instance with the specified capacity.
*
* @param initialCapacity An int.
*/
public Criteria(int initialCapacity)
{
this(Torque.getDefaultDB(), initialCapacity);
}
/**
* Creates a new instance with the default capacity which corresponds to
* the specified database.
*
* @param dbName The dabase name.
*/
public Criteria(String dbName)
{
this(dbName, DEFAULT_CAPACITY);
}
/**
* Creates a new instance with the specified capacity which corresponds to
* the specified database.
*
* @param dbName The dabase name.
* @param initialCapacity The initial capacity.
*/
public Criteria(String dbName, int initialCapacity)
{
super(initialCapacity);
this.dbName = dbName;
this.originalDbName = dbName;
}
/**
* Brings this criteria back to its initial state, so that it
* can be reused as if it was new. Except if the criteria has grown in
* capacity, it is left at the current capacity.
*/
public void clear()
{
super.clear();
ignoreCase = false;
singleRecord = false;
cascade = false;
selectModifiers.clear();
selectColumns.clear();
orderByColumns.clear();
groupByColumns.clear();
having = null;
asColumns.clear();
joins.clear();
dbName = originalDbName;
offset = 0;
limit = -1;
aliases.clear();
useTransaction = false;
}
/**
* Add an AS clause to the select columns. Usage:
* <p>
* <code>
*
* Criteria myCrit = new Criteria();
* myCrit.addAsColumn("alias", "ALIAS("+MyPeer.ID+")");
*
* </code>
*
* @param name wanted Name of the column
* @param clause SQL clause to select from the table
*
* If the name already exists, it is replaced by the new clause.
*
* @return A modified Criteria object.
*/
public Criteria addAsColumn(String name, String clause)
{
asColumns.put(name, clause);
return this;
}
/**
* Get the column aliases.
*
* @return A Map which map the column alias names
* to the alias clauses.
*/
public Map getAsColumns()
{
return asColumns;
}
/**
* Get the table aliases.
*
* @return A Map which maps the table alias names to the actual table names.
*/
public Map getAliases()
{
return aliases;
}
/**
* Allows one to specify an alias for a table that can
* be used in various parts of the SQL.
*
* @param alias a <code>String</code> value
* @param table a <code>String</code> value
*/
public void addAlias(String alias, String table)
{
aliases.put(alias, table);
}
/**
* Returns the table name associated with an alias.
*
* @param alias a <code>String</code> value
* @return a <code>String</code> value
*/
public String getTableForAlias(String alias)
{
return (String) aliases.get(alias);
}
/**
* Does this Criteria Object contain the specified key?
*
* @param table The name of the table.
* @param column The name of the column.
* @return True if this Criteria Object contain the specified key.
*/
public boolean containsKey(String table, String column)
{
return containsKey(table + '.' + column);
}
/**
* Convenience method to return value as a boolean.
*
* @param column String name of column.
* @return A boolean.
*/
public boolean getBoolean(String column)
{
return ((Boolean) getCriterion(column).getValue()).booleanValue();
}
/**
* Convenience method to return value as a boolean.
*
* @param table String name of table.
* @param column String name of column.
* @return A boolean.
*/
public boolean getBoolean(String table, String column)
{
return getBoolean(new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Will force the sql represented by this criteria to be executed within
* a transaction. This is here primarily to support the oid type in
* postgresql. Though it can be used to require any single sql statement
* to use a transaction.
*/
public void setUseTransaction(boolean v)
{
useTransaction = v;
}
/**
* called by BasePeer to determine whether the sql command specified by
* this criteria must be wrapped in a transaction.
*
* @return a <code>boolean</code> value
*/
protected boolean isUseTransaction()
{
return useTransaction;
}
/**
* Method to return criteria related to columns in a table.
*
* @param column String name of column.
* @return A Criterion.
*/
public Criterion getCriterion(String column)
{
return (Criterion) super.get(column);
}
/**
* Method to return criteria related to a column in a table.
*
* @param table String name of table.
* @param column String name of column.
* @return A Criterion.
*/
public Criterion getCriterion(String table, String column)
{
return getCriterion(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Method to return criterion that is not added automatically
* to this Criteria. This can be used to chain the
* Criterions to form a more complex where clause.
*
* @param column String full name of column (for example TABLE.COLUMN).
* @return A Criterion.
*/
public Criterion getNewCriterion(String column, Object value,
SqlEnum comparison)
{
return new Criterion(column, value, comparison);
}
/**
* Method to return criterion that is not added automatically
* to this Criteria. This can be used to chain the
* Criterions to form a more complex where clause.
*
* @param table String name of table.
* @param column String name of column.
* @return A Criterion.
*/
public Criterion getNewCriterion(String table, String column,
Object value, SqlEnum comparison)
{
return new Criterion(table, column, value, comparison);
}
/**
* This method adds a prepared Criterion object to the Criteria.
* You can get a new, empty Criterion object with the
* getNewCriterion() method. If a criterion for the requested column
* already exists, it is replaced. This is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria();
* Criteria.Criterion c = crit
* .getNewCriterion(BasePeer.ID, new Integer(5), Criteria.LESS_THAN);
* crit.add(c);
* </code>
*
* @param c A Criterion object
*
* @return A modified Criteria object.
*/
public Criteria add(Criterion c)
{
StringBuffer sb = new StringBuffer(c.getTable().length()
+ c.getColumn().length() + 1);
sb.append(c.getTable());
sb.append('.');
sb.append(c.getColumn());
super.put(sb.toString(), c);
return this;
}
/**
* Method to return a String table name.
*
* @param name A String with the name of the key.
* @return A String with the value of the object at key.
*/
public String getColumnName(String name)
{
return getCriterion(name).getColumn();
}
/**
* Method to return a comparison String.
*
* @param key String name of the key.
* @return A String with the value of the object at key.
*/
public SqlEnum getComparison(String key)
{
return getCriterion(key).getComparison();
}
/**
* Method to return a comparison String.
*
* @param table String name of table.
* @param column String name of column.
* @return A String with the value of the object at key.
*/
public SqlEnum getComparison(String table, String column)
{
return getComparison(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return a Date.
*
* @param name column name (TABLE.COLUMN)
* @return A java.util.Date with the value of object at key.
*/
public java.util.Date getDate(String name)
{
return (java.util.Date) getCriterion(name).getValue();
}
/**
* Convenience method to return a Date.
*
* @param table String name of table.
* @param column String name of column.
* @return A java.util.Date with the value of object at key.
*/
public java.util.Date getDate(String table, String column)
{
return getDate(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Get the Database(Map) name.
*
* @return A String with the Database(Map) name. By default, this
* is PoolBrokerService.DEFAULT.
*/
public String getDbName()
{
return dbName;
}
/**
* Set the DatabaseMap name. If <code>null</code> is supplied, uses value
* provided by <code>Torque.getDefaultDB()</code>.
*
* @param dbName A String with the Database(Map) name.
*/
public void setDbName(String dbName)
{
this.dbName = (dbName == null ? Torque.getDefaultDB() : dbName.trim());
}
/**
* Convenience method to return a double.
*
* @param name A String with the name of the key.
* @return A double with the value of object at key.
*/
public double getDouble(String name)
{
Object obj = getCriterion(name).getValue();
if (obj instanceof String)
{
return new Double((String) obj).doubleValue();
}
return ((Double) obj).doubleValue();
}
/**
* Convenience method to return a double.
*
* @param table String name of table.
* @param column String name of column.
* @return A double with the value of object at key.
*/
public double getDouble(String table, String column)
{
return getDouble(new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return a float.
*
* @param name A String with the name of the key.
* @return A float with the value of object at key.
*/
public float getFloat(String name)
{
Object obj = getCriterion(name).getValue();
if (obj instanceof String)
{
return new Float((String) obj).floatValue();
}
return ((Float) obj).floatValue();
}
/**
* Convenience method to return a float.
*
* @param table String name of table.
* @param column String name of column.
* @return A float with the value of object at key.
*/
public float getFloat(String table, String column)
{
return getFloat(new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return an Integer.
*
* @param name A String with the name of the key.
* @return An Integer with the value of object at key.
*/
public Integer getInteger(String name)
{
Object obj = getCriterion(name).getValue();
if (obj instanceof String)
{
return new Integer((String) obj);
}
return ((Integer) obj);
}
/**
* Convenience method to return an Integer.
*
* @param table String name of table.
* @param column String name of column.
* @return An Integer with the value of object at key.
*/
public Integer getInteger(String table, String column)
{
return getInteger(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return an int.
*
* @param name A String with the name of the key.
* @return An int with the value of object at key.
*/
public int getInt(String name)
{
Object obj = getCriterion(name).getValue();
if (obj instanceof String)
{
return new Integer((String) obj).intValue();
}
return ((Integer) obj).intValue();
}
/**
* Convenience method to return an int.
*
* @param table String name of table.
* @param column String name of column.
* @return An int with the value of object at key.
*/
public int getInt(String table, String column)
{
return getInt(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return a BigDecimal.
*
* @param name A String with the name of the key.
* @return A BigDecimal with the value of object at key.
*/
public BigDecimal getBigDecimal(String name)
{
Object obj = getCriterion(name).getValue();
if (obj instanceof String)
{
return new BigDecimal((String) obj);
}
return (BigDecimal) obj;
}
/**
* Convenience method to return a BigDecimal.
*
* @param table String name of table.
* @param column String name of column.
* @return A BigDecimal with the value of object at key.
*/
public BigDecimal getBigDecimal(String table, String column)
{
return getBigDecimal(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return a long.
*
* @param name A String with the name of the key.
* @return A long with the value of object at key.
*/
public long getLong(String name)
{
Object obj = getCriterion(name).getValue();
if (obj instanceof String)
{
return new Long((String) obj).longValue();
}
return ((Long) obj).longValue();
}
/**
* Convenience method to return a long.
*
* @param table String name of table.
* @param column String name of column.
* @return A long with the value of object at key.
*/
public long getLong(String table, String column)
{
return getLong(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return a String.
*
* @param name A String with the name of the key.
* @return A String with the value of object at key.
*/
public String getString(String name)
{
return (String) getCriterion(name).getValue();
}
/**
* Convenience method to return a String.
*
* @param table String name of table.
* @param column String name of column.
* @return A String with the value of object at key.
*/
public String getString(String table, String column)
{
return getString(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Method to return a String table name.
*
* @param name A String with the name of the key.
* @return A String with the value of object at key.
*/
public String getTableName(String name)
{
return getCriterion(name).getTable();
}
/**
* Convenience method to return a List.
*
* @param name A String with the name of the key.
* @return A List with the value of object at key.
*/
public List getList(String name)
{
return (List) getCriterion(name).getValue();
}
/**
* Convenience method to return a List.
*
* @param table String name of table.
* @param column String name of column.
* @return A List with the value of object at key.
*/
public List getList(String table, String column)
{
return getList(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Method to return the value that was added to Criteria.
*
* @param name A String with the name of the key.
* @return An Object with the value of object at key.
*/
public Object getValue(String name)
{
return getCriterion(name).getValue();
}
/**
* Method to return the value that was added to Criteria.
*
* @param table String name of table.
* @param column String name of column.
* @return An Object with the value of object at key.
*/
public Object getValue(String table, String column)
{
return getValue(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Convenience method to return an ObjectKey.
*
* @param name A String with the name of the key.
* @return An ObjectKey with the value of object at key.
*/
public ObjectKey getObjectKey(String name)
{
return (ObjectKey) getCriterion(name).getValue();
}
/**
* Convenience method to return an ObjectKey.
*
* @param table String name of table.
* @param column String name of column.
* @return A String with the value of object at key.
*/
public ObjectKey getObjectKey(String table, String column)
{
return getObjectKey(
new StringBuffer(table.length() + column.length() + 1)
.append(table).append('.').append(column)
.toString());
}
/**
* Overrides Hashtable get, so that the value placed in the
* Criterion is returned instead of the Criterion.
*
* @param key An Object.
* @return An Object.
*/
public Object get(Object key)
{
return getValue((String) key);
}
/**
* Overrides Hashtable put, so that this object is returned
* instead of the value previously in the Criteria object.
* The reason is so that it more closely matches the behavior
* of the add() methods. If you want to get the previous value
* then you should first Criteria.get() it yourself. Note, if
* you attempt to pass in an Object that is not a String, it will
* throw a NPE. The reason for this is that none of the add()
* methods support adding anything other than a String as a key.
*
* @param key An Object. Must be instanceof String!
* @param value An Object.
* @throws NullPointerException if key != String or key/value is null.
* @return Instance of self.
*/
public Object put(Object key, Object value)
{
if (!(key instanceof String))
{
throw new NullPointerException(
"Criteria: Key must be a String object.");
}
return add((String) key, value);
}
/**
* Copies all of the mappings from the specified Map to this Criteria
* These mappings will replace any mappings that this Criteria had for any
* of the keys currently in the specified Map.
*
* if the map was another Criteria, its attributes are copied to this
* Criteria, overwriting previous settings.
*
* @param t Mappings to be stored in this map.
*/
public synchronized void putAll(Map t)
{
Iterator i = t.entrySet().iterator();
while (i.hasNext())
{
Map.Entry e = (Map.Entry) i.next();
Object val = e.getValue();
if (val instanceof Criteria.Criterion)
{
super.put(e.getKey(), val);
}
else
{
put(e.getKey(), val);
}
}
if (t instanceof Criteria)
{
Criteria c = (Criteria) t;
this.joins = c.joins;
}
/* this would make a copy, not included
but might want to use some of it.
if (t instanceof Criteria)
{
Criteria c = (Criteria)t;
this.ignoreCase = c.ignoreCase;
this.singleRecord = c.singleRecord;
this.cascade = c.cascade;
this.selectModifiers = c.selectModifiers;
this.selectColumns = c.selectColumns;
this.orderByColumns = c.orderByColumns;
this.dbName = c.dbName;
this.limit = c.limit;
this.offset = c.offset;
this.aliases = c.aliases;
}
*/
}
/**
* This method adds a new criterion to the list of criterias. If a
* criterion for the requested column already exists, it is
* replaced. This is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().add("column",
* "value");
* </code>
*
* An EQUAL comparison is used for column and value.
*
* The name of the table must be used implicitly in the column name,
* so the Column name must be something like 'TABLE.id'. If you
* don't like this, you can use the add(table, column, value) method.
*
* @param column The column to run the comparison on
* @param value An Object.
*
* @return A modified Criteria object.
*/
public Criteria add (String column, Object value)
{
add(column, value, EQUAL);
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* replaced. If is used as follow:
*
* <p>
* <code>
* Criteria crit = new Criteria().add("column",
* "value"
* Criteria.GREATER_THAN);
* </code>
*
* Any comparison can be used.
*
* The name of the table must be used implicitly in the column name,
* so the Column name must be something like 'TABLE.id'. If you
* don't like this, you can use the add(table, column, value) method.
*
* @param column The column to run the comparison on
* @param value An Object.
* @param comparison A String.
*
* @return A modified Criteria object.
*/
public Criteria add(String column, Object value, SqlEnum comparison)
{
super.put(column, new Criterion(column, value, comparison));
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* replaced. If is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().add("table",
* "column",
* "value");
* </code>
*
* An EQUAL comparison is used for column and value.
*
* @param table Name of the table which contains the column
* @param column The column to run the comparison on
* @param value An Object.
*
* @return A modified Criteria object.
*/
public Criteria add(String table, String column, Object value)
{
add(table, column, value, EQUAL);
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* replaced. If is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().add("table",
* "column",
* "value",
* Criteria.GREATER_THAN);
* </code>
*
* Any comparison can be used.
*
* @param table Name of table which contains the column
* @param column The column to run the comparison on
* @param value An Object.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria add(String table,
String column,
Object value,
SqlEnum comparison)
{
StringBuffer sb = new StringBuffer(table.length()
+ column.length() + 1);
sb.append(table);
sb.append('.');
sb.append(column);
super.put(sb.toString(),
new Criterion(table, column, value, comparison));
return this;
}
/**
* Convenience method to add a boolean to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Boolean(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A Boolean.
*
* @return A modified Criteria object.
*/
public Criteria add(String column, boolean value)
{
add(column, (value ? Boolean.TRUE : Boolean.FALSE));
return this;
}
/**
* Convenience method to add a boolean to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Boolean(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A Boolean.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria add(String column, boolean value, SqlEnum comparison)
{
add(column, new Boolean(value), comparison);
return this;
}
/**
* Convenience method to add an int to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Integer(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value An int.
* @return A modified Criteria object.
*/
public Criteria add(String column, int value)
{
add(column, new Integer(value));
return this;
}
/**
* Convenience method to add an int to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Integer(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value An int.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria add(String column, int value, SqlEnum comparison)
{
add(column, new Integer(value), comparison);
return this;
}
/**
* Convenience method to add a long to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Long(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A long.
* @return A modified Criteria object.
*/
public Criteria add(String column, long value)
{
add(column, new Long(value));
return this;
}
/**
* Convenience method to add a long to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Long(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A long.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria add(String column, long value, SqlEnum comparison)
{
add(column, new Long(value), comparison);
return this;
}
/**
* Convenience method to add a float to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Float(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A float.
* @return A modified Criteria object.
*/
public Criteria add(String column, float value)
{
add(column, new Float(value));
return this;
}
/**
* Convenience method to add a float to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Float(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A float.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria add(String column, float value, SqlEnum comparison)
{
add(column, new Float(value), comparison);
return this;
}
/**
* Convenience method to add a double to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Double(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A double.
* @return A modified Criteria object.
*/
public Criteria add(String column, double value)
{
add(column, new Double(value));
return this;
}
/**
* Convenience method to add a double to Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new Double(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A double.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria add(String column, double value, SqlEnum comparison)
{
add(column, new Double(value), comparison);
return this;
}
/**
* Convenience method to add a Date object specified by
* year, month, and date into the Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new GregorianCalendar(year, month,date), EQUAL);
* </code>
*
* @param column A String value to use as column.
* @param year An int with the year.
* @param month An int with the month. Month value is 0-based.
* e.g., 0 for January
* @param date An int with the date.
* @return A modified Criteria object.
*/
public Criteria addDate(String column, int year, int month, int date)
{
add(column, new GregorianCalendar(year, month, date).getTime());
return this;
}
/**
* Convenience method to add a Date object specified by
* year, month, and date into the Criteria.
* Equal to
*
* <p>
* <code>
* add(column, new GregorianCalendar(year, month,date), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param year An int with the year.
* @param month An int with the month. Month value is 0-based.
* e.g., 0 for January
* @param date An int with the date.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria addDate(String column, int year, int month, int date,
SqlEnum comparison)
{
add(column, new GregorianCalendar(year, month, date).getTime(),
comparison);
return this;
}
/**
* This is the way that you should add a join of two tables. For
* example:
*
* <p>
* AND PROJECT.PROJECT_ID=FOO.PROJECT_ID
* <p>
*
* left = PROJECT.PROJECT_ID
* right = FOO.PROJECT_ID
*
* @param left A String with the left side of the join.
* @param right A String with the right side of the join.
* @return A modified Criteria object.
*/
public Criteria addJoin(String left, String right)
{
return addJoin(left, right, null);
}
/**
* This is the way that you should add a join of two tables. For
* example:
*
* <p>
* PROJECT LEFT JOIN FOO ON PROJECT.PROJECT_ID=FOO.PROJECT_ID
* <p>
*
* left = "PROJECT.PROJECT_ID"
* right = "FOO.PROJECT_ID"
* operator = Criteria.LEFT_JOIN
*
* @param left A String with the left side of the join.
* @param right A String with the right side of the join.
* @param operator The operator used for the join: must be one of null,
* Criteria.LEFT_JOIN, Criteria.RIGHT_JOIN, Criteria.INNER_JOIN
* @return A modified Criteria object.
*/
public Criteria addJoin(String left, String right, SqlEnum operator)
{
joins.add(new Join(left, right, operator));
return this;
}
/**
* get the List of Joins. This method is meant to
* be called by BasePeer.
* @return a List which contains objects of type Join.
* If the criteria does not contains any joins, the list is empty
*/
public List getJoins()
{
return joins;
}
/**
* get one side of the set of possible joins. This method is meant to
* be called by BasePeer.
*
* @deprecated This method is no longer used by BasePeer.
*/
public List getJoinL()
{
throw new RuntimeException("getJoinL() in Criteria is no longer supported!");
}
/**
* get one side of the set of possible joins. This method is meant to
* be called by BasePeer.
*
* @deprecated This method is no longer used by BasePeer.
*/
public List getJoinR()
{
throw new RuntimeException("getJoinL() in Criteria is no longer supported!");
}
/**
* Adds an 'IN' clause with the criteria supplied as an Object
* array. For example:
*
* <p>
* FOO.NAME IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* replaced.
*
* @param column The column to run the comparison on
* @param values An Object[] with the allowed values.
* @return A modified Criteria object.
*/
public Criteria addIn(String column, Object[] values)
{
add(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as an int array.
* For example:
*
* <p>
* FOO.ID IN ('2', '3', '7')
* <p>
*
* where 'values' contains those three integers.
*
* If a criterion for the requested column already exists, it is
* replaced.
*
* @param column The column to run the comparison on
* @param values An int[] with the allowed values.
* @return A modified Criteria object.
*/
public Criteria addIn(String column, int[] values)
{
add(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as a List.
* For example:
*
* <p>
* FOO.NAME IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* replaced.
*
* @param column The column to run the comparison on
* @param values A List with the allowed values.
* @return A modified Criteria object.
*/
public Criteria addIn(String column, List values)
{
add(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as an Object
* array. For example:
*
* <p>
* FOO.NAME NOT IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* replaced.
*
* @param column The column to run the comparison on
* @param values An Object[] with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria addNotIn(String column, Object[] values)
{
add(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as an int
* array. For example:
*
* <p>
* FOO.ID NOT IN ('2', '3', '7')
* <p>
*
* where 'values' contains those three integers.
*
* If a criterion for the requested column already exists, it is
* replaced.
*
* @param column The column to run the comparison on
* @param values An int[] with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria addNotIn(String column, int[] values)
{
add(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as a List.
* For example:
*
* <p>
* FOO.NAME NOT IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* replaced.
*
* @param column The column to run the comparison on
* @param values A List with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria addNotIn(String column, List values)
{
add(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds "ALL " to the SQL statement.
*/
public void setAll()
{
selectModifiers.add(ALL.toString());
}
/**
* Adds "DISTINCT " to the SQL statement.
*/
public void setDistinct()
{
selectModifiers.add(DISTINCT.toString());
}
/**
* Sets ignore case.
*
* @param b True if case should be ignored.
* @return A modified Criteria object.
*/
public Criteria setIgnoreCase(boolean b)
{
ignoreCase = b;
return this;
}
/**
* Is ignore case on or off?
*
* @return True if case is ignored.
*/
public boolean isIgnoreCase()
{
return ignoreCase;
}
/**
* Set single record? Set this to <code>true</code> if you expect the query
* to result in only a single result record (the default behaviour is to
* throw a TorqueException if multiple records are returned when the query
* is executed). This should be used in situations where returning multiple
* rows would indicate an error of some sort. If your query might return
* multiple records but you are only interested in the first one then you
* should be using setLimit(1).
*
* @param b set to <code>true</code> if you expect the query to select just
* one record.
* @return A modified Criteria object.
*/
public Criteria setSingleRecord(boolean b)
{
singleRecord = b;
return this;
}
/**
* Is single record?
*
* @return True if a single record is being returned.
*/
public boolean isSingleRecord()
{
return singleRecord;
}
/**
* Set cascade.
*
* @param b True if cascade is set.
* @return A modified Criteria object.
*/
public Criteria setCascade(boolean b)
{
cascade = b;
return this;
}
/**
* Is cascade set?
*
* @return True if cascade is set.
*/
public boolean isCascade()
{
return cascade;
}
/**
* Set limit.
*
* @param limit An int with the value for limit.
* @return A modified Criteria object.
*/
public Criteria setLimit(int limit)
{
this.limit = limit;
return this;
}
/**
* Get limit.
*
* @return An int with the value for limit.
*/
public int getLimit()
{
return limit;
}
/**
* Set offset.
*
* @param offset An int with the value for offset.
* @return A modified Criteria object.
*/
public Criteria setOffset(int offset)
{
this.offset = offset;
return this;
}
/**
* Get offset.
*
* @return An int with the value for offset.
*/
public int getOffset()
{
return offset;
}
/**
* Add select column.
*
* @param name A String with the name of the select column.
* @return A modified Criteria object.
*/
public Criteria addSelectColumn(String name)
{
selectColumns.add(name);
return this;
}
/**
* Get select columns.
*
* @return An StringStack with the name of the select
* columns.
*/
public UniqueList getSelectColumns()
{
return selectColumns;
}
/**
* Get select modifiers.
*
* @return An UniqueList with the select modifiers.
*/
public UniqueList getSelectModifiers()
{
return selectModifiers;
}
/**
* Add group by column name.
*
* @param groupBy The name of the column to group by.
* @return A modified Criteria object.
*/
public Criteria addGroupByColumn(String groupBy)
{
groupByColumns.add(groupBy);
return this;
}
/**
* Add order by column name, explicitly specifying ascending.
*
* @param name The name of the column to order by.
* @return A modified Criteria object.
*/
public Criteria addAscendingOrderByColumn(String name)
{
orderByColumns.add(name + ' ' + ASC);
return this;
}
/**
* Add order by column name, explicitly specifying descending.
*
* @param name The name of the column to order by.
* @return A modified Criteria object.
*/
public Criteria addDescendingOrderByColumn(String name)
{
orderByColumns.add(name + ' ' + DESC);
return this;
}
/**
* Get order by columns.
*
* @return An UniqueList with the name of the order columns.
*/
public UniqueList getOrderByColumns()
{
return orderByColumns;
}
/**
* Get group by columns.
*
* @return An UniqueList with the name of the groupBy clause.
*/
public UniqueList getGroupByColumns()
{
return groupByColumns;
}
/**
* Get Having Criterion.
*
* @return A Criterion that is the having clause.
*/
public Criterion getHaving()
{
return having;
}
/**
* Remove an object from the criteria.
*
* @param key A String with the key to be removed.
* @return The removed object.
*/
public Object remove(String key)
{
Object foo = super.remove(key);
if (foo instanceof Criterion)
{
return ((Criterion) foo).getValue();
}
return foo;
}
/**
* Build a string representation of the Criteria.
*
* @return A String with the representation of the Criteria.
*/
public String toString()
{
StringBuffer sb = new StringBuffer("Criteria:: ");
Iterator it = keySet().iterator();
while (it.hasNext())
{
String key = (String) it.next();
sb.append(key).append("<=>")
.append(super.get(key).toString()).append(": ");
}
try
{
sb.append("\nCurrent Query SQL (may not be complete or applicable): ")
.append(BasePeer.createQueryDisplayString(this));
}
catch (Exception exc)
{
log.debug("Exception when evaluating a Criteria", exc);
}
return sb.toString();
}
/**
* This method checks another Criteria to see if they contain
* the same attributes and hashtable entries.
*/
public boolean equals(Object crit)
{
boolean isEquiv = false;
if (crit == null || !(crit instanceof Criteria))
{
isEquiv = false;
}
else if (this == crit)
{
isEquiv = true;
}
else if (this.size() == ((Criteria) crit).size())
{
Criteria criteria = (Criteria) crit;
if (this.offset == criteria.getOffset()
&& this.limit == criteria.getLimit()
&& ignoreCase == criteria.isIgnoreCase()
&& singleRecord == criteria.isSingleRecord()
&& cascade == criteria.isCascade()
&& dbName.equals(criteria.getDbName())
&& selectModifiers.equals(criteria.getSelectModifiers())
&& selectColumns.equals(criteria.getSelectColumns())
&& orderByColumns.equals(criteria.getOrderByColumns())
&& aliases.equals(criteria.getAliases())
&& asColumns.equals(criteria.getAsColumns())
&& joins.equals(criteria.getJoins())
)
{
isEquiv = true;
for (Iterator it = criteria.keySet().iterator(); it.hasNext();)
{
String key = (String) it.next();
if (this.containsKey(key))
{
Criterion a = this.getCriterion(key);
Criterion b = criteria.getCriterion(key);
if (!a.equals(b))
{
isEquiv = false;
break;
}
}
else
{
isEquiv = false;
break;
}
}
}
}
return isEquiv;
}
/**
* Returns the hash code value for this Join.
*
* @return a hash code value for this object.
*/
public int hashCode()
{
int result = 16;
result = 37 * result + offset;
result = 37 * result + limit;
result = 37 * result + (ignoreCase ? 0 : 1);
result = 37 * result + (singleRecord ? 0 : 1);
result = 37 * result + (cascade ? 0 : 1);
result = 37 * result + dbName.hashCode();
result = 37 * result + selectModifiers.hashCode();
result = 37 * result + selectColumns.hashCode();
result = 37 * result + orderByColumns.hashCode();
result = 37 * result + aliases.hashCode();
result = 37 * result + asColumns.hashCode();
result = 37 * result + joins.hashCode();
result = 37 * result + super.hashCode();
return result;
}
/*
* ------------------------------------------------------------------------
*
* Start of the "and" methods
*
* ------------------------------------------------------------------------
*/
/**
* This method adds a prepared Criterion object to the Criteria as a having
* clause. You can get a new, empty Criterion object with the
* getNewCriterion() method.
*
* <p>
* <code>
* Criteria crit = new Criteria();
* Criteria.Criterion c = crit.getNewCriterion(BasePeer.ID, new Integer(5),
* Criteria.LESS_THAN);
* crit.addHaving(c);
* </code>
*
* @param having A Criterion object
* @return A modified Criteria object.
*/
public Criteria addHaving(Criterion having)
{
this.having = having;
return this;
}
/**
* This method adds a prepared Criterion object to the Criteria.
* You can get a new, empty Criterion object with the
* getNewCriterion() method. If a criterion for the requested column
* already exists, it is "AND"ed to the existing criterion.
* This is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria();
* Criteria.Criterion c = crit.getNewCriterion(BasePeer.ID, new Integer(5),
* Criteria.LESS_THAN);
* crit.and(c);
* </code>
*
* @param c A Criterion object
* @return A modified Criteria object.
*/
public Criteria and(Criterion c)
{
Criterion oc = getCriterion(c.getTable() + '.' + c.getColumn());
if (oc == null)
{
add(c);
}
else
{
oc.and(c);
}
return this;
}
/**
* This method adds a new criterion to the list of criterias. If a
* criterion for the requested column already exists, it is
* "AND"ed to the existing criterion. This is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().and("column",
* "value");
* </code>
*
* An EQUAL comparison is used for column and value.
*
* The name of the table must be used implicitly in the column name,
* so the Column name must be something like 'TABLE.id'. If you
* don't like this, you can use the and(table, column, value) method.
*
* @param column The column to run the comparison on
* @param value An Object.
*
* @return A modified Criteria object.
*/
public Criteria and(String column, Object value)
{
and(column, value, EQUAL);
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion. If is used as follow:
*
* <p>
* <code>
* Criteria crit = new Criteria().and("column",
* "value"
* Criteria.GREATER_THAN);
* </code>
*
* Any comparison can be used.
*
* The name of the table must be used implicitly in the column name,
* so the Column name must be something like 'TABLE.id'. If you
* don't like this, you can use the and(table, column, value) method.
*
* @param column The column to run the comparison on
* @param value An Object.
* @param comparison A String.
*
* @return A modified Criteria object.
*/
public Criteria and(String column, Object value, SqlEnum comparison)
{
Criterion oc = getCriterion(column);
Criterion nc = new Criterion(column, value, comparison);
if (oc == null)
{
super.put(column, nc);
}
else
{
oc.and(nc);
}
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion. If is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().and("table",
* "column",
* "value");
* </code>
*
* An EQUAL comparison is used for column and value.
*
* @param table Name of the table which contains the column
* @param column The column to run the comparison on
* @param value An Object.
* @return A modified Criteria object.
*/
public Criteria and(String table, String column, Object value)
{
and(table, column, value, EQUAL);
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion. If is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().and("table",
* "column",
* "value",
* "Criterion.GREATER_THAN");
* </code>
*
* Any comparison can be used.
*
* @param table Name of table which contains the column
* @param column The column to run the comparison on
* @param value An Object.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria and(String table, String column, Object value,
SqlEnum comparison)
{
StringBuffer sb = new StringBuffer(table.length()
+ column.length() + 1);
sb.append(table);
sb.append('.');
sb.append(column);
Criterion oc = getCriterion(table, column);
Criterion nc = new Criterion(table, column, value, comparison);
if (oc == null)
{
super.put(sb.toString(), nc);
}
else
{
oc.and(nc);
}
return this;
}
/**
* Convenience method to add a boolean to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Boolean(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A Boolean.
* @return A modified Criteria object.
*/
public Criteria and(String column, boolean value)
{
and(column, new Boolean(value));
return this;
}
/**
* Convenience method to add a boolean to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Boolean(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A Boolean.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria and(String column, boolean value, SqlEnum comparison)
{
and(column, new Boolean(value), comparison);
return this;
}
/**
* Convenience method to add an int to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Integer(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value An int.
* @return A modified Criteria object.
*/
public Criteria and(String column, int value)
{
and(column, new Integer(value));
return this;
}
/**
* Convenience method to add an int to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Integer(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value An int.
* @param comparison String describing how to compare the column with the value
* @return A modified Criteria object.
*/
public Criteria and(String column, int value, SqlEnum comparison)
{
and(column, new Integer(value), comparison);
return this;
}
/**
* Convenience method to add a long to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Long(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A long.
* @return A modified Criteria object.
*/
public Criteria and(String column, long value)
{
and(column, new Long(value));
return this;
}
/**
* Convenience method to add a long to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Long(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A long.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria and(String column, long value, SqlEnum comparison)
{
and(column, new Long(value), comparison);
return this;
}
/**
* Convenience method to add a float to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Float(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A float.
* @return A modified Criteria object.
*/
public Criteria and(String column, float value)
{
and(column, new Float(value));
return this;
}
/**
* Convenience method to add a float to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Float(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A float.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria and(String column, float value, SqlEnum comparison)
{
and(column, new Float(value), comparison);
return this;
}
/**
* Convenience method to add a double to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Double(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A double.
* @return A modified Criteria object.
*/
public Criteria and(String column, double value)
{
and(column, new Double(value));
return this;
}
/**
* Convenience method to add a double to Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new Double(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A double.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria and(String column, double value, SqlEnum comparison)
{
and(column, new Double(value), comparison);
return this;
}
/**
* Convenience method to add a Date object specified by
* year, month, and date into the Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new GregorianCalendar(year, month,date), EQUAL);
* </code>
*
* @param column A String value to use as column.
* @param year An int with the year.
* @param month An int with the month.
* @param date An int with the date.
* @return A modified Criteria object.
*/
public Criteria andDate(String column, int year, int month, int date)
{
and(column, new GregorianCalendar(year, month, date).getTime());
return this;
}
/**
* Convenience method to add a Date object specified by
* year, month, and date into the Criteria.
* Equal to
*
* <p>
* <code>
* and(column, new GregorianCalendar(year, month,date), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param year An int with the year.
* @param month An int with the month.
* @param date An int with the date.
* @param comparison String describing how to compare the column with
* the value
* @return A modified Criteria object.
*/
public Criteria andDate(String column, int year, int month, int date,
SqlEnum comparison)
{
and(column, new GregorianCalendar(year, month, date).getTime(), comparison);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as an Object array.
* For example:
*
* <p>
* FOO.NAME IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An Object[] with the allowed values.
* @return A modified Criteria object.
*/
public Criteria andIn(String column, Object[] values)
{
and(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as an int array.
* For example:
*
* <p>
* FOO.ID IN ('2', '3', '7')
* <p>
*
* where 'values' contains those three integers.
*
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An int[] with the allowed values.
* @return A modified Criteria object.
*/
public Criteria andIn(String column, int[] values)
{
and(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as a List.
* For example:
*
* <p>
* FOO.NAME IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values A List with the allowed values.
* @return A modified Criteria object.
*/
public Criteria andIn(String column, List values)
{
and(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as an Object
* array. For example:
*
* <p>
* FOO.NAME NOT IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An Object[] with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria andNotIn(String column, Object[] values)
{
and(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as an int
* array. For example:
*
* <p>
* FOO.ID NOT IN ('2', '3', '7')
* <p>
*
* where 'values' contains those three integers.
*
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An int[] with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria andNotIn(String column, int[] values)
{
and(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as a List.
* For example:
*
* <p>
* FOO.NAME NOT IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "AND"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values A List with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria andNotIn(String column, List values)
{
and(column, (Object) values, Criteria.NOT_IN);
return this;
}
/*
* ------------------------------------------------------------------------
*
* Start of the "or" methods
*
* ------------------------------------------------------------------------
*/
/**
* This method adds a prepared Criterion object to the Criteria.
* You can get a new, empty Criterion object with the
* getNewCriterion() method. If a criterion for the requested column
* already exists, it is "OR"ed to the existing criterion.
* This is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria();
* Criteria.Criterion c = crit.getNewCriterion(BasePeer.ID, new Integer(5), Criteria.LESS_THAN);
* crit.or(c);
* </code>
*
* @param c A Criterion object
* @return A modified Criteria object.
*/
public Criteria or(Criterion c)
{
Criterion oc = getCriterion(c.getTable() + '.' + c.getColumn());
if (oc == null)
{
add(c);
}
else
{
oc.or(c);
}
return this;
}
/**
* This method adds a new criterion to the list of criterias. If a
* criterion for the requested column already exists, it is
* "OR"ed to the existing criterion. This is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().or("column",
* "value");
* </code>
*
* An EQUAL comparison is used for column and value.
*
* The name of the table must be used implicitly in the column name,
* so the Column name must be something like 'TABLE.id'. If you
* don't like this, you can use the or(table, column, value) method.
*
* @param column The column to run the comparison on
* @param value An Object.
*
* @return A modified Criteria object.
*/
public Criteria or(String column, Object value)
{
or(column, value, EQUAL);
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion. If is used as follow:
*
* <p>
* <code>
* Criteria crit = new Criteria().or("column",
* "value"
* "Criterion.GREATER_THAN");
* </code>
*
* Any comparison can be used.
*
* The name of the table must be used implicitly in the column name,
* so the Column name must be something like 'TABLE.id'. If you
* don't like this, you can use the or(table, column, value) method.
*
* @param column The column to run the comparison on
* @param value An Object.
* @param comparison A String.
* @return A modified Criteria object.
*/
public Criteria or(String column, Object value, SqlEnum comparison)
{
Criterion oc = getCriterion(column);
Criterion nc = new Criterion(column, value, comparison);
if (oc == null)
{
super.put(column, nc);
}
else
{
oc.or(nc);
}
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion. If is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().or("table",
* "column",
* "value");
* </code>
*
* An EQUAL comparison is used for column and value.
*
* @param table Name of the table which contains the column
* @param column The column to run the comparison on
* @param value An Object.
* @return A modified Criteria object.
*/
public Criteria or(String table, String column, Object value)
{
or(table, column, value, EQUAL);
return this;
}
/**
* This method adds a new criterion to the list of criterias.
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion. If is used as follows:
*
* <p>
* <code>
* Criteria crit = new Criteria().or("table",
* "column",
* "value",
* "Criterion.GREATER_THAN");
* </code>
*
* Any comparison can be used.
*
* @param table Name of table which contains the column
* @param column The column to run the comparison on
* @param value An Object.
* @param comparison String describing how to compare the column with the value
* @return A modified Criteria object.
*/
public Criteria or(String table, String column, Object value,
SqlEnum comparison)
{
StringBuffer sb = new StringBuffer(table.length() + column.length() + 1);
sb.append(table);
sb.append('.');
sb.append(column);
Criterion oc = getCriterion(table, column);
Criterion nc = new Criterion(table, column, value, comparison);
if (oc == null)
{
super.put(sb.toString(), nc);
}
else
{
oc.or(nc);
}
return this;
}
/**
* Convenience method to add a boolean to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Boolean(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A Boolean.
* @return A modified Criteria object.
*/
public Criteria or(String column, boolean value)
{
or(column, new Boolean(value));
return this;
}
/**
* Convenience method to add a boolean to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Boolean(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A Boolean.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria or(String column, boolean value, SqlEnum comparison)
{
or(column, new Boolean(value), comparison);
return this;
}
/**
* Convenience method to add an int to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Integer(value), EQUAL);
* </code>
*
*
* @param column The column to run the comparison on
* @param value An int.
* @return A modified Criteria object.
*/
public Criteria or(String column, int value)
{
or(column, new Integer(value));
return this;
}
/**
* Convenience method to add an int to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Integer(value), comparison);
* </code>
*
*
* @param column The column to run the comparison on
* @param value An int.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria or(String column, int value, SqlEnum comparison)
{
or(column, new Integer(value), comparison);
return this;
}
/**
* Convenience method to add a long to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Long(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A long.
* @return A modified Criteria object.
*/
public Criteria or(String column, long value)
{
or(column, new Long(value));
return this;
}
/**
* Convenience method to add a long to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Long(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A long.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria or(String column, long value, SqlEnum comparison)
{
or(column, new Long(value), comparison);
return this;
}
/**
* Convenience method to add a float to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Float(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A float.
* @return A modified Criteria object.
*/
public Criteria or(String column, float value)
{
or(column, new Float(value));
return this;
}
/**
* Convenience method to add a float to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Float(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A float.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria or(String column, float value, SqlEnum comparison)
{
or(column, new Float(value), comparison);
return this;
}
/**
* Convenience method to add a double to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Double(value), EQUAL);
* </code>
*
* @param column The column to run the comparison on
* @param value A double.
* @return A modified Criteria object.
*/
public Criteria or(String column, double value)
{
or(column, new Double(value));
return this;
}
/**
* Convenience method to add a double to Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new Double(value), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param value A double.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria or(String column, double value, SqlEnum comparison)
{
or(column, new Double(value), comparison);
return this;
}
/**
* Convenience method to add a Date object specified by
* year, month, and date into the Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new GregorianCalendar(year, month,date), EQUAL);
* </code>
*
* @param column A String value to use as column.
* @param year An int with the year.
* @param month An int with the month.
* @param date An int with the date.
* @return A modified Criteria object.
*/
public Criteria orDate(String column, int year, int month, int date)
{
or(column, new GregorianCalendar(year, month, date));
return this;
}
/**
* Convenience method to add a Date object specified by
* year, month, and date into the Criteria.
* Equal to
*
* <p>
* <code>
* or(column, new GregorianCalendar(year, month,date), comparison);
* </code>
*
* @param column The column to run the comparison on
* @param year An int with the year.
* @param month An int with the month.
* @param date An int with the date.
* @param comparison String describing how to compare the column
* with the value
* @return A modified Criteria object.
*/
public Criteria orDate(String column, int year, int month, int date,
SqlEnum comparison)
{
or(column, new GregorianCalendar(year, month, date), comparison);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as an Object
* array. For example:
*
* <p>
* FOO.NAME IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An Object[] with the allowed values.
* @return A modified Criteria object.
*/
public Criteria orIn(String column, Object[] values)
{
or(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as an int array.
* For example:
*
* <p>
* FOO.ID IN ('2', '3', '7')
* <p>
*
* where 'values' contains those three integers.
*
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An int[] with the allowed values.
* @return A modified Criteria object.
*/
public Criteria orIn(String column, int[] values)
{
or(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds an 'IN' clause with the criteria supplied as a List.
* For example:
*
* <p>
* FOO.NAME IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values A List with the allowed values.
* @return A modified Criteria object.
*/
public Criteria orIn(String column, List values)
{
or(column, (Object) values, Criteria.IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as an Object
* array. For example:
*
* <p>
* FOO.NAME NOT IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An Object[] with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria orNotIn(String column, Object[] values)
{
or(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as an int
* array. For example:
*
* <p>
* FOO.ID NOT IN ('2', '3', '7')
* <p>
*
* where 'values' contains those three integers.
*
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values An int[] with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria orNotIn(String column, int[] values)
{
or(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Adds a 'NOT IN' clause with the criteria supplied as a List.
* For example:
*
* <p>
* FOO.NAME NOT IN ('FOO', 'BAR', 'ZOW')
* <p>
*
* where 'values' contains three objects that evaluate to the
* respective strings above when .toString() is called.
*
* If a criterion for the requested column already exists, it is
* "OR"ed to the existing criterion.
*
* @param column The column to run the comparison on
* @param values A List with the disallowed values.
* @return A modified Criteria object.
*/
public Criteria orNotIn(String column, List values)
{
or(column, (Object) values, Criteria.NOT_IN);
return this;
}
/**
* Serializes this Criteria.
*
* @param s The output stream.
* @throws IOException if an IO error occurs.
*/
private void writeObject(ObjectOutputStream s) throws IOException
{
s.defaultWriteObject();
// Joins need to be serialized manually.
ArrayList serializableJoins = null;
if (!joins.isEmpty())
{
serializableJoins = new ArrayList(joins.size());
for (Iterator jonisIter = joins.iterator(); jonisIter.hasNext();)
{
Join join = (Join) jonisIter.next();
ArrayList joinContent = new ArrayList(3);
joinContent.add(join.getLeftColumn());
joinContent.add(join.getRightColumn());
joinContent.add(join.getJoinType());
serializableJoins.add(joinContent);
}
}
s.writeObject(serializableJoins);
}
/**
* Deserialize a Criteria.
*
* @param s The input stream.
* @throws IOException if an IO error occurs.
* @throws ClassNotFoundException if the class cannot be located.
*/
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
// Criteria.put() differs somewhat from Hashtable.put().
// This necessitates some corrective behavior upon deserialization.
for (Iterator iter = keySet().iterator(); iter.hasNext();)
{
Object key = iter.next();
Object value = get(key);
if (value instanceof Criteria.Criterion)
{
super.put(key, value);
}
}
// Joins need to be deserialized manually.
this.joins = new ArrayList(3);
ArrayList joins = (ArrayList) s.readObject();
if (joins != null)
{
for (int i = 0; i < joins.size(); i++)
{
ArrayList joinContent = (ArrayList) joins.get(i);
String leftColumn = (String) joinContent.get(0);
String rightColumn = (String) joinContent.get(1);
SqlEnum joinType = null;
Object joinTypeObj = joinContent.get(2);
if (joinTypeObj != null)
{
joinType = (SqlEnum) joinTypeObj;
}
addJoin(leftColumn, rightColumn, joinType);
}
}
}
/**
* This is an inner class that describes an object in the criteria.
*/
public final class Criterion implements Serializable
{
/** Serial version. */
private static final long serialVersionUID = 7157097965404611710L;
public static final String AND = " AND ";
public static final String OR = " OR ";
/** Value of the CO. */
private Object value;
/** Comparison value. */
private SqlEnum comparison;
/** Table name. */
private String table;
/** Column name. */
private String column;
/** flag to ignore case in comparision */
private boolean ignoreStringCase = false;
/**
* The DB adaptor which might be used to get db specific
* variations of sql.
*/
private DB db;
/**
* other connected criteria and their conjunctions.
*/
private List clauses = new ArrayList();
private List conjunctions = new ArrayList();
/**
* Creates a new instance, initializing a couple members.
*/
private Criterion(Object val, SqlEnum comp)
{
this.value = val;
this.comparison = comp;
}
/**
* Create a new instance.
*
* @param table A String with the name of the table.
* @param column A String with the name of the column.
* @param val An Object with the value for the Criteria.
* @param comp A String with the comparison value.
*/
Criterion(String table, String column, Object val, SqlEnum comp)
{
this(val, comp);
this.table = (table == null ? "" : table);
this.column = (column == null ? "" : column);
}
/**
* Create a new instance.
*
* @param tableColumn A String with the full name of the
* column.
* @param val An Object with the value for the Criteria.
* @param comp A String with the comparison value.
*/
Criterion(String tableColumn, Object val, SqlEnum comp)
{
this(val, comp);
int dot = tableColumn.lastIndexOf('.');
if (dot == -1)
{
table = "";
column = tableColumn;
}
else
{
table = tableColumn.substring(0, dot);
column = tableColumn.substring(dot + 1);
}
}
/**
* Create a new instance.
*
* @param table A String with the name of the table.
* @param column A String with the name of the column.
* @param val An Object with the value for the Criteria.
*/
Criterion(String table, String column, Object val)
{
this(table, column, val, EQUAL);
}
/**
* Create a new instance.
*
* @param tableColumn A String with the full name of the
* column.
* @param val An Object with the value for the Criteria.
*/
Criterion(String tableColumn, Object val)
{
this(tableColumn, val, EQUAL);
}
/**
* Get the column name.
*
* @return A String with the column name.
*/
public String getColumn()
{
return this.column;
}
/**
* Set the table name.
*
* @param name A String with the table name.
*/
public void setTable(String name)
{
this.table = name;
}
/**
* Get the table name.
*
* @return A String with the table name.
*/
public String getTable()
{
return this.table;
}
/**
* Get the comparison.
*
* @return A String with the comparison.
*/
public SqlEnum getComparison()
{
return this.comparison;
}
/**
* Get the value.
*
* @return An Object with the value.
*/
public Object getValue()
{
return this.value;
}
/**
* Set the value of the criterion.
*
* @param value the new value.
*/
public void setValue(Object value)
{
this.value = value;
}
/**
* Get the value of db.
* The DB adaptor which might be used to get db specific
* variations of sql.
* @return value of db.
*/
public DB getDb()
{
DB db = null;
if (this.db == null)
{
// db may not be set if generating preliminary sql for
// debugging.
try
{
db = Torque.getDB(getDbName());
}
catch (Exception e)
{
// we are only doing this to allow easier debugging, so
// no need to throw up the exception, just make note of it.
log.error(
"Could not get a DB adapter, so sql may be wrong");
}
}
else
{
db = this.db;
}
return db;
}
/**
* Set the value of db.
* The DB adaptor might be used to get db specific
* variations of sql.
* @param v Value to assign to db.
*/
public void setDB(DB v)
{
this.db = v;
for (int i = 0; i < this.clauses.size(); i++)
{
((Criterion) (clauses.get(i))).setDB(v);
}
}
/**
* Sets ignore case.
*
* @param b True if case should be ignored.
* @return A modified Criteria object.
*/
public Criterion setIgnoreCase(boolean b)
{
ignoreStringCase = b;
return this;
}
/**
* Is ignore case on or off?
*
* @return True if case is ignored.
*/
public boolean isIgnoreCase()
{
return ignoreStringCase;
}
/**
* get the list of clauses in this Criterion
*/
private List getClauses()
{
return clauses;
}
/**
* get the list of conjunctions in this Criterion
*/
private List getConjunctions()
{
return conjunctions;
}
/**
* Append an AND Criterion onto this Criterion's list.
*/
public Criterion and(Criterion criterion)
{
this.clauses.add(criterion);
this.conjunctions.add(AND);
return this;
}
/**
* Append an OR Criterion onto this Criterion's list.
*/
public Criterion or(Criterion criterion)
{
this.clauses.add(criterion);
this.conjunctions.add(OR);
return this;
}
/**
* Appends a representation of the Criterion onto the buffer.
*/
public void appendTo(StringBuffer sb) throws TorqueException
{
//
// it is alright if value == null
//
if (column == null)
{
return;
}
Criterion clause = null;
for (int j = 0; j < this.clauses.size(); j++)
{
sb.append('(');
}
if (CUSTOM == comparison)
{
if (value != null && !"".equals(value))
{
sb.append((String) value);
}
}
else
{
String field = null;
if (table == null)
{
field = column;
}
else
{
field = new StringBuffer(
table.length() + 1 + column.length())
.append(table).append('.').append(column)
.toString();
}
SqlExpression.build(field, value, comparison,
ignoreStringCase || ignoreCase, getDb(), sb);
}
for (int i = 0; i < this.clauses.size(); i++)
{
sb.append(this.conjunctions.get(i));
clause = (Criterion) (this.clauses.get(i));
clause.appendTo(sb);
sb.append(')');
}
}
/**
* Appends a Prepared Statement representation of the Criterion
* onto the buffer.
*
* @param sb The stringbuffer that will receive the Prepared Statement
* @param params A list to which Prepared Statement parameters
* will be appended
*/
public void appendPsTo(StringBuffer sb, List params)
{
if (column == null || value == null)
{
return;
}
DB db = getDb();
for (int j = 0; j < this.clauses.size(); j++)
{
sb.append('(');
}
if (CUSTOM == comparison)
{
if (!"".equals(value))
{
sb.append((String) value);
}
}
else
{
String field = null;
if (table == null)
{
field = column;
}
else
{
field = new StringBuffer(
table.length() + 1 + column.length())
.append(table).append('.').append(column)
.toString();
}
if (comparison.equals(Criteria.IN)
|| comparison.equals(Criteria.NOT_IN))
{
sb.append(field)
.append(comparison);
UniqueList inClause = new UniqueList();
if (value instanceof List)
{
value = ((List) value).toArray (new Object[0]);
}
for (int i = 0; i < Array.getLength(value); i++)
{
Object item = Array.get(value, i);
inClause.add(SqlExpression.processInValue(item,
ignoreStringCase || ignoreCase,
db));
}
StringBuffer inString = new StringBuffer();
inString.append('(').append(StringUtils.join(
inClause.iterator(), (","))).append(')');
sb.append(inString.toString());
}
else
{
if (ignoreStringCase || ignoreCase)
{
sb.append(db.ignoreCase(field))
.append(comparison)
.append(db.ignoreCase("?"));
}
else
{
sb.append(field)
.append(comparison)
.append(" ? ");
}
if (value instanceof java.util.Date)
{
params.add(new java.sql.Date(
((java.util.Date) value).getTime()));
}
else if (value instanceof DateKey)
{
params.add(new java.sql.Date(
((DateKey) value).getDate().getTime()));
}
else if (value instanceof Integer)
{
params.add(value);
}
else
{
params.add(value.toString());
}
}
}
for (int i = 0; i < this.clauses.size(); i++)
{
sb.append(this.conjunctions.get(i));
Criterion clause = (Criterion) (this.clauses.get(i));
clause.appendPsTo(sb, params);
sb.append(')');
}
}
/**
* Build a string representation of the Criterion.
*
* @return A String with the representation of the Criterion.
*/
public String toString()
{
//
// it is alright if value == null
//
if (column == null)
{
return "";
}
StringBuffer expr = new StringBuffer(25);
try
{
appendTo(expr);
}
catch (TorqueException e)
{
return "Criterion cannot be evaluated";
}
return expr.toString();
}
/**
* This method checks another Criteria.Criterion to see if they contain
* the same attributes and hashtable entries.
*/
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if ((obj == null) || !(obj instanceof Criterion))
{
return false;
}
Criterion crit = (Criterion) obj;
boolean isEquiv = ((table == null && crit.getTable() == null)
|| (table != null && table.equals(crit.getTable()))
)
&& column.equals(crit.getColumn())
&& comparison.equals(crit.getComparison());
// we need to check for value equality
if (isEquiv)
{
Object b = crit.getValue();
if (value instanceof Object[] && b instanceof Object[])
{
isEquiv &= Arrays.equals((Object[]) value, (Object[]) b);
}
else if (value instanceof int[] && b instanceof int[])
{
isEquiv &= Arrays.equals((int[]) value, (int[]) b);
}
else
{
isEquiv &= value.equals(b);
}
}
// check chained criterion
isEquiv &= this.clauses.size() == crit.getClauses().size();
for (int i = 0; i < this.clauses.size(); i++)
{
isEquiv &= ((String) (conjunctions.get(i)))
.equals((String) (crit.getConjunctions().get(i)));
isEquiv &= ((Criterion) (clauses.get(i)))
.equals((Criterion) (crit.getClauses().get(i)));
}
return isEquiv;
}
/**
* Returns a hash code value for the object.
*/
public int hashCode()
{
int h = value.hashCode() ^ comparison.hashCode();
if (table != null)
{
h ^= table.hashCode();
}
if (column != null)
{
h ^= column.hashCode();
}
for (int i = 0; i < this.clauses.size(); i++)
{
h ^= ((Criterion) (clauses.get(i))).hashCode();
}
return h;
}
/**
* get all tables from nested criterion objects
*
* @return the list of tables
*/
public List getAllTables()
{
UniqueList tables = new UniqueList();
addCriterionTable(this, tables);
return tables;
}
/**
* method supporting recursion through all criterions to give
* us a StringStack of tables from each criterion
*/
private void addCriterionTable(Criterion c, UniqueList s)
{
if (c != null)
{
s.add(c.getTable());
for (int i = 0; i < c.getClauses().size(); i++)
{
addCriterionTable((Criterion) (c.getClauses().get(i)), s);
}
}
}
/**
* get an array of all criterion attached to this
* recursing through all sub criterion
*/
public Criterion[] getAttachedCriterion()
{
ArrayList crits = new ArrayList();
traverseCriterion(this, crits);
Criterion[] crita = new Criterion[crits.size()];
for (int i = 0; i < crits.size(); i++)
{
crita[i] = (Criterion) crits.get(i);
}
return crita;
}
/**
* method supporting recursion through all criterions to give
* us an ArrayList of them
*/
private void traverseCriterion(Criterion c, ArrayList a)
{
if (c != null)
{
a.add(c);
for (int i = 0; i < c.getClauses().size(); i++)
{
traverseCriterion((Criterion) (c.getClauses().get(i)), a);
}
}
}
} // end of inner class Criterion
/**
* Data object to describe a join between two tables, for example
* <pre>
* table_a LEFT JOIN table_b ON table_a.id = table_b.a_id
* </pre>
* The class is immutable. Because the class is also used by
* {@link org.apache.torque.util.BasePeer}, it is visible from the package.
*/
public static class Join
{
/** the left column of the join condition */
private String leftColumn = null;
/** the right column of the join condition */
private String rightColumn = null;
/** the type of the join (LEFT JOIN, ...), or null */
private SqlEnum joinType = null;
/**
* Constructor
* @param leftColumn the left column of the join condition;
* might contain an alias name
* @param rightColumn the right column of the join condition
* might contain an alias name
* @param joinType the type of the join. Valid join types are
* null (adding the join condition to the where clause),
* SqlEnum.LEFT_JOIN, SqlEnum.RIGHT_JOIN, and SqlEnum.INNER_JOIN
*/
public Join(
final String leftColumn,
final String rightColumn,
final SqlEnum joinType)
{
this.leftColumn = leftColumn;
this.rightColumn = rightColumn;
this.joinType = joinType;
}
/**
* @return the type of the join, i.e. SqlEnum.LEFT_JOIN, ...,
* or null for adding the join condition to the where Clause
*/
public final SqlEnum getJoinType()
{
return joinType;
}
/**
* @return the left column of the join condition
*/
public final String getLeftColumn()
{
return leftColumn;
}
/**
* @return the right column of the join condition
*/
public final String getRightColumn()
{
return rightColumn;
}
/**
* returns a String representation of the class,
* mainly for debuggung purposes
* @return a String representation of the class
*/
public String toString()
{
StringBuffer result = new StringBuffer();
if (joinType != null)
{
result.append(joinType)
.append(" : ");
}
result.append(leftColumn)
.append("=")
.append(rightColumn)
.append(" (ignoreCase not considered)");
return result.toString();
}
/**
* This method checks another Criteria.Join to see if they contain the
* same attributes.
*/
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if ((obj == null) || !(obj instanceof Join))
{
return false;
}
Join join = (Join) obj;
return ObjectUtils.equals(leftColumn, join.getLeftColumn())
&& ObjectUtils.equals(rightColumn, join.getRightColumn())
&& ObjectUtils.equals(joinType, join.getJoinType());
}
/**
* Returns the hash code value for this Join.
*
* @return a hash code value for this object.
*/
public int hashCode()
{
int result = 13;
result = 37 * result + leftColumn.hashCode();
result = 37 * result + rightColumn.hashCode();
result = 37 * result + (null == joinType ? 0 : joinType.hashCode());
return result;
}
} // end of inner class Join
}