use of org.jooq.meta.UniqueKeyDefinition in project jOOQ by jOOQ.
the class JavaGenerator method generateRecord0.
private final void generateRecord0(Definition tableUdtOrEmbeddable, JavaWriter out) {
final UniqueKeyDefinition key = (tableUdtOrEmbeddable instanceof TableDefinition) ? ((TableDefinition) tableUdtOrEmbeddable).getPrimaryKey() : null;
final String className = getStrategy().getJavaClassName(tableUdtOrEmbeddable, Mode.RECORD);
final String tableIdentifier = !(tableUdtOrEmbeddable instanceof EmbeddableDefinition) ? out.ref(getStrategy().getFullJavaIdentifier(tableUdtOrEmbeddable), 2) : null;
final List<String> interfaces = out.ref(getStrategy().getJavaClassImplements(tableUdtOrEmbeddable, Mode.RECORD));
printPackage(out, tableUdtOrEmbeddable, Mode.RECORD);
if (tableUdtOrEmbeddable instanceof TableDefinition)
generateRecordClassJavadoc((TableDefinition) tableUdtOrEmbeddable, out);
else if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
generateEmbeddableClassJavadoc((EmbeddableDefinition) tableUdtOrEmbeddable, out);
else
generateUDTRecordClassJavadoc((UDTDefinition) tableUdtOrEmbeddable, out);
printClassAnnotations(out, tableUdtOrEmbeddable, Mode.RECORD);
if (tableUdtOrEmbeddable instanceof TableDefinition)
printTableJPAAnnotation(out, (TableDefinition) tableUdtOrEmbeddable);
Class<?> baseClass;
if (tableUdtOrEmbeddable instanceof UDTDefinition)
baseClass = UDTRecordImpl.class;
else if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
baseClass = EmbeddableRecordImpl.class;
else if (generateRelations() && key != null)
baseClass = UpdatableRecordImpl.class;
else
baseClass = TableRecordImpl.class;
// [#10481] Use the types from replaced embeddables if applicable
List<Definition> embeddablesAndColumns = embeddablesAndColumns(tableUdtOrEmbeddable);
List<Definition> embeddablesAndUnreplacedColumns = embeddablesAndUnreplacedColumns(tableUdtOrEmbeddable);
List<Definition> replacingEmbeddablesAndUnreplacedColumns = replacingEmbeddablesAndUnreplacedColumns(tableUdtOrEmbeddable);
List<Definition> embeddablesOrColumns = embeddablesOrColumns(tableUdtOrEmbeddable);
int degree = replacingEmbeddablesAndUnreplacedColumns.size();
String rowType = null;
String rowTypeRecord = null;
// [#6072] Generate these super types only if configured to do so
if (generateRecordsImplementingRecordN() && degree > 0 && degree <= Constants.MAX_ROW_DEGREE) {
rowType = refRowType(out, replacingEmbeddablesAndUnreplacedColumns);
if (scala)
rowTypeRecord = out.ref(Record.class.getName() + degree) + "[" + rowType + "]";
else
rowTypeRecord = out.ref(Record.class.getName() + degree) + "<" + rowType + ">";
interfaces.add(rowTypeRecord);
}
if (generateInterfaces())
interfaces.add(out.ref(getStrategy().getFullJavaClassName(tableUdtOrEmbeddable, Mode.INTERFACE)));
if (scala)
if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
out.println("%sclass %s extends %s[%s](%s.%s.getDataType.getRow)[[before= with ][separator= with ][%s]] {", visibility(), className, baseClass, className, out.ref(getStrategy().getFullJavaIdentifier(((EmbeddableDefinition) tableUdtOrEmbeddable).getTable()), 2), getStrategy().getJavaIdentifier(tableUdtOrEmbeddable), interfaces);
else
out.println("%sclass %s extends %s[%s](%s)[[before= with ][separator= with ][%s]] {", visibility(), className, baseClass, className, tableIdentifier, interfaces);
else if (kotlin)
if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
out.println("%sopen class %s() : %s<%s>(%s.%s.dataType.row)[[before=, ][%s]] {", visibility(), className, baseClass, className, out.ref(getStrategy().getFullJavaIdentifier(((EmbeddableDefinition) tableUdtOrEmbeddable).getTable()), 2), getStrategy().getJavaIdentifier(tableUdtOrEmbeddable), interfaces);
else
out.println("%sopen class %s() : %s<%s>(%s)[[before=, ][%s]] {", visibility(), className, baseClass, className, tableIdentifier, interfaces);
else
out.println("%sclass %s extends %s<%s>[[before= implements ][%s]] {", visibility(), className, baseClass, className, interfaces);
out.printSerial();
for (Definition column : embeddablesAndUnreplacedColumns) {
final int index = replacingEmbeddablesAndUnreplacedColumns.indexOf(column);
if (column instanceof EmbeddableDefinition) {
final EmbeddableDefinition embeddable = (EmbeddableDefinition) column;
generateEmbeddableRecordSetter(embeddable, index, out);
generateEmbeddableRecordGetter(embeddable, index, out);
} else {
final TypedElementDefinition<?> c = (TypedElementDefinition<?>) column;
if (tableUdtOrEmbeddable instanceof TableDefinition) {
generateRecordSetter(c, index, out);
generateRecordGetter(c, index, out);
} else if (tableUdtOrEmbeddable instanceof EmbeddableDefinition) {
generateEmbeddableSetter(c, index, out);
generateEmbeddableGetter(c, index, out);
} else {
generateUDTRecordSetter(c, index, out);
generateUDTRecordGetter(c, index, out);
}
}
}
if (generateRelations() && key != null) {
int keyDegree = key.getKeyColumns().size();
if (keyDegree <= Constants.MAX_ROW_DEGREE) {
final String recordNType = out.ref(Record.class.getName() + keyDegree);
final String keyType = refRowType(out, key.getKeyColumns());
out.header("Primary key information");
if (scala) {
out.println();
out.println("%soverride def key: %s[%s] = super.key.asInstanceOf[ %s[%s] ]", visibilityPublic(), recordNType, keyType, recordNType, keyType);
} else if (kotlin) {
out.println();
out.println("%soverride fun key(): %s<%s> = super.key() as %s<%s>", visibilityPublic(), recordNType, keyType, recordNType, keyType);
} else {
out.overrideInherit();
printNonnullAnnotation(out);
out.println("%s%s<%s> key() {", visibilityPublic(), recordNType, keyType);
out.println("return (%s) super.key();", recordNType);
out.println("}");
}
}
}
if (tableUdtOrEmbeddable instanceof UDTDefinition) {
// [#799] Oracle UDT's can have member procedures
for (RoutineDefinition routine : ((UDTDefinition) tableUdtOrEmbeddable).getRoutines()) {
// Instance methods ship with a SELF parameter at the first position
// [#1584] Static methods don't have that
boolean instance = routine.getInParameters().size() > 0 && routine.getInParameters().get(0).getInputName().toUpperCase(getStrategy().getTargetLocale()).equals("SELF");
try {
if (!routine.isSQLUsable()) {
// Instance execute() convenience method
printConvenienceMethodProcedure(out, routine, instance);
} else {
// Instance execute() convenience method
if (!routine.isAggregate()) {
printConvenienceMethodFunction(out, routine, instance);
}
}
} catch (Exception e) {
log.error("Error while generating routine " + routine, e);
}
}
}
// [#3130] Invalid UDTs may have a degree of 0
if (generateRecordsImplementingRecordN() && degree > 0 && degree <= Constants.MAX_ROW_DEGREE) {
final String recordNType = out.ref(Row.class.getName() + degree);
out.header("Record%s type implementation", degree);
// fieldsRow()
if (scala) {
out.println();
out.println("%soverride def fieldsRow: %s[%s] = super.fieldsRow.asInstanceOf[ %s[%s] ]", visibilityPublic(), recordNType, rowType, recordNType, rowType);
} else if (kotlin) {
out.println();
out.println("%soverride fun fieldsRow(): %s<%s> = super.fieldsRow() as %s<%s>", visibilityPublic(), recordNType, rowType, recordNType, rowType);
} else {
out.overrideInherit();
printNonnullAnnotation(out);
out.println("%s%s<%s> fieldsRow() {", visibilityPublic(), recordNType, rowType);
out.println("return (%s) super.fieldsRow();", recordNType);
out.println("}");
}
// valuesRow()
if (scala) {
out.println();
out.println("%soverride def valuesRow: %s[%s] = super.valuesRow.asInstanceOf[ %s[%s] ]", visibilityPublic(), recordNType, rowType, recordNType, rowType);
} else if (kotlin) {
out.println("%soverride fun valuesRow(): %s<%s> = super.valuesRow() as %s<%s>", visibilityPublic(), recordNType, rowType, recordNType, rowType);
} else {
out.overrideInherit();
printNonnullAnnotation(out);
out.println("%s%s<%s> valuesRow() {", visibilityPublic(), recordNType, rowType);
out.println("return (%s) super.valuesRow();", recordNType);
out.println("}");
}
// field[N]()
for (int i = 1; i <= degree; i++) {
Definition column = replacingEmbeddablesAndUnreplacedColumns.get(i - 1);
if (column instanceof EmbeddableColumnDefinition)
column = ((EmbeddableColumnDefinition) column).getReferencingColumn();
final String colTypeFull = getJavaType(column, out);
final String colType = out.ref(colTypeFull);
final String colIdentifierFull = out.ref(getStrategy().getFullJavaIdentifier(column), colRefSegments(column));
final String colIdentifier = getStrategy().getJavaIdentifier(column);
if (scala) {
printDeprecationIfUnknownType(out, colTypeFull);
if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
out.println("%soverride def field%s: %s[%s] = field(%s).asInstanceOf[%s [%s] ]", visibilityPublic(), i, Field.class, colType, i - 1, Field.class, colType);
else
out.println("%soverride def field%s: %s[%s] = %s", visibilityPublic(), i, Field.class, colType, colIdentifierFull);
} else if (kotlin) {
printDeprecationIfUnknownType(out, colTypeFull);
if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
out.println("%soverride fun field%s(): %s<%s?> = field(%s) as %s<%s?>", visibilityPublic(), i, Field.class, colType, i - 1, Field.class, colType);
else if (tableUdtOrEmbeddable instanceof UDTDefinition)
out.println("%soverride fun field%s(): %s<%s%s> = %s.%s", visibilityPublic(), i, Field.class, colType, column instanceof EmbeddableDefinition ? "" : "?", out.ref(getStrategy().getFullJavaIdentifier(((AttributeDefinition) column).getContainer()), 2), colIdentifier);
else
out.println("%soverride fun field%s(): %s<%s%s> = %s", visibilityPublic(), i, Field.class, colType, column instanceof EmbeddableDefinition ? "" : "?", colIdentifierFull);
} else {
if (printDeprecationIfUnknownType(out, colTypeFull))
out.override();
else
out.overrideInherit();
printNonnullAnnotation(out);
out.println("%s%s<%s> field%s() {", visibilityPublic(), Field.class, colType, i);
if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
out.println("return (%s<%s>) field(%s);", Field.class, colType, i - 1);
else
out.println("return %s;", colIdentifierFull);
out.println("}");
}
}
// component[N]()
for (int i = 1; i <= degree; i++) {
Definition column = replacingEmbeddablesAndUnreplacedColumns.get(i - 1);
final String colTypeFull = getJavaType(column, out);
final String colType = out.ref(colTypeFull);
final String colGetter = getStrategy().getJavaGetterName(column, Mode.RECORD);
final String colMember = getStrategy().getJavaMemberName(column, Mode.POJO);
if (scala) {
printDeprecationIfUnknownType(out, colTypeFull);
out.println("%soverride def component%s: %s = %s", visibilityPublic(), i, colType, colGetter);
} else if (kotlin) {
printDeprecationIfUnknownType(out, colTypeFull);
out.println("%soverride fun component%s(): %s? = %s", visibilityPublic(), i, colType, colMember);
} else {
if (printDeprecationIfUnknownType(out, colTypeFull))
out.override();
else
out.overrideInherit();
printNullableOrNonnullAnnotation(out, column);
out.println("%s%s component%s() {", visibilityPublic(), colType, i);
out.println("return %s();", colGetter);
out.println("}");
}
}
// value[N]()
for (int i = 1; i <= degree; i++) {
Definition column = replacingEmbeddablesAndUnreplacedColumns.get(i - 1);
final String colTypeFull = getJavaType(column, out);
final String colType = out.ref(colTypeFull);
final String colGetter = getStrategy().getJavaGetterName(column, Mode.RECORD);
final String colMember = getStrategy().getJavaMemberName(column, Mode.POJO);
if (scala) {
printDeprecationIfUnknownType(out, colTypeFull);
out.println("%soverride def value%s: %s = %s", visibilityPublic(), i, colType, colGetter);
} else if (kotlin) {
printDeprecationIfUnknownType(out, colTypeFull);
out.println("%soverride fun value%s(): %s? = %s", visibilityPublic(), i, colType, colMember);
} else {
if (printDeprecationIfUnknownType(out, colTypeFull))
out.override();
else
out.overrideInherit();
printNullableOrNonnullAnnotation(out, column);
out.println("%s%s value%s() {", visibilityPublic(), colType, i);
out.println("return %s();", colGetter);
out.println("}");
}
}
// value[N](T[N])
for (int i = 1; i <= degree; i++) {
Definition column = replacingEmbeddablesAndUnreplacedColumns.get(i - 1);
final String colTypeFull = getJavaType(column, out);
final String colType = out.ref(colTypeFull);
final String colSetter = getStrategy().getJavaSetterName(column, Mode.RECORD);
final String colMember = getStrategy().getJavaMemberName(column, Mode.POJO);
if (scala) {
out.println();
printDeprecationIfUnknownType(out, colTypeFull);
out.println("%soverride def value%s(value: %s): %s = {", visibilityPublic(), i, colType, className);
out.println("%s(value)", colSetter);
out.println("this");
out.println("}");
} else if (kotlin) {
out.println();
printDeprecationIfUnknownType(out, colTypeFull);
out.println("%soverride fun value%s(value: %s%s): %s {", visibilityPublic(), i, colType, column instanceof EmbeddableDefinition ? "" : "?", className);
out.println("this.%s = value", colMember);
out.println("return this");
out.println("}");
} else {
final String nullableAnnotation = nullableOrNonnullAnnotation(out, column);
if (printDeprecationIfUnknownType(out, colTypeFull))
out.override();
else
out.overrideInherit();
printNonnullAnnotation(out);
out.println("%s%s value%s([[before=@][after= ][%s]]%s value) {", visibilityPublic(), className, i, list(nullableAnnotation), varargsIfArray(colType));
out.println("%s(value);", colSetter);
out.println("return this;");
out.println("}");
}
}
List<String> arguments = new ArrayList<>(degree);
List<String> calls = new ArrayList<>(degree);
for (int i = 1; i <= degree; i++) {
final Definition column = replacingEmbeddablesAndUnreplacedColumns.get(i - 1);
final String colType = getJavaTypeRef(column, out);
if (scala) {
arguments.add("value" + i + " : " + colType);
calls.add("this.value" + i + "(value" + i + ")");
} else if (kotlin) {
arguments.add("value" + i + ": " + colType + (column instanceof EmbeddableDefinition ? "" : "?"));
calls.add("this.value" + i + "(value" + i + ")");
} else {
final String nullableAnnotation = nullableOrNonnullAnnotation(out, column);
arguments.add((nullableAnnotation == null ? "" : "@" + nullableAnnotation + " ") + colType + " value" + i);
calls.add("value" + i + "(value" + i + ");");
}
}
if (scala) {
out.println();
out.println("%soverride def values([[%s]]): %s = {", visibilityPublic(), arguments, className);
for (String call : calls) out.println(call);
out.println("this");
out.println("}");
} else if (kotlin) {
out.println();
out.println("%soverride fun values([[%s]]): %s {", visibilityPublic(), arguments, className);
for (String call : calls) out.println(call);
out.println("return this");
out.println("}");
} else {
out.overrideInherit();
printNonnullAnnotation(out);
out.println("%s%s values([[%s]]) {", visibilityPublic(), className, arguments);
for (String call : calls) out.println(call);
out.println("return this;");
out.println("}");
}
}
if (generateInterfaces())
printFromAndInto(out, tableUdtOrEmbeddable, Mode.RECORD);
if (scala || kotlin) {
} else {
out.header("Constructors");
out.javadoc("Create a detached %s", className);
out.println("%s%s() {", visibility(), className);
if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
out.println("super(%s.%s.getDataType().getRow());", out.ref(getStrategy().getFullJavaIdentifier(((EmbeddableDefinition) tableUdtOrEmbeddable).getTable()), 2), getStrategy().getJavaIdentifier(tableUdtOrEmbeddable));
else
out.println("super(%s);", tableIdentifier);
out.println("}");
}
// [#3130] Invalid UDTs may have a degree of 0
// [#3176] Avoid generating constructors for tables with more than 255 columns (Java's method argument limit)
generateRecordConstructor(tableUdtOrEmbeddable, out, replacingEmbeddablesAndUnreplacedColumns, false);
if (!replacingEmbeddablesAndUnreplacedColumns.equals(embeddablesOrColumns))
generateRecordConstructor(tableUdtOrEmbeddable, out, embeddablesOrColumns, false);
if (generatePojos())
generateRecordConstructor(tableUdtOrEmbeddable, out, replacingEmbeddablesAndUnreplacedColumns, true);
if (tableUdtOrEmbeddable instanceof TableDefinition)
generateRecordClassFooter((TableDefinition) tableUdtOrEmbeddable, out);
else if (tableUdtOrEmbeddable instanceof EmbeddableDefinition)
generateEmbeddableClassFooter((EmbeddableDefinition) tableUdtOrEmbeddable, out);
else
generateUDTRecordClassFooter((UDTDefinition) tableUdtOrEmbeddable, out);
out.println("}");
}
use of org.jooq.meta.UniqueKeyDefinition in project jOOQ by jOOQ.
the class XMLGenerator method generate0.
@Override
public void generate0(Database db) {
logDatabaseParameters(db);
log.info("");
logGenerationRemarks(db);
log.info("");
log.info("----------------------------------------------------------");
TextWriter out = new TextWriter(getStrategy().getFile("information_schema.xml"), targetEncoding);
log.info("");
log.info("Generating XML", out.file().getName());
log.info("==========================================================");
InformationSchema is = new InformationSchema();
boolean hasNonDefaultCatalogs = false;
for (CatalogDefinition c : db.getCatalogs()) {
if (!StringUtils.isBlank(c.getName())) {
hasNonDefaultCatalogs = true;
break;
}
}
for (CatalogDefinition c : db.getCatalogs()) {
String catalogName = c.getOutputName();
if (hasNonDefaultCatalogs)
is.getCatalogs().add(new Catalog().withCatalogName(catalogName).withComment(generateCommentsOnCatalogs() ? c.getComment() : null));
for (SchemaDefinition s : c.getSchemata()) {
String schemaName = s.getOutputName();
Schema schema = new Schema();
schema.setCatalogName(catalogName);
schema.setSchemaName(schemaName);
if (generateCommentsOnSchemas())
schema.setComment(s.getComment());
is.getSchemata().add(schema);
for (TableDefinition t : s.getTables()) {
String tableName = t.getOutputName();
Table table = new Table();
table.setTableCatalog(catalogName);
table.setTableSchema(schemaName);
table.setTableName(tableName);
table.setTableType(t.isView() ? TableType.VIEW : t.isTemporary() ? TableType.GLOBAL_TEMPORARY : TableType.BASE_TABLE);
if (generateCommentsOnTables())
table.setComment(t.getComment());
is.getTables().add(table);
if (t.isView()) {
View view = new View();
view.setTableCatalog(catalogName);
view.setTableSchema(schemaName);
view.setTableName(tableName);
if (generateSourcesOnViews())
view.setViewDefinition(t.getSource());
is.getViews().add(view);
}
for (ColumnDefinition co : t.getColumns()) {
String columnName = co.getOutputName();
DataTypeDefinition type = co.getType();
Column column = new Column();
column.setTableCatalog(catalogName);
column.setTableSchema(schemaName);
column.setTableName(tableName);
column.setColumnName(columnName);
if (generateCommentsOnColumns())
column.setComment(co.getComment());
column.setCharacterMaximumLength(type.getLength());
column.setColumnDefault(type.getDefaultValue());
column.setDataType(type.getType());
if (co.isIdentity())
column.setIdentityGeneration("YES");
column.setIsNullable(type.isNullable());
column.setNumericPrecision(type.getPrecision());
column.setNumericScale(type.getScale());
column.setOrdinalPosition(co.getPosition());
column.setReadonly(co.isReadonly());
if (type.isComputed()) {
column.setIsGenerated(type.isComputed());
column.setGenerationExpression(type.getGeneratedAlwaysAs());
column.setGenerationOption(type.getGenerationOption() == VIRTUAL ? "VIRTUAL" : type.getGenerationOption() == STORED ? "STORED" : null);
}
is.getColumns().add(column);
}
}
for (IndexDefinition i : db.getIndexes(s)) {
String indexName = i.getOutputName();
TableDefinition table = i.getTable();
List<IndexColumnDefinition> columns = i.getIndexColumns();
Index index = new Index();
index.setIndexCatalog(catalogName);
index.setIndexSchema(schemaName);
index.setIndexName(indexName);
if (generateCommentsOnKeys())
index.setComment(i.getComment());
index.setTableCatalog(table.getCatalog().getOutputName());
index.setTableSchema(table.getSchema().getOutputName());
index.setTableName(table.getOutputName());
index.setIsUnique(i.isUnique());
is.getIndexes().add(index);
for (int j = 0; j < columns.size(); j++) {
IndexColumnDefinition indexColumn = columns.get(j);
ColumnDefinition column = indexColumn.getColumn();
IndexColumnUsage ic = new IndexColumnUsage();
ic.setIndexCatalog(catalogName);
ic.setIndexSchema(schemaName);
ic.setIndexName(indexName);
ic.setColumnName(column.getOutputName());
ic.setOrdinalPosition(j + 1);
ic.setIsDescending(indexColumn.getSortOrder() == SortOrder.DESC);
ic.setTableCatalog(table.getCatalog().getOutputName());
ic.setTableSchema(table.getSchema().getOutputName());
ic.setTableName(table.getOutputName());
is.getIndexColumnUsages().add(ic);
}
}
for (UniqueKeyDefinition u : db.getKeys(s)) {
String constraintName = u.getOutputName();
TableDefinition table = u.getTable();
List<ColumnDefinition> columns = u.getKeyColumns();
TableConstraint tc = new TableConstraint();
tc.setConstraintCatalog(catalogName);
tc.setConstraintSchema(schemaName);
tc.setConstraintName(constraintName);
tc.setConstraintType(u.isPrimaryKey() ? PRIMARY_KEY : UNIQUE);
if (generateCommentsOnKeys())
tc.setComment(u.getComment());
tc.setTableCatalog(table.getCatalog().getOutputName());
tc.setTableSchema(table.getSchema().getOutputName());
tc.setTableName(table.getOutputName());
tc.setEnforced(u.enforced());
is.getTableConstraints().add(tc);
for (int i = 0; i < columns.size(); i++) {
ColumnDefinition column = columns.get(i);
KeyColumnUsage kc = new KeyColumnUsage();
kc.setConstraintCatalog(catalogName);
kc.setConstraintSchema(schemaName);
kc.setConstraintName(constraintName);
kc.setColumnName(column.getOutputName());
kc.setOrdinalPosition(i + 1);
kc.setTableCatalog(table.getCatalog().getOutputName());
kc.setTableSchema(table.getSchema().getOutputName());
kc.setTableName(table.getOutputName());
is.getKeyColumnUsages().add(kc);
}
}
for (ForeignKeyDefinition f : db.getForeignKeys(s)) {
String constraintName = f.getOutputName();
UniqueKeyDefinition referenced = f.getReferencedKey();
TableDefinition table = f.getKeyTable();
List<ColumnDefinition> columns = f.getKeyColumns();
TableConstraint tc = new TableConstraint();
tc.setConstraintCatalog(catalogName);
tc.setConstraintSchema(schemaName);
tc.setConstraintName(constraintName);
tc.setConstraintType(FOREIGN_KEY);
if (generateCommentsOnKeys())
tc.setComment(f.getComment());
tc.setTableCatalog(table.getCatalog().getOutputName());
tc.setTableSchema(table.getSchema().getOutputName());
tc.setTableName(table.getOutputName());
tc.setEnforced(f.enforced());
ReferentialConstraint rc = new ReferentialConstraint();
rc.setConstraintCatalog(catalogName);
rc.setConstraintSchema(schemaName);
rc.setConstraintName(constraintName);
rc.setUniqueConstraintCatalog(referenced.getCatalog().getOutputName());
rc.setUniqueConstraintSchema(referenced.getSchema().getOutputName());
rc.setUniqueConstraintName(referenced.getOutputName());
is.getTableConstraints().add(tc);
is.getReferentialConstraints().add(rc);
for (int i = 0; i < columns.size(); i++) {
ColumnDefinition column = columns.get(i);
KeyColumnUsage kc = new KeyColumnUsage();
kc.setConstraintCatalog(catalogName);
kc.setConstraintSchema(schemaName);
kc.setConstraintName(constraintName);
kc.setColumnName(column.getOutputName());
kc.setOrdinalPosition(i + 1);
kc.setTableCatalog(table.getCatalog().getOutputName());
kc.setTableSchema(table.getSchema().getOutputName());
kc.setTableName(table.getOutputName());
is.getKeyColumnUsages().add(kc);
}
}
for (CheckConstraintDefinition ch : db.getCheckConstraints(s)) {
String constraintName = ch.getOutputName();
TableDefinition table = ch.getTable();
TableConstraint tc = new TableConstraint();
tc.setConstraintCatalog(catalogName);
tc.setConstraintSchema(schemaName);
tc.setConstraintName(constraintName);
tc.setConstraintType(CHECK);
if (generateCommentsOnKeys())
tc.setComment(ch.getComment());
tc.setTableCatalog(table.getCatalog().getOutputName());
tc.setTableSchema(table.getSchema().getOutputName());
tc.setTableName(table.getOutputName());
tc.setEnforced(ch.enforced());
is.getTableConstraints().add(tc);
CheckConstraint cc = new CheckConstraint();
cc.setConstraintCatalog(catalogName);
cc.setConstraintSchema(schemaName);
cc.setConstraintName(constraintName);
cc.setCheckClause(ch.getCheckClause());
is.getCheckConstraints().add(cc);
}
for (SequenceDefinition se : db.getSequences(s)) {
String sequenceName = se.getOutputName();
DataTypeDefinition type = se.getType();
Sequence sequence = new Sequence();
sequence.setSequenceCatalog(catalogName);
sequence.setSequenceSchema(schemaName);
sequence.setSequenceName(sequenceName);
if (generateCommentsOnSequences())
sequence.setComment(se.getComment());
sequence.setCharacterMaximumLength(type.getLength());
sequence.setDataType(type.getType());
sequence.setNumericPrecision(type.getPrecision());
sequence.setNumericScale(type.getScale());
sequence.setStartValue(Convert.convert(se.getStartWith(), BigInteger.class));
sequence.setIncrement(Convert.convert(se.getIncrementBy(), BigInteger.class));
sequence.setMinimumValue(Convert.convert(se.getMinvalue(), BigInteger.class));
sequence.setMaximumValue(Convert.convert(se.getMaxvalue(), BigInteger.class));
sequence.setCycleOption(se.getCycle());
sequence.setCache(Convert.convert(se.getCache(), BigInteger.class));
is.getSequences().add(sequence);
}
for (PackageDefinition pkg : db.getPackages(s)) for (RoutineDefinition r : pkg.getRoutines()) exportRoutine(is, r, catalogName, schemaName);
for (RoutineDefinition r : db.getRoutines(s)) exportRoutine(is, r, catalogName, schemaName);
}
}
StringWriter writer = new StringWriter();
MiniJAXB.marshal(is, writer);
out.print(writer.toString());
out.close();
}
Aggregations