protected void buildExpectedResults() { ReadAllQuery query = new ReadAllQuery(); query.setReferenceClass(Employee.class); Vector employees = (Vector) getSession().executeQuery(query); Vector distinctEmployees = new Vector(); // initialize distinctEmployees distinctEmployees.addElement(employees.elementAt(0)); // check employees with duplicate province and add only distinct employees to distinctEmployees for (int i = 1; i < employees.size(); i++) { boolean duplicateFound = false; // iterate through distinctEmployees to check for duplicate provinces, if found, employee not // added for (int j = 0; j < distinctEmployees.size(); j++) { if ((((Employee) employees.elementAt(i)).getAddress().getProvince()) .equals((((Employee) distinctEmployees.elementAt(j)).getAddress().getProvince()))) { duplicateFound = true; } } if (!duplicateFound) { distinctEmployees.addElement(employees.elementAt(i)); } } for (Enumeration e = distinctEmployees.elements(); e.hasMoreElements(); ) { Employee emp = (Employee) e.nextElement(); Object[] result = new Object[1]; result[0] = emp.getAddress().getProvince(); addResult(result, null); } }
/** Append the string containing the SQL insert string for the given table. */ protected SQLCall buildCallWithoutReturning(AbstractSession session) { SQLCall call = new SQLCall(); call.returnNothing(); Writer writer = new CharArrayWriter(200); try { writer.write("INSERT "); if (getHintString() != null) { writer.write(getHintString()); writer.write(" "); } writer.write("INTO "); writer.write(getTable().getQualifiedNameDelimited(session.getPlatform())); writer.write(" ("); Vector fieldsForTable = new Vector(); for (Enumeration fieldsEnum = getModifyRow().keys(); fieldsEnum.hasMoreElements(); ) { DatabaseField field = (DatabaseField) fieldsEnum.nextElement(); if (field.getTable().equals(getTable()) || (!field.hasTableName())) { fieldsForTable.addElement(field); } } if (fieldsForTable.isEmpty()) { throw QueryException.objectToInsertIsEmpty(getTable()); } for (int i = 0; i < fieldsForTable.size(); i++) { writer.write( ((DatabaseField) fieldsForTable.elementAt(i)).getNameDelimited(session.getPlatform())); if ((i + 1) < fieldsForTable.size()) { writer.write(", "); } } writer.write(") VALUES ("); for (int i = 0; i < fieldsForTable.size(); i++) { DatabaseField field = (DatabaseField) fieldsForTable.elementAt(i); call.appendModify(writer, field); if ((i + 1) < fieldsForTable.size()) { writer.write(", "); } } writer.write(")"); call.setSQLString(writer.toString()); } catch (IOException exception) { throw ValidationException.fileError(exception); } return call; }
/** * Reset the commit order from the session's descriptors. This uses the constraint dependencies in * the descriptor's mappings, to decide which descriptors are dependent on which other * descriptors. Multiple computations of the commit order should produce the same ordering. This * is done to improve performance on unit of work writes through decreasing the stack size, and * acts as a deadlock avoidance mechanism. */ public void initializeCommitOrder() { Vector descriptors = Helper.buildVectorFromMapElements(getSession().getDescriptors()); // Must ensure uniqueness, some descriptor my be register twice for interfaces. descriptors = Helper.addAllUniqueToVector(new Vector(descriptors.size()), descriptors); Object[] descriptorsArray = new Object[descriptors.size()]; for (int index = 0; index < descriptors.size(); index++) { descriptorsArray[index] = descriptors.elementAt(index); } Arrays.sort(descriptorsArray, new DescriptorCompare()); descriptors = new Vector(descriptors.size()); for (int index = 0; index < descriptorsArray.length; index++) { descriptors.addElement(descriptorsArray[index]); } CommitOrderCalculator calculator = new CommitOrderCalculator(getSession()); calculator.addNodes(descriptors); calculator.calculateMappingDependencies(); calculator.orderCommits(); descriptors = calculator.getOrderedDescriptors(); calculator = new CommitOrderCalculator(getSession()); calculator.addNodes(descriptors); calculator.calculateSpecifiedDependencies(); calculator.orderCommits(); setCommitOrder(calculator.getOrderedClasses()); }
public Vector getParentInterfaceNames() { if (parentInterfaceNames.isEmpty() && !parentInterfaces.isEmpty()) { for (int i = 0; i < parentInterfaces.size(); i++) { parentInterfaceNames.addElement(((Class) parentInterfaces.elementAt(i)).getName()); } } return parentInterfaceNames; }
public Vector getAttributeFromAll(String attributeName, Vector objects) { ClassDescriptor descriptor = getSession().getClassDescriptor(getReferenceClass()); DirectToFieldMapping mapping = (DirectToFieldMapping) descriptor.getMappingForAttributeName(attributeName); Vector attributes = new Vector(); Object currentObject; for (int i = 0; i < objects.size(); i++) { currentObject = objects.elementAt(i); if (currentObject.getClass() == ReportQueryResult.class) { attributes.addElement(((ReportQueryResult) currentObject).get(attributeName)); } else { attributes.addElement(mapping.getAttributeValueFromObject(currentObject)); } } return attributes; }
/** * INTERNAL: Used in case outer joins should be printed in FROM clause. Each of the additional * tables mapped to expressions that joins it. */ public Map additionalExpressionCriteriaMap() { if (getDescriptor() == null) { return null; } HashMap tablesJoinExpressions = new HashMap(); Vector tables = getDescriptor().getTables(); // skip the main table - start with i=1 int tablesSize = tables.size(); if (shouldUseOuterJoin()) { for (int i = 1; i < tablesSize; i++) { DatabaseTable table = (DatabaseTable) tables.elementAt(i); Expression joinExpression = (Expression) getDescriptor().getQueryManager().getTablesJoinExpressions().get(table); joinExpression = getBaseExpression().twist(joinExpression, this); tablesJoinExpressions.put(table, joinExpression); } } if (isUsingOuterJoinForMultitableInheritance()) { List childrenTables = getDescriptor().getInheritancePolicy().getChildrenTables(); tablesSize = childrenTables.size(); for (int i = 0; i < tablesSize; i++) { DatabaseTable table = (DatabaseTable) childrenTables.get(i); Expression joinExpression = (Expression) getDescriptor() .getInheritancePolicy() .getChildrenTablesJoinExpressions() .get(table); joinExpression = getBaseExpression().twist(joinExpression, this); tablesJoinExpressions.put(table, joinExpression); } } return tablesJoinExpressions; }
/** * INTERNAL This method iterates through a collection and gets the values from the objects to * conform in an in-memory query. Creation date: (1/19/01 1:18:27 PM) */ public Object valuesFromCollection( Object object, AbstractSession session, int valueHolderPolicy, boolean isObjectUnregistered) { // in case the mapping is null - this can happen if a query key is being used // In this case, check for the query key and find it's mapping. boolean readMappingFromQueryKey = false; if (getMapping() == null) { getMappingFromQueryKey(); readMappingFromQueryKey = true; } // For bug 2780817 get the mapping directly from the object. In EJB 2.0 // inheritance, each child must override mappings defined in an abstract // class with its own. DatabaseMapping mapping = this.mapping; ClassDescriptor descriptor = mapping.getDescriptor(); if (descriptor.hasInheritance() && (descriptor.getJavaClass() != object.getClass())) { mapping = session .getDescriptor(object.getClass()) .getObjectBuilder() .getMappingForAttributeName(getName()); descriptor = mapping.getDescriptor(); } // fetch group support if (descriptor.hasFetchGroupManager()) { FetchGroupManager fetchGroupManager = descriptor.getFetchGroupManager(); if (fetchGroupManager.isPartialObject(object) && (!fetchGroupManager.isAttributeFetched(object, mapping.getAttributeName()))) { // the conforming attribute is not fetched, simply throw exception throw QueryException.cannotConformUnfetchedAttribute(mapping.getAttributeName()); } } if (mapping.isDirectToFieldMapping()) { return ((AbstractDirectMapping) mapping).valueFromObject(object, mapping.getField(), session); } else if (mapping.isForeignReferenceMapping()) { // CR 3677 integration of a ValueHolderPolicy Object valueFromMapping = mapping.getAttributeValueFromObject(object); if (!((ForeignReferenceMapping) mapping) .getIndirectionPolicy() .objectIsInstantiated(valueFromMapping)) { if (valueHolderPolicy != InMemoryQueryIndirectionPolicy.SHOULD_TRIGGER_INDIRECTION) { // If the client wishes us to trigger the indirection then we should do so, // Other wise throw the exception throw QueryException .mustInstantiateValueholders(); // you should instantiate the valueholder for this to // work } // maybe we should throw this exception from the start, to save time } Object valueToIterate = mapping.getRealAttributeValueFromObject(object, session); UnitOfWorkImpl uow = isObjectUnregistered ? (UnitOfWorkImpl) session : null; // First check that object in fact is unregistered. // toDo: ?? Why is this commented out? Why are we supporting the unregistered thing at all? // Does not seem to be any public API for this, nor every used internally? // if (isObjectUnregistered) { // isObjectUnregistered = !uow.getCloneMapping().containsKey(object); // } if (mapping.isCollectionMapping() && (valueToIterate != null)) { // For bug 2766379 must use the correct version of vectorFor to // unwrap the result same time. valueToIterate = mapping.getContainerPolicy().vectorFor(valueToIterate, session); // toDo: If the value is empty, need to support correct inner/outer join filtering // symantics. // For CR 2612601, try to partially replace the result with already // registered objects. if (isObjectUnregistered && (uow.getCloneMapping().get(object) == null)) { Vector objectValues = (Vector) valueToIterate; for (int i = 0; i < objectValues.size(); i++) { Object original = objectValues.elementAt(i); Object clone = uow.getIdentityMapAccessorInstance() .getIdentityMapManager() .getFromIdentityMap(original); if (clone != null) { objectValues.setElementAt(clone, i); } } } // For CR 2612601, conforming without registering, a query could be // bob.get("address").get("city").equal("Ottawa"); where the address // has been registered and modified in the UOW, but bob has not. Thus // even though bob does not point to the modified address now, it will // as soon as it is registered, so should point to it here. } else if (isObjectUnregistered && (uow.getCloneMapping().get(object) == null)) { Object clone = uow.getIdentityMapAccessorInstance() .getIdentityMapManager() .getFromIdentityMap(valueToIterate); if (clone != null) { valueToIterate = clone; } } return valueToIterate; } else if (mapping.isAggregateMapping()) { Object aggregateValue = mapping.getAttributeValueFromObject(object); // Bug 3995468 - if this query key is to a mapping in an aggregate object, get the object from // actual mapping rather than the aggregate mapping while (readMappingFromQueryKey && mapping.isAggregateObjectMapping() && !((AggregateObjectMapping) mapping) .getReferenceClass() .equals(queryKey.getDescriptor().getJavaClass())) { mapping = mapping .getReferenceDescriptor() .getObjectBuilder() .getMappingForField(((DirectQueryKey) queryKey).getField()); aggregateValue = mapping.getRealAttributeValueFromObject(aggregateValue, session); } return aggregateValue; } else { throw QueryException.cannotConformExpression(); } }
public void test() { ReadAllQuery query = new ReadAllQuery(); ScrollableCursor cursor = null; try { query.setReferenceClass(Employee.class); if (TYPE_SCROLL_INSENSITIVE_isSupported && CONCUR_UPDATABLE_isSupported) { query.useScrollableCursor(2); } else { ScrollableCursorPolicy policy = new ScrollableCursorPolicy(); if (!TYPE_SCROLL_INSENSITIVE_isSupported) { policy.setResultSetType(ScrollableCursorPolicy.TYPE_SCROLL_SENSITIVE); } if (!CONCUR_UPDATABLE_isSupported) { policy.setResultSetConcurrency(ScrollableCursorPolicy.CONCUR_READ_ONLY); } policy.setPageSize(2); query.useScrollableCursor(policy); } // if (configuration != null) { ExpressionBuilder builder = new ExpressionBuilder(); Expression exp = builder.get("salary").greaterThan(50000); query.setSelectionCriteria(exp); query.conformResultsInUnitOfWork(); } cursor = (ScrollableCursor) getSession().executeQuery(query); try { // test to see if we can iterate through a list and then iterate // in reverse through the same list. int totalItems = 0; while (cursor.hasNext()) { readWithNext.addElement(cursor.next()); totalItems++; } while (cursor.hasPrevious()) { readWithPrevious.addElement(cursor.previous()); totalItems--; } cursorSuccess = (totalItems == 0); int size = readWithPrevious.size(); for (int i = 0; i < readWithNext.size(); i++) { cursorSuccess = (cursorSuccess && (readWithNext.elementAt(i) == readWithPrevious.elementAt((size - 1) - i))); } } catch (org.eclipse.persistence.exceptions.QueryException ex) { caughtException = ex; } } finally { if (cursor != null) { cursor.close(); } } }