private void buildSelectClause(
      StringBuilder queryStringBuilder,
      CriteriaQueryTranslator criteriaQueryTranslator,
      Set<String> associationPaths) {
    // "distinct" is needed only for association criteria, but it prevents specifying ordering by
    // "ace.id"
    if (associationPaths.isEmpty()) {
      queryStringBuilder.append("select ");
    } else {
      queryStringBuilder.append("select distinct ");
    }
    queryStringBuilder.append(criteriaQueryTranslator.getRootSQLALias());
    queryStringBuilder.append(" from AccessControlEntry ace, ");
    queryStringBuilder.append(persistentClass.getSimpleName());
    queryStringBuilder.append(' ');
    queryStringBuilder.append(criteriaQueryTranslator.getRootSQLALias());

    for (String associationPath : associationPaths) {
      queryStringBuilder.append(" join ");
      queryStringBuilder.append(criteriaQueryTranslator.getRootSQLALias());
      queryStringBuilder.append('.');
      queryStringBuilder.append(associationPath);
      queryStringBuilder.append(" as ");
      queryStringBuilder.append(
          criteriaQueryTranslator.getSQLAlias(
              criteriaQueryTranslator.getCriteria(associationPath)));
    }
  }
  private List<TypedValue> buildWhereClause(
      StringBuilder queryStringBuilder,
      QueryModel queryModel,
      Criteria criteria,
      CriteriaQueryTranslator criteriaQueryTranslator) {
    List<TypedValue> parameters = new ArrayList<TypedValue>();

    queryStringBuilder.append(" where ");

    if (queryModel.getConditions() != null) {
      for (Condition condition : queryModel.getConditions()) {
        Criterion criterion = (Criterion) condition.getConstraint();

        queryStringBuilder.append(criterion.toSqlString(criteria, criteriaQueryTranslator));
        queryStringBuilder.append(" and ");

        parameters.addAll(
            Arrays.asList(criterion.getTypedValues(criteria, criteriaQueryTranslator)));
      }
    }

    if (queryModel.getAssociationConditions() != null) {
      for (Map.Entry<String, List<Condition>> associationCriteriaEntry :
          queryModel.getAssociationConditions().entrySet()) {
        CriteriaImpl.Subcriteria associationCriteria =
            (CriteriaImpl.Subcriteria)
                criteriaQueryTranslator.getCriteria(associationCriteriaEntry.getKey());

        for (Condition condition : associationCriteriaEntry.getValue()) {
          Criterion criterion = (Criterion) condition.getConstraint();

          queryStringBuilder.append(
              criterion.toSqlString(associationCriteria, criteriaQueryTranslator));
          queryStringBuilder.append(" and ");

          parameters.addAll(
              Arrays.asList(
                  criterion.getTypedValues(associationCriteria, criteriaQueryTranslator)));
        }
      }
    }

    queryStringBuilder.append(" ace.objectType = '");
    queryStringBuilder.append(persistentClass.getSimpleName());
    queryStringBuilder.append("' and ace.objectId = ");
    queryStringBuilder.append(criteriaQueryTranslator.getRootSQLALias());
    queryStringBuilder.append('.');
    queryStringBuilder.append(idField);
    queryStringBuilder.append(" and ace.accessibleBy = ? ");

    return parameters;
  }
  protected String generateTableAlias(int n, PropertyPath path, Joinable joinable) {
    // TODO: deal with side-effects (changes to includeInResultRowList, userAliasList,
    // resultTypeList)!!!

    // for collection-of-entity, we are called twice for given "path"
    // once for the collection Joinable, once for the entity Joinable.
    // the second call will/must "consume" the alias + perform side effects according to
    // consumesEntityAlias()
    // for collection-of-other, however, there is only one call
    // it must "consume" the alias + perform side effects, despite what consumeEntityAlias() return
    // says
    //
    // note: the logic for adding to the userAliasList is still strictly based on
    // consumesEntityAlias return value
    boolean checkForSqlAlias = joinable.consumesEntityAlias();

    if (!checkForSqlAlias && joinable.isCollection()) {
      // is it a collection-of-other (component or value) ?
      CollectionPersister collectionPersister = (CollectionPersister) joinable;
      Type elementType = collectionPersister.getElementType();
      if (elementType.isComponentType() || !elementType.isEntityType()) {
        checkForSqlAlias = true;
      }
    }

    String sqlAlias = null;

    if (checkForSqlAlias) {
      final Criteria subcriteria = translator.getCriteria(path.getFullPath());
      sqlAlias = subcriteria == null ? null : translator.getSQLAlias(subcriteria);

      if (joinable.consumesEntityAlias() && !translator.hasProjection()) {
        includeInResultRowList.add(subcriteria != null && subcriteria.getAlias() != null);
        if (sqlAlias != null) {
          if (subcriteria.getAlias() != null) {
            userAliasList.add(subcriteria.getAlias());
            resultTypeList.add(translator.getResultType(subcriteria));
          }
        }
      }
    }

    if (sqlAlias == null) {
      sqlAlias = super.generateTableAlias(n + translator.getSQLAliasCount(), path, joinable);
    }

    return sqlAlias;
  }