/** * PUBLIC: * Function, return an expression that adds to a date based on * the specified datePart. This is eqivalent to the Sybase DATEADD funtion. * <p>Example: * <pre><blockquote> * TopLink: employee.get("date").addDate("year", 2) * Java: NA * SQL: DATEADD(date, 2, year) * </pre></blockquote> */ public Expression addDate(String datePart, int numberToAdd) { return addDate(datePart, new Integer(numberToAdd)); }
/** * PUBLIC: * Function, to add months to a date. */ public Expression addMonths(int months) { return addMonths(new Integer(months)); }
/** * INTERNAL: * Find the alias for a given table */ public DatabaseTable aliasForTable(DatabaseTable table) { return getBaseExpression().aliasForTable(table); }
/** * PUBLIC: * Return an expression that performs a key word search. * <p>Example: * <pre><blockquote> * TopLink: project.get("description").containsAllKeyWords("TopLink rdbms java") * </blockquote></pre> */ public Expression containsAllKeyWords(String spaceSeperatedKeyWords) { StringTokenizer tokenizer = new StringTokenizer(spaceSeperatedKeyWords); Expression expression = null; while (tokenizer.hasMoreTokens()) { String token = tokenizer.nextToken(); if (expression == null) { expression = containsSubstringIgnoringCase(token); } else { expression = expression.and(containsSubstringIgnoringCase(token)); } } if (expression == null) { return like("%"); } else { return expression; } }
/** * Delete all criteria is created with target foreign keys and source keys. * This criteria is then used to delete target records from the table. */ protected Expression getDeleteAllCriteria(AbstractSession session) { Expression expression; Expression criteria = null; Expression builder = new ExpressionBuilder(); for (Iterator keys = getTargetForeignKeyToSourceKeys().keySet().iterator(); keys.hasNext();) { DatabaseField targetForeignKey = (DatabaseField)keys.next(); DatabaseField sourceKey = (DatabaseField)getTargetForeignKeyToSourceKeys().get(targetForeignKey); expression = builder.getField(targetForeignKey).equal(builder.getParameter(sourceKey)); criteria = expression.and(criteria); } return criteria; }
Expression baseExp = count.getBaseExpression(); boolean distinctUsed = false; if (baseExp.isFunctionExpression() && (((FunctionExpression)baseExp).getOperator().getSelector() == ExpressionOperator.Distinct)) { distinctUsed = true; baseExp = ((FunctionExpression)baseExp).getBaseExpression(); if (baseExp.isQueryKeyExpression()) { } else if (baseExp.isExpressionBuilder()) { newDescriptor = getSession().getDescriptor(((ExpressionBuilder)baseExp).getQueryClass()); Expression countArg = baseExp.get(pk.getAttributeName()); if (distinctUsed) { countArg = countArg.distinct(); Expression countArg = baseExp.get(pk.getAttributeName()); while (pk.isAggregateObjectMapping()) { newDescriptor = ((AggregateObjectMapping)pk).getReferenceDescriptor(); pk = getMappingOfFirstPrimaryKey(newDescriptor); countArg = countArg.get(pk.getAttributeName()); if (clonedExpressions.get(baseExp.getBuilder()) != null) { baseExp = (QueryKeyExpression)baseExp.copiedVersionFrom(clonedExpressions); } else { baseExp = (QueryKeyExpression)baseExp.rebuildOn(getExpressionBuilder()); ExpressionBuilder countBuilder = baseExp.getBuilder(); ExpressionBuilder outerBuilder = new ExpressionBuilder();
if(getSecondChild().isFunctionExpression()) { FunctionExpression funcExp = (FunctionExpression)getSecondChild(); if(funcExp.getOperator().isAnyOrAll()) { ExpressionBuilder builder = getFirstChild().getBuilder(); subSelectCriteria = subBuilder.equal(getFirstChild()).and(subSelectCriteria); } else { subSelectCriteria = subBuilder.notEqual(getFirstChild()).and(subSelectCriteria); subSelectCriteria = subBuilder.notEqual(getFirstChild()).and(subSelectCriteria); } else { subSelectCriteria = subBuilder.equal(getFirstChild()).and(subSelectCriteria); return newExp.normalize(normalizer); getSecondChild().isQueryKeyExpression() &&//.equal(anyOf() or get()) first.setBaseExpression(first.getBaseExpression().normalize(normalizer)); if (getSecondChild().isConstantExpression()) { Object targetObject = ((ConstantExpression)getSecondChild()).getValue(); foreignKeyJoin = first.getMapping().buildObjectJoinExpression(first, targetObject, getSession()); } else if (getSecondChild().isObjectExpression() || getSecondChild().isParameterExpression()) { foreignKeyJoin = first.getMapping().buildObjectJoinExpression(first, getSecondChild(), getSession()); } else { if (getSecondChild().isConstantExpression()) { Expression keyExpression = first.getDescriptor().getObjectBuilder().buildPrimaryKeyExpressionFromObject(((ConstantExpression)getSecondChild()).getValue(), getSession());
sourceFieldsEnum.hasNext();) { DatabaseField field = (DatabaseField)sourceFieldsEnum.next(); Expression join = base.getField(field); if (expression.isObjectExpression() && ((ObjectExpression)expression).shouldUseOuterJoin()){ join = join.equalOuterJoin(join); } else { join = join.equal(join); foreignKeyJoin = foreignKeyJoin.and(join); DatabaseField targetField = (DatabaseField)targetFieldsEnum.next(); Expression join = null; if (expression.isObjectExpression() && ((ObjectExpression)expression).shouldUseOuterJoin()){ join = base.getField(sourceField).equalOuterJoin(argument.getField(targetField)); } else { join = base.getField(sourceField).equal(argument.getField(targetField)); foreignKeyJoin = foreignKeyJoin.and(join);
/** */ 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); } } }
expression = expression.copiedVersionFrom(clonedExpressions); expression = (Expression)additionalJoin.clone(); } else { 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 = additionalJoin.rebuildOn(builder); expression = expression.and(additionalJoin); additionalJoin.getBuilder().setWasAdditionJoinCriteriaUsed(true);
setBuilder(new ExpressionBuilder()); } else { setBuilder(getWhereClause().getBuilder()); ExpressionBuilder originalBuilder = expression.getBuilder(); if (originalBuilder != builder) { expression = expression.copiedVersionFrom(clonedExpressions); } else { expression = expression.rebuildOn(builder); startWithExpression = getStartWithExpression().rebuildOn(builder); allExpressions.addElement(startWithExpression); connectByExpression = getConnectByExpression().rebuildOn(builder); newRoot = oldRoot.normalize(normalizer); expression.normalize(normalizer); setNormalizedWhereClause(normalizer.getAdditionalExpression()); } else { setNormalizedWhereClause(newRoot.and(normalizer.getAdditionalExpression()));
/** * PUBLIC: * Provide order support for queryKeyName in ascending order. * Called from the EJBAnnotationsProcessor when an @OrderBy on an * aggregate is found. */ public void addAggregateOrderBy(String aggregateName, String queryKeyName, boolean isDescending) { this.hasOrderBy = true; ReadAllQuery readAllQuery = (ReadAllQuery) getSelectionQuery(); ExpressionBuilder builder = readAllQuery.getExpressionBuilder(); Expression expression = builder.get(aggregateName).get(queryKeyName).toUpperCase(); if (isDescending) { readAllQuery.addOrdering(expression.descending()); } else { readAllQuery.addOrdering(expression.ascending()); } }
/** * INTERNAL: * Append the branch with all subclasses expression to the statement. */ public void appendWithAllSubclassesExpression(SQLSelectStatement selectStatement) { if (getWithAllSubclassesExpression() != null) { // For Flashback: Must always rebuild with simple expression on right. if (selectStatement.getWhereClause() == null) { selectStatement.setWhereClause((Expression)getWithAllSubclassesExpression().clone()); } else { selectStatement.setWhereClause(selectStatement.getWhereClause().and(getWithAllSubclassesExpression())); } } }
ExpressionBuilder clonedBuilder = attributeExpression.getBuilder(); if (clonedBuilder.wasQueryClassSetInternally() && ((ReportQuery)getQuery()).getExpressionBuilder() != clonedBuilder){ attributeExpression = attributeExpression.rebuildOn(clonedBuilder); }else if (clonedExpressions != null && clonedExpressions.get(clonedBuilder) != null) { Expression cloneExpression = (Expression)clonedExpressions.get(attributeExpression); if ((cloneExpression != null) && !cloneExpression.isExpressionBuilder()) { attributeExpression = cloneExpression; } else { attributeExpression = attributeExpression.rebuildOn(clonedBuilder); if (attributeExpression.isExpressionBuilder() && item.getDescriptor().getQueryManager().getAdditionalJoinExpression() != null && !(((ExpressionBuilder)clonedBuilder).wasAdditionJoinCriteriaUsed()) ){ if (selectStatement.getWhereClause() == null ) { selectStatement.setWhereClause(item.getDescriptor().getQueryManager().getAdditionalJoinExpression().rebuildOn(clonedBuilder)); } else { selectStatement.setWhereClause(selectStatement.getWhereClause().and(item.getDescriptor().getQueryManager().getAdditionalJoinExpression().rebuildOn(clonedBuilder)));
/** * INTERNAL: * Used to allow object level comparisons. */ public Expression buildObjectJoinExpression(Expression expression, Expression argument, AbstractSession session) { Expression attributeByAttributeComparison = null; //Enumeration mappingsEnum = getSourceToTargetKeyFields().elements(); Enumeration mappingsEnum = getReferenceDescriptor().getMappings().elements(); for (; mappingsEnum.hasMoreElements();) { DatabaseMapping mapping = (DatabaseMapping)mappingsEnum.nextElement(); String attributeName = mapping.getAttributeName(); Expression join = expression.get(attributeName).equal(argument.get(attributeName)); if (attributeByAttributeComparison == null) { attributeByAttributeComparison = join; } else { attributeByAttributeComparison = attributeByAttributeComparison.and(join); } } return attributeByAttributeComparison; }
/** * INTERNAL: * Return the expression to join the main table of this node to any auxiliary tables. */ public Expression additionalExpressionCriteria() { if (getDescriptor() == null) { return null; } Expression criteria = getDescriptor().getQueryManager().getAdditionalJoinExpression(); if (criteria != null) { criteria = getBaseExpression().twist(criteria, this); if (shouldUseOuterJoin() && getSession().getPlatform().shouldPrintOuterJoinInWhereClause()) { criteria.convertToUseOuterJoin(); } } if(getSession().getPlatform().shouldPrintOuterJoinInWhereClause()) { if(isUsingOuterJoinForMultitableInheritance()) { Expression childrenCriteria = getDescriptor().getInheritancePolicy().getChildrenJoinExpression(); childrenCriteria = getBaseExpression().twist(childrenCriteria, this); childrenCriteria.convertToUseOuterJoin(); if(criteria == null) { criteria = childrenCriteria; } else { criteria = criteria.and(childrenCriteria); } } } return criteria; }
/** * INTERNAL: * Assign aliases to any tables which I own. Start with t<initialValue>, * and return the new value of the counter , i.e. if initialValue is one * and I have tables ADDRESS and EMPLOYEE I will assign them t1 and t2 respectively, and return 3. */ public int assignTableAliasesStartingAt(int initialValue) { if (hasBeenAliased()) { return initialValue; } int counter = initialValue; Vector ownedTables = getOwnedTables(); if (ownedTables != null) { for (Enumeration e = ownedTables.elements(); e.hasMoreElements();) { assignAlias("t" + counter, (DatabaseTable)e.nextElement()); counter++; } } return counter; }