/** * The output arguments are used to get values back from the proc. */ public void addOutputArgument(String argumentName, Class type) { addOutputArgument(new FieldDefinition(argumentName, type)); }
/** * INTERNAL: * May need to override this method if the platform supports ALTER TABLE ADD <column> * and the generated sql doesn't work. * Write the string that follows ALTER TABLE to create a sql statement for * the platform in order to append a new column to an existing table. */ public void writeAddColumnClause(Writer writer, AbstractSession session, TableDefinition table, FieldDefinition field) throws IOException { writer.write("ADD "); field.appendDBString(writer, session, table); }
/** * Build a field definition object from a database field. */ private FieldDefinition getDirectCollectionReferenceKeyFieldDefFromDBField(DatabaseField dbField) { FieldDefinition fieldDef = (FieldDefinition)getFieldDefFromDBField(dbField, true).clone(); //direct collection/map table reference kye filed is not unique, need to set it as non-pk. fieldDef.setIsPrimaryKey(false); return fieldDef; }
/** * PUBLIC: * Add the field to the table, default sizes are used. * This field is set as part of the primary key. * @param type is the Java class type corresponding to the database type. */ public void addPrimaryKeyField(String fieldName, Class type, int fieldSize) { FieldDefinition fieldDef = new FieldDefinition(fieldName, type, fieldSize); fieldDef.setIsPrimaryKey(true); addField(fieldDef); }
protected void addFieldLines(FieldDefinition field, NonreflectiveMethodDefinition method) { String fieldName = "field" + field.getName(); method.addLine("FieldDefinition " + fieldName + " = new FieldDefinition();"); method.addLine(fieldName + ".setName(\"" + field.getName() + "\");"); String fieldTypeName = field.getTypeName(); if (fieldTypeName != null) { method.addLine(fieldName + ".setTypeName(\"" + field.getTypeName() + "\");"); } else {//did not set the field type name, so use the Java type data method.addLine(fieldName + ".setType(" + field.getType().getName() + ".class);"); } method.addLine(fieldName + ".setSize(" + field.getSize() + ");"); method.addLine(fieldName + ".setSubSize(" + field.getSubSize() + ");"); method.addLine(fieldName + ".setIsPrimaryKey(" + field.isPrimaryKey() + ");"); method.addLine(fieldName + ".setIsIdentity(" + field.isIdentity() + ");"); method.addLine(fieldName + ".setUnique(" + field.isUnique() + ");"); method.addLine(fieldName + ".setShouldAllowNull(" + field.shouldAllowNull() + ");"); method.addLine("table.addField(" + fieldName + ");"); }
if (fkFieldDef.getTypeDefinition() == null || fkFieldDef.getTypeDefinition().trim().equals("")) { fkFieldDef.setTypeDefinition(targetFieldDef.getTypeDefinition()); fkFieldDef.setType(targetFieldDef.getType()); fkFieldDef.setSize(targetFieldDef.getSize()); fkFieldDef.setSubSize(targetFieldDef.getSubSize());
if (getType() != null) { fieldType = session.getPlatform().getFieldTypeDefinition(getType()); if (fieldType == null) { throw ValidationException.javaTypeIsNotAValidDatabaseType(getType()); fieldType = new FieldTypeDefinition(getTypeName()); writer.write(getName()); writer.write(" "); writer.write(fieldType.getName()); if ((fieldType.isSizeAllowed()) && ((getSize() != 0) || (fieldType.isSizeRequired()))) { writer.write("("); if (getSize() == 0) { writer.write(new Integer(fieldType.getDefaultSize()).toString()); } else { writer.write(new Integer(getSize()).toString()); if (getSubSize() != 0) { writer.write(","); writer.write(new Integer(getSubSize()).toString()); } else if (fieldType.getDefaultSubSize() != 0) { writer.write(","); if (getAdditional() != null) { writer.write(" " + getAdditional());
writer.write(getName()); writer.write(" "); if (getTypeDefinition() != null) { //apply user-defined complete type definition writer.write(getTypeDefinition()); if (getType() != null) { //translate Java 'type' fieldType = platform.getFieldTypeDefinition(getType()); if (fieldType == null) { throw ValidationException.javaTypeIsNotAValidDatabaseType(getType()); } else if (getTypeName() != null) { //translate generic type name Map<String, Class> fieldTypes = platform.getClassTypes(); Class type = fieldTypes.get(getTypeName()); if (type == null) { // if unknown type name, use as it is fieldType = new FieldTypeDefinition(getTypeName()); } else { fieldType = platform.getFieldTypeDefinition(type); String qualifiedName = table.getFullName() + '.' + getName(); boolean shouldPrintFieldIdentityClause = isIdentity() && platform.shouldPrintFieldIdentityClause(session, qualifiedName); platform.printFieldTypeSize(writer, this, fieldType, shouldPrintFieldIdentityClause); if (shouldAllowNull() && fieldType.shouldAllowNull()) { platform.printFieldNullClause(writer); } else { platform.printFieldNotNullClause(writer); if (isUnique()) {
fkFieldDef.setType(targetFieldDef.getType()); fkFieldDef.setSize(targetFieldDef.getSize()); fkFieldDef.setSubSize(targetFieldDef.getSubSize());
protected void printFieldTypeSize(Writer writer, FieldDefinition field, FieldTypeDefinition fieldType) throws IOException { writer.write(fieldType.getName()); if ((fieldType.isSizeAllowed()) && ((field.getSize() != 0) || (fieldType.isSizeRequired()))) { writer.write("("); if (field.getSize() == 0) { writer.write(Integer.toString(fieldType.getDefaultSize())); } else { writer.write(Integer.toString(field.getSize())); } if (field.getSubSize() != 0) { writer.write(","); writer.write(Integer.toString(field.getSubSize())); } else if (fieldType.getDefaultSubSize() != 0) { writer.write(","); writer.write(Integer.toString(fieldType.getDefaultSubSize())); } writer.write(")"); } }
/** * PUBLIC: */ public List<String> getPrimaryKeyFieldNames() { List<String> keyNames = new ArrayList<String>(); for (FieldDefinition field : getFields()) { if (field.isPrimaryKey()) { keyNames.add(field.getName()); } } return keyNames; }
/** * Build a foreign key constraint using FieldDefinition.getForeignKeyFieldName(). */ protected ForeignKeyConstraint buildForeignKeyConstraint(FieldDefinition field, DatabasePlatform platform) { Vector sourceFields = new Vector(); Vector targetFields = new Vector(); ForeignKeyConstraint fkConstraint = new ForeignKeyConstraint(); DatabaseField tempTargetField = new DatabaseField(field.getForeignKeyFieldName()); DatabaseField tempSourceField = new DatabaseField(field.getName()); sourceFields.addElement(tempSourceField.getName()); targetFields.addElement(tempTargetField.getName()); fkConstraint.setSourceFields(sourceFields); fkConstraint.setTargetFields(targetFields); fkConstraint.setTargetTable(tempTargetField.getTable().getQualifiedNameDelimited(platform)); String tempName = buildForeignKeyConstraintName(this.getName(), tempSourceField.getName(), platform.getMaxForeignKeyNameSize(), platform); fkConstraint.setName(tempName); return fkConstraint; }
FieldDefinition field = (FieldDefinition)variablesEnum.nextElement(); writer.write("\t"); writer.write(field.getName()); writer.write(" "); writer.write(field.getTypeName()); writer.write(platform.getBatchDelimiterString()); writer.write("\n");
writer.write(" "); if (getTypeDefinition() != null) { //apply user-defined complete type definition writer.write(typeDefinition); platform.printFieldUnique(writer, shouldPrintFieldIdentityClause); } else { setUnique(false); session.log(SessionLog.WARNING, SessionLog.DDL, "removing_unique_constraint", qualifiedName); setUnique(false); String constraintName = table.buildUniqueKeyConstraintName(table.getName(), table.getFields().indexOf(this), platform.getMaxUniqueKeyNameSize()); table.addUniqueKeyConstraint(constraintName, name);
@Override /** * EclipseLink does not support length dependent type mapping. * Map varchar types with length > MAX_VARCHAR_UNICODE_LENGTH to CLOB (i.e clob); shorter types to NVARCHAR (n) * See also bugs 317597, 317448 */ protected void printFieldTypeSize(Writer writer, FieldDefinition field, FieldTypeDefinition fieldType) throws IOException { String typeName = fieldType.getName(); Class javaFieldType = field.getType(); if ("NVARCHAR".equals(typeName)) { if (field.getSize() > MAX_VARTYPE_LENGTH) { fieldType = new FieldTypeDefinition("NCLOB", false); } } else if ("VARBINARY".equals(typeName)) { if (field.getSize() > MAX_VARTYPE_LENGTH || field.getSize() == 0) { fieldType = new FieldTypeDefinition("BLOB", false); } } super.printFieldTypeSize(writer, field, fieldType); if (fieldType.getTypesuffix() != null) { writer.append(" " + fieldType.getTypesuffix()); } }
DatabaseField dbField = fieldDef.getDatabaseField(); if ( dbField == null ) { dbField = new DatabaseField(fieldDef.getName());
/** * PUBLIC: * Return the field the corresponds to the name. */ public FieldDefinition getField(String fieldName) { for (FieldDefinition field : getFields()) { if (field.getName().equals(fieldName)) { return field; } } return null; }
/** * INTERNAL: * Build the foreign key constraints. */ protected void buildFieldTypes(AbstractSession session) { FieldDefinition field = null; // The ForeignKeyConstraint object is the newer way of doing things. // We support FieldDefinition.getForeignKeyFieldName() due to backwards compatibility // by converting it. To allow mixing both ways, we just add converted one to foreignKeys list. for (Enumeration enumtr = getFields().elements(); enumtr.hasMoreElements();) { field = (FieldDefinition)enumtr.nextElement(); if (field.getForeignKeyFieldName() != null) { addForeignKeyConstraint(buildForeignKeyConstraint(field, session.getPlatform())); } } }