hibernate--sqlquery实现类，看看addentity等等方法内部实现

1.hibernate几个相关的实现类都在hibernate.core.x.x.xx.final.jar下的internal包里。

2.SQLQueryImpl类

package org.hibernate.internal;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.MappingException;
import org.hibernate.Query;
import org.hibernate.QueryException;
import org.hibernate.SQLQuery;
import org.hibernate.SQLQuery.FetchReturn;
import org.hibernate.SQLQuery.ReturnProperty;
import org.hibernate.SQLQuery.RootReturn;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.ResultSetMappingDefinition;
import org.hibernate.engine.query.spi.ParameterMetadata;
import org.hibernate.engine.query.spi.sql.NativeSQLQueryConstructorReturn;
import org.hibernate.engine.query.spi.sql.NativeSQLQueryJoinReturn;
import org.hibernate.engine.query.spi.sql.NativeSQLQueryReturn;
import org.hibernate.engine.query.spi.sql.NativeSQLQueryRootReturn;
import org.hibernate.engine.query.spi.sql.NativeSQLQueryScalarReturn;
import org.hibernate.engine.query.spi.sql.NativeSQLQuerySpecification;
import org.hibernate.engine.spi.NamedSQLQueryDefinition;
import org.hibernate.engine.spi.QueryParameters;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.type.Type;

