Examples with TargetServer com.cubrid.common.ui.cubrid.database.erwin.xmlmodel.TargetServer used on opensource projects

Example 1 with TargetServer

use of com.cubrid.common.ui.cubrid.database.erwin.xmlmodel.TargetServer in project cubrid-manager by CUBRID.

the class ExportSchemaTask method execute.

public void execute() {
    // FIXME logic code move to core module
    entityMap.clear();
    relationshipMap.clear();
    entityAttrMap.clear();
    ERwin4 root = new ERwin4();
    Model model = new Model();
    // DEFUALT database type "ODBC" "194"
    model.setTargetServer("194");
    model.setDbmsVersion("3");
    model.setModelProps(new Model.ModelProps());
    model.getModelProps().setDbmsVersion(new DBMSVersion());
    model.getModelProps().getDbmsVersion().setValue("3");
    model.getModelProps().setTargetServer(new TargetServer());
    model.getModelProps().getTargetServer().setValue("194");
    model.setId(getUUID());
    root.setModel(model);
    RelationshipGroups relationShipGroups = new RelationshipGroups();
    model.setRelationshipGroups(relationShipGroups);
    model.setDefaultValueGroups(new DefaultValueGroups());
    EntityGroups groups = new EntityGroups();
    model.setEntityGroups(groups);
    for (Entry<String, SchemaInfo> entry : allSchemaInfos.entrySet()) {
        String physicalTableName = entry.getKey();
        String logicalTableName = physicalTableName;
        if (tablePLMap != null) {
            String logical = tablePLMap.get(physicalTableName);
            logicalTableName = StringUtil.isEmpty(logical) ? physicalTableName : logical;
        }
        SchemaInfo schemaInfo = entry.getValue();
        if (schemaInfo.isSystemClass()) {
            continue;
        }
        Entity entity = new Entity();
        groups.getEntity().add(entity);
        entity.setId(getUUID());
        entity.setName(logicalTableName);
        entityMap.put(physicalTableName, entity);
        entityAttrMap.put(physicalTableName, new HashMap<String, Attribute>());
        EntityPropsList entityPropsList = new EntityPropsList();
        entity.setEntityProps(entityPropsList);
        entityPropsList.setPhysicalName(new EntityPropsList.PhysicalName());
        entityPropsList.getPhysicalName().setValue(physicalTableName);
        Type type = new Type();
        if (schemaInfo.getVirtual().equals(ClassType.NORMAL.getText())) {
            type.setValue(ERXmlModelConstant.ENTITYTYPE_TABLE_STR);
        } else {
            type.setValue(ERXmlModelConstant.ENTITYTYPE_VIEW_STR);
        }
        entityPropsList.setType(type);
        Name nameEntityProps = new Name();
        nameEntityProps.setValue(logicalTableName);
        entityPropsList.setName(nameEntityProps);
        List<DBAttribute> attributes = schemaInfo.getAttributes();
        AttributeGroups attributeGroups = new AttributeGroups();
        entity.setAttributeGroups(attributeGroups);
        Map<String, Attribute> schemaAttrMap = new HashMap<String, Attribute>();
        int attrOrder = 1;
        for (DBAttribute dbAttr : attributes) {
            Attribute attribute = new Attribute();
            attributeGroups.getAttribute().add(attribute);
            attribute.setId(getUUID());
            String logicalAttrName = getLogicalAttrName(physicalTableName, dbAttr.getName());
            if (StringUtil.isEmpty(logicalAttrName)) {
                logicalAttrName = dbAttr.getName();
            }
            attribute.setName(logicalAttrName);
            schemaAttrMap.put(dbAttr.getName(), attribute);
            AttributePropsList attributePropsList = new AttributePropsList();
            attribute.setAttributeProps(attributePropsList);
            attributePropsList.setPhysicalName(new PhysicalName());
            attributePropsList.getPhysicalName().setValue(dbAttr.getName());
            com.cubrid.common.ui.cubrid.database.erwin.xmlmodel.AttributePropsList.Type attrType = new com.cubrid.common.ui.cubrid.database.erwin.xmlmodel.AttributePropsList.Type();
            attributePropsList.setType(attrType);
            if (dbAttr.isNotNull() && dbAttr.isUnique()) {
                attrType.setValue("" + ERXmlModelConstant.ATTRIBUTE_TYPE_PK);
            } else {
                attrType.setValue("100");
            }
            Datatype dataType = new Datatype();
            String typeValue = dbAttr.getType();
            if (!StringUtil.isEmpty(dbAttr.getEnumeration())) {
                typeValue += dbAttr.getEnumeration();
            }
            dataType.setValue(typeValue);
            attributePropsList.setDataType(dataType);
            com.cubrid.common.ui.cubrid.database.erwin.xmlmodel.AttributePropsList.Name propName = new com.cubrid.common.ui.cubrid.database.erwin.xmlmodel.AttributePropsList.Name();
            propName.setValue(logicalAttrName);
            attributePropsList.setName(propName);
            LogicalDataType logicalDataType = new LogicalDataType();
            String logicalAttrType = getLogicalAttrType(physicalTableName, dbAttr.getName());
            if (StringUtil.isEmpty(logicalAttrType)) {
                logicalAttrType = typeValue;
            }
            logicalDataType.setValue(logicalAttrType);
            attributePropsList.setLogicalDataType(logicalDataType);
            if (dbAttr.isNotNull()) {
                NullOption nullOption = new NullOption();
                nullOption.setValue("" + 1);
                attributePropsList.setNullOption(nullOption);
            }
            Order order = new Order();
            attributePropsList.setOrder(order);
            order.setValue("" + attrOrder++);
            if (dbAttr.getDefault() != null) {
                String defaultNameStr = handleSpace(dbAttr.getDefault());
                String defaultName = "default_" + defaultNameStr;
                Default defaultValue = null;
                attributePropsList.setDefaultValue(new AttributePropsList.DefaultValue());
                if (defaultNodeMap.containsKey(defaultName)) {
                    defaultValue = defaultNodeMap.get(defaultName);
                    attributePropsList.getDefaultValue().setValue(defaultValue.getId());
                    continue;
                }
                String defaultId = getUUID();
                DefaultValueGroups defaultValueGroups = model.getDefaultValueGroups();
                attributePropsList.getDefaultValue().setValue(defaultId);
                defaultValue = new Default();
                defaultValue.setId(defaultId);
                defaultValue.setName("default_" + defaultNameStr);
                defaultValueGroups.getDefault().add(defaultValue);
                defaultNodeMap.put(defaultValue.getName(), defaultValue);
                DefaultPropsList defaultPropsList = new DefaultPropsList();
                defaultValue.setDefaultProps(defaultPropsList);
                defaultPropsList.setName(new DefaultPropsList.Name());
                defaultPropsList.getName().setValue(defaultValue.getName());
                defaultPropsList.setServerValue(new ServerValue());
                defaultPropsList.getServerValue().setValue(dbAttr.getDefault());
                defaultPropsList.setLogicalDefaultValue(new LogicalDefaultValue());
                defaultPropsList.getLogicalDefaultValue().setValue(dbAttr.getDefault());
            }
        }
        entityAttrMap.put(physicalTableName, schemaAttrMap);
    }
    List<String> relIds = new ArrayList<String>();
    for (Entry<String, SchemaInfo> entry : allSchemaInfos.entrySet()) {
        Entity entity = entityMap.get(entry.getKey());
        if (entity == null)
            continue;
        SchemaInfo schemaInfo = entry.getValue();
        Map<String, Attribute> schemaAttrMap = entityAttrMap.get(schemaInfo.getClassname());
        KeyGroupGroups keyGroups = new KeyGroupGroups();
        entity.setKeyGroupGroups(keyGroups);
        // counter for index
        int fk = 1;
        int idx = 1;
        int uidx = 1;
        List<Constraint> constraints = schemaInfo.getConstraints();
        for (Constraint constraint : constraints) {
            if (!isValid(constraint)) {
                continue;
            }
            KeyGroup keyGroup = new KeyGroup();
            keyGroups.getKeyGroup().add(keyGroup);
            keyGroup.setId(getUUID());
            keyGroup.setName(constraint.getName());
            KeyGroupPropsList keyGroupPropsList = new KeyGroupPropsList();
            keyGroup.setKeyGroupProps(keyGroupPropsList);
            KeyGroupMemberGroups keyGroupMemberGroups = new KeyGroupMemberGroups();
            keyGroup.setKeyGroupMemberGroups(keyGroupMemberGroups);
            KeyGroupType keyGrouptype = new KeyGroupType();
            keyGroupPropsList.setKeyGroupType(keyGrouptype);
            if (constraint.getType().equals(ConstraintType.PRIMARYKEY.getText())) {
                keyGrouptype.setValue("PK");
                List<String> keyAttr = constraint.getAttributes();
                int order = 1;
                for (String keyName : keyAttr) {
                    KeyGroupMember keyGroupMember = new KeyGroupMember();
                    keyGroupMemberGroups.getKeyGroupMember().add(keyGroupMember);
                    keyGroupMember.setId(getUUID());
                    keyGroupMember.setName("" + order);
                    KeyGroupMemberPropsList propList = new KeyGroupMemberPropsList();
                    keyGroupMember.setKeyGroupMemberProps(propList);
                    KeyGroupPosition position = new KeyGroupPosition();
                    propList.setKeyGroupPosition(position);
                    position.setValue("" + order++);
                    KeyGroupMemberColumn column = new KeyGroupMemberColumn();
                    Attribute attrTemp = schemaAttrMap.get(keyName);
                    column.setValue(attrTemp.getId());
                    propList.setKeyGroupMemberColumn(column);
                }
            } else if (constraint.getType().equals(ConstraintType.FOREIGNKEY.getText())) {
                keyGrouptype.setValue("IF" + fk++);
                String relId = getUUID();
                keyGroupPropsList.setKeyGroupRelationPointer(new KeyGroupRelationPointer());
                keyGroupPropsList.getKeyGroupRelationPointer().setValue(relId);
                relIds.add(relId);
                List<String> keyAttr = constraint.getAttributes();
                String inherit = constraint.getReferencedTable();
                Entity pEntity = entityMap.get(inherit);
                if (pEntity == null) {
                    continue;
                }
                Map<String, Attribute> tempAttrMap = entityAttrMap.get(schemaInfo.getClassname());
                Map<String, Attribute> parentAttrMap = entityAttrMap.get(inherit);
                Relationship relationShip = new Relationship();
                relationShip.setId(relId);
                relationshipMap.put(relId, relationShip);
                relationShip.setName("R/" + fk);
                model.getRelationshipGroups().getRelationship().add(relationShip);
                RelationshipPropsList relationShipPropsList = new RelationshipPropsList();
                relationShip.setRelationshipProps(relationShipPropsList);
                relationShipPropsList.setName(new RelationshipPropsList.Name());
                relationShipPropsList.getName().setValue(relationShip.getName());
                // type == 7 : non-identify fk
                relationShipPropsList.setType(new RelationshipPropsList.Type());
                relationShipPropsList.getType().setValue("2");
                relationShipPropsList.setRelationshipNoNulls(new RelationshipNoNulls());
                relationShipPropsList.getRelationshipNoNulls().setValue("101");
                relationShipPropsList.setRelationshipSequence(new RelationshipSequence());
                relationShipPropsList.getRelationshipSequence().setValue("1");
                relationShipPropsList.setRelationshipParentInsertRule(new RelationshipParentInsertRule());
                relationShipPropsList.getRelationshipParentInsertRule().setValue("0");
                relationShipPropsList.setRelationshipParentUpdateRule(new RelationshipParentUpdateRule());
                relationShipPropsList.setRelationshipParentDeleteRule(new RelationshipParentDeleteRule());
                relationShipPropsList.setRelationshipChildInsertRule(new RelationshipChildInsertRule());
                relationShipPropsList.getRelationshipChildInsertRule().setValue("0");
                relationShipPropsList.setRelationshipChildUpdateRule(new RelationshipChildUpdateRule());
                relationShipPropsList.getRelationshipChildUpdateRule().setValue("0");
                relationShipPropsList.setRelationshipChildDeleteRule(new RelationshipChildDeleteRule());
                relationShipPropsList.getRelationshipChildDeleteRule().setValue("0");
                List<String> rules = constraint.getRules();
                for (String rule : rules) {
                    if (rule.indexOf("ON UPDATE") != -1) {
                        int tmp = rule.replace("ON UPDATE ", "").hashCode();
                        RelationshipParentUpdateRule updateRule = relationShipPropsList.getRelationshipParentUpdateRule();
                        if (tmp == "CASCADE".hashCode()) {
                            updateRule.setValue("10001");
                        } else if (tmp == "NO ACTION".hashCode()) {
                            updateRule.setValue("9998");
                        } else if (tmp == "RESTRICT".hashCode()) {
                            updateRule.setValue("10000");
                        }
                    } else if (rule.indexOf("ON DELETE") != -1) {
                        int tmp = rule.replace("ON DELETE ", "").hashCode();
                        RelationshipParentDeleteRule deleteRule = relationShipPropsList.getRelationshipParentDeleteRule();
                        if (tmp == "CASCADE".hashCode()) {
                            deleteRule.setValue("10005");
                        } else if (tmp == "NO ACTION".hashCode()) {
                            deleteRule.setValue("9999");
                        } else if (tmp == "RESTRICT".hashCode()) {
                            deleteRule.setValue("10004");
                        }
                    }
                }
                relationShipPropsList.setRelationshipParentEntity(new RelationshipParentEntity());
                relationShipPropsList.getRelationshipParentEntity().setValue(pEntity.getId());
                relationShipPropsList.setRelationshipChildEntity(new RelationshipChildEntity());
                relationShipPropsList.getRelationshipChildEntity().setValue(entityMap.get(schemaInfo.getClassname()).getId());
                LinkedList<String> pkAttr = new LinkedList<String>();
                SchemaInfo parentTable = allSchemaInfos.get(inherit);
                for (Constraint con : parentTable.getConstraints()) {
                    if (con.getType().equals(ConstraintType.PRIMARYKEY.getText())) {
                        pkAttr.addAll(con.getAttributes());
                        break;
                    }
                }
                int order = 1;
                for (String keyName : keyAttr) {
                    KeyGroupMember keyGroupMember = new KeyGroupMember();
                    keyGroupMemberGroups.getKeyGroupMember().add(keyGroupMember);
                    keyGroupMember.setId(getUUID());
                    keyGroupMember.setName("" + order);
                    KeyGroupMemberPropsList propList = new KeyGroupMemberPropsList();
                    keyGroupMember.setKeyGroupMemberProps(propList);
                    KeyGroupPosition position = new KeyGroupPosition();
                    propList.setKeyGroupPosition(position);
                    position.setValue("" + order++);
                    KeyGroupMemberColumn column = new KeyGroupMemberColumn();
                    String parentPkAttr = pkAttr.remove();
                    Attribute attrTemp = tempAttrMap.get(keyName);
                    column.setValue(attrTemp.getId());
                    propList.setKeyGroupMemberColumn(column);
                    // Attribute parent part
                    Attribute schemaAttr = schemaAttrMap.get(keyName);
                    AttributePropsList schemaPropList = schemaAttr.getAttributeProps();
                    Attribute parentPkAttrNode = parentAttrMap.get(parentPkAttr);
                    ParentAttribute pAttribute = new ParentAttribute();
                    pAttribute.setValue(parentPkAttrNode.getId());
                    schemaPropList.setParentAttribute(pAttribute);
                    schemaAttr.getAttributeProps().setParentRelationship(new ParentRelationship());
                    schemaAttr.getAttributeProps().getParentRelationship().setValue(relId);
                }
            } else if (constraint.getType().equals(ConstraintType.INDEX.getText()) || constraint.getType().equals(ConstraintType.REVERSEINDEX.getText())) {
                keyGrouptype.setValue("IE" + idx++);
                List<String> keyAttr = constraint.getAttributes();
                int order = 1;
                for (String keyName : keyAttr) {
                    KeyGroupMember keyGroupMember = new KeyGroupMember();
                    keyGroupMemberGroups.getKeyGroupMember().add(keyGroupMember);
                    keyGroupMember.setId(getUUID());
                    keyGroupMember.setName("" + order);
                    KeyGroupMemberPropsList propList = new KeyGroupMemberPropsList();
                    keyGroupMember.setKeyGroupMemberProps(propList);
                    for (String rule : constraint.getRules()) {
                        if (rule.toLowerCase().startsWith(keyName.toLowerCase())) {
                            if (rule.toLowerCase().indexOf(" desc") != -1) {
                                propList.setKeyGroupSortOrder(new KeyGroupSortOrder());
                                propList.getKeyGroupSortOrder().setValue("DESC");
                            }
                        }
                    }
                    KeyGroupPosition position = new KeyGroupPosition();
                    propList.setKeyGroupPosition(position);
                    position.setValue("" + order++);
                    KeyGroupMemberColumn column = new KeyGroupMemberColumn();
                    Attribute attrTemp = schemaAttrMap.get(keyName);
                    column.setValue(attrTemp.getId());
                    propList.setKeyGroupMemberColumn(column);
                }
            } else if (constraint.getType().equals(ConstraintType.UNIQUE.getText()) || constraint.getType().equals(ConstraintType.REVERSEUNIQUE.getText())) {
                keyGrouptype.setValue("AK" + uidx++);
                List<String> keyAttr = constraint.getAttributes();
                int order = 1;
                for (String keyName : keyAttr) {
                    KeyGroupMember keyGroupMember = new KeyGroupMember();
                    keyGroupMemberGroups.getKeyGroupMember().add(keyGroupMember);
                    keyGroupMember.setId(getUUID());
                    keyGroupMember.setName("" + order);
                    KeyGroupMemberPropsList propList = new KeyGroupMemberPropsList();
                    keyGroupMember.setKeyGroupMemberProps(propList);
                    KeyGroupPosition position = new KeyGroupPosition();
                    propList.setKeyGroupPosition(position);
                    position.setValue("" + order++);
                    KeyGroupMemberColumn column = new KeyGroupMemberColumn();
                    Attribute attrTemp = schemaAttrMap.get(keyName);
                    column.setValue(attrTemp.getId());
                    propList.setKeyGroupMemberColumn(column);
                    KeyGroupSortOrder sortOrder = new KeyGroupSortOrder();
                    propList.setKeyGroupSortOrder(sortOrder);
                    for (String rule : constraint.getRules()) {
                        if (rule.toLowerCase().startsWith(keyName.toLowerCase())) {
                            String orderStr = rule.replace(keyName.toLowerCase(), "").replaceAll(" ", "");
                            sortOrder.setValue(orderStr);
                        }
                    }
                }
            }
        }
    }
    setDrawData(model);
    FileOutputStream fout = null;
    try {
        File f = new File(filename);
        if (!f.exists()) {
            try {
                f.createNewFile();
            } catch (IOException e) {
                CommonUITool.openErrorBox(Messages.bind(Messages.errCreateFile, filename));
                return;
            }
        }
        fout = new FileOutputStream(f);
        marshaller.marshal(root, fout);
        fout.close();
    } catch (Exception e) {
        LOGGER.error(e.getMessage(), e);
        isSuccess = false;
    } finally {
        try {
            if (fout != null) {
                fout.flush();
                fout.close();
            }
        } catch (IOException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }
    isSuccess = true;
}