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);
}
}
/**
* INTERNAL: Return the value for in memory comparison. This is only valid for valueable
* expressions.
*/
public Object valueFromObject(
Object object,
AbstractSession session,
AbstractRecord translationRow,
int valueHolderPolicy,
boolean isObjectUnregistered) {
// The expression may be across a relationship, in which case it must be traversed.
if ((!getBaseExpression().isExpressionBuilder())
&& getBaseExpression().isQueryKeyExpression()) {
object =
getBaseExpression()
.valueFromObject(
object, session, translationRow, valueHolderPolicy, isObjectUnregistered);
// toDo: Null means the join filters out the row, returning null is not correct if an inner
// join,
// outer/inner joins need to be fixed to filter correctly.
if (object == null) {
return null;
}
// If from an anyof the object will be a collection of values,
// A new vector must union the object values and the values extracted from it.
if (object instanceof Vector) {
Vector comparisonVector = new Vector(((Vector) object).size() + 2);
for (Enumeration valuesToIterate = ((Vector) object).elements();
valuesToIterate.hasMoreElements(); ) {
Object vectorObject = valuesToIterate.nextElement();
if (vectorObject == null) {
comparisonVector.addElement(vectorObject);
} else {
Object valueOrValues =
valuesFromCollection(
vectorObject, session, valueHolderPolicy, isObjectUnregistered);
// If a collection of values were extracted union them.
if (valueOrValues instanceof Vector) {
for (Enumeration nestedValuesToIterate = ((Vector) valueOrValues).elements();
nestedValuesToIterate.hasMoreElements(); ) {
comparisonVector.addElement(nestedValuesToIterate.nextElement());
}
} else {
comparisonVector.addElement(valueOrValues);
}
}
}
return comparisonVector;
}
}
return valuesFromCollection(object, session, valueHolderPolicy, isObjectUnregistered);
}
/**
* INTERNAL: This methods clones all the fields and ensures that each collection refers to the
* same clones.
*/
@Override
public Object clone() {
VariableOneToOneMapping clone = (VariableOneToOneMapping) super.clone();
Map setOfKeys = new HashMap(getSourceToTargetQueryKeyNames().size());
Map sourceToTarget = new HashMap(getSourceToTargetQueryKeyNames().size());
Vector foreignKeys =
org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(
getForeignKeyFields().size());
if (getTypeField() != null) {
clone.setTypeField((DatabaseField) this.getTypeField().clone());
}
for (Iterator enumtr = getSourceToTargetQueryKeyNames().keySet().iterator();
enumtr.hasNext(); ) {
// Clone the SourceKeyFields
DatabaseField field = (DatabaseField) enumtr.next();
DatabaseField clonedField = (DatabaseField) field.clone();
setOfKeys.put(field, clonedField);
// on the next line I'm cloning the query key names
sourceToTarget.put(clonedField, getSourceToTargetQueryKeyNames().get(field));
}
for (Enumeration enumtr = getForeignKeyFields().elements(); enumtr.hasMoreElements(); ) {
DatabaseField field = (DatabaseField) enumtr.nextElement();
foreignKeys.addElement(setOfKeys.get(field));
}
clone.setSourceToTargetQueryKeyFields(sourceToTarget);
clone.setForeignKeyFields(foreignKeys);
clone.setTypeIndicatorTranslation(new HashMap(this.getTypeIndicatorTranslation()));
return clone;
}
/**
* INTERNAL: Returns the first field from each of the owned tables, used for fine-grained
* pessimistic locking.
*/
protected Vector getForUpdateOfFields() {
Vector allFields = getFields();
int expected = getTableAliases().size();
Vector firstFields = new Vector(expected);
DatabaseTable lastTable = null;
DatabaseField field = null;
int i = 0;
// The following loop takes O(n*m) time. n=# of fields. m=#tables.
// However, in the m=1 case this will take one pass only.
// Also assuming that fields are generally sorted by table, this will
// take O(n) time.
// An even faster way may be to go getDescriptor().getAdditionalPrimaryKeyFields.
while ((i < allFields.size()) && (firstFields.size() < expected)) {
field = (DatabaseField) allFields.elementAt(i++);
if ((lastTable == null) || !field.getTable().equals(lastTable)) {
lastTable = field.getTable();
int j = 0;
while (j < firstFields.size()) {
if (lastTable.equals(((DatabaseField) firstFields.elementAt(j)).getTable())) {
break;
}
j++;
}
if (j == firstFields.size()) {
firstFields.addElement(field);
}
}
}
return firstFields;
}
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;
}
public ReadAllBindAllParametersTest() {
v = new Vector(2);
v.addElement(new BigDecimal(1001));
v.addElement(new BigDecimal(1002));
setName("ReadAllBindAllParametersTest");
setDescription(
"Tests all combinations of shouldBindAllParameters attributes on Session and Query");
}
/**
* PUBLIC: Return the foreign key field names associated with the mapping. These are only the
* source fields that are writable.
*/
public Vector getForeignKeyFieldNames() {
Vector fieldNames = new Vector(getForeignKeyFields().size());
for (Enumeration fieldsEnum = getForeignKeyFields().elements();
fieldsEnum.hasMoreElements(); ) {
fieldNames.addElement(((DatabaseField) fieldsEnum.nextElement()).getQualifiedName());
}
return fieldNames;
}
protected void setup() {
beginTransaction();
// Acquire a unit of work with a class read-only.
Vector readOnlyClasses = new Vector();
readOnlyClasses.addElement(Country.class);
uow = getSession().acquireUnitOfWork();
uow.removeAllReadOnlyClasses();
uow.addReadOnlyClasses(readOnlyClasses);
}
/** PUBLIC: Return a collection of the field to query key associations. */
public Vector getSourceToTargetQueryKeyFieldAssociations() {
Vector associations = new Vector(getSourceToTargetQueryKeyNames().size());
Iterator sourceFieldEnum = getSourceToTargetQueryKeyNames().keySet().iterator();
Iterator targetQueryKeyEnum = getSourceToTargetQueryKeyNames().values().iterator();
while (sourceFieldEnum.hasNext()) {
Object fieldValue = ((DatabaseField) sourceFieldEnum.next()).getQualifiedName();
Object attributeValue = targetQueryKeyEnum.next();
associations.addElement(new Association(fieldValue, attributeValue));
}
return associations;
}
/** INTERNAL: Return all the fields populated by this mapping. */
@Override
protected Vector collectFields() {
DatabaseField type = getTypeField();
// Get a shallow copy of the Vector
if (type != null) {
Vector sourceFields = (Vector) getForeignKeyFields().clone();
sourceFields.addElement(type);
return sourceFields;
} else {
return getForeignKeyFields();
}
}
/**
* PUBLIC: Return the foreign key field names associated with the mapping. These are only the
* source fields that are writable.
*/
public void setForeignKeyFieldNames(Vector fieldNames) {
Vector fields =
org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(
fieldNames.size());
for (Enumeration fieldNamesEnum = fieldNames.elements(); fieldNamesEnum.hasMoreElements(); ) {
fields.addElement(new DatabaseField((String) fieldNamesEnum.nextElement()));
}
setForeignKeyFields(fields);
if (!fields.isEmpty()) {
setIsForeignKeyRelationship(true);
}
}
/**
* INTERNAL: Return the class indicator associations for XML. List of class-name/value
* associations.
*/
public Vector getClassIndicatorAssociations() {
Vector associations = new Vector();
Iterator classesEnum = getTypeIndicatorNameTranslation().keySet().iterator();
Iterator valuesEnum = getTypeIndicatorNameTranslation().values().iterator();
while (classesEnum.hasNext()) {
Object className = classesEnum.next();
// If the project was built in runtime is a class, MW is a string.
if (className instanceof Class) {
className = ((Class) className).getName();
}
Object value = valuesEnum.next();
associations.addElement(new TypedAssociation(className, value));
}
return associations;
}
/** INTERNAL: */
public Vector getOwnedTables() {
if ((getMapping() != null) && getMapping().isNestedTableMapping()) {
Vector nestedTable = null;
if (shouldQueryToManyRelationship()) {
nestedTable = (Vector) super.getOwnedTables().clone();
} else {
nestedTable = new Vector(1);
}
nestedTable.addElement(new NestedTable(this));
return nestedTable;
}
if ((getMapping() != null)
&& (getMapping().isReferenceMapping() || getMapping().isStructureMapping())) {
return null;
}
return super.getOwnedTables();
}
/** INTERNAL: Return all the fields */
public Vector getFields() {
if (isAttribute()) {
Vector result = new Vector(1);
DatabaseField field = getField();
if (field != null) {
result.addElement(field);
}
return result;
} else {
Vector result = new Vector();
result.addAll(super.getFields());
if (mapping.isCollectionMapping()) {
List<DatabaseField> fields =
mapping.getContainerPolicy().getAllFieldsForMapKey((CollectionMapping) mapping);
if (fields != null) {
result.addAll(fields);
}
}
return result;
}
}
/** Returns all the aggregate fields. */
protected Vector collectFields() {
Vector fields = new Vector(1);
fields.addElement(getField());
return fields;
}
/** INTERNAL: Conform the result if specified. */
protected Object conformResult(
Object result,
UnitOfWorkImpl unitOfWork,
AbstractRecord arguments,
boolean buildDirectlyFromRows) {
if (getSelectionCriteria() != null) {
ExpressionBuilder builder = getSelectionCriteria().getBuilder();
builder.setSession(unitOfWork.getRootSession(null));
builder.setQueryClass(getReferenceClass());
}
// If the query is redirected then the collection returned might no longer
// correspond to the original container policy. CR#2342-S.M.
ContainerPolicy cp;
if (getRedirector() != null) {
cp = ContainerPolicy.buildPolicyFor(result.getClass());
} else {
cp = getContainerPolicy();
}
// This code is now a great deal different... For one, registration is done
// as part of conforming. Also, this should only be called if one actually
// is conforming.
// First scan the UnitOfWork for conforming instances.
// This will walk through the entire cache of registered objects.
// Let p be objects from result not in the cache.
// Let c be objects from cache.
// Presently p intersect c = empty set, but later p subset c.
// By checking cache now doesConform will be called p fewer times.
Map indexedInterimResult =
unitOfWork.scanForConformingInstances(
getSelectionCriteria(), getReferenceClass(), arguments, this);
Cursor cursor = null;
// In the case of cursors just conform/register the initially read collection.
if (cp.isCursorPolicy()) {
cursor = (Cursor) result;
cp = ContainerPolicy.buildPolicyFor(ClassConstants.Vector_class);
// In nested UnitOfWork session might have been session of the parent.
cursor.setSession(unitOfWork);
result = cursor.getObjectCollection();
// for later incremental conforming...
cursor.setInitiallyConformingIndex(indexedInterimResult);
cursor.setSelectionCriteriaClone(getSelectionCriteria());
cursor.setTranslationRow(arguments);
}
// Now conform the result from the database.
// Remove any deleted or changed objects that no longer conform.
// Deletes will only work for simple queries, queries with or's or anyof's may not return
// correct results when untriggered indirection is in the model.
Vector fromDatabase = null;
// When building directly from rows, one of the performance benefits
// is that we no longer have to wrap and then unwrap the originals.
// result is just a vector, not a container of wrapped originals.
if (buildDirectlyFromRows) {
Vector rows = (Vector) result;
fromDatabase = new Vector(rows.size());
for (int i = 0; i < rows.size(); i++) {
Object object = rows.elementAt(i);
// null is placed in the row collection for 1-m joining to filter duplicate rows.
if (object != null) {
Object clone =
conformIndividualResult(
object,
unitOfWork,
arguments,
getSelectionCriteria(),
indexedInterimResult,
buildDirectlyFromRows);
if (clone != null) {
fromDatabase.addElement(clone);
}
}
}
} else {
fromDatabase = new Vector(cp.sizeFor(result));
AbstractSession sessionToUse = unitOfWork.getParent();
for (Object iter = cp.iteratorFor(result); cp.hasNext(iter); ) {
Object object = cp.next(iter, sessionToUse);
Object clone =
conformIndividualResult(
object,
unitOfWork,
arguments,
getSelectionCriteria(),
indexedInterimResult,
buildDirectlyFromRows);
if (clone != null) {
fromDatabase.addElement(clone);
}
}
}
// Now add the unwrapped conforming instances into an appropriate container.
// Wrapping is done automatically.
// Make sure a vector of exactly the right size is returned.
Object conformedResult =
cp.containerInstance(indexedInterimResult.size() + fromDatabase.size());
Object eachClone;
for (Iterator enumtr = indexedInterimResult.values().iterator(); enumtr.hasNext(); ) {
eachClone = enumtr.next();
cp.addInto(eachClone, conformedResult, unitOfWork);
}
for (Enumeration enumtr = fromDatabase.elements(); enumtr.hasMoreElements(); ) {
eachClone = enumtr.nextElement();
cp.addInto(eachClone, conformedResult, unitOfWork);
}
if (cursor != null) {
cursor.setObjectCollection((Vector) conformedResult);
// For nested UOW must copy all in object collection to
// initiallyConformingIndex, as some of these could have been from
// the parent UnitOfWork.
if (unitOfWork.isNestedUnitOfWork()) {
for (Enumeration enumtr = cursor.getObjectCollection().elements();
enumtr.hasMoreElements(); ) {
Object clone = enumtr.nextElement();
indexedInterimResult.put(clone, clone);
}
}
return cursor;
} else {
return conformedResult;
}
}
public void addUnsupportedPlatform(Class platform) {
if (unsupportedPlatforms == null) {
unsupportedPlatforms = new Vector();
}
unsupportedPlatforms.addElement(platform);
}
public void addSupportedPlatform(Class platform) {
if (supportedPlatforms == null) {
supportedPlatforms = new Vector();
}
supportedPlatforms.addElement(platform);
}
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();
}
}
}
