/** * Create an expression literal but without null validation. * * @param value * @return expression literal */ protected <T> Expression<T> internalLiteral(T value){ return new ExpressionImpl<T>(metamodel, (Class<T>) (value == null? null: value.getClass()), new ConstantExpression(value, new ExpressionBuilder()), value); }
/** * Create expression to return current timestamp. * * @return expression for current timestamp */ public Expression<java.sql.Timestamp> currentTimestamp(){ return new ExpressionImpl(metamodel, ClassConstants.TIMESTAMP, new ExpressionBuilder().currentTimeStamp()); }
protected org.eclipse.persistence.expressions.Expression getBaseExpression() { if (this.roots.isEmpty()) { return new ExpressionBuilder(); } else { return ((RootImpl)this.roots.iterator().next()).getCurrentNode(); } }
public ParameterExpressionImpl(Metamodel metamodel, Class<T> javaType, String name){ super(metamodel, javaType, new ExpressionBuilder().getParameter(name, javaType)); this.name = name; this.internalName = name; }
/** * Create expression to return current date. * * @return expression for current date */ public Expression<java.sql.Date> currentDate(){ return new ExpressionImpl(metamodel, ClassConstants.SQLDATE, new ExpressionBuilder().currentDateDate()); }
/** * INTERNAL: * Initialize the expression builder which should be used for this query. If * there is a where clause, use its expression builder, otherwise * generate one and cache it. This helps avoid unnecessary rebuilds. */ protected void initializeDefaultBuilder() { initializeQuerySpecificDefaultBuilder(); if(defaultBuilder == null) { defaultBuilder = new ExpressionBuilder(); } }
public ParameterExpressionImpl(Metamodel metamodel, Class<T> javaType){ super(metamodel, javaType, null); this.internalName = String.valueOf(System.identityHashCode(this)); this.currentNode = new ExpressionBuilder().getParameter(this.internalName, javaType); }
/** * INTERNAL: * Initialize the expression builder which should be used for this query. If * there is a where clause, use its expression builder, otherwise * generate one and cache it. This helps avoid unnecessary rebuilds. */ protected void initializeDefaultBuilder() { initializeQuerySpecificDefaultBuilder(); if(defaultBuilder == null) { defaultBuilder = new ExpressionBuilder(); } }
/** * Create an expression for a null literal with the given type. * * @param resultClass type of the null literal * @return null expression literal */ public <T> Expression<T> nullLiteral(Class<T> resultClass){ return new ExpressionImpl<T>(metamodel, resultClass, new ConstantExpression(null, new ExpressionBuilder()), null); }
public Expression generateBaseBuilderExpression(GenerationContext context) { //create builder, and add it, and answer it //BUG 3106877: Need to create builder using the actual class (if using parallel expressions) if (context.useParallelExpressions()) { return new ExpressionBuilder(this.resolveClass(context)); } else { return new ExpressionBuilder(); } }
/** * Create an expression literal. * * @param value * @return expression literal */ public <T> Expression<T> literal(T value){ if (value == null) { throw new IllegalArgumentException( ExceptionLocalization.buildMessage("jpa_criteriaapi_null_literal_value", new Object[]{})); } return new ExpressionImpl<T>(metamodel, (Class<T>) (value.getClass()), new ConstantExpression(value, new ExpressionBuilder()), value); }
/** * Create simple case expression. * * @param expression * to be tested against the case conditions * @return simple case expression */ public <C, R> SimpleCase<C, R> selectCase(Expression<? extends C> expression){ ArgumentListFunctionExpression caseStatement = new ExpressionBuilder().caseStatement(); return new SimpleCaseImpl(metamodel, Object.class, caseStatement, new ArrayList(), expression); }
/** * Add an "else" clause to the case expression. * @param result "else" result * @return expression */ public Expression<R> otherwise(R result){ org.eclipse.persistence.expressions.Expression resultExp = org.eclipse.persistence.expressions.Expression.from(result, new ExpressionBuilder()); ((ArgumentListFunctionExpression)currentNode).addRightMostChild(resultExp); return this; }
/** * PUBLIC: * Provide ascending order support for this direct collection mapping. */ public void addAscendingOrdering() { this.hasOrderBy = true; orderByExpressions.add(new ExpressionBuilder().getField(getDirectFieldName()).ascending()); }
/** * PUBLIC: * Provide descending order support for this direct collection mapping. */ public void addDescendingOrdering() { this.hasOrderBy = true; orderByExpressions.add(new ExpressionBuilder().getField(getDirectFieldName()).descending()); }
/** * Create a predicate corresponding to a some expression over the subquery * results. This is equivalent to an any expression. * * @param subquery * @return all expression */ public <Y> Expression<Y> some(Subquery<Y> subquery){ return new FunctionExpressionImpl<Y>(metamodel, (Class<Y>) subquery.getJavaType(), new ExpressionBuilder().some(((InternalSelection)subquery).getCurrentNode()), buildList(subquery), "some"); }
/** * Create a predicate corresponding to an any expression over the subquery * results. This is equivalent to a some expression. * * @param subquery * @return any expression */ public <Y> Expression<Y> any(Subquery<Y> subquery){ return new FunctionExpressionImpl<Y>(metamodel, (Class<Y>) subquery.getJavaType(), new ExpressionBuilder().any(((InternalSelection)subquery).getCurrentNode()), buildList(subquery), "any"); }
/** * {@inheritDoc} */ @Override public void visit(AbstractSchemaName expression) { ClassDescriptor descriptor = queryContext.getDescriptor(expression.getText()); type[0] = descriptor.getJavaClass(); queryExpression = new ExpressionBuilder(type[0]); }
/** * 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())); }
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; }