public class SQLQueryImpl extends AbstractQueryImpl
  implements SQLQuery
{
  private List<NativeSQLQueryReturn> queryReturns;
  private List<ReturnBuilder> queryReturnBuilders;
  private boolean autoDiscoverTypes;
  private Collection<String> querySpaces;
  private final boolean callable;
  private final LockOptions lockOptions = new LockOptions();

  SQLQueryImpl(NamedSQLQueryDefinition queryDef, SessionImplementor session, ParameterMetadata parameterMetadata)
  {
    super(queryDef.getQueryString(), queryDef.getFlushMode(), session, parameterMetadata);
    if (queryDef.getResultSetRef() != null) {
      ResultSetMappingDefinition definition = session.getFactory().getResultSetMapping(queryDef.getResultSetRef());

      if (definition == null) {
        throw new MappingException("Unable to find resultset-ref definition: " + queryDef.getResultSetRef());
      }

      this.queryReturns = new ArrayList(Arrays.asList(definition.getQueryReturns()));
    }
    else if ((queryDef.getQueryReturns() != null) && (queryDef.getQueryReturns().length > 0)) {
      this.queryReturns = new ArrayList(Arrays.asList(queryDef.getQueryReturns()));
    }
    else {
      this.queryReturns = new ArrayList();
    }

    this.querySpaces = queryDef.getQuerySpaces();
    this.callable = queryDef.isCallable();
  }

  SQLQueryImpl(String sql, SessionImplementor session, ParameterMetadata parameterMetadata) {
    this(sql, false, session, parameterMetadata);
  }

  SQLQueryImpl(String sql, boolean callable, SessionImplementor session, ParameterMetadata parameterMetadata) {
    super(sql, null, session, parameterMetadata);
    this.queryReturns = new ArrayList();
    this.querySpaces = null;
    this.callable = callable;
  }

  public List<NativeSQLQueryReturn> getQueryReturns()
  {
    prepareQueryReturnsIfNecessary();
    return this.queryReturns;
  }

  public Collection<String> getSynchronizedQuerySpaces()
  {
    return this.querySpaces;
  }

  public boolean isCallable()
  {
    return this.callable;
  }

  public List list() throws HibernateException
  {
    verifyParameters();
    before();

    Map namedParams = getNamedParams();
    NativeSQLQuerySpecification spec = generateQuerySpecification(namedParams);
    try
    {
      return getSession().list(spec, getQueryParameters(namedParams));
    }
    finally {
      after();
    }
  }

  private NativeSQLQuerySpecification generateQuerySpecification(Map namedParams) {
    return new NativeSQLQuerySpecification(expandParameterLists(namedParams), (NativeSQLQueryReturn[])this.queryReturns.toArray(new NativeSQLQueryReturn[this.queryReturns.size()]), this.querySpaces);
  }

  public ScrollableResults scroll(ScrollMode scrollMode)
    throws HibernateException
  {
    verifyParameters();
    before();

    Map namedParams = getNamedParams();
    NativeSQLQuerySpecification spec = generateQuerySpecification(namedParams);

    QueryParameters qp = getQueryParameters(namedParams);
    qp.setScrollMode(scrollMode);
    try
    {
      return getSession().scroll(spec, qp);
    }
    finally {
      after();
    }
  }

  public ScrollableResults scroll() throws HibernateException {
    return scroll(this.session.getFactory().getDialect().defaultScrollMode());
  }

  public Iterator iterate() throws HibernateException {
    throw new UnsupportedOperationException("SQL queries do not currently support iteration");
  }

  public QueryParameters getQueryParameters(Map namedParams)
  {
    QueryParameters qp = super.getQueryParameters(namedParams);
    qp.setCallable(this.callable);
    qp.setAutoDiscoverScalarTypes(this.autoDiscoverTypes);
    return qp;
  }

  protected void verifyParameters()
  {
    prepareQueryReturnsIfNecessary();
    verifyParameters(this.callable);
    boolean noReturns = (this.queryReturns == null) || (this.queryReturns.isEmpty());
    if (noReturns) {
      this.autoDiscoverTypes = noReturns;
    }
    else
      for (NativeSQLQueryReturn queryReturn : this.queryReturns)
        if ((queryReturn instanceof NativeSQLQueryScalarReturn)) {
          NativeSQLQueryScalarReturn scalar = (NativeSQLQueryScalarReturn)queryReturn;
          if (scalar.getType() == null) {
            this.autoDiscoverTypes = true;
            break;
          }
        }
        else if (NativeSQLQueryConstructorReturn.class.isInstance(queryReturn)) {
          this.autoDiscoverTypes = true;
          break;
        }
  }

  private void prepareQueryReturnsIfNecessary()
  {
    if (this.queryReturnBuilders != null) {
      if (!this.queryReturnBuilders.isEmpty()) {
        if (this.queryReturns != null) {
          this.queryReturns.clear();
          this.queryReturns = null;
        }
        this.queryReturns = new ArrayList();
        for (ReturnBuilder builder : this.queryReturnBuilders) {
          this.queryReturns.add(builder.buildReturn());
        }
        this.queryReturnBuilders.clear();
      }
      this.queryReturnBuilders = null;
    }
  }

  public String[] getReturnAliases() throws HibernateException
  {
    throw new UnsupportedOperationException("SQL queries do not currently support returning aliases");
  }

  public Type[] getReturnTypes() throws HibernateException
  {
    throw new UnsupportedOperationException("not yet implemented for SQL queries");
  }

  public Query setLockMode(String alias, LockMode lockMode) {
    throw new UnsupportedOperationException("cannot set the lock mode for a native SQL query");
  }

  public Query setLockOptions(LockOptions lockOptions) {
    throw new UnsupportedOperationException("cannot set lock options for a native SQL query");
  }

  public LockOptions getLockOptions()
  {
    return this.lockOptions;
  }

  public SQLQuery addScalar(final String columnAlias, final Type type) {
    if (this.queryReturnBuilders == null) {
      this.queryReturnBuilders = new ArrayList();
    }
    this.queryReturnBuilders.add(new ReturnBuilder()
    {
      public NativeSQLQueryReturn buildReturn() {
        return new NativeSQLQueryScalarReturn(columnAlias, type);
      }
    });
    return this;
  }

  public SQLQuery addScalar(String columnAlias) {
    return addScalar(columnAlias, null);
  }

  public SQLQuery.RootReturn addRoot(String tableAlias, String entityName) {
    RootReturnBuilder builder = new RootReturnBuilder(tableAlias, entityName, null);
    if (this.queryReturnBuilders == null) {
      this.queryReturnBuilders = new ArrayList();
    }
    this.queryReturnBuilders.add(builder);
    return builder;
  }

  public SQLQuery.RootReturn addRoot(String tableAlias, Class entityType) {
    return addRoot(tableAlias, entityType.getName());
  }

250   public SQLQuery addEntity(String entityName) {
251     return addEntity(StringHelper.unqualify(entityName), entityName);////////////////////////////////////////////////////////相关到internal包下的util包下的StringHelper.class类
252   }

254   public SQLQuery addEntity(String alias, String entityName) {
255     addRoot(alias, entityName);
256     return this;
257   }

  public SQLQuery addEntity(String alias, String entityName, LockMode lockMode) {
    addRoot(alias, entityName).setLockMode(lockMode);
    return this;
  }

264   public SQLQuery addEntity(Class entityType) {
265     return addEntity(entityType.getName());
266   }

  public SQLQuery addEntity(String alias, Class entityClass) {
    return addEntity(alias, entityClass.getName());
  }

  public SQLQuery addEntity(String alias, Class entityClass, LockMode lockMode) {
    return addEntity(alias, entityClass.getName(), lockMode);
  }

  public SQLQuery.FetchReturn addFetch(String tableAlias, String ownerTableAlias, String joinPropertyName) {
    FetchReturnBuilder builder = new FetchReturnBuilder(tableAlias, ownerTableAlias, joinPropertyName, null);
    if (this.queryReturnBuilders == null) {
      this.queryReturnBuilders = new ArrayList();
    }
    this.queryReturnBuilders.add(builder);
    return builder;
  }

  public SQLQuery addJoin(String tableAlias, String ownerTableAlias, String joinPropertyName) {
    addFetch(tableAlias, ownerTableAlias, joinPropertyName);
    return this;
  }

  public SQLQuery addJoin(String alias, String path) {
    createFetchJoin(alias, path);
    return this;
  }

  private SQLQuery.FetchReturn createFetchJoin(String tableAlias, String path) {
    int loc = path.indexOf('.');
    if (loc < 0) {
      throw new QueryException("not a property path: " + path);
    }
    String ownerTableAlias = path.substring(0, loc);
    String joinedPropertyName = path.substring(loc + 1);
    return addFetch(tableAlias, ownerTableAlias, joinedPropertyName);
  }

  public SQLQuery addJoin(String alias, String path, LockMode lockMode) {
    createFetchJoin(alias, path).setLockMode(lockMode);
    return this;
  }

  public SQLQuery setResultSetMapping(String name) {
    ResultSetMappingDefinition mapping = this.session.getFactory().getResultSetMapping(name);
    if (mapping == null) {
      throw new MappingException("Unknown SqlResultSetMapping [" + name + "]");
    }
    NativeSQLQueryReturn[] returns = mapping.getQueryReturns();
    this.queryReturns.addAll(Arrays.asList(returns));
    return this;
  }

  public SQLQuery addSynchronizedQuerySpace(String querySpace) {
    if (this.querySpaces == null) {
      this.querySpaces = new ArrayList();
    }
    this.querySpaces.add(querySpace);
    return this;
  }

  public SQLQuery addSynchronizedEntityName(String entityName) {
    return addQuerySpaces(getSession().getFactory().getEntityPersister(entityName).getQuerySpaces());
  }

  public SQLQuery addSynchronizedEntityClass(Class entityClass) {
    return addQuerySpaces(getSession().getFactory().getEntityPersister(entityClass.getName()).getQuerySpaces());
  }

  private SQLQuery addQuerySpaces(Serializable[] spaces) {
    if (spaces != null) {
      if (this.querySpaces == null) {
        this.querySpaces = new ArrayList();
      }
      this.querySpaces.addAll(Arrays.asList((String[])spaces));
    }
    return this;
  }

  public int executeUpdate() throws HibernateException {
    Map namedParams = getNamedParams();
    before();
    try {
      return getSession().executeNativeUpdate(generateQuerySpecification(namedParams), getQueryParameters(namedParams));
    }
    finally
    {
      after();
    }
  }

  private static abstract interface ReturnBuilder
  {
    public abstract NativeSQLQueryReturn buildReturn();
  }

  private class FetchReturnBuilder
    implements SQLQuery.FetchReturn, SQLQueryImpl.ReturnBuilder
  {
    private final String alias;
    private String ownerTableAlias;
    private final String joinedPropertyName;
    private LockMode lockMode = LockMode.READ;
    private Map<String, String[]> propertyMappings;

    private FetchReturnBuilder(String alias, String ownerTableAlias, String joinedPropertyName)
    {
      this.alias = alias;
      this.ownerTableAlias = ownerTableAlias;
      this.joinedPropertyName = joinedPropertyName;
    }

    public SQLQuery.FetchReturn setLockMode(LockMode lockMode) {
      this.lockMode = lockMode;
      return this;
    }

    public SQLQuery.FetchReturn addProperty(String propertyName, String columnAlias) {
      addProperty(propertyName).addColumnAlias(columnAlias);
      return this;
    }

    public SQLQuery.ReturnProperty addProperty(final String propertyName) {
      if (this.propertyMappings == null) {
        this.propertyMappings = new HashMap();
      }
      return new SQLQuery.ReturnProperty() {
        public SQLQuery.ReturnProperty addColumnAlias(String columnAlias) {
          String[] columnAliases = (String[])SQLQueryImpl.FetchReturnBuilder.this.propertyMappings.get(propertyName);
          if (columnAliases == null) {
            columnAliases = new String[] { columnAlias };
          } else {
            String[] newColumnAliases = new String[columnAliases.length + 1];
            System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
            newColumnAliases[columnAliases.length] = columnAlias;
            columnAliases = newColumnAliases;
          }
          SQLQueryImpl.FetchReturnBuilder.this.propertyMappings.put(propertyName, columnAliases);
          return this;
        }
      };
    }

    public NativeSQLQueryReturn buildReturn() {
      return new NativeSQLQueryJoinReturn(this.alias, this.ownerTableAlias, this.joinedPropertyName, this.propertyMappings, this.lockMode);
    }
  }

  private class RootReturnBuilder
    implements SQLQuery.RootReturn, SQLQueryImpl.ReturnBuilder
  {
    private final String alias;
    private final String entityName;
    private LockMode lockMode = LockMode.READ;
    private Map<String, String[]> propertyMappings;

    private RootReturnBuilder(String alias, String entityName)
    {
      this.alias = alias;
      this.entityName = entityName;
    }

    public SQLQuery.RootReturn setLockMode(LockMode lockMode) {
      this.lockMode = lockMode;
      return this;
    }

    public SQLQuery.RootReturn setDiscriminatorAlias(String alias) {
      addProperty("class", alias);
      return this;
    }

    public SQLQuery.RootReturn addProperty(String propertyName, String columnAlias) {
      addProperty(propertyName).addColumnAlias(columnAlias);
      return this;
    }

    public SQLQuery.ReturnProperty addProperty(final String propertyName) {
      if (this.propertyMappings == null) {
        this.propertyMappings = new HashMap();
      }
      return new SQLQuery.ReturnProperty() {
        public SQLQuery.ReturnProperty addColumnAlias(String columnAlias) {
          String[] columnAliases = (String[])SQLQueryImpl.RootReturnBuilder.this.propertyMappings.get(propertyName);
          if (columnAliases == null) {
            columnAliases = new String[] { columnAlias };
          } else {
            String[] newColumnAliases = new String[columnAliases.length + 1];
            System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
            newColumnAliases[columnAliases.length] = columnAlias;
            columnAliases = newColumnAliases;
          }
          SQLQueryImpl.RootReturnBuilder.this.propertyMappings.put(propertyName, columnAliases);
          return this;
        }
      };
    }

    public NativeSQLQueryReturn buildReturn() {
      return new NativeSQLQueryRootReturn(this.alias, this.entityName, this.propertyMappings, this.lockMode);
    }
  }
}

