protected Hashtable removeDuplicateAndValidateInfos(AbstractSession session) {
Hashtable infoHashtable = new Hashtable();
for (int i = 0; i < infos.size(); i++) {
Info info1 = infos.get(i);
info1 = (Info) info1.clone();
DatabaseField descField = getDescriptor().buildField(info1.getField());
if (info1.getField().getType() == null) {
info1.setField(descField);
} else {
// keep the original type if specified
info1.getField().setName(descField.getName());
info1
.getField()
.setTableName(
getDescriptor().getDefaultTable().getQualifiedNameDelimited(session.getPlatform()));
}
Info info2 = (Info) infoHashtable.get(info1.getField());
if (info2 == null) {
infoHashtable.put(info1.getField(), info1);
} else {
Info infoMerged = mergeInfos(info1, info2, session, getDescriptor());
if (infoMerged != null) {
// substitute info2 with infoMerged
infoHashtable.put(infoMerged.getField(), infoMerged);
} else {
// couldn't merge info1 and info2 due to a conflict.
// substitute info2 with info1
infoHashtable.put(info1.getField(), info1);
}
}
}
return infoHashtable;
}
/** INTERNAL: Both ReturningPolicies should be initialized */
public boolean hasEqualMains(ReturningPolicy policy) {
Collection[][] mainToCompare = policy.main;
if (main == mainToCompare) {
return true;
}
for (int operation = INSERT; operation <= UPDATE; operation++) {
for (int state = RETURN_ONLY; state < MAIN_SIZE; state++) {
if ((main[operation][state] == null) && (mainToCompare[operation][state] != null)) {
return false;
}
if ((main[operation][state] != null) && (mainToCompare[operation][state] == null)) {
return false;
}
if (!main[operation][state].equals(mainToCompare[operation][state])) {
return false;
}
}
}
// now compare types
Hashtable allFields = new Hashtable();
for (int operation = INSERT; operation <= UPDATE; operation++) {
if (main[operation][ALL] != null) {
Iterator it = main[operation][ALL].iterator();
while (it.hasNext()) {
DatabaseField field = (DatabaseField) it.next();
allFields.put(field, field);
}
}
}
for (int operation = INSERT; operation <= UPDATE; operation++) {
if (mainToCompare[operation][ALL] != null) {
Iterator it = mainToCompare[operation][ALL].iterator();
while (it.hasNext()) {
DatabaseField fieldToCompare = (DatabaseField) it.next();
DatabaseField field = (DatabaseField) allFields.get(fieldToCompare);
if (!field.getType().equals(fieldToCompare.getType())) {
return false;
}
}
}
}
return true;
}
/** INTERNAL: */
public void validationAfterDescriptorInitialization(AbstractSession session) {
Hashtable mapped = new Hashtable();
for (int operation = INSERT; operation <= UPDATE; operation++) {
if ((main[operation][MAPPED] != null) && !main[operation][MAPPED].isEmpty()) {
Iterator it = main[operation][MAPPED].iterator();
while (it.hasNext()) {
DatabaseField field = (DatabaseField) it.next();
mapped.put(field, field);
}
}
}
if (!mapped.isEmpty()) {
for (Enumeration fields = getDescriptor().getFields().elements();
fields.hasMoreElements(); ) {
DatabaseField fieldInDescriptor = (DatabaseField) fields.nextElement();
DatabaseField fieldInMain = (DatabaseField) mapped.get(fieldInDescriptor);
if (fieldInMain != null) {
if (fieldInMain.getType() == null) {
if (getDescriptor().isReturnTypeRequiredForReturningPolicy()) {
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyMappedFieldTypeNotSet(
fieldInMain.getName(), getDescriptor()));
}
} else if (isThereATypeConflict(fieldInMain, fieldInDescriptor)) {
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyAndDescriptorFieldTypeConflict(
fieldInMain.getName(),
fieldInMain.getType().getName(),
fieldInDescriptor.getType().getName(),
getDescriptor()));
}
}
}
}
if (!(session.getDatasourcePlatform() instanceof DatabasePlatform)) {
// don't attempt further diagnostics on non-relational platforms
return;
}
WriteObjectQuery[] query = {
getDescriptor().getQueryManager().getInsertQuery(),
getDescriptor().getQueryManager().getUpdateQuery()
};
String[] queryTypeName = {"InsertObjectQuery", "UpdateObjectQuery"};
for (int operation = INSERT; operation <= UPDATE; operation++) {
if ((main[operation][ALL] != null) && !main[operation][ALL].isEmpty()) {
// this operation requires some fields to be returned
if ((query[operation] == null) || (query[operation].getDatasourceCall() == null)) {
if (!session.getPlatform().canBuildCallWithReturning()) {
session
.getIntegrityChecker()
.handleError(
DescriptorException.noCustomQueryForReturningPolicy(
queryTypeName[operation],
Helper.getShortClassName(session.getPlatform()),
getDescriptor()));
}
} else if (query[operation].getDatasourceCall() instanceof StoredProcedureCall) {
// SQLCall with custom SQL calculates its outputRowFields later (in prepare() method) -
// that's why SQLCall can't be verified here.
DatabaseCall customCall = (DatabaseCall) query[operation].getDatasourceCall();
Enumeration outputRowFields = customCall.getOutputRowFields().elements();
Collection notFoundInOutputRow = createCollection();
notFoundInOutputRow.addAll(main[operation][ALL]);
while (outputRowFields.hasMoreElements()) {
notFoundInOutputRow.remove(outputRowFields.nextElement());
}
if (!notFoundInOutputRow.isEmpty()) {
Iterator it = notFoundInOutputRow.iterator();
while (it.hasNext()) {
DatabaseField field = (DatabaseField) it.next();
session
.getIntegrityChecker()
.handleError(
DescriptorException.customQueryAndReturningPolicyFieldConflict(
field.getName(), queryTypeName[operation], getDescriptor()));
}
}
}
}
}
}