Java tutorial
package org.apache.torque.criteria; /* * 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.Serializable; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.apache.commons.collections.ListUtils; import org.apache.commons.lang.builder.EqualsBuilder; import org.apache.commons.lang.builder.HashCodeBuilder; import org.apache.torque.Column; /** * Describes one or more where clause parts in the Criteria. * Either the parts list is not null and represents this criterion * or the column, value, comparison and ignoreStringCase columns * are not null and represent this criterion. */ public class Criterion implements Serializable { /** Serial version. */ private static final long serialVersionUID = 7157097965404611710L; /** Constant for the operator " AND ". */ public static final String AND = " AND "; /** Constant for the operator " OR ". */ public static final String OR = " OR "; /** * Left-hand-side value of the comparison, may be null. * If this object implements the Column interface, it is interpreted as * a value computed by the database, otherwise as verbatim value. */ private Object lValue; /** Comparison operator. Can only be null if sql is not null. */ private SqlEnum comparison; /** * Right-hand-side value of the comparison, may be null. * If this object implements the Column interface, it is interpreted as * a value computed by the database, otherwise as verbatim value. */ private Object rValue; /** A verbatim SQL for this Criterion. */ private String sql; /** * Replacements for the placeholders in the verbatim SQL. * Is only used if sql is not null. */ private Object[] preparedStatementReplacements; /** Flag to ignore case in comparison */ private boolean ignoreCase = false; /** * The criterion objects which form a composite criterion. * Either this list is not null and represents this criterion * or the column, value, comparison and ignoreStringCase columns * are not null and represent this criterion. */ private List<Criterion> parts; /** * The operator (AND, OR...) how the composite criterions * are connected. */ private String conjunction; /** * Create a new instance. * Either this Criterion represents a comparison without verbatim SQL; * in this case the parameters lValue and comparison must be not null, * rValue may be not null and sql and preparedStatementReplacements must * be null; or it represents a verbatim sql condition, in which case * the parameter comparison must be null and the sql must be not null * (preparedStatementReplacements may be set to contain sql placeholder * replacement values, and lValue and rValue can be set to add columns * to the automatically computed from clause of the query). * * @param lValue the left hand side value of the comparison. * If this value should be a value from the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. * @param rValue the right hand side value of the comparison. * If this value should be a value from the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. * @param comparison The comparison operator. Either this parameter or * sql must be not null. * @param sql a verbatim sql condition. Either this parameter or * comparison must be not null. * @param preparedStatementReplacements Values for the placeholders * in the verbatim sql condition. * * @throws NullPointerException if column is null. */ public Criterion(Object lValue, Object rValue, SqlEnum comparison, String sql, Object[] preparedStatementReplacements) { if (comparison != null && (sql != null || preparedStatementReplacements != null)) { throw new IllegalArgumentException("Either comparison or " + "some of (sql, preparedStatementReplacements) " + "can be not null, not both"); } if ((lValue == null || comparison == null) && (sql == null)) { throw new IllegalArgumentException( "Either the values" + "(lValue, comparison) or " + "sql must be not null"); } this.lValue = lValue; this.comparison = comparison; this.rValue = rValue; this.sql = sql; this.preparedStatementReplacements = preparedStatementReplacements; } /** * Create a new instance without verbatim sql, using equals as * comparison operator. * * @param lValue the left hand side value of the comparison, not null. * If this value should be a value from the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. * @param rValue the right hand side value of the comparison. * If this value should be a value from the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. */ public Criterion(Object lValue, Object rValue) { this(lValue, rValue, Criteria.EQUAL, null, null); } /** * Create a new instance without verbatim sql. * * @param lValue the left hand side value of the comparison, not null. * If this value should be a value from the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. * @param rValue the right hand side value of the comparison. * If this value should be a value from the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. * @param comparison The comparison operator, not null. */ public Criterion(Object lValue, Object rValue, SqlEnum comparison) { this(lValue, rValue, comparison, null, null); } /** * Creates a shallow copy of the given Criterion. * * @param toCopy the Criterion to copy from, not null. */ public Criterion(Criterion toCopy) { this.lValue = toCopy.lValue; this.comparison = toCopy.comparison; this.rValue = toCopy.rValue; this.sql = toCopy.sql; this.preparedStatementReplacements = toCopy.preparedStatementReplacements; this.ignoreCase = toCopy.ignoreCase; if (toCopy.parts != null) { this.parts = new ArrayList<Criterion>(toCopy.parts.size()); for (Criterion part : toCopy.parts) { this.parts.add(new Criterion(part)); } } this.conjunction = toCopy.conjunction; } /** * Get the left hand side value of the comparison. * * @return the left hand side value of the comparison. * If this value is a value computed by the database, * the object implements the * <code>org.apache.torque.Column</code> interface. */ public Object getLValue() { return this.lValue; } /** * Set the left hand side value of the comparison. * * @param lValue the left hand side value of the comparison. * If this value is a value computed by the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. */ public void setLValue(Object lValue) { this.lValue = lValue; } /** * Get the comparison. * * @return A String with the comparison, or null if this * Criterion represents a verbatim sql condition. */ public SqlEnum getComparison() { return this.comparison; } /** * Get the right hand side value of the comparison. * * @return the right hand side value of the comparison. * If this value is a value computed by the database, * the object implements the * <code>org.apache.torque.Column</code> interface. */ public Object getRValue() { return this.rValue; } /** * Set the right hand side value of the comparison. * * @param rValue the right hand side value of the comparison. * If this value is a value computed by the database, * the object must implement the * <code>org.apache.torque.Column</code> interface. */ public void setRValue(Object rValue) { this.rValue = rValue; } /** * Returns the verbatim sql for this condition. * * @return the verbatim sql for this condition, or null if this * Criterion does not represent a verbatim sql condition. */ public String getSql() { return sql; } /** * Returns the prepared statement replacements for a verbatim sql condition. * * @return the replacement values, or null. */ public Object[] getPreparedStatementReplacements() { return preparedStatementReplacements; } /** * Returns whether this Criterion represents a verbatim sql condition. * * @return true if this Criterion represents a verbatim sql condition, * false if the sql is computed from lValue, comparison and rValue. */ public boolean isVerbatimSqlCondition() { return (sql != null); } /** * Sets ignore case. ignoreCase is ignored for a verbatim sql statement. * * @param b True if case should be ignored. * @return A modified Criterion object. */ public Criterion setIgnoreCase(boolean b) { ignoreCase = b; return this; } /** * Is ignore case on or off? * * @return True if case is ignored. */ public boolean isIgnoreCase() { return ignoreCase; } /** * Returns the parts of which this criterion consists. * * @return an unmodifiable list of the clauses, * or null if this criterion is not a composite criterion. */ public List<Criterion> getParts() { if (parts == null) { return null; } return Collections.unmodifiableList(parts); } /** * Returns the conjunction for the parts of this criterion * * @return the conjunction, or null if this criterion is not a * composite criterion. */ public String getConjunction() { return conjunction; } /** * Returns whether this criterion is a composite criterion. * * @return true if this criterion is a composite criterion, * false if it represents a single condition. */ public boolean isComposite() { return parts != null; } /** * Replaces this criterion's condition with * (this criterion's condition AND criterion). * * @param criterion the criterion to and with this criterion, * not null. */ public Criterion and(Criterion criterion) { addCompositeCriterion(criterion, AND); return this; } /** * Replaces this criterion's condition with * (this criterion's condition OR criterion). * * @param criterion the criterion to and with this criterion, * not null. */ public Criterion or(Criterion criterion) { addCompositeCriterion(criterion, OR); return this; } /** * Add a composite criterion to this criterion. * * @param criterion the criterion to add, not null. * @param conjunction the conjunction by which to add the criterion, * not null. * * @throws NullPointerException if criterion is null. */ private void addCompositeCriterion(Criterion criterion, String conjunction) { if (criterion == null) { throw new NullPointerException("criterion must not be null"); } if (isComposite() && this.conjunction.equals(conjunction)) { parts.add(new Criterion(criterion)); } else { Criterion copy = new Criterion(this); parts = new ArrayList<Criterion>(); parts.add(copy); parts.add(new Criterion(criterion)); this.conjunction = conjunction; this.rValue = null; this.comparison = null; this.lValue = null; this.sql = null; this.preparedStatementReplacements = null; this.ignoreCase = false; } } /** * Appends a debug String representation of the Criterion * onto the String builder. */ @SuppressWarnings("deprecation") public void appendTo(StringBuilder sb) { if (isComposite()) { boolean first = true; for (Criterion part : parts) { if (!first) { sb.append(conjunction); } if (part.isComposite()) { sb.append('('); } part.appendTo(sb); if (part.isComposite()) { sb.append(')'); } first = false; } } else { if (SqlEnum.CUSTOM == comparison) { if (rValue != null && !"".equals(rValue)) { sb.append((String) rValue); } } else if (isVerbatimSqlCondition()) { sb.append(sql); } else { String lValueDisplay; if (lValue instanceof Column) { lValueDisplay = ((Column) lValue).getSqlExpression(); } else if (lValue != null) { lValueDisplay = lValue.toString(); } else { lValueDisplay = ""; } String rValueDisplay; if (rValue instanceof Column) { rValueDisplay = ((Column) rValue).getSqlExpression(); } else if (rValue != null) { rValueDisplay = rValue.toString(); } else { rValueDisplay = ""; } sb.append(lValueDisplay).append(comparison).append(rValueDisplay); } } } /** * Build a string representation of the Criterion for debug purposes. * * @return A String with the representation of the Criterion. */ @Override public String toString() { StringBuilder builder = new StringBuilder(); appendTo(builder); return builder.toString(); } /** * This method checks another Criteria.Criterion to see if they contain * the same attributes. */ @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (obj.getClass() != this.getClass()) { return false; } Criterion criterion = (Criterion) obj; EqualsBuilder equalsBuilder = new EqualsBuilder(); equalsBuilder.append(criterion.lValue, this.lValue).append(criterion.comparison, this.comparison) .append(criterion.rValue, this.rValue).append(criterion.sql, this.sql) .append(criterion.preparedStatementReplacements, this.preparedStatementReplacements) .append(criterion.ignoreCase, this.ignoreCase).append(criterion.parts, this.parts) .append(criterion.conjunction, this.conjunction); return equalsBuilder.isEquals(); } /** * Returns a hash code value for the object. */ @Override public int hashCode() { HashCodeBuilder hashCodeBuilder = new HashCodeBuilder(); hashCodeBuilder.append(this.lValue).append(this.comparison).append(this.rValue).append(this.sql) .append(this.preparedStatementReplacements).append(this.ignoreCase).append(this.parts) .append(this.conjunction); return hashCodeBuilder.toHashCode(); } }