3.StringHelper.class

package org.hibernate.internal.util;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Iterator;
import java.util.Locale;
import java.util.StringTokenizer;
import org.hibernate.dialect.Dialect;
import org.hibernate.internal.util.collections.ArrayHelper;

public final class StringHelper
{
  private static final int ALIAS_TRUNCATE_LENGTH = 10;
  public static final String WHITESPACE = " \n\r\f\t";
  public static final String BATCH_ID_PLACEHOLDER = "$$BATCH_ID_PLACEHOLDER$$";

  public static int lastIndexOfLetter(String string)
  {
    for (int i = 0; i < string.length(); i++) {
      char character = string.charAt(i);

      if ((!Character.isLetter(character)) && ('_' != character)) return i - 1;
    }
    return string.length() - 1;
  }

  public static String join(String seperator, String[] strings) {
    int length = strings.length;
    if (length == 0) return "";
    StringBuilder buf = new StringBuilder(length * strings[0].length()).append(strings[0]);

    for (int i = 1; i < length; i++) {
      buf.append(seperator).append(strings[i]);
    }
    return buf.toString();
  }

  public static String joinWithQualifierAndSuffix(String[] values, String qualifier, String suffix, String deliminator) {
    int length = values.length;
    if (length == 0) return "";
    StringBuilder buf = new StringBuilder(length * (values[0].length() + suffix.length())).append(qualify(qualifier, values[0])).append(suffix);

    for (int i = 1; i < length; i++) {
      buf.append(deliminator).append(qualify(qualifier, values[i])).append(suffix);
    }
    return buf.toString();
  }

