protected void initializeSelectionStatement(AbstractSession session) { SQLSelectStatement statement = new SQLSelectStatement(); statement.addTable(getReferenceTable()); statement.addField((DatabaseField)getDirectField().clone()); statement.setWhereClause(getSelectionCriteria()); if(listOrderField != null) { Expression expField = getListOrderFieldExpression(statement.getBuilder()); statement.addField(expField); } statement.normalize(session, null); getSelectionQuery().setSQLStatement(statement); }
if (getWhereClause() != null) { iterator.iterateOn(getWhereClause()); } else if (hasOuterJoinExpressions()) { Expression outerJoinCriteria = getOuterJoinExpressionsHolders().get(0).joinExpression; if (outerJoinCriteria != null){ iterator.iterateOn(outerJoinCriteria); for (Object field : getFields()) { if (field instanceof Expression) { iterator.iterateOn((Expression)field); if (hasNonSelectFields()) { for (Object field : getNonSelectFields()) { if (field instanceof Expression) { iterator.iterateOn((Expression)field); iterator.iterateOn(getBuilder()); setTableAliases(allTables); addTable(table);
try { Vector selectFields = null; printer.setRequiresDistinct(shouldDistinctBeUsed()); if (hasUnionExpressions()) { int size = getUnionExpressions().size(); for (int index = 0; index < size; index++) { printer.printString("("); if (getHintString() != null) { printer.printString(getHintString()); printer.printString(" "); if (shouldDistinctBeUsed()) { printer.printString("DISTINCT "); selectFields = writeFieldsIn(printer); setUseUniqueFieldAliases(false); appendFromClauseToWriter(printer); if (!(getWhereClause() == null)) { printer.printString(" WHERE "); printer.printExpression(getWhereClause()); if (hasHierarchicalQueryExpressions()) { appendHierarchicalQueryClauseToWriter(printer);
/** * INTERNAL: */ protected Vector writeFieldsIn(ExpressionSQLPrinter printer) { this.lastTable = null; Vector newFields = NonSynchronizedVector.newInstance(); for (Object next : getFields()) { // Fields can be null placeholders for fetch groups. if (next != null) { if (next instanceof Expression) { writeFieldsFromExpression(printer, (Expression)next, newFields); } else { writeField(printer, (DatabaseField)next); newFields.add(next); } } } return newFields; }
/** * 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, Map 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(getTables().get(0)); normalize(theSession, theDescriptor, clonedExpressions); }
if (getBuilder() == null) { if (getWhereClause() == null) { setBuilder(new ExpressionBuilder()); } else { setBuilder(getWhereClause().getBuilder()); ExpressionBuilder builder = getBuilder(); if ((session.getAsOfClause() != null) && !isSubSelect()) { getWhereClause().asOf(session.getAsOfClause()); } else if (builder.hasAsOfClause() && builder.getAsOfClause().isUniversal()) { getWhereClause().asOf(((UniversalAsOfClause)builder.getAsOfClause()).getAsOfClause()); if (getWhereClause() == builder) { setWhereClause(null); rebuildAndAddExpressions(getFields(), allExpressions, builder, clonedExpressions); if (hasNonSelectFields()) { rebuildAndAddExpressions(getNonSelectFields(), allExpressions, builder, clonedExpressions); if (hasGroupByExpressions()) { rebuildAndAddExpressions(getGroupByExpressions(), allExpressions, builder, clonedExpressions); if (hasUnionExpressions()) { rebuildAndAddExpressions(getUnionExpressions(), allExpressions, builder, clonedExpressions); if (hasHavingExpression()) {
if (getBuilder() == null) { if (getWhereClause() == null) { setBuilder(new ExpressionBuilder()); } else { setBuilder(getWhereClause().getBuilder()); ExpressionBuilder builder = getBuilder(); if ((session.getAsOfClause() != null) && !isSubSelect()) { getWhereClause().asOf(session.getAsOfClause()); } else if (builder.hasAsOfClause() && builder.getAsOfClause().isUniversal()) { getWhereClause().asOf(((UniversalAsOfClause)builder.getAsOfClause()).getAsOfClause()); if (getWhereClause() == builder) { setWhereClause(null); rebuildAndAddExpressions(getFields(), allExpressions, builder, clonedExpressions); if (hasNonSelectFields()) { rebuildAndAddExpressions(getNonSelectFields(), allExpressions, builder, clonedExpressions); if (hasGroupByExpressions()) { rebuildAndAddExpressions(getGroupByExpressions(), allExpressions, builder, clonedExpressions); if (hasHavingExpression()) { Expression expression = getHavingExpression(); ExpressionBuilder originalBuilder = expression.getBuilder();
try { Vector selectFields = null; printer.setRequiresDistinct(shouldDistinctBeUsed()); printer.printString("SELECT "); if (getHintString() != null) { printer.printString(getHintString()); printer.printString(" "); if (shouldDistinctBeUsed()) { printer.printString("DISTINCT "); selectFields = writeFieldsIn(printer); setUseUniqueFieldAliases(false); appendFromClauseToWriter(printer); if (!(getWhereClause() == null)) { printer.printString(" WHERE "); printer.printExpression(getWhereClause()); if (hasHierarchicalQueryExpressions()) { appendHierarchicalQueryClauseToWriter(printer); if (hasGroupByExpressions()) { appendGroupByClauseToWriter(printer); if (hasHavingExpression()) {
/** * INTERNAL: * Return a select statement that will be used to query the class indicators required to query. * This is used in the abstract-multiple read. */ public SQLSelectStatement buildClassIndicatorSelectStatement(ObjectLevelReadQuery query) { SQLSelectStatement selectStatement; selectStatement = new SQLSelectStatement(); selectStatement.useDistinct(); selectStatement.addTable(classIndicatorField.getTable()); selectStatement.addField(getClassIndicatorField()); // 2612538 - the default size of Map (32) is appropriate Map clonedExpressions = new IdentityHashMap(); selectStatement.setWhereClause(((ExpressionQueryMechanism)query.getQueryMechanism()).buildBaseSelectionCriteria(false, clonedExpressions)); appendWithAllSubclassesExpression(selectStatement); selectStatement.setTranslationRow(query.getTranslationRow()); if (query.isReadAllQuery() && ((ReadAllQuery)query).hasHierarchicalExpressions()) { ReadAllQuery readAllQuery = (ReadAllQuery)query; selectStatement.setHierarchicalQueryExpressions(readAllQuery.getStartWithExpression(), readAllQuery.getConnectByExpression(), readAllQuery.getOrderSiblingsByExpressions()); } selectStatement.setHintString(query.getHintString()); selectStatement.normalize(query.getSession(), getDescriptor(), clonedExpressions); return selectStatement; }
/** * Build the select statement for selecting the locator */ private SQLSelectStatement buildSelectStatementForLocator(WriteObjectQuery writeQuery, DatabaseCall call, AbstractSession session) { SQLSelectStatement selectStatement = new SQLSelectStatement(); Vector tables = writeQuery.getDescriptor().getTables(); selectStatement.setTables(tables); //rather than get ALL fields from the descriptor, only use the LOB-related fields to build the minimal SELECT statement. selectStatement.setFields(call.getContexts().getFields()); //the where clause setting here is sufficient if the object does not map to multiple tables. selectStatement.setWhereClause(writeQuery.getDescriptor().getObjectBuilder().buildPrimaryKeyExpressionFromObject(writeQuery.getObject(), session)); //need pessimistic locking for the locator select selectStatement.setLockingClause(ForUpdateClause.newInstance(ObjectBuildingQuery.LOCK)); if (tables.size() > 1) { //the primary key expression from the primary table Expression expression = selectStatement.getWhereClause(); //additional join from the non-primary tables Expression additionalJoin = writeQuery.getDescriptor().getQueryManager().getAdditionalJoinExpression(); if (additionalJoin != null) { expression = expression.and(additionalJoin); } //where clause now contains extra joins across all tables selectStatement.setWhereClause(expression); } //normalize the statement at the end, such as assign alias to all tables, and build sorting statement selectStatement.normalize(session, writeQuery.getDescriptor()); return selectStatement; }
/** * INTERNAL: * Get the ref for the object. * This is required for use by Refs, there might be a better way to do it when objID are supported. * (i.e. getting it from the object or identity map). */ public Ref getRef(Object object, AbstractSession session) { SQLSelectStatement statement = new SQLSelectStatement(); statement.addTable(getTables().firstElement());// Assumed only one for obj-rel descriptors. statement.getFields().addElement(new org.eclipse.persistence.expressions.ExpressionBuilder().ref()); statement.setWhereClause(getObjectBuilder().buildPrimaryKeyExpressionFromObject(object, session)); statement.setRequiresAliases(true); statement.normalize(session, this); ValueReadQuery valueQuery = new ValueReadQuery(); valueQuery.setSQLStatement(statement); valueQuery.checkPrepare(session, new DatabaseRecord(), true); // Must return unwrapped Ref on WLS. valueQuery.getCall().setIsNativeConnectionRequired(true); Ref ref = (Ref)session.executeQuery(valueQuery); return ref; }
/** * Return the appropriate select statement to perform a does exist check * @param field fields for does exist check. */ protected SQLSelectStatement buildSelectStatementForDoesExist(DatabaseField field) { // Build appropriate select statement SQLSelectStatement selectStatement; selectStatement = new SQLSelectStatement(); selectStatement.addField(field); selectStatement.setWhereClause(((Expression)getDescriptor().getObjectBuilder().getPrimaryKeyExpression().clone()).and(getDescriptor().getQueryManager().getAdditionalJoinExpression())); selectStatement.setTranslationRow(getTranslationRow()); selectStatement.normalize(getSession(), getQuery().getDescriptor()); selectStatement.setHintString(getQuery().getHintString()); return selectStatement; }
/** * INTERNAL: * Build a select statement for all subclasses on the view using the same * selection criteria as the query. */ public SQLSelectStatement buildViewSelectStatement(ObjectLevelReadQuery query) { // 2612538 - the default size of Map (32) is appropriate Map clonedExpressions = new IdentityHashMap(); ExpressionQueryMechanism mechanism = (ExpressionQueryMechanism)query.getQueryMechanism(); // CR#3166555 - Have the mechanism build the statement to avoid duplicating code and ensure that lock-mode, hints, hierarchical, etc. are set. SQLSelectStatement selectStatement = mechanism.buildBaseSelectStatement(false, clonedExpressions); selectStatement.setTables(org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(1)); selectStatement.addTable(getReadAllSubclassesView()); // Case, normal read for branch inheritance class that reads subclasses all in its own table(s). if (getWithAllSubclassesExpression() != null) { Expression branchIndicator = (Expression)getWithAllSubclassesExpression().clone(); if (branchIndicator != null) { selectStatement.setWhereClause(branchIndicator.and(selectStatement.getWhereClause())); } } selectStatement.setFields(mechanism.getSelectionFields(selectStatement, true)); selectStatement.normalizeForView(query.getSession(), getDescriptor(), clonedExpressions); // Allow for joining indexes to be computed to ensure distinct rows if (query.hasJoining()) { query.getJoinedAttributeManager().computeJoiningMappingIndexes(false, query.getSession(), 0); } return selectStatement; }
boolean shouldPrintUpdateClause = !printer.getPlatform().shouldPrintLockingClauseAfterWhereClause() && (getForUpdateClause() != null); Collection aliasesOfTablesToBeLocked = null; boolean shouldPrintUpdateClauseForAllTables = false; if(shouldPrintUpdateClause) { aliasesOfTablesToBeLocked = getForUpdateClause().getAliasesOfTablesToBeLocked(this); shouldPrintUpdateClauseForAllTables = aliasesOfTablesToBeLocked.size() == getTableAliases().size(); if (hasOuterJoinExpressions()) { if (session.getPlatform().isInformixOuterJoin()) { appendFromClauseForInformixOuterJoin(printer, outerJoinedAliases); } else if (!session.getPlatform().shouldPrintOuterJoinInWhereClause()) { appendFromClauseForOuterJoin(printer, outerJoinedAliases, aliasesOfTablesToBeLocked, shouldPrintUpdateClauseForAllTables); if (getTableAliases().isEmpty()) { throw QueryException.invalidBuilderInQuery(null);// Query is set in execute. for (Enumeration aliasesEnum = getTableAliases().keys(); aliasesEnum.hasMoreElements();) { DatabaseTable alias = (DatabaseTable)aliasesEnum.nextElement(); DatabaseTable table = (DatabaseTable)getTableAliases().get(alias); if (requiresAliases()) { if (!firstTable) { writer.write(", "); getForUpdateClause().printSQL(printer, this);
if (getWhereClause() != null) { iterator.iterateOn(getWhereClause()); } else if (hasOuterJoinExpressions()) { Expression outerJoinCriteria = (Expression)getOuterJoinedMappingCriteria().firstElement(); if (outerJoinCriteria != null){ iterator.iterateOn(outerJoinCriteria); for (Iterator fields = getFields().iterator(); fields.hasNext();) { Object field = fields.next(); if (field instanceof Expression) { iterator.iterateOn(getBuilder()); setTableAliases(allTables); addTable((DatabaseTable)e.nextElement());
/** * When distinct is used with order by the ordered fields must be in the select clause. */ protected void addOrderByExpressionToSelectForDistinct() { for (Expression orderExpression : getOrderByExpressions()) { Expression fieldExpression = orderExpression; while (fieldExpression.isFunctionExpression() && (fieldExpression.getOperator().isOrderOperator())) { fieldExpression = ((FunctionExpression)fieldExpression).getBaseExpression(); } // Changed to call a method to loop through the fields vector and check each element // individually. Jon D. May 4, 2000 for pr 7811 if ((fieldExpression.selectIfOrderedBy()) && !fieldsContainField(getFields(), fieldExpression)) { addField(fieldExpression); } } }
protected void initializeSelectionStatement(AbstractSession session) { if (selectionQuery.isReadAllQuery()){ ((ReadAllQuery)selectionQuery).addAdditionalField((DatabaseField)getDirectField().clone()); } else { SQLSelectStatement statement = (SQLSelectStatement)selectionQuery.getSQLStatement(); statement.addTable(getReferenceTable()); statement.addField((DatabaseField)getDirectField().clone()); getContainerPolicy().addAdditionalFieldsToQuery(selectionQuery, null); statement.normalize(session, null); } if (selectionQuery.isDirectReadQuery()){ ((DirectReadQuery)selectionQuery).setResultType(DataReadQuery.MAP); } }
selectStatementForExist.setTranslationRow(getQuery().getTranslationRow()); boolean isMainCase = selectStatementForExist.requiresAliases(); if(isMainCase) { if(getExecutionSession().getPlatform().shouldAlwaysUseTempStorageForModifyAll()) { selectCallForExist = (SQLCall)selectStatementForExist.buildCall(getSession()); if(selectCallForExist != null) { expIterator.setResult(selectCallForExistFields); expIterator.iterateOn(selectStatementForExist.getWhereClause()); expIterator.iterateOn((Expression)selStatement.getFields().get(0)); expIterator.iterateOn(selStatement.getWhereClause());
/** * Return the appropriate select statement containing the fields in the table. * This is used as a second read to a concrete class with subclasses in an abstract-multiple table read. */ protected SQLSelectStatement buildConcreteSelectStatement() { // 2612538 - the default size of Map (32) is appropriate Map clonedExpressions = new IdentityHashMap(); SQLSelectStatement selectStatement = buildBaseSelectStatement(false, clonedExpressions); // Case of class with subclasses that also has instances on abstract-multiple table read. if (getDescriptor().hasInheritance() && getDescriptor().getInheritancePolicy().shouldReadSubclasses()) { Expression concrete = getDescriptor().getInheritancePolicy().getOnlyInstancesExpression(); if ((concrete != null) && (selectStatement.getWhereClause() != null)) { selectStatement.setWhereClause(selectStatement.getWhereClause().and(concrete)); } else if (concrete != null) { selectStatement.setWhereClause((Expression)concrete.clone()); } } selectStatement.setFields(getSelectionFields(selectStatement, false)); selectStatement.normalize(getSession(), getDescriptor(), clonedExpressions); // Allow for joining indexes to be computed to ensure distinct rows. if (((ObjectLevelReadQuery)getQuery()).hasJoining()) { ((ObjectLevelReadQuery)getQuery()).getJoinedAttributeManager().computeJoiningMappingIndexes(false, getSession(), 0); } return selectStatement; }
/** * INTERNAL: * Used by DirectMapMapping to rebuild select query. */ protected void initOrRebuildSelectQuery() { this.selectionQuery.setSQLStatement(new SQLSelectStatement()); }