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; }
/** * PUBLIC: * Return a new expression that applies the function to the given expression. */ public static Expression acos(Expression expression) { ExpressionOperator anOperator = expression.getOperator(ExpressionOperator.Acos); return anOperator.expressionFor(expression); }
/** * INTERNAL: * Print SQL */ public void printSQL(ExpressionSQLPrinter printer) { // If both sides are parameters, some databases don't allow binding. if (printer.getPlatform().isDynamicSQLRequiredForFunctions() && ((this.firstChild.isParameterExpression() || this.firstChild.isConstantExpression()) && (this.secondChild.isParameterExpression() || this.secondChild.isConstantExpression()))) { printer.getCall().setUsesBinding(false); } if (isEqualNull(printer)) { this.firstChild.isNull().printSQL(printer); } else if (isNotEqualNull(printer)) { this.firstChild.notNull().printSQL(printer); } else { super.printSQL(printer); } }
/** * 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); } }
/** * 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: * When given an expression, this method will return a new expression with the optimistic * locking values included. The values are taken from the passed in database row. * This expression will be used in a delete call. */ public Expression buildDeleteExpression(DatabaseTable table, Expression mainExpression, AbstractRecord row) { return mainExpression.and(buildExpression(table, row, null, mainExpression.getBuilder())); }
/** * 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)); }
/** * Check if the expression is an equal null expression, these must be handle in a special way in SQL. */ public boolean isEqualNull(ExpressionSQLPrinter printer) { if (isObjectComparison()) { return false; } else if (this.operator.getSelector() != ExpressionOperator.Equal) { return false; } else if (this.secondChild.isConstantExpression() && (((ConstantExpression)this.secondChild).getValue() == null)) { return true; } else if (this.secondChild.isParameterExpression() && (printer.getTranslationRow() != null) && (((ParameterExpression)this.secondChild).getValue(printer.getTranslationRow(), printer.getSession()) == null)) { return true; } else { return false; } }
/** * INTERNAL: * Print SQL onto the stream, using the ExpressionPrinter for context */ public void printSQL(ExpressionSQLPrinter printer) { // to support custom types, print expressions derived from field expressions and direct query keys with their aliases // Note: This is also necessary for TableExpressions, but they are taken care of by their associated FieldExpression. if (getBaseExpression() != null && getBaseExpression().isFieldExpression() || (getBaseExpression().isQueryKeyExpression() && ((QueryKeyExpression)getBaseExpression()).isAttribute())){ getBaseExpression().printSQL(printer); printer.printString("."); } printer.printField(getAliasedField()); }
/** * When distinct is used with order by the ordered fields must be in the select clause. */ protected void addOrderByExpressionToSelectForDistinct() { for (Expression orderExpression : getOrderByExpressions()) { Expression fieldExpression = orderExpression; while (fieldExpression.isFunctionExpression() && (fieldExpression.getOperator().isOrderOperator())) { fieldExpression = ((FunctionExpression)fieldExpression).getBaseExpression(); } // Changed to call a method to loop through the fields vector and check each element // individually. Jon D. May 4, 2000 for pr 7811 if ((fieldExpression.selectIfOrderedBy()) && !fieldsContainField(getFields(), fieldExpression)) { addField(fieldExpression); } } }
if (expression.isQueryKeyExpression()) { ((QueryKeyExpression)expression).getBuilder().setSession(session.getRootSession(null)); ((QueryKeyExpression)expression).getBuilder().setQueryClass(getDescriptor().getJavaClass()); DatabaseMapping mapping = ((QueryKeyExpression)expression).getMapping(); if (!((QueryKeyExpression)expression).getBaseExpression().isExpressionBuilder()) { if(foreignFields==null){ foreignFields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(); foreignFields.add(expression); }else{ foreignFields.addAll(expression.getSelectionFields(this)); throw QueryException.specifiedPartialAttributeDoesNotExist(this, expression.getName(), descriptor.getJavaClass().getName()); foreignFields.add(expression); }else{ foreignFields.addAll(expression.getSelectionFields(this)); localFields.addAll(expression.getSelectionFields(this));
/** * INTERNAL: * Normalize the expression into a printable structure. */ public Expression normalize(ExpressionNormalizer normalizer) { Expression expression = super.normalize(normalizer); // to support custom types, print expressions derived from field expressions, table expressions and direct query keys with their aliases if (getBaseExpression() != null && getBaseExpression().isFieldExpression() || getBaseExpression().isTableExpression() || (getBaseExpression().isQueryKeyExpression() && ((QueryKeyExpression)getBaseExpression()).isAttribute())){ getBuilder().getStatement().setRequiresAliases(true); } return expression; }
@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); }
if (expression.isQueryKeyExpression()) { ((QueryKeyExpression)expression).getBuilder().setSession(session.getRootSession(null)); ((QueryKeyExpression)expression).getBuilder().setQueryClass(getDescriptor().getJavaClass()); DatabaseMapping mapping = ((QueryKeyExpression)expression).getMapping(); if (!((QueryKeyExpression)expression).getBaseExpression().isExpressionBuilder()) { if(foreignFields==null){ foreignFields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(); foreignFields.add(expression); }else{ foreignFields.addAll(expression.getFields()); throw QueryException.specifiedPartialAttributeDoesNotExist(this, expression.getName(), descriptor.getJavaClass().getName()); foreignFields.add(expression); }else{ foreignFields.addAll(expression.getFields()); localFields.addAll(expression.getFields());
public void setWhereClause(Expression expression) { whereClause = expression; if (expression != null) { builder = expression.getBuilder(); } }
public void printNull(ConstantExpression nullValueExpression) { if(session.getPlatform().shouldBindLiterals()) { DatabaseField field = null; Expression localBase = nullValueExpression.getLocalBase(); if(localBase != null && (localBase.isFieldExpression() || localBase.isQueryKeyExpression())) { field = ((DataExpression)localBase).getField(); } session.getPlatform().appendLiteralToCall(getCall(), getWriter(), field); } else { session.getPlatform().appendLiteralToCall(getCall(), getWriter(), null); } }
/** * INTERNAL: * Return the ordering query keys. * Used for Workbench integration. */ public List<Expression> getOrderByQueryKeyExpressions() { List<Expression> expressions = new ArrayList<Expression> (); if ((getSelectionQuery() != null) && getSelectionQuery().isReadAllQuery()) { for (Expression orderExpression : ((ReadAllQuery)getSelectionQuery()).getOrderByExpressions()) { if (orderExpression.isFunctionExpression() && ((FunctionExpression)orderExpression).getBaseExpression().isQueryKeyExpression()) { expressions.add(orderExpression); } } } return expressions; }
/** * Do any required validation for this node. Throw an exception if it's incorrect. * Ensure that both sides are not data expressions. */ public void validateNode() { if (this.firstChild != null) { if (this.firstChild.isDataExpression() || this.firstChild.isConstantExpression()) { throw QueryException.invalidExpression(this); } } if (this.secondChild != null) { if (this.secondChild.isDataExpression() || this.secondChild.isConstantExpression()) { throw QueryException.invalidExpression(this); } } }
/** * INTERNAL: * Return the value for in memory comparison. * This is only valid for valueable expressions. */ public Object valueFromObject(Object object, AbstractSession session, AbstractRecord translationRow, int valueHolderPolicy, boolean isObjectUnregistered) { // PERF: direct-access. if(this.localBase != null) { return this.localBase.getFieldValue(this.value, session); } return this.value; }
if (expression.isExpressionBuilder()) { ClassDescriptor baseDescriptor = getLeafDescriptorFor(baseExpression, rootDescriptor); if (expression.isMapEntryExpression()){ CollectionMapping mapping = (CollectionMapping)owningDescriptor.getObjectBuilder().getMappingForAttributeName(baseExpression.getName()); String attributeName = expression.getName();