  public static String join(String seperator, Iterator objects) {
    StringBuilder buf = new StringBuilder();
    if (objects.hasNext()) buf.append(objects.next());
    while (objects.hasNext()) {
      buf.append(seperator).append(objects.next());
    }
    return buf.toString();
  }

  public static String[] add(String[] x, String sep, String[] y) {
    String[] result = new String[x.length];
    for (int i = 0; i < x.length; i++) {
      result[i] = new StringBuilder().append(x[i]).append(sep).append(y[i]).toString();
    }
    return result;
  }

  public static String repeat(String string, int times) {
    StringBuilder buf = new StringBuilder(string.length() * times);
    for (int i = 0; i < times; i++) buf.append(string);
    return buf.toString();
  }

  public static String repeat(String string, int times, String deliminator) {
    StringBuilder buf = new StringBuilder(string.length() * times + deliminator.length() * (times - 1)).append(string);

    for (int i = 1; i < times; i++) {
      buf.append(deliminator).append(string);
    }
    return buf.toString();
  }

  public static String repeat(char character, int times) {
    char[] buffer = new char[times];
    Arrays.fill(buffer, character);
    return new String(buffer);
  }

  public static String replace(String template, String placeholder, String replacement)
  {
    return replace(template, placeholder, replacement, false);
  }

