/**
* 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;
}
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: Print SQL onto the stream, using the ExpressionPrinter for context */
public void printSQL(ExpressionSQLPrinter printer) {
if (isAttribute()) {
printer.printField(getAliasedField());
}
// If the mapping is a direct collection then this falls into a gray area.
// It must be treated as an attribute at this moment for it has a direct field.
// However it is not an attribute in the sense that it also represents a foreign
// reference and a mapping criteria has been added.
// For bug 2900974 these are now handled as non-attributes during normalize but
// as attributes when printing SQL.
//
if ((!isAttribute()) && (getMapping() != null) && getMapping().isDirectCollectionMapping()) {
DirectCollectionMapping directCollectionMapping = (DirectCollectionMapping) getMapping();
// The aliased table comes for free as it was a required part of the join criteria.
TableExpression table =
(TableExpression) getTable(directCollectionMapping.getReferenceTable());
DatabaseTable aliasedTable = table.aliasForTable(table.getTable());
DatabaseField aliasedField = (DatabaseField) directCollectionMapping.getDirectField().clone();
aliasedField.setTable(aliasedTable);
printer.printField(aliasedField);
}
if ((getMapping() != null) && getMapping().isNestedTableMapping()) {
DatabaseTable tableAlias = aliasForTable(new NestedTable(this));
printer.printString(tableAlias.getName());
}
}
/** INTERNAL: */
protected Vector<DatabaseField> getVectorOfFieldsToGenerate(int operation, DatabaseTable table) {
if (this.main[operation][ALL] == null) {
return null;
}
if (this.tableToFieldsForGenerationMap == null) {
// the method is called for the first time
tableToFieldsForGenerationMap = new HashMap[NUM_OPERATIONS];
}
if (this.tableToFieldsForGenerationMap[operation] == null) {
// the method is called for the first time for this operation
this.tableToFieldsForGenerationMap[operation] = new HashMap();
}
Vector<DatabaseField> fieldsForGeneration =
this.tableToFieldsForGenerationMap[operation].get(table);
if (fieldsForGeneration == null) {
// the method is called for the first time for this operation and this table
fieldsForGeneration = new NonSynchronizedVector();
Iterator it = this.main[operation][ALL].iterator();
while (it.hasNext()) {
DatabaseField field = (DatabaseField) it.next();
if (field.getTable().equals(table)) {
fieldsForGeneration.add(field);
}
}
this.tableToFieldsForGenerationMap[operation].put(table, fieldsForGeneration);
}
return fieldsForGeneration;
}
/**
* 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;
}
/** Munge the table for all the fields in the row. */
protected AbstractRecord convertToFullyQualifiedRow(AbstractRecord row) {
DatabaseRecord result = new DatabaseRecord(row.size());
for (Enumeration stream = row.keys(); stream.hasMoreElements(); ) {
DatabaseField key = (DatabaseField) stream.nextElement();
result.put(new DatabaseField(key.getName(), this.getRootElement()), row.get(key));
}
return result;
}
Info(DatabaseField field, boolean isInsert, boolean isInsertModeReturnOnly, boolean isUpdate) {
this.field = field;
if (field != null) {
if (field.getType() != null) {
setReferenceClass(field.getType());
}
}
this.isInsert = isInsert;
this.isInsertModeReturnOnly = isInsertModeReturnOnly;
this.isUpdate = isUpdate;
}
/** 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;
}
@Override
public int hashCode() {
DatabaseField field = getField();
Class type = field != null ? field.getType() : null;
boolean isInsert = isInsert();
boolean isInsertModeReturnOnly = isInsertModeReturnOnly();
boolean isUpdate = isUpdate();
int result = field != null ? field.hashCode() : 0;
result = 31 * result + (type != null ? type.hashCode() : 0);
result = 31 * result + (isInsert ? 1 : 0);
result = 31 * result + (isInsertModeReturnOnly ? 1 : 0);
result = 31 * result + (isUpdate ? 1 : 0);
return result;
}
/**
* INTERNAL Used by SQLCall.appendModify(..) If the field should be passed to
* customModifyInDatabaseCall, return true, otherwise false. Methods
* shouldCustomModifyInDatabaseCall and customModifyInDatabaseCall should be kept in sync:
* shouldCustomModifyInDatabaseCall should return true if and only if the field is handled by
* customModifyInDatabaseCall.
*/
public boolean shouldUseCustomModifyForCall(DatabaseField field) {
Class type = field.getType();
if ((type != null) && isOracle9Specific(type)) {
return true;
}
return super.shouldUseCustomModifyForCall(field);
}
/**
* 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;
}
/** 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;
}
protected static boolean verifyField(
AbstractSession session, DatabaseField field, ClassDescriptor descriptor) {
boolean ok = true;
if (field.equals(descriptor.getSequenceNumberField())) {
ok = false;
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyFieldNotSupported(field.getName(), descriptor));
} else if (descriptor.hasInheritance()
&& field.equals(descriptor.getInheritancePolicy().getClassIndicatorField())) {
ok = false;
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyFieldNotSupported(field.getName(), descriptor));
} else if (descriptor.usesOptimisticLocking()) {
OptimisticLockingPolicy optimisticLockingPolicy = descriptor.getOptimisticLockingPolicy();
if (optimisticLockingPolicy instanceof VersionLockingPolicy) {
VersionLockingPolicy versionLockingPolicy = (VersionLockingPolicy) optimisticLockingPolicy;
if (field.equals(versionLockingPolicy.getWriteLockField())) {
ok = false;
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyFieldNotSupported(
field.getName(), descriptor));
}
}
}
return ok;
}
/** INTERNAL: */
protected void fieldIsNotFromDescriptor(DatabaseField field) {
if (field.getTable().equals(getDescriptor().getDefaultTable())) {
if (this.fieldsNotFromDescriptor_DefaultTable == null) {
this.fieldsNotFromDescriptor_DefaultTable = new HashMap();
}
this.fieldsNotFromDescriptor_DefaultTable.put(field, field);
} else {
if (this.fieldsNotFromDescriptor_OtherTables == null) {
this.fieldsNotFromDescriptor_OtherTables = new HashMap();
}
this.fieldsNotFromDescriptor_OtherTables.put(field, field);
}
}
/** INTERNAL: Alias the database field for our current environment */
protected void initializeAliasedField() {
DatabaseField tempField = (DatabaseField) getField().clone();
DatabaseTable aliasedTable = getAliasedTable();
// Put in a special check here so that if the aliasing does nothing we don't cache the
// result because it's invalid. This saves us from caching premature data if e.g. debugging
// causes us to print too early"
// if (aliasedTable.equals(getField().getTable())) {
// return;
// } else {
aliasedField = tempField;
aliasedField.setTable(aliasedTable);
// }
}
protected static boolean verifyFieldAndMapping(
AbstractSession session,
DatabaseField field,
ClassDescriptor descriptor,
DatabaseMapping mapping) {
verifyField(session, field, descriptor);
while (mapping.isAggregateObjectMapping()) {
ClassDescriptor referenceDescriptor =
((AggregateObjectMapping) mapping).getReferenceDescriptor();
mapping = referenceDescriptor.getObjectBuilder().getMappingForField(field);
verifyFieldAndMapping(session, field, referenceDescriptor, mapping);
}
if (!mapping.isDirectToFieldMapping() && !mapping.isTransformationMapping()) {
String mappingTypeName = Helper.getShortClassName(mapping);
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyMappingNotSupported(
field.getName(), mappingTypeName, mapping));
return false;
} else {
return true;
}
}
/**
* INTERNAL: Used by SQLCall.translate(..) The binding *must* be performed (NCHAR, NSTRING,
* NCLOB). In these special cases the method returns a wrapper object which knows whether it
* should be bound or appended and knows how to do that.
*/
public Object getCustomModifyValueForCall(
Call call, Object value, DatabaseField field, boolean shouldBind) {
Class type = field.getType();
if ((type != null) && isOracle9Specific(type)) {
if (value == null) {
return null;
}
if (NCHAR.equals(type) || NSTRING.equals(type)) {
return new NTypeBindCallCustomParameter(value);
} else if (NCLOB.equals(type)) {
value = convertToDatabaseType(value);
if (shouldUseLocatorForLOBWrite()) {
if (lobValueExceedsLimit(value)) {
((DatabaseCall) call).addContext(field, value);
value = new String(" ");
}
}
return new NTypeBindCallCustomParameter(value);
} else if (XMLTYPE.equals(type)) {
return getXMLTypeFactory().createXMLTypeBindCallCustomParameter(value);
}
}
return super.getCustomModifyValueForCall(call, value, field, shouldBind);
}
/**
* INTERNAL: Build and return the nested rows from the specified field value. This method allows
* the field value to be an ARRAY containing other structures such as arrays or Struct, or direct
* values.
*/
public static Object buildContainerFromArray(
Array fieldValue, ObjectRelationalDatabaseField arrayField, AbstractSession session)
throws DatabaseException {
if (arrayField.getType() == null) {
return fieldValue;
}
Object[] objects = null;
try {
objects = (Object[]) fieldValue.getArray();
} catch (java.sql.SQLException ex) {
throw DatabaseException.sqlException(ex, session, false);
}
if (objects == null) {
return null;
}
boolean isNestedStructure = false;
ObjectRelationalDataTypeDescriptor ord = null;
DatabaseField nestedType = null;
if (arrayField != null) {
nestedType = arrayField.getNestedTypeField();
if ((nestedType != null) && nestedType.getSqlType() == Types.STRUCT) {
ClassDescriptor descriptor = session.getDescriptor(nestedType.getType());
if ((descriptor != null) && (descriptor.isObjectRelationalDataTypeDescriptor())) {
// this is used to convert non-null objects passed through stored procedures and custom
// SQL to structs
ord = (ObjectRelationalDataTypeDescriptor) descriptor;
}
} else if ((nestedType != null) && (nestedType instanceof ObjectRelationalDatabaseField)) {
isNestedStructure = true;
}
}
// handle ARRAY conversions
ReadObjectQuery query = new ReadObjectQuery();
query.setSession(session);
ContainerPolicy cp = ContainerPolicy.buildPolicyFor(arrayField.getType());
Object container = cp.containerInstance(objects.length);
for (int i = 0; i < objects.length; i++) {
Object arrayValue = objects[i];
if (arrayValue == null) {
return null;
}
if (ord != null) {
AbstractRecord nestedRow = ord.buildRowFromStructure((Struct) arrayValue);
ClassDescriptor descriptor = ord;
if (descriptor.hasInheritance()) {
Class newElementClass =
descriptor.getInheritancePolicy().classFromRow(nestedRow, session);
if (!descriptor.getJavaClass().equals(newElementClass)) {
descriptor = session.getDescriptor(newElementClass);
if (descriptor == null) {
descriptor = ord;
}
}
}
arrayValue = descriptor.getObjectBuilder().buildNewInstance();
descriptor
.getObjectBuilder()
.buildAttributesIntoObject(arrayValue, nestedRow, query, null, false);
} else if (isNestedStructure && (arrayValue instanceof Array)) {
arrayValue =
buildContainerFromArray(
(Array) arrayValue, (ObjectRelationalDatabaseField) nestedType, session);
}
cp.addInto(arrayValue, container, session);
}
return container;
}
public void setField(DatabaseField field) {
this.field = field;
if ((field.getType() == null) && (referenceClass != null)) {
field.setType(referenceClass);
}
}
/** INTERNAL: */
protected DatabaseField createField(String qualifiedName, Class type) {
DatabaseField field = new DatabaseField(qualifiedName);
field.setType(type);
return field;
}
// used only on equal fields: field1.equals(field2)
protected static boolean isThereATypeConflict(DatabaseField field1, DatabaseField field2) {
return (field1.getType() != null)
&& (field2.getType() != null)
&& !field1.getType().equals(field2.getType());
}
/** 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()));
}
}
}
}
}
}
/** INTERNAL: */
public void initialize(AbstractSession session) {
clearInitialization();
main = new Collection[NUM_OPERATIONS][MAIN_SIZE];
// The order of descriptor initialization guarantees initialization of Parent before children.
// main array is copied from Parent's ReturningPolicy
if (getDescriptor().isChildDescriptor()) {
ClassDescriptor parentDescriptor =
getDescriptor().getInheritancePolicy().getParentDescriptor();
if (parentDescriptor.hasReturningPolicy()) {
copyMainFrom(parentDescriptor.getReturningPolicy());
}
}
if (!infos.isEmpty()) {
Hashtable infoHashtable = removeDuplicateAndValidateInfos(session);
Hashtable infoHashtableUnmapped = (Hashtable) infoHashtable.clone();
for (Enumeration fields = getDescriptor().getFields().elements();
fields.hasMoreElements(); ) {
DatabaseField field = (DatabaseField) fields.nextElement();
Info info = (Info) infoHashtableUnmapped.get(field);
if (info != null) {
infoHashtableUnmapped.remove(field);
if (verifyFieldAndMapping(session, field)) {
if (info.getField().getType() == null) {
addMappedFieldToMain(field, info);
} else {
addMappedFieldToMain(info.getField(), info);
fieldIsNotFromDescriptor(info.getField());
}
}
}
}
if (!infoHashtableUnmapped.isEmpty()) {
Enumeration fields = infoHashtableUnmapped.keys();
while (fields.hasMoreElements()) {
DatabaseField field = (DatabaseField) fields.nextElement();
Info info = (Info) infoHashtableUnmapped.get(field);
if (verifyField(session, field, getDescriptor())) {
if (field.getType() != null) {
addUnmappedFieldToMain(field, info);
fieldIsNotFromDescriptor(field);
session.log(
SessionLog.FINEST,
SessionLog.QUERY,
"added_unmapped_field_to_returning_policy",
info.toString(),
getDescriptor().getJavaClassName());
} else {
if (getDescriptor().isReturnTypeRequiredForReturningPolicy()) {
session
.getIntegrityChecker()
.handleError(
DescriptorException.returningPolicyUnmappedFieldTypeNotSet(
field.getName(), getDescriptor()));
}
}
}
}
}
}
initializeIsUsedToSetPrimaryKey();
}
public void createDDL() {
DatabaseConvertGUI.setReadSuccess(true);
databaseName = generateDatabaseName();
sb.append("CREATE DATABASE " + databaseName + ";\r\n");
sb.append("USE " + databaseName + ";\r\n");
for (int boundCount = 0;
boundCount <= maxBound;
boundCount++) { // process tables in order from least dependent (least number of bound
// tables) to most dependent
for (int tableCount = 0;
tableCount < numBoundTables.length;
tableCount++) { // step through list of tables
if (numBoundTables[tableCount] == boundCount) { //
sb.append("CREATE TABLE " + tables[tableCount].getName() + " (\r\n");
int[] nativeFields = tables[tableCount].getNativeFieldsArray();
int[] relatedFields = tables[tableCount].getRelatedFieldsArray();
boolean[] primaryKey = new boolean[nativeFields.length];
int numPrimaryKey = 0;
int numForeignKey = 0;
for (int nativeFieldCount = 0;
nativeFieldCount < nativeFields.length;
nativeFieldCount++) { // print out the fields
DatabaseField currentField = getField(nativeFields[nativeFieldCount]);
sb.append(
"\t" + currentField.getName() + " " + strDataType[currentField.getDataType()]);
if (currentField.getDataType() == 0) { // varchar
sb.append(
"("
+ currentField.getVarcharValue()
+ ")"); // append varchar length in () if data type is varchar
}
if (currentField.getDisallowNull()) {
sb.append(" NOT NULL");
}
if (!currentField.getDefaultValue().equals("")) {
if (currentField.getDataType() == 1) { // boolean data type
sb.append(" DEFAULT " + convertStrBooleanToInt(currentField.getDefaultValue()));
} else { // any other data type
sb.append(" DEFAULT " + currentField.getDefaultValue());
}
}
if (currentField.getIsPrimaryKey()) {
primaryKey[nativeFieldCount] = true;
numPrimaryKey++;
} else {
primaryKey[nativeFieldCount] = false;
}
if (currentField.getFieldBound() != 0) {
numForeignKey++;
}
sb.append(",\r\n"); // end of field
}
if (numPrimaryKey > 0) { // table has primary key(s)
sb.append("CONSTRAINT " + tables[tableCount].getName() + "_PK PRIMARY KEY (");
for (int i = 0; i < primaryKey.length; i++) {
if (primaryKey[i]) {
sb.append(getField(nativeFields[i]).getName());
numPrimaryKey--;
if (numPrimaryKey > 0) {
sb.append(", ");
}
}
}
sb.append(")");
if (numForeignKey > 0) {
sb.append(",");
}
sb.append("\r\n");
}
if (numForeignKey > 0) { // table has foreign keys
int currentFK = 1;
for (int i = 0; i < relatedFields.length; i++) {
if (relatedFields[i] != 0) {
sb.append(
"CONSTRAINT "
+ tables[tableCount].getName()
+ "_FK"
+ currentFK
+ " FOREIGN KEY("
+ getField(nativeFields[i]).getName()
+ ") REFERENCES "
+ getTable(getField(nativeFields[i]).getTableBound()).getName()
+ "("
+ getField(relatedFields[i]).getName()
+ ")");
if (currentFK < numForeignKey) {
sb.append(",\r\n");
}
currentFK++;
}
}
sb.append("\r\n");
}
sb.append(");\r\n\r\n"); // end of table
}
}
}
}