/** * INTERNAL: * Override this method if the platform needs to use a custom function based on the DatabaseField * @return An expression for the given field set equal to a parameter matching the field */ public Expression createExpressionFor(DatabaseField field, Expression builder) { Expression subExp1 = builder.getField(field); Expression subExp2 = builder.getParameter(field); return subExp1.equal(subExp2); } }
public Predicate getOn() { if (this.on == null) { return null; } if (((ExpressionImpl)this.on).isPredicate()) return (Predicate)this.on; //see queryBuilder.isTrue(this.on); List list = new ArrayList(); list.add(this.on); return new CompoundExpressionImpl(this.metamodel, ((InternalSelection)this.on).getCurrentNode().equal(true), list, "equals"); }
/** * INTERNAL: * Join criteria is created to read target records (nested table) from the table. */ @Override public Expression getJoinCriteria(ObjectExpression context, Expression base) { return context.ref().equal(base.value()); }
/** * INTERNAL: * Join criteria is created to read target records (nested table) from the table. */ @Override public Expression getJoinCriteria(ObjectExpression context, Expression base) { return context.ref().equal(base.value()); }
/** * INTERNAL: * Adds to the passed expression a single relation table field joined to source field. * Used to extend pessimistic locking clause in source query. */ public Expression joinRelationTableField(Expression expression, Expression baseExpression) { return baseExpression.getField(this.sourceKeyFields.get(0)).equal(baseExpression.getTable(relationTable).getField(this.sourceRelationKeyFields.get(0))).and(expression); }
/** * INTERNAL: * Adds to the passed expression a single relation table field joined to source field. * Used to extend pessimistic locking clause in source query. */ public Expression joinRelationTableField(Expression expression, Expression baseExpression) { return baseExpression.getField(this.sourceKeyFields.get(0)).equal(baseExpression.getTable(relationTable).getField(this.sourceRelationKeyFields.get(0))).and(expression); }
/** * INTERNAL: * Adds to the passed expression a single relation table field joined to source field. * Used to extend pessimistic locking clause in source query. */ public Expression joinRelationTableField(Expression expression, Expression baseExpression) { return baseExpression.getField(this.sourceKeyFields.get(0)).equal(baseExpression.getTable(relationTable).getField(this.sourceRelationKeyFields.get(0))).and(expression); }
/** * Create a predicate that tests whether an element is a member of a * collection. * * @param elem * element * @param collection * expression * @return predicate */ public <E, C extends Collection<E>> Predicate isMember(E elem, Expression<C> collection){ return new CompoundExpressionImpl(metamodel, ((InternalSelection)collection).getCurrentNode().equal(elem), buildList(collection, internalLiteral(elem)), "isMember"); }
/** * Create a predicate that tests whether an element is a member of a * collection. * * @param elem * element expression * @param collection * expression * @return predicate */ public <E, C extends Collection<E>> Predicate isMember(Expression<E> elem, Expression<C> collection){ return new CompoundExpressionImpl(metamodel, ((InternalSelection)collection).getCurrentNode().equal(((InternalSelection)elem).getCurrentNode()), buildList(collection, elem), "isMember"); }
/** * Resolve the expression. The steps are: * 1. Set the expressionBuilder for the left and right nodes * 2. Generate the expression for the left node * 3. Add the .equals to the where clause returned from step 2 * 4. Generate the expression for the right side and use it as the parameter for the .equals() * 5. Return the completed where clause to the caller */ public Expression generateExpression(GenerationContext context) { Expression whereClause = getLeft().generateExpression(context); whereClause = whereClause.equal(getRight().generateExpression(context)); return whereClause; }
/** * INTERNAL: * Returns an expression that will be used for both the update and * delete where clause */ protected Expression buildExpression() { ExpressionBuilder builder = new ExpressionBuilder(); return builder.getField(getWriteLockField()).equal(builder.getParameter(getWriteLockField())); }
/** * Create a predicate that tests whether a collection is not empty. * * @param collection * expression * @return predicate */ public <C extends Collection<?>> Predicate isNotEmpty(Expression<C> collection){ return new CompoundExpressionImpl(metamodel, ((InternalSelection)collection).getCurrentNode().size(ClassConstants.INTEGER).equal(0).not(), buildList(collection), "isNotEmpty"); }
/** * INTERNAL: * Returns an expression that will be used for both the update and * delete where clause */ protected Expression buildExpression() { ExpressionBuilder builder = new ExpressionBuilder(); return builder.getField(getWriteLockField()).equal(builder.getParameter(getWriteLockField())); }
/** * INTERNAL: * Returns an expression that will be used for both the update and * delete where clause */ protected Expression buildExpression() { ExpressionBuilder builder = new ExpressionBuilder(); return builder.getField(getWriteLockField()).equal(builder.getParameter(getWriteLockField())); }
/** * INTERNAL: * Join criteria is created to read target records (nested table) from the table. */ public Expression getJoinCriteria(QueryKeyExpression exp) { ExpressionBuilder builder = new ExpressionBuilder(); Expression selectionCriteria = builder.ref().equal(builder.value()); return exp.getBaseExpression().twist(selectionCriteria, exp); }
protected org.eclipse.persistence.expressions.Expression internalCorrelate(FromImpl from){ org.eclipse.persistence.expressions.Expression expression = ((InternalSelection)from).getCurrentNode(); ExpressionBuilder builder = new ExpressionBuilder(expression.getBuilder().getQueryClass()); org.eclipse.persistence.expressions.Expression correlated = expression.rebuildOn(builder); expression = expression.equal(correlated); this.correlations.add(expression); org.eclipse.persistence.expressions.Expression selectionCriteria = expression.and(this.subQuery.getSelectionCriteria()); this.subQuery.setSelectionCriteria(selectionCriteria); return correlated; }
@Override public Expression createExpressionFor(DatabaseField field, Expression builder) { if (field.getType() == java.sql.Clob.class || field.getType() == java.sql.Blob.class) { Expression subExp1 = builder.getField(field); Expression subExp2 = builder.getParameter(field); subExp1 = subExp1.getFunction("dbms_lob.compare", subExp2); return subExp1.equal(0); } return super.createExpressionFor(field, builder); }
public InImpl(Metamodel metamodel, ExpressionImpl leftExpression, ExpressionImpl rightExp, List expressions) { super(metamodel, (rightExp.isParameter()? leftExpression.getCurrentNode().in(rightExp.getCurrentNode()): leftExpression.getCurrentNode().equal(rightExp.getCurrentNode())), expressions, "in"); this.leftExpression = leftExpression; }
/** * INTERNAL: * Selection criteria is created to read target records (nested table) from the table. */ protected void initializeSelectionCriteria(AbstractSession session) { Expression exp1; Expression exp2; ExpressionBuilder builder = new ExpressionBuilder(); Expression queryKey = builder.getManualQueryKey(getAttributeName(), getDescriptor()); exp1 = builder.ref().equal(queryKey.get(getAttributeName()).value()); exp2 = getDescriptor().getObjectBuilder().getPrimaryKeyExpression().rebuildOn(queryKey); setSelectionCriteria(exp1.and(exp2)); }
/** * INTERNAL: * Selection criteria is created to read target records (nested table) from the table. **/ protected void initializeSelectionCriteria(AbstractSession session) { Expression exp1; Expression exp2; ExpressionBuilder builder = new ExpressionBuilder(); Expression queryKey = builder.getManualQueryKey(getAttributeName(), getDescriptor()); exp1 = builder.ref().equal(queryKey.get(getAttributeName()).value()); exp2 = getDescriptor().getObjectBuilder().getPrimaryKeyExpression().rebuildOn(queryKey); setSelectionCriteria(exp1.and(exp2)); }