  public static String[] replace(String[] templates, String placeholder, String replacement) {
    String[] result = new String[templates.length];
    for (int i = 0; i < templates.length; i++) {
      result[i] = replace(templates[i], placeholder, replacement);
    }
    return result;
  }

  public static String replace(String template, String placeholder, String replacement, boolean wholeWords) {
    return replace(template, placeholder, replacement, wholeWords, false);
  }

  public static String replace(String template, String placeholder, String replacement, boolean wholeWords, boolean encloseInParensIfNecessary)
  {
    if (template == null) {
      return template;
    }
    int loc = template.indexOf(placeholder);
    if (loc < 0) {
      return template;
    }

    String beforePlaceholder = template.substring(0, loc);
    String afterPlaceholder = template.substring(loc + placeholder.length());
    return replace(beforePlaceholder, afterPlaceholder, placeholder, replacement, wholeWords, encloseInParensIfNecessary);
  }

  public static String replace(String beforePlaceholder, String afterPlaceholder, String placeholder, String replacement, boolean wholeWords, boolean encloseInParensIfNecessary)
  {
    boolean actuallyReplace = (!wholeWords) || (afterPlaceholder.length() == 0) || (!Character.isJavaIdentifierPart(afterPlaceholder.charAt(0)));

    boolean encloseInParens = (actuallyReplace) && (encloseInParensIfNecessary) && (getLastNonWhitespaceCharacter(beforePlaceholder) != '(') && (getFirstNonWhitespaceCharacter(afterPlaceholder) != ')');

    StringBuilder buf = new StringBuilder(beforePlaceholder);
    if (encloseInParens) {
      buf.append('(');
    }
    buf.append(actuallyReplace ? replacement : placeholder);
    if (encloseInParens) {
      buf.append(')');
    }
    buf.append(replace(afterPlaceholder, placeholder, replacement, wholeWords, encloseInParensIfNecessary));

    return buf.toString();
  }

  public static char getLastNonWhitespaceCharacter(String str) {
    if ((str != null) && (str.length() > 0)) {
      for (int i = str.length() - 1; i >= 0; i--) {
        char ch = str.charAt(i);
        if (!Character.isWhitespace(ch)) {
          return ch;
        }
      }
    }
    return '\000';
  }

