/** * 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(); } }
/** * INTERNAL * Generate the a new TopLink ConstantExpression for this node. */ public Expression generateExpression(GenerationContext context) { Expression whereClause = new ConstantExpression(getLiteral(), new ExpressionBuilder()); return whereClause; }
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(); } }
/** * INTERNAL * Generate the expression. */ public Expression generateExpression(GenerationContext context) { Expression whereClause = new ConstantExpression(new Integer(0), new ExpressionBuilder()); whereClause = ExpressionMath.subtract(whereClause, getLeft().generateExpression(context)); return whereClause; }
/** * 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; }
/** * This method would allow customers to get the potential selection criteria for a mapping * prior to initialization. This would allow them to more easily create an ammendment method * that would ammend the SQL for the join. * * CR#3922 - This method is almost the same as buildDefaultSelectionCriteria() the difference * is that TargetForeignKeysToSourceKeys contains more information after login then SourceKeyFields * contains before login. */ public Expression buildSelectionCriteria() { //CR3922 Expression selectionCriteria = null; Expression builder = new ExpressionBuilder(); Enumeration sourceKeys = this.getSourceKeyFields().elements(); for (Enumeration targetForeignKeys = this.getTargetForeignKeyFields().elements(); targetForeignKeys.hasMoreElements();) { DatabaseField targetForeignKey = (DatabaseField)targetForeignKeys.nextElement(); DatabaseField sourceKey = (DatabaseField)sourceKeys.nextElement(); Expression partialSelectionCriteria = builder.getField(targetForeignKey).equal(builder.getParameter(sourceKey)); selectionCriteria = partialSelectionCriteria.and(selectionCriteria); } return selectionCriteria; }
/** * The selection criteria are created with target foreign keys and source "primary" keys. * These criteria are then used to read the target records from the table. * These criteria are also used as the default "delete all" criteria. * * CR#3922 - This method is almost the same as buildSelectionCriteria() the difference * is that TargetForeignKeysToSourceKeys contains more information after login then SourceKeyFields * contains before login. */ protected Expression buildDefaultSelectionCriteria() { Expression selectionCriteria = null; Expression builder = new ExpressionBuilder(); for (Iterator keys = this.getTargetForeignKeysToSourceKeys().keySet().iterator(); keys.hasNext();) { DatabaseField targetForeignKey = (DatabaseField)keys.next(); DatabaseField sourceKey = (DatabaseField)this.getTargetForeignKeysToSourceKeys().get(targetForeignKey); Expression partialSelectionCriteria = builder.getField(targetForeignKey).equal(builder.getParameter(sourceKey)); selectionCriteria = partialSelectionCriteria.and(selectionCriteria); } return selectionCriteria; }
/** * Build the primary key expression from the specified primary key values. */ public Expression buildPrimaryKeyExpressionFromKeys(Vector primaryKeyValues, AbstractSession session) { Expression expression = null; Expression subExpression; Expression builder = new ExpressionBuilder(); List primaryKeyFields = getDescriptor().getPrimaryKeyFields(); for (int index = 0; index < primaryKeyFields.size(); index++) { Object value = primaryKeyValues.get(index); DatabaseField field = (DatabaseField)primaryKeyFields.get(index); if (value != null) { subExpression = builder.getField(field).equal(value); expression = subExpression.and(expression); } } return expression; }
/** * INTERNAL: * Selection criteria is created with target foreign keys and source keys. * This criteria is then used to read records from the target table. */ protected void initializeSelectionCriteria(AbstractSession session) { Expression expression; Expression criteria; 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(getSelectionCriteria()); setSelectionCriteria(criteria); } }
/** */ 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; }
/** * 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() { DatabaseQueryMechanism mech = getQueryMechanism(); if (mech.isExpressionQueryMechanism() && ((ExpressionQueryMechanism)mech).getExpressionBuilder() != null) { this.defaultBuilder = ((ExpressionQueryMechanism)mech).getExpressionBuilder(); return; } this.defaultBuilder = new ExpressionBuilder(); }
/** * Build the primary key expression for the secondary table. */ public Expression buildPrimaryKeyExpression(DatabaseTable table) throws DescriptorException { if (getDescriptor().getTables().firstElement().equals(table)) { return getPrimaryKeyExpression(); } Map keyMapping = (Map)getDescriptor().getAdditionalTablePrimaryKeyFields().get(table); if (keyMapping == null) { throw DescriptorException.multipleTablePrimaryKeyNotSpecified(getDescriptor()); } ExpressionBuilder builder = new ExpressionBuilder(); Expression expression = null; for (Iterator primaryKeyEnum = keyMapping.values().iterator(); primaryKeyEnum.hasNext();) { DatabaseField field = (DatabaseField)primaryKeyEnum.next(); expression = (builder.getField(field).equal(builder.getParameter(field))).and(expression); } return expression; }
/** * 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 * Generate the TopLink expression for this node */ public Expression generateExpression(GenerationContext context) { Expression expr = context.getBaseExpression(); if (expr == null) { expr = new ExpressionBuilder(); } Expression result = null; if (type == Date.class) { result = expr.currentDateDate(); } else if (type == Time.class) { result = expr.currentTime(); } else if (type == Timestamp.class) { result = expr.currentDate(); } return result; }
/** * INTERNAL * Initialize the base expression in the generation context. */ public void initBaseExpression(ModifyAllQuery theQuery, GenerationContext generationContext) { ModifyNode queryNode = (ModifyNode)getQueryNode(); String variable = queryNode.getCanonicalAbstractSchemaIdentifier(); Class referenceClass = theQuery.getReferenceClass(); // Create a new expression builder for the reference class ExpressionBuilder builder = new ExpressionBuilder(referenceClass); // Use the expression builder as the default expression builder for the query theQuery.setExpressionBuilder(builder); // Add the expression builder to the expression cache in the context generationContext.setBaseExpression(variable, builder); }
/** * 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); }
/** * Create an expression to represent one of the nodes on a SetToNode. * We will assume that set_to nodes change elements that are direct mappings on the reference * class of the query. */ protected Expression getExpressionForNode(Node node, Class referenceClass, GenerationContext context) { Expression expression = null; if (node.isAttributeNode()) { // look up a preexisting expression based on the reference class of the query. String classVariable = context.getParseTreeContext().getVariableNameForClass(referenceClass, context); expression = context.expressionFor(classVariable); if (expression == null) { expression = new ExpressionBuilder(); context.addExpression(expression, classVariable); } expression = node.addToExpression(expression, context); } else { expression = node.generateExpression(context); } return expression; }
/** * 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())); } } }
protected SQLSelectStatement createSQLSelectStatementForModifyAll(Expression whereClause, Expression inheritanceExpression, ClassDescriptor desc, boolean useCustomaryInheritanceExpression) { ExpressionBuilder builder; if(whereClause != null) { whereClause = (Expression)whereClause.clone(); builder = whereClause.getBuilder(); } else { builder = new ExpressionBuilder(); } ReportQuery reportQuery = new ReportQuery(desc.getJavaClass(), builder); reportQuery.setDescriptor(desc); reportQuery.setShouldRetrieveFirstPrimaryKey(true); reportQuery.setSelectionCriteria(whereClause); reportQuery.setSession(getSession()); return ((ExpressionQueryMechanism)reportQuery.getQueryMechanism()).buildReportQuerySelectStatement(false, useCustomaryInheritanceExpression, inheritanceExpression); }
public Expression generateExpressionForAlias(GenerationContext context) { // BUG 3105651: Verify if we need to resolve this alias, or just use // an empty ExpressionBuilder. See OrderByItemNode.generateExpression() // for more details if (context.getParseTree().getQueryNode().isSelectNode() && context.shouldCheckSelectNodeBeforeResolving() && (((SelectNode)context.getParseTree().getQueryNode()).isSelected(this.getCanonicalVariableName()))) { return new ExpressionBuilder(); } Node nodeForAlias = getNodeForAlias(context); //assume that if there is no node available for the given variable, then //there must be an alias mismatch. Assume they know their attribute names better //than their alias names. - JGL if (nodeForAlias == null) { throw EJBQLException.aliasResolutionException( context.getParseTreeContext().getQueryInfo(), getLine(), getColumn(), getVariableName()); } //create builder, and answer it return nodeForAlias.generateExpression(context); }