if ((!isExpressionQuery()) || (!isDefaultPropertiesQuery())) { return super.equals(object); if (!getExpressionBuilder().equals(query.getExpressionBuilder())) { return false; if (hasJoining()) { if (!query.hasJoining()) { return false; List joinedAttributes = getJoinedAttributeManager().getJoinedAttributeExpressions(); List otherJoinedAttributes = query.getJoinedAttributeManager().getJoinedAttributeExpressions(); int size = joinedAttributes.size(); if (size != otherJoinedAttributes.size()) { } else if (query.hasJoining()) { return false; if (hasOrderByExpressions()) { if (!query.hasOrderByExpressions()) { return false; List orderBys = getOrderByExpressions(); List otherOrderBys = query.getOrderByExpressions(); int size = orderBys.size(); if (size != otherOrderBys.size()) { } else if (query.hasOrderByExpressions()) { return false;
if ((!shouldMaintainCache()) && shouldRefreshIdentityMapResult() && (!this.descriptor.isAggregateCollectionDescriptor())) { throw QueryException.refreshNotPossibleWithoutCache(this); if (shouldMaintainCache() && hasPartialAttributeExpressions()) { throw QueryException.cannotCachePartialObjects(this); if (hasAsOfClause() && (getSession().getAsOfClause() == null)) { if (shouldMaintainCache()) { throw QueryException.historicalQueriesMustPreserveGlobalCache(); } else if (!getSession().getPlatform().isOracle() && !getSession().getProject().hasGenericHistorySupport()) { throw QueryException.historicalQueriesOnlySupportedOnOracle(); if (hasPartialAttributeExpressions()) { for (int index = 0; index < getPartialAttributeExpressions().size(); index++) { Expression expression = getPartialAttributeExpressions().get(index); getJoinedAttributeManager().setIsToManyJoinQuery(true); if (!shouldOuterJoinSubclasses()) { setShouldOuterJoinSubclasses(getMaxRows()>0 || getFirstResult()>0 || (this.descriptor != null && this.descriptor.hasInheritance() && (this.descriptor.getInheritancePolicy().shouldOuterJoinSubclasses()|| this.getExpressionBuilder().isTreatUsed()) )); if (!shouldOuterJoinSubclasses() && this.descriptor.hasInheritance() && this.descriptor.getInheritancePolicy().requiresMultipleTableSubclassRead()) { getConcreteSubclassCalls(); if (hasJoining()) { getConcreteSubclassJoinedMappingIndexes(); getConcreteSubclassQueries();
Object result = null; if (!shouldMaintainCache() || isReadOnly()) { result = unitOfWork.getParent().executeQuery(this, translationRow); } else { result = execute(unitOfWork, translationRow);
/** * PUBLIC: * Add the ordering expression. This allows for ordering across relationships or functions. * Example: readAllQuery.addOrdering(expBuilder.get("address").get("city").toUpperCase().descending()) */ public void addOrdering(Expression orderingExpression) { getOrderByExpressions().add(orderingExpression); //Bug2804042 Must un-prepare if prepared as the SQL may change. setIsPrepared(false); setShouldOuterJoinSubclasses(true); }
/** * PUBLIC: * Specify the relationship attribute to be join fetched in this query. * The query will join the object(s) being read with the attribute, * this allows all of the data required for the object(s) to be read in a single query instead of (n) queries. * This should be used when the application knows that it requires the part for all of the objects being read. * * <p>Note: This cannot be used for objects where it is possible not to have a part, * as these objects will be omitted from the result set, * unless an outer join is used through passing and expression using "getAllowingNull". * To join fetch collection relationships use the addJoinedAttribute(Expression) using "anyOf" to "anyOfAllowingNone". * * <p>Example: query.addJoinedAttribute("address") * * @see #addJoinedAttribute(Expression) * @see ReadAllQuery#addBatchReadAttribute(Expression) */ public void addJoinedAttribute(String attributeName) { addJoinedAttribute(getExpressionBuilder().get(attributeName)); }
/** * INTERNAL: * Clone the query */ public Object clone() { ObjectLevelReadQuery cloneQuery = (ObjectLevelReadQuery)super.clone(); // Must also clone the joined expressions as always joined attribute will be added // don't use setters as this will trigger unprepare. if (cloneQuery.hasJoining()) { cloneQuery.joinedAttributeManager = (JoinedAttributeManager)cloneQuery.getJoinedAttributeManager().clone(); cloneQuery.joinedAttributeManager.setBaseQuery(cloneQuery); } if (hasNonFetchJoinedAttributeExpressions()){ cloneQuery.setNonFetchJoinAttributeExpressions(new ArrayList<Expression>(this.nonFetchJoinAttributeExpressions)); } // Don't use setters as that will trigger unprepare if (hasOrderByExpressions()) { cloneQuery.orderByExpressions = new ArrayList<Expression>(getOrderByExpressions()); } return cloneQuery; }
buildSelectionCriteria(this.session); checkDescriptor(this.session); if (hasJoining()) { this.joinedAttributeManager.prepareJoinExpressions(this.session); prepareFetchGroup(); if (getQueryMechanism().isExpressionQueryMechanism() && this.descriptor.getObjectBuilder().hasJoinedAttributes()) { getJoinedAttributeManager().processJoinedMappings(this.session); if (this.joinedAttributeManager.hasOrderByExpressions()) { for (Expression orderBy : this.joinedAttributeManager.getOrderByExpressions()) { addOrdering(orderBy); addAdditionalField(additionalField); setLockMode(ObjectBuildingQuery.NO_LOCK); } else if (this.lockModeType.contains(PESSIMISTIC_)) { setLockMode(ObjectBuildingQuery.LOCK); } else { if (timeout.intValue() == 0) { setLockMode(ObjectBuildingQuery.LOCK_NOWAIT); } else { this.lockingClause = ForUpdateClause.newInstance(timeout); if (isDefaultLock()) { setWasDefaultLockMode(true); ForUpdateOfClause lockingClause = null;
if (readQuery.shouldRefreshIdentityMapResult()) { method.addLine(queryIdentifier + ".setShouldRefreshIdentityMapResult(" + String.valueOf(readQuery.shouldRefreshIdentityMapResult()) + ");"); if (readQuery.getCacheUsage() != ObjectLevelReadQuery.UseDescriptorSetting) { String cacheUsage = "ObjectLevelReadQuery.UseDescriptorSetting"; if (readQuery.getCacheUsage() == ObjectLevelReadQuery.DoNotCheckCache) { cacheUsage = "ObjectLevelReadQuery.DoNotCheckCache"; } else if (readQuery.getCacheUsage() == ObjectLevelReadQuery.CheckCacheByExactPrimaryKey) { cacheUsage = "ObjectLevelReadQuery.CheckCacheByExactPrimaryKey"; } else if (readQuery.getCacheUsage() == ObjectLevelReadQuery.CheckCacheByPrimaryKey) { cacheUsage = "ObjectLevelReadQuery.CheckCacheByPrimaryKey"; } else if (readQuery.getCacheUsage() == ObjectLevelReadQuery.CheckCacheThenDatabase) { cacheUsage = "ObjectLevelReadQuery.CheckCacheThenDatabase"; } else if (readQuery.getCacheUsage() == ObjectLevelReadQuery.CheckCacheOnly) { cacheUsage = "ObjectLevelReadQuery.CheckCacheOnly"; } else if (readQuery.getCacheUsage() == ObjectLevelReadQuery.ConformResultsInUnitOfWork) { cacheUsage = "ObjectLevelReadQuery.ConformResultsInUnitOfWork"; if (readQuery.getLockMode() != ObjectLevelReadQuery.DEFAULT_LOCK_MODE) { String lockMode = null; if (readQuery.getLockMode() == ObjectLevelReadQuery.NO_LOCK && !readQuery.isReportQuery()) { lockMode = "ObjectLevelReadQuery.NO_LOCK"; } else if (readQuery.getLockMode() == ObjectLevelReadQuery.LOCK) { lockMode = "ObjectLevelReadQuery.LOCK"; } else if (readQuery.getLockMode() == ObjectLevelReadQuery.LOCK_NOWAIT) { lockMode = "ObjectLevelReadQuery.LOCK_NOWAIT"; if (readQuery.shouldRefreshRemoteIdentityMapResult()) { method.addLine(queryIdentifier + ".setShouldRefreshRemoteIdentityMapResult(" + String.valueOf(readQuery.shouldRefreshRemoteIdentityMapResult()) + ");");
if ((!shouldMaintainCache()) && shouldRefreshIdentityMapResult() && (!this.descriptor.isAggregateCollectionDescriptor())) { throw QueryException.refreshNotPossibleWithoutCache(this); if (shouldMaintainCache() && hasPartialAttributeExpressions()) { throw QueryException.cannotCachePartialObjects(this); if (hasAsOfClause() && (getSession().getAsOfClause() == null)) { if (shouldMaintainCache()) { throw QueryException.historicalQueriesMustPreserveGlobalCache(); } else if (!getSession().getPlatform().isOracle() && !getSession().getProject().hasGenericHistorySupport()) { throw QueryException.historicalQueriesOnlySupportedOnOracle(); if ((!this.descriptor.hasFetchGroupManager()) && ((getFetchGroup() != null) || (getFetchGroupName() != null))) { throw QueryException.fetchGroupValidOnlyIfFetchGroupManagerInDescriptor(this.descriptor.getJavaClassName(), getName()); if (hasJoining()) { getJoinedAttributeManager().prepareJoinExpressions(getSession()); if (hasPartialAttributeExpressions()) { for (int index = 0; index < getPartialAttributeExpressions().size(); index++) { Expression expression = getPartialAttributeExpressions().get(index); getJoinedAttributeManager().setIsToManyJoinQuery(true); if (!shouldOuterJoinSubclasses()) { setShouldOuterJoinSubclasses(getMaxRows()>0 || getFirstResult()>0 || (this.descriptor != null && this.descriptor.hasInheritance() && this.descriptor.getInheritancePolicy().shouldOuterJoinSubclasses()) ); if ((!shouldOuterJoinSubclasses()) && this.descriptor.hasInheritance() && this.descriptor.getInheritancePolicy().requiresMultipleTableSubclassRead()) {
ObjectLevelReadQuery query = (ObjectLevelReadQuery)getQuery(); selectStatement.setQuery(query); selectStatement.setLockingClause(query.getLockingClause()); selectStatement.setDistinctState(query.getDistinctState()); selectStatement.setTables((Vector)getDescriptor().getTables().clone()); selectStatement.setWhereClause(buildBaseSelectionCriteria(isSubSelect, clonedExpressions, shouldUseAdditionalJoinExpression)); if (query.hasDefaultBuilder() && !query.getExpressionBuilder().wasQueryClassSetInternally()){ selectStatement.setBuilder((ExpressionBuilder)query.getExpressionBuilder().copiedVersionFrom(clonedExpressions)); if (query.hasOrderByExpressions()) { selectStatement.setOrderByExpressions(cloneExpressions(query.getOrderByExpressions(), clonedExpressions)); if (query.hasNonFetchJoinedAttributeExpressions()) { selectStatement.setNonSelectFields(cloneExpressions(query.getNonFetchJoinAttributeExpressions(), clonedExpressions)); if (query.hasUnionExpressions()) { selectStatement.setUnionExpressions(cloneExpressions(query.getUnionExpressions(), clonedExpressions)); readAllquery.getDirection()); selectStatement.setHintString(query.getHintString()); selectStatement.setTranslationRow(getTranslationRow()); return selectStatement;
ObjectLevelReadQuery query = (ObjectLevelReadQuery)getQuery(); selectStatement.setQuery(query); selectStatement.setLockingClause(query.getLockingClause()); selectStatement.setDistinctState(query.getDistinctState()); selectStatement.setTables((Vector)getDescriptor().getTables().clone()); selectStatement.setWhereClause(buildBaseSelectionCriteria(isSubSelect, clonedExpressions)); if (!query.isReportQuery() && query.hasDefaultBuilder() && !query.getExpressionBuilder().wasQueryClassSetInternally()){ selectStatement.setBuilder((ExpressionBuilder)query.getExpressionBuilder().copiedVersionFrom(clonedExpressions)); if (query.hasOrderByExpressions()) { selectStatement.setOrderByExpressions(cloneExpressions(query.getOrderByExpressions(), clonedExpressions)); cloneExpressions(readAllquery.getOrderSiblingsByExpressions(), clonedExpressions)); selectStatement.setHintString(query.getHintString()); selectStatement.setTranslationRow(getTranslationRow()); return selectStatement;
interaction.setProperty(OPERATION, MongoOperation.FIND); interaction.setProperty(COLLECTION, ((EISDescriptor)query.getDescriptor()).getDataTypeName()); if (readQuery.getFirstResult() > 0) { interaction.setProperty(SKIP, readQuery.getFirstResult()); if (readQuery.getMaxRows() > 0) { interaction.setProperty(LIMIT, readQuery.getMaxRows()); if (readQuery.getFetchSize() > 0) { interaction.setProperty(BATCH_SIZE, readQuery.getMaxRows()); appendExpressionToQueryRow(statement.getWhereClause(), row, query); if (readQuery.hasOrderByExpressions()) { DatabaseRecord sort = new DatabaseRecord(); for (Expression orderBy : readQuery.getOrderByExpressions()) { appendExpressionToSortRow(orderBy, sort, query); if (readQuery.isReportQuery()) { DatabaseRecord select = new DatabaseRecord(); for (Object field : ((SQLSelectStatement)statement).getFields()) {
this.referenceClass = objectQuery.referenceClass; this.distinctState = objectQuery.distinctState; if (objectQuery.hasJoining()) { getJoinedAttributeManager().copyFrom(objectQuery.getJoinedAttributeManager()); if (objectQuery.hasBatchReadAttributes()) { this.batchFetchPolicy = objectQuery.getBatchFetchPolicy().clone(); this.additionalFields = objectQuery.additionalFields; this.partialAttributeExpressions = objectQuery.partialAttributeExpressions; if (objectQuery.hasOrderByExpressions()) { this.orderByExpressions = objectQuery.orderByExpressions; if (objectQuery.hasUnionExpressions()) { this.unionExpressions = objectQuery.unionExpressions;
/** * INTERNAL * Apply this node to the passed query */ public void applyToQuery(ObjectLevelReadQuery theQuery, GenerationContext context) { if (theQuery.isReportQuery()){ ReportQuery reportQuery = (ReportQuery)theQuery; reportQuery.addAttribute("date", generateExpression(context), type); } }
olrq.checkDescriptor(activeSession); ClassDescriptor descriptor = olrq.getDescriptor(); Expression expression = olrq.getExpressionBuilder(); while (tokenizer.hasMoreTokens()){ String token = tokenizer.nextToken(); olrq.addJoinedAttribute(expression); } else { throw new IllegalArgumentException(ExceptionLocalization.buildMessage("ejb30-wrong-type-for-query-hint",new Object[]{getQueryId(query), name, getPrintValue(valueToApply)}));
query.addNonFetchJoinedAttribute(((InternalSelection) join).getCurrentNode()); query.setDistinctState(ObjectLevelReadQuery.USE_DISTINCT); } else { query.setDistinctState(ObjectLevelReadQuery.DONT_USE_DISTINCT); if (query.hasJoining()) { query.setShouldFilterDuplicates(false); orderExp = orderExp.descending(); query.addOrdering(orderExp);
DatabaseQuery query = getDatabaseQueryInternal(); boolean isObjectLevelReadQuery = query.isObjectLevelReadQuery(); if (isFlushModeAUTO() && (!isObjectLevelReadQuery || !((ObjectLevelReadQuery)query).isReadOnly())) { performPreQueryFlush(); if (isObjectLevelReadQuery) { if (((ObjectLevelReadQuery)query).shouldConformResultsInUnitOfWork()) { cloneSharedQuery(); query = getDatabaseQueryInternal(); ((ObjectLevelReadQuery)query).setCacheUsage(ObjectLevelReadQuery.UseDescriptorSetting); shouldResetConformResultsInUnitOfWork = true; if (((ObjectLevelReadQuery)query).setLockModeType(lockMode.name(), (AbstractSession) getActiveSession())) { throw new PersistenceException(ExceptionLocalization.buildMessage("ejb30-wrong-lock_called_without_version_locking-index", null)); ((ObjectLevelReadQuery)query).conformResultsInUnitOfWork();
List<org.eclipse.persistence.expressions.Expression> list = ((FromImpl) this.roots.iterator().next()).findJoinFetches(); for (org.eclipse.persistence.expressions.Expression fetch : list) { query.addJoinedAttribute(fetch); query.setExpressionBuilder(list.get(0).getBuilder()); List<org.eclipse.persistence.expressions.Expression> list = ((FromImpl) this.roots.iterator().next()).findJoinFetches(); for (org.eclipse.persistence.expressions.Expression fetch : list) { query.addJoinedAttribute(fetch); query.setExpressionBuilder(((InternalSelection)selection).getCurrentNode().getBuilder()); query.setReferenceClass(((SelectionImpl) this.selection).getCurrentNode().getBuilder().getQueryClass()); if (!this.selection.isCompoundSelection() && ((InternalExpression) this.selection).isCompoundExpression()) { if (((FunctionExpressionImpl) this.selection).getOperation() == CriteriaBuilderImpl.SIZE) { query.setReferenceClass(this.queryType); ((ReportQuery) query).addItem(this.selection.getAlias(), ((SelectionImpl) this.selection).getCurrentNode(), ((FromImpl) this.selection).findJoinFetches()); ((ReportQuery) query).setShouldReturnSingleAttribute(true); List<org.eclipse.persistence.expressions.Expression> list = ((FromImpl) this.roots.iterator().next()).findJoinFetches(); if (!list.isEmpty()) { query.setExpressionBuilder(list.get(0).getBuilder()); // set the builder to one of the fetches bases. query.addJoinedAttribute(fetch); query.setExpressionBuilder(this.selection.currentNode.getBuilder()); if (query.getReferenceClass() == null){
this.referenceClass = objectQuery.referenceClass; this.distinctState = objectQuery.distinctState; if (objectQuery.hasJoining()) { JoinedAttributeManager thisManager = getJoinedAttributeManager(); JoinedAttributeManager queryManager = objectQuery.getJoinedAttributeManager(); thisManager.setJoinedAttributeExpressions_(queryManager.getJoinedAttributeExpressions()); thisManager.setJoinedMappingExpressions_(queryManager.getJoinedMappingExpressions()); this.additionalFields = objectQuery.additionalFields; this.partialAttributeExpressions = objectQuery.partialAttributeExpressions; if (objectQuery.hasOrderByExpressions()) { this.orderByExpressions = objectQuery.orderByExpressions;
/** * PUBLIC: * Order the query results by the object's attribute or query key name. */ public void addDescendingOrdering(String queryKeyName) { addOrdering(getExpressionBuilder().get(queryKeyName).descending()); }