  public static char getFirstNonWhitespaceCharacter(String str) {
    if ((str != null) && (str.length() > 0)) {
      for (int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);
        if (!Character.isWhitespace(ch)) {
          return ch;
        }
      }
    }
    return '\000';
  }

  public static String replaceOnce(String template, String placeholder, String replacement) {
    if (template == null) {
      return template;
    }
    int loc = template.indexOf(placeholder);
    if (loc < 0) {
      return template;
    }

    return new StringBuilder(template.substring(0, loc)).append(replacement).append(template.substring(loc + placeholder.length())).toString();
  }

  public static String[] split(String seperators, String list)
  {
    return split(seperators, list, false);
  }

  public static String[] split(String seperators, String list, boolean include) {
    StringTokenizer tokens = new StringTokenizer(list, seperators, include);
    String[] result = new String[tokens.countTokens()];
    int i = 0;
    while (tokens.hasMoreTokens()) {
      result[(i++)] = tokens.nextToken();
    }
    return result;
  }

  public static String unqualify(String qualifiedName) {
    int loc = qualifiedName.lastIndexOf(".");
    return loc < 0 ? qualifiedName : qualifiedName.substring(loc + 1);
  }

  public static String qualifier(String qualifiedName) {
    int loc = qualifiedName.lastIndexOf(".");
    return loc < 0 ? "" : qualifiedName.substring(0, loc);
  }

  public static String collapse(String name)
  {
    if (name == null) {
      return null;
    }
    int breakPoint = name.lastIndexOf(46);
    if (breakPoint < 0) {
      return name;
    }
    return new StringBuilder().append(collapseQualifier(name.substring(0, breakPoint), true)).append(name.substring(breakPoint)).toString();
  }

  public static String collapseQualifier(String qualifier, boolean includeDots)
  {
    StringTokenizer tokenizer = new StringTokenizer(qualifier, ".");
    String collapsed = Character.toString(tokenizer.nextToken().charAt(0));
    while (tokenizer.hasMoreTokens()) {
      if (includeDots) {
        collapsed = new StringBuilder().append(collapsed).append('.').toString();
      }
      collapsed = new StringBuilder().append(collapsed).append(tokenizer.nextToken().charAt(0)).toString();
    }
    return collapsed;
  }

  public static String partiallyUnqualify(String name, String qualifierBase)
  {
    if ((name == null) || (!name.startsWith(qualifierBase))) {
      return name;
    }
    return name.substring(qualifierBase.length() + 1);
  }

  public static String collapseQualifierBase(String name, String qualifierBase)
  {
    if ((name == null) || (!name.startsWith(qualifierBase))) {
      return collapse(name);
    }
    return new StringBuilder().append(collapseQualifier(qualifierBase, true)).append(name.substring(qualifierBase.length())).toString();
  }

  public static String[] suffix(String[] columns, String suffix) {
    if (suffix == null) return columns;
    String[] qualified = new String[columns.length];
    for (int i = 0; i < columns.length; i++) {
      qualified[i] = suffix(columns[i], suffix);
    }
    return qualified;
  }

  private static String suffix(String name, String suffix) {
    return suffix == null ? name : new StringBuilder().append(name).append(suffix).toString();
  }

  public static String root(String qualifiedName) {
    int loc = qualifiedName.indexOf(".");
    return loc < 0 ? qualifiedName : qualifiedName.substring(0, loc);
  }

  public static String unroot(String qualifiedName) {
    int loc = qualifiedName.indexOf(".");
    return loc < 0 ? qualifiedName : qualifiedName.substring(loc + 1, qualifiedName.length());
  }

  public static boolean booleanValue(String tfString) {
    String trimmed = tfString.trim().toLowerCase(Locale.ROOT);
    return (trimmed.equals("true")) || (trimmed.equals("t"));
  }

  public static String toString(Object[] array) {
    int len = array.length;
    if (len == 0) return "";
    StringBuilder buf = new StringBuilder(len * 12);
    for (int i = 0; i < len - 1; i++) {
      buf.append(array[i]).append(", ");
    }
    return buf.append(array[(len - 1)]).toString();
  }

  public static String[] multiply(String string, Iterator placeholders, Iterator replacements) {
    String[] result = { string };
    while (placeholders.hasNext()) {
      result = multiply(result, (String)placeholders.next(), (String[])replacements.next());
    }
    return result;
  }

  private static String[] multiply(String[] strings, String placeholder, String[] replacements) {
    String[] results = new String[replacements.length * strings.length];
    int n = 0;
    for (int i = 0; i < replacements.length; i++) {
      for (int j = 0; j < strings.length; j++) {
        results[(n++)] = replaceOnce(strings[j], placeholder, replacements[i]);
      }
    }
    return results;
  }

  public static int countUnquoted(String string, char character) {
    if ('\'' == character) {
      throw new IllegalArgumentException("Unquoted count of quotes is invalid");
    }
    if (string == null) {
      return 0;
    }

    int count = 0;
    int stringLength = string.length();
    boolean inQuote = false;
    for (int indx = 0; indx < stringLength; indx++) {
      char c = string.charAt(indx);
      if (inQuote) {
        if ('\'' == c) {
          inQuote = false;
        }
      }
      else if ('\'' == c) {
        inQuote = true;
      }
      else if (c == character) {
        count++;
      }
    }
    return count;
  }

  public static int[] locateUnquoted(String string, char character) {
    if ('\'' == character) {
      throw new IllegalArgumentException("Unquoted count of quotes is invalid");
    }
    if (string == null) {
      return new int[0];
    }

    ArrayList locations = new ArrayList(20);

    int stringLength = string.length();
    boolean inQuote = false;
    for (int indx = 0; indx < stringLength; indx++) {
      char c = string.charAt(indx);
      if (inQuote) {
        if ('\'' == c) {
          inQuote = false;
        }
      }
      else if ('\'' == c) {
        inQuote = true;
      }
      else if (c == character) {
        locations.add(Integer.valueOf(indx));
      }
    }
    return ArrayHelper.toIntArray(locations);
  }

  public static boolean isNotEmpty(String string) {
    return (string != null) && (string.length() > 0);
  }

  public static boolean isEmpty(String string) {
    return (string == null) || (string.length() == 0);
  }

  public static String qualify(String prefix, String name) {
    if ((name == null) || (prefix == null)) {
      throw new NullPointerException("prefix or name were null attempting to build qualified name");
    }
    return new StringBuilder().append(prefix).append('.').append(name).toString();
  }

  public static String[] qualify(String prefix, String[] names) {
    if (prefix == null) {
      return names;
    }
    int len = names.length;
    String[] qualified = new String[len];
    for (int i = 0; i < len; i++) {
      qualified[i] = qualify(prefix, names[i]);
    }
    return qualified;
  }

  public static String[] qualifyIfNot(String prefix, String[] names) {
    if (prefix == null) {
      return names;
    }
    int len = names.length;
    String[] qualified = new String[len];
    for (int i = 0; i < len; i++) {
      if (names[i].indexOf(46) < 0) {
        qualified[i] = qualify(prefix, names[i]);
      }
      else {
        qualified[i] = names[i];
      }
    }
    return qualified;
  }

  public static int firstIndexOfChar(String sqlString, BitSet keys, int startindex) {
    int i = startindex; for (int size = sqlString.length(); i < size; i++) {
      if (keys.get(sqlString.charAt(i))) {
        return i;
      }
    }
    return -1;
  }

  public static int firstIndexOfChar(String sqlString, String string, int startindex)
  {
    BitSet keys = new BitSet();
    int i = 0; for (int size = string.length(); i < size; i++) {
      keys.set(string.charAt(i));
    }
    return firstIndexOfChar(sqlString, keys, startindex);
  }

  public static String truncate(String string, int length)
  {
    if (string.length() <= length) {
      return string;
    }

    return string.substring(0, length);
  }

  public static String generateAlias(String description)
  {
    return new StringBuilder().append(generateAliasRoot(description)).append('_').toString();
  }

  public static String generateAlias(String description, int unique)
  {
    return new StringBuilder().append(generateAliasRoot(description)).append(Integer.toString(unique)).append('_').toString();
  }

  private static String generateAliasRoot(String description)
  {
    String result = truncate(unqualifyEntityName(description), 10).toLowerCase(Locale.ROOT).replace('/', '_').replace('$', '_');

    result = cleanAlias(result);
    if (Character.isDigit(result.charAt(result.length() - 1))) {
      return new StringBuilder().append(result).append("x").toString();
    }

    return result;
  }

  private static String cleanAlias(String alias)
  {
    char[] chars = alias.toCharArray();

    if (!Character.isLetter(chars[0])) {
      for (int i = 1; i < chars.length; i++)
      {
        if (Character.isLetter(chars[i])) {
          return alias.substring(i);
        }
      }
    }
    return alias;
  }

  public static String unqualifyEntityName(String entityName) {
    String result = unqualify(entityName);
    int slashPos = result.indexOf(47);
    if (slashPos > 0) {
      result = result.substring(0, slashPos - 1);
    }
    return result;
  }

  public static String moveAndToBeginning(String filter) {
    if (filter.trim().length() > 0) {
      filter = new StringBuilder().append(filter).append(" and ").toString();
      if (filter.startsWith(" and ")) filter = filter.substring(4);
    }
    return filter;
  }

  public static boolean isQuoted(String name)
  {
    return (name != null) && (name.length() != 0) && (((name.charAt(0) == '`') && (name.charAt(name.length() - 1) == '`')) || ((name.charAt(0) == '"') && (name.charAt(name.length() - 1) == '"')));
  }

  public static String quote(String name)
  {
    if ((isEmpty(name)) || (isQuoted(name))) {
      return name;
    }

    if ((name.startsWith("\"")) && (name.endsWith("\""))) {
      name = name.substring(1, name.length() - 1);
    }

    return new StringBuilder(name.length() + 2).append('`').append(name).append('`').toString();
  }

  public static String unquote(String name)
  {
    return isQuoted(name) ? name.substring(1, name.length() - 1) : name;
  }

  public static boolean isQuoted(String name, Dialect dialect)
  {
    return (name != null) && (name.length() != 0) && (((name.charAt(0) == '`') && (name.charAt(name.length() - 1) == '`')) || ((name.charAt(0) == '"') && (name.charAt(name.length() - 1) == '"')) || ((name.charAt(0) == dialect.openQuote()) && (name.charAt(name.length() - 1) == dialect.closeQuote())));
  }

  public static String unquote(String name, Dialect dialect)
  {
    return isQuoted(name, dialect) ? name.substring(1, name.length() - 1) : name;
  }

  public static String[] unquote(String[] names, Dialect dialect)
  {
    if (names == null) {
      return null;
    }
    String[] unquoted = new String[names.length];
    for (int i = 0; i < names.length; i++) {
      unquoted[i] = unquote(names[i], dialect);
    }
    return unquoted;
  }

  public static StringBuilder buildBatchFetchRestrictionFragment(String alias, String[] columnNames, Dialect dialect)
  {
    if (columnNames.length == 1)
    {
      return new StringBuilder(qualify(alias, columnNames[0])).append(" in (").append("$$BATCH_ID_PLACEHOLDER$$").append(")");
    }

    if (dialect.supportsRowValueConstructorSyntaxInInList())
    {
      StringBuilder builder = new StringBuilder();
      builder.append("(");
      boolean firstPass = true;
      String deliminator = "";
      for (String columnName : columnNames) {
        builder.append(deliminator).append(qualify(alias, columnName));
        if (firstPass) {
          firstPass = false;
          deliminator = ",";
        }
      }
      builder.append(") in (");
      builder.append("$$BATCH_ID_PLACEHOLDER$$");
      builder.append(")");
      return builder;
    }

    return new StringBuilder("(").append("$$BATCH_ID_PLACEHOLDER$$").append(")");
  }

  public static String expandBatchIdPlaceholder(String sql, Serializable[] ids, String alias, String[] keyColumnNames, Dialect dialect)
  {
    if (keyColumnNames.length == 1)
    {
      return replace(sql, "$$BATCH_ID_PLACEHOLDER$$", repeat("?", ids.length, ","));
    }

    if (dialect.supportsRowValueConstructorSyntaxInInList()) {
      String tuple = new StringBuilder().append("(").append(repeat("?", keyColumnNames.length, ",")).append(")").toString();
      return replace(sql, "$$BATCH_ID_PLACEHOLDER$$", repeat(tuple, ids.length, ","));
    }

    String keyCheck = new StringBuilder().append("(").append(joinWithQualifierAndSuffix(keyColumnNames, alias, " = ?", " and ")).append(")").toString();
    return replace(sql, "$$BATCH_ID_PLACEHOLDER$$", repeat(keyCheck, ids.length, " or "));
  }

  public static String[] toArrayElement(String s)
  {
    return new String[] { (s == null) || (s.length() == 0) ? new String[0] : s };
  }
}

