/**
* Return the first employee that has a long enough name for the test. If no match is found throw
* a warning exception. See bug 223005
*
* @param vectorOfEmployees
* @param minFirstNameLength
* @param testName
* @return
*/
public Employee getEmployeeWithRequiredNameLength(
Vector vectorOfEmployees, int minFirstNameLength, String testName) {
Employee empMatch = null;
Vector<Employee> employees = vectorOfEmployees;
String firstName;
StringBuffer partialFirstName;
// Loop through the collection of employees to find one that matches our test requirements
for (int i = 0; i < employees.size(); i++) {
empMatch = employees.get(i);
firstName = empMatch.getFirstName();
// Verify length criteria
if (firstName.length() >= minFirstNameLength) {
// exit the for loop - return the last empMatch
i = employees.size();
}
}
// If we could not find a proper employee for testing - throw a warning
if (null == empMatch) {
throw new RuntimeException(
testName
+ " Setup Failed: unable to find an Employee with firstName size of at least "
+ minFirstNameLength);
} else {
return empMatch;
}
}
/**
* 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());
}
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;
}
/** PUBLIC: Set the class indicator associations. */
public void setClassIndicatorAssociations(Vector classIndicatorAssociations) {
setTypeIndicatorNameTranslation(new HashMap(classIndicatorAssociations.size() + 1));
setTypeIndicatorTranslation(new HashMap((classIndicatorAssociations.size() * 2) + 1));
for (Enumeration associationsEnum = classIndicatorAssociations.elements();
associationsEnum.hasMoreElements(); ) {
Association association = (Association) associationsEnum.nextElement();
Object classValue = association.getKey();
if (classValue instanceof Class) {
// 904 projects will be a class type.
addClassIndicator((Class) association.getKey(), association.getValue());
} else {
addClassNameIndicator((String) association.getKey(), association.getValue());
}
}
}
protected void buildExpectedResults() {
Vector employees = getSession().readAllObjects(Employee.class);
Object[] result = new Object[1];
result[0] = new java.math.BigDecimal(employees.size());
addResult(result, null);
}
/**
* INTERNAL: Build and return the appropriate field value for the specified set of nested rows.
* The database better be expecting an ARRAY. It looks like we can ignore inheritance here....
*/
public Object buildFieldValueFromNestedRows(
Vector nestedRows, String structureName, AbstractSession session) throws DatabaseException {
Object[] fields = new Object[nestedRows.size()];
java.sql.Connection connection = ((DatabaseAccessor) session.getAccessor()).getConnection();
boolean reconnected = false;
try {
if (connection == null) {
((DatabaseAccessor) session.getAccessor()).incrementCallCount(session);
reconnected = true;
connection = ((DatabaseAccessor) session.getAccessor()).getConnection();
}
int i = 0;
for (Enumeration stream = nestedRows.elements(); stream.hasMoreElements(); ) {
AbstractRecord nestedRow = (AbstractRecord) stream.nextElement();
fields[i++] = this.buildStructureFromRow(nestedRow, session, connection);
}
return session.getPlatform().createArray(structureName, fields, session, connection);
} catch (java.sql.SQLException exception) {
throw DatabaseException.sqlException(exception, session, false);
} finally {
if (reconnected) {
((DatabaseAccessor) session.getAccessor()).decrementCallCount();
}
}
}
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;
}
/**
* Verify that the query ran successfully, and that the number of objects returned matches the
* number of managed employees.
*/
protected void verify() throws Exception {
Vector params = new Vector();
params.add(someManager.getId()); // numberOfManagedEmployees
try {
Vector results = (Vector) getSession().executeQuery(query, params);
if (!(numberOfManagedEmployees == results.size())) {
throw new TestErrorException(
results.size()
+ " objects were read from the database, but originially there were, "
+ numberOfManagedEmployees
+ ".");
}
} catch (org.eclipse.persistence.exceptions.DatabaseException e) {
throw new TestErrorException(
"Custom SQL subquery with parameters failed with a DatabaseException.");
}
}
/** PUBLIC: Set a collection of the source to target query key/field associations. */
public void setSourceToTargetQueryKeyFieldAssociations(
Vector sourceToTargetQueryKeyFieldAssociations) {
setSourceToTargetQueryKeyFields(
new HashMap(sourceToTargetQueryKeyFieldAssociations.size() + 1));
for (Enumeration associationsEnum = sourceToTargetQueryKeyFieldAssociations.elements();
associationsEnum.hasMoreElements(); ) {
Association association = (Association) associationsEnum.nextElement();
Object sourceField = new DatabaseField((String) association.getKey());
String targetQueryKey = (String) association.getValue();
getSourceToTargetQueryKeyNames().put(sourceField, targetQueryKey);
}
}
/**
* 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);
}
}
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;
}
/** Retrieve next page size of objects from the remote cursored stream */
public Vector cursoredStreamNextPage(
RemoteCursoredStream remoteCursoredStream,
ReadQuery query,
DistributedSession session,
int pageSize) {
Transporter transporter = null;
try {
transporter =
getRemoteSessionController()
.cursoredStreamNextPage(new Transporter(remoteCursoredStream.getID()), pageSize);
} catch (RemoteException exception) {
throw CommunicationException.errorInInvocation(exception);
}
if (transporter == null) {
return null;
}
if (!transporter.wasOperationSuccessful()) {
throw transporter.getException();
}
Vector serverNextPageObjects = (Vector) transporter.getObject();
if (serverNextPageObjects == null) {
cursoredStreamClose(remoteCursoredStream.getID());
return null;
}
Vector clientNextPageObjects = serverNextPageObjects;
if (query.isReadAllQuery() && (!query.isReportQuery())) { // could be DataReadQuery
clientNextPageObjects = new Vector(serverNextPageObjects.size());
for (Enumeration objEnum = serverNextPageObjects.elements(); objEnum.hasMoreElements(); ) {
// 2612538 - the default size of Map (32) is appropriate
Object clientObject =
session.getObjectCorrespondingTo(
objEnum.nextElement(),
transporter.getObjectDescriptors(),
new IdentityHashMap(),
(ObjectLevelReadQuery) query);
clientNextPageObjects.addElement(clientObject);
}
}
return clientNextPageObjects;
}
/**
* 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 verify() {
if (results.size() != 6) {
throw new TestErrorException(
"The incorrect number of results was returned from a ReportQuery that included a random function.");
}
}
/** INTERNAL: Auto-Default orderedFields to fields */
public void initialize(AbstractSession session) throws DescriptorException {
super.initialize(session);
if (orderedFields == null || orderedFields.size() == 0) {
orderedFields = getAllFields();
}
}
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();
}
}
}
