public void setup() throws Exception {
DatabaseLogin login;
login = (DatabaseLogin) getSession().getLogin().clone();
server = new Server(login);
server.serverSession.setLogLevel(getSession().getLogLevel());
server.serverSession.setLog(getSession().getLog());
server.copyDescriptors(getSession());
ClassDescriptor d = (server.serverSession).getClassDescriptor(BigBadObject.class);
DatabaseMapping m;
Vector v = d.getMappings();
int mappings = v.size();
int i = 0;
while (i < mappings) {
m = (DatabaseMapping) v.get(i);
m.setWeight(new Integer(Integer.MAX_VALUE - 1));
i++;
}
m = d.getMappingForAttributeName("number02");
m.setWeight(new Integer(Integer.MAX_VALUE));
server.login();
server.serverSession.setLogLevel(getSession().getLogLevel());
server.serverSession.setLog(getSession().getLog());
}
/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
@Override
public Object valueFromObject(Object object, DatabaseField field, AbstractSession session) {
// First check if the value can be obtained from the value holder's row.
AbstractRecord referenceRow =
getIndirectionPolicy().extractReferenceRow(getAttributeValueFromObject(object));
if (referenceRow != null) {
Object value = referenceRow.get(field);
// Must ensure the classification to get a cache hit.
try {
value = session.getDatasourcePlatform().convertObject(value, getFieldClassification(field));
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
}
return value;
}
// 2.5.1.6 PWK. added to support batch reading on variable one to ones
Object referenceObject = getRealAttributeValueFromObject(object, session);
String queryKeyName = (String) getSourceToTargetQueryKeyNames().get(field);
ClassDescriptor objectDescriptor = session.getDescriptor(referenceObject.getClass());
DatabaseField targetField =
objectDescriptor.getObjectBuilder().getTargetFieldForQueryKeyName(queryKeyName);
if (targetField == null) {
return null;
}
return objectDescriptor
.getObjectBuilder()
.extractValueFromObjectForField(referenceObject, targetField, session);
}
public void setup() {
ConcurrentTestRefreshWithOptimisticLocking.execute = true;
try {
getSession().getLog().write("WARNING, some tests may take 3 minutes or more");
getSession().getLog().flush();
} catch (java.io.IOException e) {
}
try {
DatabaseLogin login = (DatabaseLogin) getSession().getLogin().clone();
ConcurrentTestRefreshWithOptimisticLocking.server =
new Server(login, numThreads, numThreads + 2);
ConcurrentTestRefreshWithOptimisticLocking.server.serverSession.setSessionLog(
getSession().getSessionLog());
ConcurrentTestRefreshWithOptimisticLocking.server.login();
ConcurrentTestRefreshWithOptimisticLocking.server.copyDescriptors(getSession());
ClassDescriptor empDesc =
this.server.serverSession.getClassDescriptor(DeadLockEmployee.class);
this.oldVersionRefresh = empDesc.shouldOnlyRefreshCacheIfNewerVersion();
empDesc.onlyRefreshCacheIfNewerVersion();
} catch (ValidationException ex) {
this.verify();
}
for (int count = 0; count < numThreads; ++count) {
ConcurrentTestRefreshWithOptimisticLocking.threadList[count] =
new Thread(new ConcurrentTestRefreshWithOptimisticLocking(false, count).runnable());
ConcurrentTestRefreshWithOptimisticLocking.timeList[count] = System.currentTimeMillis();
}
}
/**
* INTERNAL: this returns a single expression to represent the join from the main table to all
* child descriptor tables Only if outer joins should be printed in the where clause
*
* @return Expression
*/
public Expression getTreatCriteria() {
if (getDescriptor() == null) {
return null;
}
// need to build this using just the multiple tables on this descriptor not included in the
// parent's join expression
Expression criteria = null;
if (getSession().getPlatform().shouldPrintOuterJoinInWhereClause()) {
Vector tables = getDescriptor().getTables(); // This child's tables
ClassDescriptor parentDescriptor = this.typeExpressionBase.getDescriptor();
int tablesSize = tables.size();
if (parentDescriptor.hasInheritance()
&& parentDescriptor.getInheritancePolicy().hasMultipleTableChild()) {
// look up the joins from the parent descriptor to our tables.
for (int i = 0; i < tablesSize; i++) {
DatabaseTable table = (DatabaseTable) tables.elementAt(i);
Expression joinExpression =
parentDescriptor.getInheritancePolicy().getChildrenTablesJoinExpressions().get(table);
// Some of our tables might be the in our parent as well, so ignore the lack of a
// joinExpression
if (joinExpression != null) {
joinExpression = this.baseExpression.twist(joinExpression, this);
if (shouldUseOuterJoin()) {
joinExpression = joinExpression.convertToUseOuterJoin();
}
criteria = joinExpression.and(criteria);
}
}
}
}
return criteria;
}
/**
* Commit all of the objects of the class type in the change set. This allows for the order of the
* classes to be processed optimally.
*/
protected void commitNewObjectsForClassWithChangeSet(
UnitOfWorkChangeSet uowChangeSet, Class theClass) {
Map<ObjectChangeSet, ObjectChangeSet> newObjectChangesList =
uowChangeSet.getNewObjectChangeSets().get(theClass);
if (newObjectChangesList != null) { // may be no changes for that class type.
AbstractSession session = getSession();
ClassDescriptor descriptor = session.getDescriptor(theClass);
List<ObjectChangeSet> newChangeSets = new ArrayList(newObjectChangesList.values());
int size = newChangeSets.size();
for (int index = 0; index < size; index++) {
ObjectChangeSet changeSetToWrite = newChangeSets.get(index);
Object objectToWrite = changeSetToWrite.getUnitOfWorkClone();
if (!isProcessedCommit(objectToWrite)) {
// PERF: Get the descriptor query, to avoid extra query creation.
InsertObjectQuery commitQuery = descriptor.getQueryManager().getInsertQuery();
if (commitQuery == null) {
commitQuery = new InsertObjectQuery();
commitQuery.setDescriptor(descriptor);
} else {
// Ensure original query has been prepared.
commitQuery.checkPrepare(session, commitQuery.getTranslationRow());
commitQuery = (InsertObjectQuery) commitQuery.clone();
}
commitQuery.setIsExecutionClone(true);
commitQuery.setObjectChangeSet(changeSetToWrite);
commitQuery.setObject(objectToWrite);
commitQuery.cascadeOnlyDependentParts();
commitQuery.setModifyRow(null);
session.executeQuery(commitQuery);
}
uowChangeSet.putNewObjectInChangesList(changeSetToWrite, session);
}
}
}
/**
* INTERNAL: Return the classification for the field contained in the mapping. This is used to
* convert the row value to a consistent java value.
*/
@Override
public Class getFieldClassification(DatabaseField fieldToClassify) {
if ((getTypeField() != null) && (fieldToClassify.equals(getTypeField()))) {
return getTypeField().getType();
}
String queryKey = (String) getSourceToTargetQueryKeyNames().get(fieldToClassify);
if (queryKey == null) {
return null;
}
// Search any of the implementor descriptors for a mapping for the query-key.
Iterator iterator =
getReferenceDescriptor().getInterfacePolicy().getChildDescriptors().iterator();
if (iterator.hasNext()) {
ClassDescriptor firstChild = (ClassDescriptor) iterator.next();
DatabaseMapping mapping = firstChild.getObjectBuilder().getMappingForAttributeName(queryKey);
if ((mapping != null) && (mapping.isDirectToFieldMapping())) {
return ((AbstractDirectMapping) mapping).getAttributeClassification();
}
QueryKey targetQueryKey = firstChild.getQueryKeyNamed(queryKey);
if ((targetQueryKey != null) && (targetQueryKey.isDirectQueryKey())) {
return firstChild
.getObjectBuilder()
.getFieldClassification(((DirectQueryKey) targetQueryKey).getField());
}
}
return null;
}
/** Delete all of the objects with the matching class. */
public void deleteAllObjects(Class theClass, List objects, AbstractSession session) {
ClassDescriptor descriptor = null;
if (((UnitOfWorkImpl) session).shouldOrderUpdates()) { // bug 331064 - Sort the delete order
objects = sort(theClass, objects);
}
int size = objects.size();
for (int index = 0; index < size; index++) {
Object objectToDelete = objects.get(index);
if (objectToDelete.getClass() == theClass) {
if (descriptor == null) {
descriptor = session.getDescriptor(theClass);
}
// PERF: Get the descriptor query, to avoid extra query creation.
DeleteObjectQuery deleteQuery = descriptor.getQueryManager().getDeleteQuery();
if (deleteQuery == null) {
deleteQuery = new DeleteObjectQuery();
deleteQuery.setDescriptor(descriptor);
} else {
// Ensure original query has been prepared.
deleteQuery.checkPrepare(session, deleteQuery.getTranslationRow());
deleteQuery = (DeleteObjectQuery) deleteQuery.clone();
}
deleteQuery.setIsExecutionClone(true);
deleteQuery.setObject(objectToDelete);
session.executeQuery(deleteQuery);
}
}
}
public Object getObjectForUpdate(
Session session,
Object objectToUpdateBeforeChange,
Object objectToUpdateAfterChange,
boolean useUOW) {
ClassDescriptor desc = session.getClassDescriptor(objectToUpdateBeforeChange);
Record rowBeforeChange =
desc.getObjectBuilder()
.buildRow(objectToUpdateBeforeChange, (AbstractSession) session, WriteType.UPDATE);
Record rowAfterChange =
desc.getObjectBuilder()
.buildRow(objectToUpdateAfterChange, (AbstractSession) session, WriteType.UPDATE);
Record rowChange = new DatabaseRecord();
getChange(
rowChange,
session,
objectToUpdateBeforeChange,
objectToUpdateAfterChange,
desc,
useUOW,
WriteType.UPDATE);
Record rowReturn = getRowForUpdate(rowChange);
if (rowReturn != null && !rowReturn.isEmpty()) {
Record row = new DatabaseRecord(rowAfterChange.size());
row.putAll(rowAfterChange);
row.putAll(rowReturn);
return readObjectFromRow(session, desc, row);
} else {
return objectToUpdateAfterChange;
}
}
/** @param clazzDescriptor */
protected void iconizeTableName(final ClassDescriptor clazzDescriptor, final Session session) {
final String alias = clazzDescriptor.getAlias();
final String tableName = NameUtils.camelCaseToUnderscore(alias);
LogSupport.logFine(session, "Set Tablename to {0}", tableName);
clazzDescriptor.setTableName(tableName);
}
/** {@inheritDoc} */
@Override
public void initialize(XRServiceAdapter xrService, QueryOperation queryOperation) {
if (descriptor != null) {
ClassDescriptor cd = xrService.getORSession().getProject().getDescriptorForAlias(descriptor);
databaseQuery = cd.getQueryManager().getQuery(name);
} else {
databaseQuery = xrService.getORSession().getQuery(name);
}
}
/** Override the constructor for Aggregate system to allow us to read and write XML */
public CMWorkbenchIntegrationSystem() {
super();
ClassDescriptor descriptor =
(ClassDescriptor) project.getDescriptors().get(ConversionDataObject.class);
addNamedQueries(descriptor.getQueryManager());
buildProject();
}
public void testXmlPropertiesOnField() {
ClassDescriptor descriptor = project.getClassDescriptor(Foo.class);
DatabaseMapping mapping = descriptor.getMappingForAttributeName("bar2");
Map<Object, Object> properties = mapping.getProperties();
assertTrue("Incorrect number of properties", properties.size() == 1);
Object property = properties.get(FIELD_PROPERTY_2_NAME);
assertNotNull(property);
assertTrue("Incorrect value for property", property.equals("bar2Value"));
}
public void setup() {
super.setup();
// add a join between BabyMonitor and Baby what will complete a loop when combined with the
// superclass' joins
ClassDescriptor descriptor = getSession().getClassDescriptor(BabyMonitor.class);
oldJoinFetch = ((OneToOneMapping) descriptor.getMappingForAttributeName("baby")).getJoinFetch();
((OneToOneMapping) descriptor.getMappingForAttributeName("baby")).useInnerJoinFetch();
descriptor.reInitializeJoinedAttributes();
}
protected ClassDescriptor buildAbstractDirectMappingDescriptor() {
ClassDescriptor descriptor = super.buildAbstractDirectMappingDescriptor();
XMLDirectMapping attributeClassificationNameMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("attributeClassification");
attributeClassificationNameMapping.setGetMethodName("getAttributeClassificationName");
attributeClassificationNameMapping.setSetMethodName("setAttributeClassificationName");
return descriptor;
}
protected ClassDescriptor buildQueryArgumentDescriptor() {
ClassDescriptor descriptor = super.buildQueryArgumentDescriptor();
XMLDirectMapping referenceClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("type");
referenceClassMapping.setGetMethodName("getTypeName");
referenceClassMapping.setSetMethodName("setTypeName");
return descriptor;
}
protected ClassDescriptor buildInterfaceContainerPolicyDescriptor() {
ClassDescriptor descriptor = super.buildInterfaceContainerPolicyDescriptor();
XMLDirectMapping referenceClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("containerClass");
referenceClassMapping.setGetMethodName("getContainerClassName");
referenceClassMapping.setSetMethodName("setContainerClassName");
return descriptor;
}
protected ClassDescriptor buildInstantiationPolicyDescriptor() {
ClassDescriptor descriptor = super.buildInstantiationPolicyDescriptor();
XMLDirectMapping referenceClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("factoryClass");
referenceClassMapping.setGetMethodName("getFactoryClassName");
referenceClassMapping.setSetMethodName("setFactoryClassName");
return descriptor;
}
protected ClassDescriptor buildInheritancePolicyDescriptor() {
ClassDescriptor descriptor = super.buildInheritancePolicyDescriptor();
XMLDirectMapping referenceClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("parentClass");
referenceClassMapping.setGetMethodName("getParentClassName");
referenceClassMapping.setSetMethodName("setParentClassName");
return descriptor;
}
protected ClassDescriptor buildForeignReferenceMappingDescriptor() {
ClassDescriptor descriptor = super.buildForeignReferenceMappingDescriptor();
XMLDirectMapping referenceClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("referenceClass");
referenceClassMapping.setGetMethodName("getReferenceClassName");
referenceClassMapping.setSetMethodName("setReferenceClassName");
return descriptor;
}
protected ClassDescriptor buildTransformerBasedFieldTransformationDescriptor() {
ClassDescriptor descriptor = super.buildTransformerBasedFieldTransformationDescriptor();
XMLDirectMapping objectClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("transformerClass");
objectClassMapping.setGetMethodName("getTransformerClassName");
objectClassMapping.setSetMethodName("setTransformerClassName");
return descriptor;
}
protected ClassDescriptor buildMethodBaseQueryRedirectorDescriptor() {
ClassDescriptor descriptor = super.buildMethodBaseQueryRedirectorDescriptor();
XMLDirectMapping referenceClassMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("methodClass");
referenceClassMapping.setGetMethodName("getMethodClassName");
referenceClassMapping.setSetMethodName("setMethodClassName");
return descriptor;
}
protected ClassDescriptor buildTypedAssociationDescriptor() {
ClassDescriptor descriptor = super.buildTypedAssociationDescriptor();
XMLDirectMapping keyMapping = (XMLDirectMapping) descriptor.getMappingForAttributeName("key");
keyMapping.setAttributeClassification(null);
keyMapping.setGetMethodName("getKey");
keyMapping.setSetMethodName("setKey");
return descriptor;
}
public void testForRedirectorsAndInterceptors() {
ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
assertTrue(
"CacheInterceptor was not set on decriptor",
descriptor.getCacheInterceptorClassName() != null);
assertTrue(
"All queries default redirector was not set on decriptor",
descriptor.getDefaultQueryRedirector() != null);
assertTrue(
"Read All queries default redirector was not set on decriptor",
descriptor.getDefaultReadAllQueryRedirector() != null);
assertTrue(
"Read Object queries default redirector was not set on decriptor",
descriptor.getDefaultReadObjectQueryRedirector() != null);
assertTrue(
"Report queries default redirector was not set on decriptor",
descriptor.getDefaultReportQueryRedirector() != null);
assertTrue(
"Insert queries default redirector was not set on decriptor",
descriptor.getDefaultInsertObjectQueryRedirector() != null);
assertTrue(
"Update queries default redirector was not set on decriptor",
descriptor.getDefaultUpdateObjectQueryRedirector() != null);
assertTrue(
"Delete queries default redirector was not set on decriptor",
descriptor.getDefaultDeleteObjectQueryRedirector() != null);
}
public void testClassProperties() {
ClassDescriptor descriptor = project.getClassDescriptor(Foo.class);
Map<Object, Object> properties = descriptor.getProperties();
assertTrue("Incorrect number of properties", properties.size() == 2);
Object property = properties.get(CLASS_PROPERTY_1_NAME);
assertNotNull(property);
assertTrue("Incorrect value for property", property.equals("value1"));
property = properties.get(CLASS_PROPERTY_2_NAME);
assertNotNull(property);
assertTrue("Incorrect value for property", property.equals(new Integer("121")));
}
@Override
protected ClassDescriptor buildPLSQLrecordDescriptor() {
ClassDescriptor descriptor = super.buildPLSQLrecordDescriptor();
XMLDirectMapping javaTypeMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("javaType");
javaTypeMapping.setGetMethodName("getJavaTypeName");
javaTypeMapping.setSetMethodName("setJavaTypeName");
return descriptor;
}
private Object wrapEnumeration(Object object, Class enumerationClass) {
Class generatedClass = this.getClassToGeneratedClasses().get(enumerationClass.getName());
if (generatedClass != null && WrappedValue.class.isAssignableFrom(generatedClass)) {
ClassDescriptor desc =
xmlMarshaller.getXMLContext().getSession(generatedClass).getDescriptor(generatedClass);
Object newObject = desc.getInstantiationPolicy().buildNewInstance();
((WrappedValue) newObject).setValue(object);
object = newObject;
}
return object;
}
@Override
protected ClassDescriptor buildStoredProcedureArgumentDescriptor() {
ClassDescriptor descriptor = super.buildStoredProcedureArgumentDescriptor();
XMLDirectMapping argumentTypeMapping =
(XMLDirectMapping) descriptor.getMappingForAttributeName("argumentType");
argumentTypeMapping.setGetMethodName("getArgumentTypeName");
argumentTypeMapping.setSetMethodName("setArgumentTypeName");
return descriptor;
}
@Test
public void testExtensionAttribute_eclipselink_data() {
ClassDescriptor classDescriptor = jpaMetadataProvider.getClassDescriptor(TestDataObject.class);
ClassDescriptor referenceDescriptor =
jpaMetadataProvider.getClassDescriptor(TestDataObjectExtension.class);
assertNotNull(
"A classDescriptor should have been retrieved from JPA for TestDataObject",
classDescriptor);
assertNotNull(
"A classDescriptor should have been retrieved from JPA for TestDataObjectExtension",
referenceDescriptor);
DatabaseMapping databaseMapping = classDescriptor.getMappingForAttributeName("extension");
assertNotNull("extension mapping missing from metamodel", databaseMapping);
assertTrue("Should be a OneToOne mapping", databaseMapping instanceof OneToOneMapping);
OneToOneMapping mapping = (OneToOneMapping) databaseMapping;
assertEquals(
"Should be mapped by primaryKeyProperty", "primaryKeyProperty", mapping.getMappedBy());
Map<DatabaseField, DatabaseField> databaseFields = mapping.getSourceToTargetKeyFields();
assertEquals(1, databaseFields.size());
for (DatabaseField sourceField : databaseFields.keySet()) {
DatabaseField targetField = databaseFields.get(sourceField);
assertEquals("PK_PROP", sourceField.getName());
assertEquals("PK_PROP", targetField.getName());
}
assertNotNull(
"Reference descriptor missing from relationship", mapping.getReferenceDescriptor());
assertEquals(
"Reference descriptor should be the one for TestDataObjectExtension",
referenceDescriptor,
mapping.getReferenceDescriptor());
assertNotNull("selection query relationship missing", mapping.getSelectionQuery());
assertNotNull("selection query missing name", mapping.getSelectionQuery().getName());
assertEquals(
"selection query name incorrect", "extension", mapping.getSelectionQuery().getName());
assertNotNull(
"selection query reference class", mapping.getSelectionQuery().getReferenceClass());
assertEquals(
"selection query reference class incorrect",
TestDataObjectExtension.class,
mapping.getSelectionQuery().getReferenceClass());
assertNotNull(
"selection query reference class name",
mapping.getSelectionQuery().getReferenceClassName());
assertNotNull(
"selection query source mapping missing", mapping.getSelectionQuery().getSourceMapping());
assertEquals(
"selection query source mapping incorrect",
mapping,
mapping.getSelectionQuery().getSourceMapping());
}
protected int removeOptimisticLocking(Project project) {
int removed = 0;
Iterator descriptors = project.getDescriptors().values().iterator();
while (descriptors.hasNext()) {
ClassDescriptor desc = (ClassDescriptor) descriptors.next();
if (desc.getOptimisticLockingPolicy() != null) {
desc.setOptimisticLockingPolicy(null);
removed++;
}
}
return removed;
}
public void reset() {
getAbstractSession().rollbackTransaction();
getSession().getIdentityMapAccessor().initializeIdentityMaps();
descriptor.getQueryManager().setReadObjectQuery(readObjectQuery);
descriptor.getQueryManager().setReadAllQuery(readAllQuery);
descriptor.getQueryManager().setDeleteQuery(deleteObjectQuery);
descriptor.getQueryManager().setInsertQuery(insertQuery);
descriptor.getQueryManager().setUpdateQuery(updateQuery);
boolean redirectedReadObject = false;
boolean redirectedReadAll = false;
boolean redirectedDeleteObject = false;
boolean redirectedInsert = false;
boolean redirectedUpdate = false;
}