总结：

addentity最终调用的是addroot方法，StringHelper是帮助截取参数。总之最最后返回的是一个list（private List<ReturnBuilder> queryReturnBuilders;--在SqlQueryImpl类里的一个变量）

//addentity最终调用的一个
public SQLQuery addEntity(String alias, String entityName) {
    addRoot(alias, entityName);
    return this;
  }
//StringHelper帮助构造方法参数
 public static String unquote(String name)
  {
    return isQuoted(name) ? name.substring(1, name.length() - 1) : name;
  }

  public static boolean isQuoted(String name, Dialect dialect)
  {
    return (name != null) && (name.length() != 0) && (((name.charAt(0) == '`') && (name.charAt(name.length() - 1) == '`')) || ((name.charAt(0) == '"') && (name.charAt(name.length() - 1) == '"')) || ((name.charAt(0) == dialect.openQuote()) && (name.charAt(name.length() - 1) == dialect.closeQuote())));
  }
//都要调用addRoot方法
 public SQLQuery.RootReturn addRoot(String tableAlias, String entityName) {
    RootReturnBuilder builder = new RootReturnBuilder(tableAlias, entityName, null);
    if (this.queryReturnBuilders == null) {
      this.queryReturnBuilders = new ArrayList();
    }
    this.queryReturnBuilders.add(builder);
    return builder;
  }
