Open Source Repository

Home /hibernate/hibernate-3.2.7.ga | Repository Home


org/hibernate/persister/entity/Queryable.java
//$Id: Queryable.java 10825 2006-11-16 19:33:19Z [email protected] $
package org.hibernate.persister.entity;

/**
 * Extends the generic <tt>EntityPersister</tt> contract to add
 * operations required by the Hibernate Query Language
 *
 @author Gavin King
 */
public interface Queryable extends Loadable, PropertyMapping, Joinable {

  /**
   * Is this an abstract class?
   */
  public boolean isAbstract();
  /**
   * Is this class explicit polymorphism only?
   */
  public boolean isExplicitPolymorphism();
  /**
   * Get the class that this class is mapped as a subclass of -
   * not necessarily the direct superclass
   */
  public String getMappedSuperclass();
  /**
   * Get the discriminator value for this particular concrete subclass,
   * as a string that may be embedded in a select statement
   */
  public String getDiscriminatorSQLValue();

  /**
   * Given a query alias and an identifying suffix, render the intentifier select fragment.
   */
  public String identifierSelectFragment(String name, String suffix);
  /**
   * Given a query alias and an identifying suffix, render the property select fragment.
   */
  public String propertySelectFragment(String alias, String suffix, boolean allProperties);

  /**
   * Get the names of columns used to persist the identifier
   */
  public String[] getIdentifierColumnNames();

  /**
   * Is the inheritence hierarchy described by this persister contained across
   * multiple tables?
   *
   @return True if the inheritence hierarchy is spread across multiple tables; false otherwise.
   */
  public boolean isMultiTable();

  /**
   * Get the names of all tables used in the hierarchy (up and down) ordered such
   * that deletes in the given order would not cause contraint violations.
   *
   @return The ordered array of table names.
   */
  public String[] getConstraintOrderedTableNameClosure();

  /**
   * For each table specified in {@link #getConstraintOrderedTableNameClosure()}, get
   * the columns that define the key between the various hierarchy classes.
   <p/>
   * The first dimension here corresponds to the table indexes returned in
   {@link #getConstraintOrderedTableNameClosure()}.
   <p/>
   * The second dimension should have the same length across all the elements in
   * the first dimension.  If not, that'd be a problem ;)
   *
   @return
   */
  public String[][] getContraintOrderedTableKeyColumnClosure();

  /**
   * Get the name of the temporary table to be used to (potentially) store id values
   * when performing bulk update/deletes.
   *
   @return The appropriate temporary table name.
   */
  public String getTemporaryIdTableName();

  /**
   * Get the appropriate DDL command for generating the temporary table to
   * be used to (potentially) store id values when performing bulk update/deletes.
   *
   @return The appropriate temporary table creation command.
   */
  public String getTemporaryIdTableDDL();

  /**
   * Given a property name, determine the number of the table which contains the column
   * to which this property is mapped.
   <p/>
   * Note that this is <b>not</b> relative to the results from {@link #getConstraintOrderedTableNameClosure()}.
   * It is relative to the subclass table name closure maintained internal to the persister (yick!).
   * It is also relative to the indexing used to resolve {@link #getSubclassTableName}...
   *
   @param propertyPath The name of the property.
   @return The nunber of the table to which the property is mapped.
   */
  public int getSubclassPropertyTableNumber(String propertyPath);

  /**
   * Determine whether the given property is declared by our
   * mapped class, our super class, or one of our subclasses...
   <p/>
   * Note: the method is called 'subclass property...' simply
   * for consistency sake (e.g. {@link #getSubclassPropertyTableNumber}
   *
   @param propertyPath The property name.
   @return The property declarer
   */
  public Declarer getSubclassPropertyDeclarer(String propertyPath);

  /**
   * Get the name of the table with the given index from the internal
   * array.
   *
   @param number The index into the internal array.
   @return
   */
  public String getSubclassTableName(int number);
  
  /**
   * Is the version property included in insert statements?
   */
  public boolean isVersionPropertyInsertable();

  /**
   * The alias used for any filter conditions (mapped where-fragments or
   * enabled-filters).
   </p>
   * This may or may not be different from the root alias depending upon the
   * inheritence mapping strategy.
   *
   @param rootAlias The root alias
   @return The alias used for "filter conditions" within the where clause.
   */
  public String generateFilterConditionAlias(String rootAlias);

  public static class Declarer {
    public static final Declarer CLASS = new Declarer"class" );
    public static final Declarer SUBCLASS = new Declarer"subclass" );
    public static final Declarer SUPERCLASS = new Declarer"superclass" );
    private final String name;
    public Declarer(String name) {
      this.name = name;
    }
    public String toString() {
      return name;
    }
  }
}