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(); } }
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 (hasBeenAliased()) { return initialValue; if (doesNotRepresentAnObjectInTheQuery()) { return initialValue; if (hasViewTable()) { DatabaseTable aliased = (DatabaseTable)viewTable.clone(); String alias = "t" + initialValue; aliased.setName(alias); assignAlias(alias, viewTable); aliasedViewTable = aliased; return initialValue + 1;
/** * 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: Find the alias for a given table. Handle the special case where we are bogus * and it should be aliased against our derived tables instead. */ public DatabaseTable aliasForTable(DatabaseTable table) { if (hasViewTable()) { return getAliasedViewTable(); } if (doesNotRepresentAnObjectInTheQuery()) { for (Enumeration e = derivedTables.elements(); e.hasMoreElements();) { TableExpression t = (TableExpression)e.nextElement(); DatabaseTable result = t.aliasForTable(table); if (result != null) { return result; } } } else { return super.aliasForTable(table); } return null;// No alias found in the derived tables }
/** */ public Expression generateExpression(GenerationContext context) { //create builder, and add Class baseClass = context.getBaseQueryClass(); ExpressionBuilder builder = new ExpressionBuilder(baseClass); Expression whereClause = builder.getParameter(getParameterName(), getType()); return whereClause; }
setBuilder(new ExpressionBuilder()); } else { setBuilder(getWhereClause().getBuilder()); builder.setSession(session.getRootSession(null)); if (!builder.doesNotRepresentAnObjectInTheQuery()) { if (descriptor != null) { Class queryClass = builder.getQueryClass(); builder.setQueryClass(descriptor.getJavaClass()); builder.normalize(normalizer);
newDescriptor = getSession().getDescriptor(((ExpressionBuilder)baseExp).getQueryClass()); ExpressionBuilder outerBuilder = new ExpressionBuilder(); outerBuilder.setQueryClass(newDescriptor.getJavaClass()); subSelect.setSelectionCriteria(baseExp.equal(outerBuilder).and(getSelectionCriteria())); } else { subSelect.setSelectionCriteria(baseExp.equal(outerBuilder)); setSelectionCriteria(outerBuilder.exists(subSelect)); count.setBaseExpression(outerBuilder); count.getChildren().setElementAt( outerBuilder, 0);
protected void initializeSelectionCriteria(AbstractSession session) { Expression exp1; Expression exp2; Expression expression; Expression criteria = null; Enumeration referenceKeysEnum; Enumeration sourceKeysEnum; ExpressionBuilder base = new ExpressionBuilder(); TableExpression table = (TableExpression)base.getTable(getReferenceTable()); referenceKeysEnum = getReferenceKeyFields().elements(); sourceKeysEnum = getSourceKeyFields().elements(); for (; referenceKeysEnum.hasMoreElements();) { DatabaseField referenceKey = (DatabaseField)referenceKeysEnum.nextElement(); DatabaseField sourceKey = (DatabaseField)sourceKeysEnum.nextElement(); exp1 = table.getField(referenceKey); exp2 = base.getParameter(sourceKey); expression = exp1.equal(exp2); if (criteria == null) { criteria = expression; } else { criteria = expression.and(criteria); } } setSelectionCriteria(criteria); }
/** * INTERNAL: * Initialize the expression to use for queries to the class and its subclasses. */ protected void initializeWithAllSubclassesExpression() throws DescriptorException { if (getWithAllSubclassesExpression() == null) { if (hasClassExtractor()) { return; } if (isChildDescriptor() && shouldReadSubclasses()) { setWithAllSubclassesExpression(new ExpressionBuilder().getField(getClassIndicatorField()).in(getAllChildClassIndicators())); } } }
if (clonedBuilder.wasQueryClassSetInternally() && ((ReportQuery)getQuery()).getExpressionBuilder() != clonedBuilder){ clonedBuilder = (ExpressionBuilder)clonedBuilder.copiedVersionFrom(clonedExpressions); attributeExpression = attributeExpression.rebuildOn(clonedBuilder); && !(((ExpressionBuilder)clonedBuilder).wasAdditionJoinCriteriaUsed()) ){ if (selectStatement.getWhereClause() == null ) { selectStatement.setWhereClause(item.getDescriptor().getQueryManager().getAdditionalJoinExpression().rebuildOn(clonedBuilder));
if (query.isObjectLevelReadQuery()){ ExpressionBuilder builder = ((ObjectLevelReadQuery)query).getExpressionBuilder(); if ((additionalJoin.getBuilder() != builder) && (additionalJoin.getBuilder().getQueryClass() == null)) { if ((!isSubSelect) && (builder != null)) { builder = (ExpressionBuilder)builder.copiedVersionFrom(clonedExpressions); additionalJoin.getBuilder().setWasAdditionJoinCriteriaUsed(true);
/** * INTERNAL: * Normalize an expression mapping all of the descriptor's tables to the view. * This is used to allow a descriptor to read from a view, but write to tables. * This is used in the multiple table and subclasses read so all of the descriptor's * possible tables must be mapped to the view. */ public void normalizeForView(AbstractSession theSession, ClassDescriptor theDescriptor, Dictionary clonedExpressions) { ExpressionBuilder builder; // bug 3878553 - alias all view selects. setRequiresAliases(true); if (getWhereClause() != null) { builder = getWhereClause().getBuilder(); } else { builder = new ExpressionBuilder(); setBuilder(builder); } builder.setViewTable((DatabaseTable)getTables().firstElement()); normalize(theSession, theDescriptor, clonedExpressions); }
/** */ public Expression addToExpression(Expression parentExpression, GenerationContext context) { if (isCollectionAttribute()) { //special case for NOT MEMBER OF if (context.hasMemberOfNode()) { return parentExpression.noneOf(name, new ExpressionBuilder().equal(context.getMemberOfNode().getLeftExpression())); } return outerJoin ? parentExpression.anyOfAllowingNone(name) : parentExpression.anyOf(name); } else { // check whether collection attribute is required if (requiresCollectionAttribute()) { throw EJBQLException.invalidCollectionMemberDecl( context.getParseTreeContext().getQueryInfo(), getLine(), getColumn(), name); } if (context.shouldUseOuterJoins() || isOuterJoin()) { return parentExpression.getAllowingNull(name); } else { return parentExpression.get(name); } } }
/** * INTERNAL: * Selection criteria is created with source foreign keys and target keys. */ protected void initializePrivateOwnedCriteria() { if (!isForeignKeyRelationship()) { setPrivateOwnedCriteria(getSelectionCriteria()); } else { Expression pkCriteria = getDescriptor().getObjectBuilder().getPrimaryKeyExpression(); ExpressionBuilder builder = new ExpressionBuilder(); Expression backRef = builder.getManualQueryKey(getAttributeName() + "-back-ref", getDescriptor()); Expression newPKCriteria = pkCriteria.rebuildOn(backRef); Expression twistedSelection = backRef.twist(getSelectionCriteria(), builder); if (getDescriptor().getQueryManager().getAdditionalJoinExpression() != null) { // We don't have to twist the additional join because it's all against the same node, which is our base // but we do have to rebuild it onto the manual query key Expression rebuiltAdditional = getDescriptor().getQueryManager().getAdditionalJoinExpression().rebuildOn(backRef); if (twistedSelection == null) { twistedSelection = rebuiltAdditional; } else { twistedSelection = twistedSelection.and(rebuiltAdditional); } } setPrivateOwnedCriteria(newPKCriteria.and(twistedSelection)); } }
tableName = getBuilder().aliasForTable(defaultTable).getName(); } else { tableName = defaultTable.getName();
/** * INTERNAL: * Override Expression.registerIn to check if the new base expression * has already been provided for the clone. * @see oracle.toplink.essentials.expressions.Expression#cloneUsing(Expression) * @bug 2637484 INVALID QUERY KEY EXCEPTION THROWN USING BATCH READS AND PARALLEL EXPRESSIONS */ protected Expression registerIn(Dictionary alreadyDone) { // Here do a special check to see if this a cloneUsing(newBase) call. Object value = alreadyDone.get(alreadyDone); if ((value == null) || (value == alreadyDone)) { // This is a normal cloning operation. return super.registerIn(alreadyDone); } ObjectExpression copy = (ObjectExpression)value; // copy is actually the newBase of a cloneUsing. alreadyDone.put(alreadyDone, alreadyDone); alreadyDone.put(this, copy); // Now need to copy over the derived expressions, etc. if (this.derivedExpressions != null) { if (copy.derivedExpressions == null) { copy.derivedExpressions = copyCollection(this.derivedExpressions, alreadyDone); } else { copy.derivedExpressions.addAll(copyCollection(this.derivedExpressions, alreadyDone)); } } // Do the same for these protected fields. copy.postCopyIn(alreadyDone, this.derivedFields, this.derivedTables); return copy; }
/** * INTERNAL: Alias the tables in all of our nodes. */ public void assignAliases(Vector allExpressions) { // For sub-selects all statements must share aliasing information. // For CR#2627019 currentAliasNumber = getCurrentAliasNumber(); ExpressionIterator iterator = new ExpressionIterator() { public void iterate(Expression each) { currentAliasNumber = each.assignTableAliasesStartingAt(currentAliasNumber); } }; if (allExpressions.isEmpty()) { // bug 3878553 - ensure aliases are always assigned for when required . if ((getBuilder() != null) && requiresAliases()) { getBuilder().assignTableAliasesStartingAt(currentAliasNumber); } } else { for (Enumeration expressionEnum = allExpressions.elements(); expressionEnum.hasMoreElements();) { Expression expression = (Expression)expressionEnum.nextElement(); iterator.iterateOn(expression); } } // For sub-selects update aliasing information of all statements. // For CR#2627019 setCurrentAliasNumber(currentAliasNumber); }
/** * INTERNAL: * Clone the query, including its selection criteria. * <p> * Normally selection criteria are not cloned here as they are cloned * later on during prepare. */ public Object deepClone() { ObjectLevelReadQuery clone = (ObjectLevelReadQuery)clone(); if (getSelectionCriteria() != null) { clone.setSelectionCriteria((Expression)getSelectionCriteria().clone()); } else if (defaultBuilder != null) { clone.defaultBuilder = (ExpressionBuilder)defaultBuilder.clone(); } return clone; }