//相关的内部类RootReturnBuilder
private class RootReturnBuilder
    implements SQLQuery.RootReturn, SQLQueryImpl.ReturnBuilder
  {
    private final String alias;
    private final String entityName;
    private LockMode lockMode = LockMode.READ;
    private Map<String, String[]> propertyMappings;

    private RootReturnBuilder(String alias, String entityName)
    {
      this.alias = alias;
      this.entityName = entityName;
    }

    public SQLQuery.RootReturn setLockMode(LockMode lockMode) {
      this.lockMode = lockMode;
      return this;
    }

    public SQLQuery.RootReturn setDiscriminatorAlias(String alias) {
      addProperty("class", alias);
      return this;
    }

    public SQLQuery.RootReturn addProperty(String propertyName, String columnAlias) {
      addProperty(propertyName).addColumnAlias(columnAlias);
      return this;
    }

    public SQLQuery.ReturnProperty addProperty(final String propertyName) {
      if (this.propertyMappings == null) {
        this.propertyMappings = new HashMap();
      }
      return new SQLQuery.ReturnProperty() {
        public SQLQuery.ReturnProperty addColumnAlias(String columnAlias) {
          String[] columnAliases = (String[])SQLQueryImpl.RootReturnBuilder.this.propertyMappings.get(propertyName);
          if (columnAliases == null) {
            columnAliases = new String[] { columnAlias };
          } else {
            String[] newColumnAliases = new String[columnAliases.length + 1];
            System.arraycopy(columnAliases, 0, newColumnAliases, 0, columnAliases.length);
            newColumnAliases[columnAliases.length] = columnAlias;
            columnAliases = newColumnAliases;
          }
          SQLQueryImpl.RootReturnBuilder.this.propertyMappings.put(propertyName, columnAliases);
          return this;
        }
      };
    }