/**
  * INTERNAL: Rebuild myself against the base, with the values of parameters supplied by the
  * context expression. This is used for transforming a standalone expression (e.g. the join
  * criteria of a mapping) into part of some larger expression. You normally would not call this
  * directly, instead calling twist See the comment there for more details"
  */
 public Expression twistedForBaseAndContext(Expression newBase, Expression context) {
   Expression twistedBase = getBaseExpression().twistedForBaseAndContext(newBase, context);
   QueryKeyExpression result = (QueryKeyExpression) twistedBase.get(getName());
   if (shouldUseOuterJoin) {
     result.doUseOuterJoin();
   }
   if (shouldQueryToManyRelationship) {
     result.doQueryToManyRelationship();
   }
   return result;
 }
  /**
   * Return an expression that allows you to treat its base as if it were a subclass of the class
   * returned by the base This can only be called on an ExpressionBuilder, the result of
   * expression.get(String), expression.getAllowingNull(String), the result of
   * expression.anyOf("String") or the result of expression.anyOfAllowingNull("String")
   *
   * <p>downcast uses Expression.type() internally to guarantee the results are of the specified
   * class.
   *
   * <p>Example:
   *
   * <pre><blockquote>
   *     Expression: employee.get("project").as(LargeProject.class).get("budget").equal(1000)
   *     Java: ((LargeProject)employee.getProjects().get(0)).getBudget() == 1000
   *     SQL: LPROJ.PROJ_ID (+)= PROJ.PROJ_ID AND L_PROJ.BUDGET = 1000 AND PROJ.TYPE = "L"
   * </blockquote></pre>
   */
  @Override
  public Expression treat(Class castClass) {
    // to be used on expressionBuilders
    QueryKeyExpression clonedExpression = new TreatAsExpression(castClass, this);
    clonedExpression.shouldQueryToManyRelationship = false;
    clonedExpression.hasQueryKey = false;
    clonedExpression.hasMapping = false;

    this.addDerivedExpression(clonedExpression);
    return clonedExpression;
  }
 /**
  * PUBLIC: Return an expression representing traversal of a 1:many or many:many relationship. This
  * allows you to query whether any of the "many" side of the relationship satisfies the remaining
  * criteria.
  *
  * <p>Example:
  *
  * <pre><blockquote>
  *     Expression: employee.anyOf("managedEmployees").get("firstName").equal("Bob")
  *     Java: no direct equivalent
  *     SQL: SELECT DISTINCT ... WHERE (t2.MGR_ID = t1.ID) AND (t2.F_NAME = 'Bob')
  * </pre>
  *
  * </blockquote>
  *
  * @parameter shouldJoinBeIndependent indicates whether a new expression should be created.
  */
 @Override
 public Expression anyOf(String attributeName, boolean shouldJoinBeIndependent) {
   QueryKeyExpression queryKey;
   if (shouldJoinBeIndependent) {
     queryKey = newDerivedExpressionNamed(attributeName);
   } else {
     queryKey = derivedExpressionNamed(attributeName);
   }
   queryKey.doQueryToManyRelationship();
   return queryKey;
 }
 /**
  * INTERNAL: Return if the expression is equal to the other. This is used to allow dynamic
  * expression's SQL to be cached.
  */
 public boolean equals(Object object) {
   if (this == object) {
     return true;
   }
   if (!super.equals(object)) {
     return false;
   }
   QueryKeyExpression expression = (QueryKeyExpression) object;
   // Return false for anyOf expressions, as equality is unknown.
   if (shouldQueryToManyRelationship() || expression.shouldQueryToManyRelationship()) {
     return false;
   }
   return ((getName() == expression.getName())
       || ((getName() != null) && getName().equals(expression.getName())));
 }
  /**
   * INTERNAL: This expression is built on a different base than the one we want. Rebuild it and
   * return the root of the new tree
   */
  public Expression rebuildOn(Expression newBase) {
    Expression newLocalBase = getBaseExpression().rebuildOn(newBase);
    QueryKeyExpression result = null;

    // For bug 3096634 rebuild outer joins correctly from the start.
    if (shouldUseOuterJoin) {
      result = (QueryKeyExpression) newLocalBase.getAllowingNull(getName());
    } else {
      result = (QueryKeyExpression) newLocalBase.get(getName());
    }
    if (shouldQueryToManyRelationship) {
      result.doQueryToManyRelationship();
    }
    result.setSelectIfOrderedBy(selectIfOrderedBy());
    return result;
  }
 public QueryKeyExpression existingDerivedExpressionNamed(String attributeName) {
   if (this.derivedExpressions == null) {
     return null;
   }
   List<Expression> derivedExpressionsCopy;
   synchronized (this) {
     derivedExpressionsCopy = new ArrayList(this.derivedExpressions);
   }
   for (Expression derivedExpression : derivedExpressionsCopy) {
     QueryKeyExpression exp = (QueryKeyExpression) derivedExpression;
     if (exp.getName().equals(attributeName)) {
       return exp;
     }
   }
   return null;
 }
 public void writeSubexpressionsTo(BufferedWriter writer, int indent) throws IOException {
   if (this.typeExpressionBase != null) {
     this.typeExpressionBase.toString(writer, indent);
   } else {
     super.writeSubexpressionsTo(writer, indent);
   }
 }
Ejemplo n.º 8
0
 /** INTERNAL: Return if the attribute is specified for batch reading. */
 public boolean isAttributeBatchRead(String attributeName) {
   if (!hasBatchReadAttributes()) {
     return false;
   }
   Vector batchReadAttributeExpressions = getBatchReadAttributeExpressions();
   int size = batchReadAttributeExpressions.size();
   for (int index = 0; index < size; index++) {
     QueryKeyExpression expression = (QueryKeyExpression) batchReadAttributeExpressions.get(index);
     while (!expression.getBaseExpression().isExpressionBuilder()) {
       expression = (QueryKeyExpression) expression.getBaseExpression();
     }
     if (expression.getName().equals(attributeName)) {
       return true;
     }
   }
   return false;
 }
 @Override
 protected void postCopyIn(Map alreadyDone) {
   super.postCopyIn(alreadyDone);
   this.typeExpressionBase = (ObjectExpression) typeExpressionBase.copiedVersionFrom(alreadyDone);
 }