/** * Add an attribute represented by the given attribute name to the list of joins for this query. * Note: Mapping level joins are represented separately from query level joins. */ public void addJoinedMapping(String attributeName) { addJoinedMappingExpression(this.baseExpressionBuilder.get(attributeName)); }
/** * 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 void setSelectionCriteria(Expression expression) { super.setSelectionCriteria(expression); if ((expression != null) && (defaultBuilder != null) && (defaultBuilder.getQueryClass() == null)){ // For flashback: Must make sure expression and defaultBuilder always in sync. ExpressionBuilder newBuilder = expression.getBuilder(); if (newBuilder != defaultBuilder) { if (hasAsOfClause() && getAsOfClause().isUniversal()) { newBuilder.asOf(defaultBuilder.getAsOfClause()); } defaultBuilder = newBuilder; } } }
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()); }
/** * 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()); }
if (hasBeenNormalized()) { return this; } else { setHasBeenNormalized(true); setSession(normalizer.getSession().getRootSession(null)); if (getDescriptor() == null) { throw QueryException.noExpressionBuilderFound(this); criteria = getDescriptor().getQueryManager().getAdditionalJoinExpression(); if (criteria != null) { criteria = twist(criteria, this); if (isUsingOuterJoinForMultitableInheritance() && getSession().getPlatform().shouldPrintOuterJoinInWhereClause()) { Expression childrenCriteria = getDescriptor().getInheritancePolicy().getChildrenJoinExpression(); childrenCriteria = this.twist(childrenCriteria, this); childrenCriteria.convertToUseOuterJoin(); if(criteria == null) { if (isUsingOuterJoinForMultitableInheritance() && (!getSession().getPlatform().shouldPrintOuterJoinInWhereClause())) { normalizer.getStatement().getOuterJoinExpressions().addElement(null); normalizer.getStatement().getOuterJoinedMappingCriteria().addElement(null); normalizer.getStatement().getOuterJoinedAdditionalJoinCriteria().addElement(additionalExpressionCriteriaMap()); normalizer.getStatement().getDescriptorsForMultitableInheritanceOnly().add(this.getDescriptor()); setStatement(normalizer.getStatement()); if (getAsOfClause() == null) { asOf(AsOfClause.NO_CLAUSE);
ExpressionBuilder builder = new ExpressionBuilder(this.referenceClass); builder.setQueryClassAndDescriptor(this.referenceClass, getReferenceDescriptor()); ReadAllQuery batchQuery = new ReadAllQuery(this.referenceClass, builder); batchQuery.setName(getAttributeName()); ExpressionBuilder subBuilder = new ExpressionBuilder(descriptorToUse.getJavaClass()); subBuilder.setQueryClassAndDescriptor(descriptorToUse.getJavaClass(), descriptorToUse); ReportQuery subQuery = new ReportQuery(descriptorToUse.getJavaClass(), subBuilder); subQuery.setDescriptor(descriptorToUse); subQuery.setShouldRetrieveFirstPrimaryKey(true); Expression subCriteria = subBuilder.twist(getSelectionCriteria(), builder); if (query.getSelectionCriteria() != null) { subBuilder.asOf(query.getSession().getAsOfClause()); } else if (batchQuery.getAsOfClause() == null) { subBuilder.asOf(AsOfClause.NO_CLAUSE); } else { subBuilder.asOf(batchQuery.getAsOfClause()); batchSelectionCriteria = builder.exists(subQuery); } else if (batchType == BatchFetchType.IN) { Expression backRef = builder.getManualQueryKey(getAttributeName() + "-back-ref", descriptorToUse); batchSelectionCriteria = backRef.twist(getSelectionCriteria(), builder); if (query.getSelectionCriteria() != null) { if (expressionBuilder.getQueryClass() == null) { expressionBuilder.setQueryClass(query.getReferenceClass());
builder = new ExpressionBuilder(); builder.asOf(query.getAsOfClause()); ExpressionBuilder subBuilder = new ExpressionBuilder(descriptorToUse.getJavaClass()); subBuilder.setQueryClassAndDescriptor(descriptorToUse.getJavaClass(), descriptorToUse); ReportQuery subQuery = new ReportQuery(descriptorToUse.getJavaClass(), subBuilder); subQuery.setDescriptor(descriptorToUse); subQuery.setShouldRetrieveFirstPrimaryKey(true); Expression subCriteria = subBuilder.twist(getSelectionCriteria(), builder); if (query.getSelectionCriteria() != null) { batchSelectionCriteria = builder.exists(subQuery); } else if (batchType == BatchFetchType.IN) { batchSelectionCriteria = builder.twist(this.selectionQuery.getSelectionCriteria(), builder); } else { batchSelectionCriteria = builder.twist(this.selectionQuery.getSQLStatement().getWhereClause(), builder); builder.asOf(query.getSession().getAsOfClause()); } else if (builder.getAsOfClause() == null) { builder.asOf(AsOfClause.NO_CLAUSE); batchStatement.addField(builder.getTable(this.referenceTable).getField(keyField)); batchStatement.addField(builder.getTable(this.referenceTable).getField(this.directField)); batchStatement.setWhereClause(batchSelectionCriteria); batchQuery.setSQLStatement(batchStatement);
/** * Add the mapping for join fetch, prepare and return the join expression being used. */ public Expression addAndPrepareJoinedMapping(ForeignReferenceMapping mapping, AbstractSession session) { Expression joinMappingExpression = null; if (mapping.isCollectionMapping()) { if (mapping.isInnerJoinFetched()) { joinMappingExpression = getBaseExpressionBuilder().anyOf(mapping.getAttributeName(), false); } else if (mapping.isOuterJoinFetched()) { joinMappingExpression = getBaseExpressionBuilder().anyOfAllowingNone(mapping.getAttributeName(), false); } } else { if (mapping.isInnerJoinFetched()) { joinMappingExpression = getBaseExpressionBuilder().get(mapping.getAttributeName()); } else if (mapping.isOuterJoinFetched()) { joinMappingExpression = getBaseExpressionBuilder().getAllowingNull(mapping.getAttributeName()); } } if (joinMappingExpression != null) { joinMappingExpression = prepareJoinExpression(joinMappingExpression, session); addJoinedMappingExpression(joinMappingExpression); } return joinMappingExpression; }
if (hasBeenAliased()) { return initialValue; if (doesNotRepresentAnObjectInTheQuery()) { return initialValue; if (hasViewTable()) { DatabaseTable aliased = viewTable.clone(); String alias = "t" + initialValue; aliased.setName(alias); assignAlias(alias, viewTable); aliasedViewTable = aliased; hasBeenAliased = true;
builder = new ExpressionBuilder(); builder.asOf(query.getAsOfClause()); twisted = builder.twist(getSelectionQuery().getSelectionCriteria(), builder); } else { twisted = builder.twist(getSelectionQuery().getSQLStatement().getWhereClause(), builder); builder.asOf(query.getSession().getAsOfClause()); } else if (builder.getAsOfClause() == null) { builder.asOf(AsOfClause.NO_CLAUSE); batchStatement.addField(builder.getTable(getReferenceTable()).getField((DatabaseField)enumtr.nextElement())); batchStatement.addField(builder.getTable(getReferenceTable()).getField(getDirectField()));
/** * Return if the expression is by primary key. */ public boolean isPrimaryKeyExpression(boolean requiresExactMatch, Expression expression, AbstractSession session) { expression.getBuilder().setSession(session.getRootSession(null)); List<DatabaseField> keyFields = this.descriptor.getPrimaryKeyFields(); int size = keyFields.size(); Set<DatabaseField> fields = new HashSet(size); boolean isValid = expression.extractFields(requiresExactMatch, true, this.descriptor, keyFields, fields); if (requiresExactMatch && (!isValid)) { return false; } // Check that the sizes match. if (fields.size() != size) { return false; } return true; }
statement.getBuilder().asOf(((ObjectLevelReadQuery)sourceQuery).getAsOfClause()); ExpressionBuilder builder = statement.getBuilder(); if (sourceQuery.getSession().getAsOfClause() != null) { builder.asOf(sourceQuery.getSession().getAsOfClause()); } else if (builder.getAsOfClause() == null) { builder.asOf(AsOfClause.NO_CLAUSE); if (builder.hasAsOfClause()) { statement.getTables().set(0, getHistoryPolicy().getHistoricalTables().elementAt(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())); }
/** * PUBLIC: * Provide ascending order support for this direct collection mapping. */ public void addAscendingOrdering() { this.hasOrderBy = true; orderByExpressions.add(new ExpressionBuilder().getField(getDirectFieldName()).ascending()); }
/** * INTERNAL: * Add additional fields and check for history. */ protected void postPrepareNestedBatchQuery(ReadQuery batchQuery, ReadAllQuery query) { ReadAllQuery mappingBatchQuery = (ReadAllQuery)batchQuery; mappingBatchQuery.setShouldIncludeData(true); for (Enumeration relationFieldsEnum = getSourceRelationKeyFields().elements(); relationFieldsEnum.hasMoreElements();) { mappingBatchQuery.getAdditionalFields().add(mappingBatchQuery.getExpressionBuilder().getTable(getRelationTable()).getField((DatabaseField)relationFieldsEnum.nextElement())); } if (getHistoryPolicy() != null) { ExpressionBuilder builder = mappingBatchQuery.getExpressionBuilder(); Expression twisted = batchQuery.getSelectionCriteria(); if (query.getSession().getAsOfClause() != null) { builder.asOf(query.getSession().getAsOfClause()); } else if (builder.getAsOfClause() == null) { builder.asOf(AsOfClause.NO_CLAUSE); } twisted = twisted.and(getHistoryPolicy().additionalHistoryExpression(builder)); mappingBatchQuery.setSelectionCriteria(twisted); } }
/** * INTERNAL: * If the alias is for a query key item, then return its descriptor. * If it is for a function, then it has no descriptor. */ @Override public ClassDescriptor getContainingDescriptor() { AbstractSession session = getBuilder().getSession(); if (this.containingDescriptor == null) { Expression expression = getItem().getAttributeExpression(); if (expression.isQueryKeyExpression()) { // Need to ensure expression has a session before getting its descriptor. if (expression.getBuilder().getSession() == null) { expression.getBuilder().setSession(session); } this.containingDescriptor = ((QueryKeyExpression)expression).getContainingDescriptor(); return this.containingDescriptor; } return null; } return containingDescriptor; }
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; }
/** * INTERNAL: * Add additional fields and check for history. */ @Override protected void postPrepareNestedBatchQuery(ReadQuery batchQuery, ObjectLevelReadQuery query) { super.postPrepareNestedBatchQuery(batchQuery, query); ReadAllQuery mappingBatchQuery = (ReadAllQuery)batchQuery; this.mechanism.postPrepareNestedBatchQuery(batchQuery, query); if (this.historyPolicy != null) { ExpressionBuilder builder = mappingBatchQuery.getExpressionBuilder(); Expression twisted = batchQuery.getSelectionCriteria(); if (query.getSession().getAsOfClause() != null) { builder.asOf(query.getSession().getAsOfClause()); } else if (builder.getAsOfClause() == null) { builder.asOf(AsOfClause.NO_CLAUSE); } twisted = twisted.and(this.historyPolicy.additionalHistoryExpression(builder, builder)); mappingBatchQuery.setSelectionCriteria(twisted); } }