Examples with DBAttribute com.cubrid.common.core.common.model.DBAttribute used on opensource projects

Example 76 with DBAttribute

use of com.cubrid.common.core.common.model.DBAttribute in project cubrid-manager by CUBRID.

the class TableEditorPart method changeForEditAttribute.

/**
	 * Make a change log for editing attribute
	 *
	 * @param attrName
	 * @param lastAttr attribute previous changed by the user
	 * @param editAttr attribute to be changed by the user
	 * @param origAttr attribute on a server
	 * @return
	 */
public boolean changeForEditAttribute(String attrName, DBAttribute editAttr, DBAttribute origAttr) {
    // FIXME move this logic to core module
    if (database == null || editAttr == null) {
        return false;
    }
    String tableName = newSchemaInfo.getClassname();
    editAttr.setInherit(tableName);
    String newAttrName = editAttr.getName();
    // new attribute
    if (origAttr == null) {
        if (!StringUtil.isEmpty(attrName) && newSchemaInfo.replaceDBAttributeByName(attrName, editAttr)) {
            // replace
            addDropAttrLog(attrName, false);
            addNewAttrLog(newAttrName, false);
        }
    } else {
        // existed attribute to changed with a name
        addEditAttrLog(attrName, newAttrName, false);
    }
    if (origAttr == null) {
        origAttr = new DBAttribute();
    }
    if (!origAttr.isUnique() && newSchemaInfo.getUniqueByAttrName(editAttr.getName()) == null && editAttr.isUnique()) {
        Constraint unique = new Constraint(true);
        unique.setType(Constraint.ConstraintType.UNIQUE.getText());
        unique.addAttribute(newAttrName);
        unique.addRule(newAttrName + " ASC");
        unique.setName(ConstraintNamingUtil.getUniqueName(tableName, unique.getRules()));
        newSchemaInfo.addConstraint(unique);
        addNewUniqueLog(unique);
    } else if (origAttr.isUnique() && !editAttr.isUnique()) {
        if (oldSchemaInfo != null) {
            Constraint unique = oldSchemaInfo.getUniqueByAttrName(origAttr.getName());
            addDelUniqueLog(unique);
        }
        newSchemaInfo.removeUniqueByAttrName(attrName);
    } else if (!origAttr.isUnique() && !editAttr.isUnique()) {
        Constraint unique = newSchemaInfo.getUniqueByAttrName(attrName);
        if (unique != null) {
            addDelUniqueLog(unique);
        }
        newSchemaInfo.removeUniqueByAttrName(attrName);
    }
    indexTableView.setInput(newSchemaInfo);
    fkTableView.setInput(newSchemaInfo);
    if (database != null && database.getDatabaseInfo() != null && newSchemaInfo != null) {
        SuperClassUtil.fireSuperClassChanged(database.getDatabaseInfo(), oldSchemaInfo, newSchemaInfo, newSchemaInfo.getSuperClasses());
    }
    attrLabelProvider.setSchema(newSchemaInfo);
    loadColumnData();
    columnTableView.setSelection(new StructuredSelection(editAttr), true);
    columnsTable.setFocus();
    handleSelectionChangeInColumnTable();
    return true;
}

Example 77 with DBAttribute

use of com.cubrid.common.core.common.model.DBAttribute in project cubrid-manager by CUBRID.

the class TableEditorPart method removeTempDBAttributeByName.

/**
	 * Remove temporary attribute by name
	 *
	 * @param name
	 */
public void removeTempDBAttributeByName(String name) {
    List<DBAttribute> removeList = new ArrayList<DBAttribute>();
    for (DBAttribute attr : tempDBAttributeList) {
        if (!StringUtil.isEmpty(name) && StringUtil.isEqual(name, attr.getName())) {
            removeList.add(attr);
        }
    }
    tempDBAttributeList.removeAll(removeList);
}

Example 78 with DBAttribute

use of com.cubrid.common.core.common.model.DBAttribute in project cubrid-manager by CUBRID.

the class TableEditorPart method openEditIndexDialog.

/**
	 * Open the index edit dialog with the constraint object
	 *
	 * @param editedIndex Constraint
	 */
private void openEditIndexDialog(Constraint editedIndex) {
    boolean isNewConstraint = true;
    for (int i = 0, len = originalConstraints.size(); i < len; i++) {
        if (originalConstraints.get(i) == editedIndex) {
            isNewConstraint = false;
        }
    }
    AddIndexDialog dlg = new AddIndexDialog(getSite().getShell(), newSchemaInfo, database, editedIndex, isNewConstraint);
    int returnCode = dlg.open();
    if (returnCode == AddIndexDialog.OK) {
        Constraint newIndex = dlg.getIndexConstraint();
        if (newIndex == null) {
            return;
        }
        newSchemaInfo.removeConstraintByName(editedIndex.getName(), editedIndex.getType());
        newSchemaInfo.addConstraint(newIndex);
        // For bug TOOLS-2394 Unique index can't be added again
        if (Constraint.ConstraintType.UNIQUE.getText().equals(newIndex.getType()) && newIndex.getAttributes().size() == 1) {
            DBAttribute attr = newSchemaInfo.getDBAttributeByName(newIndex.getAttributes().get(0), false);
            attr.setUnique(true);
            loadColumnData();
        }
        boolean modifiedUK = Constraint.ConstraintType.UNIQUE.getText().equals(editedIndex.getType()) && editedIndex.getAttributes().size() == 1;
        boolean noNewUK = !Constraint.ConstraintType.UNIQUE.getText().equals(newIndex.getType()) || newIndex.getAttributes().size() != 1;
        if (modifiedUK && noNewUK) {
            String attrName = editedIndex.getAttributes().get(0);
            DBAttribute attr = newSchemaInfo.getDBAttributeByName(attrName, false);
            if (attr != null) {
                attr.setUnique(false);
                loadColumnData();
            }
        }
        String key1 = editedIndex.getDefaultName(newSchemaInfo.getClassname()) + "$" + editedIndex.getName();
        String key2 = newIndex.getDefaultName(newSchemaInfo.getClassname()) + "$" + newIndex.getName();
        SchemaChangeLog changeLog = new SchemaChangeLog(key1, key2, SchemeInnerType.TYPE_INDEX);
        schemaChangeMgr.addSchemeChangeLog(changeLog);
        indexTableView.setInput(newSchemaInfo);
    }
}

Example 79 with DBAttribute

use of com.cubrid.common.core.common.model.DBAttribute 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;
}

Example 80 with DBAttribute

use of com.cubrid.common.core.common.model.DBAttribute in project cubrid-manager by CUBRID.

the class ColumnProposalAdvisor method loadProposal.

/**
	 * load proposal for database
	 * 
	 * @param databaseInfo
	 */
private void loadProposal(final DatabaseInfo databaseInfo) {
    final String key = makeKey(databaseInfo);
    Job job = new Job("Load database schema information job") {

        protected IStatus run(IProgressMonitor monitor) {
            List<String> tableNames = new ArrayList<String>();
            Map<String, List<ColumnProposalDetailInfo>> columns = new HashMap<String, List<ColumnProposalDetailInfo>>();
            GetAllSchemaTask task = null;
            try {
                task = new GetAllSchemaTask(databaseInfo, monitor);
                task.setNeedCollationInfo(false);
                task.execute();
                /*Check is canceled*/
                if (task.isCancel()) {
                    return Status.CANCEL_STATUS;
                }
                if (task.isSuccess()) {
                    Map<String, SchemaInfo> schemas = task.getSchemas();
                    Map<String, SchemaComment> descriptions = task.getComments();
                    List<String> fetchedTableNames = new ArrayList<String>();
                    for (SchemaInfo schemaInfo : schemas.values()) {
                        if (schemaInfo.isSystemClass()) {
                            continue;
                        }
                        String tableName = schemaInfo.getClassname();
                        if (ConstantsUtil.isExtensionalSystemTable(tableName)) {
                            continue;
                        }
                        fetchedTableNames.add(tableName);
                    }
                    Collections.sort(fetchedTableNames);
                    for (String tableName : fetchedTableNames) {
                        if (!tableNames.contains(tableName)) {
                            tableNames.add(tableName);
                        }
                        if (columns.containsKey(tableName)) {
                            continue;
                        }
                        SchemaInfo schemaInfo = schemas.get(tableName);
                        if (schemaInfo == null) {
                            continue;
                        }
                        if (descriptions != null) {
                            SchemaComment schemaComment = SchemaCommentHandler.find(descriptions, tableName, null);
                            if (schemaComment != null) {
                                String description = schemaComment.getDescription();
                                schemaInfo.setDescription(description);
                            }
                        }
                        List<ColumnProposalDetailInfo> colInfoList = new ArrayList<ColumnProposalDetailInfo>();
                        columns.put(tableName, colInfoList);
                        List<DBAttribute> dbClassAttrList = schemaInfo.getClassAttributes();
                        for (DBAttribute attr : dbClassAttrList) {
                            ColumnProposalDetailInfo colInfo = new ColumnProposalDetailInfo(schemaInfo, attr);
                            colInfoList.add(colInfo);
                        }
                        List<DBAttribute> attrList = schemaInfo.getAttributes();
                        for (DBAttribute attr : attrList) {
                            ColumnProposalDetailInfo colInfo = new ColumnProposalDetailInfo(schemaInfo, attr);
                            colInfoList.add(colInfo);
                        }
                        columns.put(schemaInfo.getClassname(), colInfoList);
                    }
                    /*Cache the data*/
                    ColumnProposal proposal = new ColumnProposal();
                    proposal.setTableNames(tableNames);
                    proposal.setColumns(columns);
                    synchronized (ColumnProposalAdvisor.class) {
                        cachedMap.put(key, proposal);
                    }
                }
            } catch (Exception e) {
                LOGGER.error(e.getMessage(), e);
            } finally {
                synchronized (ColumnProposalAdvisor.class) {
                    collectingKeys.remove(key);
                }
                task.finish();
            }
            return Status.OK_STATUS;
        }
    };
    /*Record collecting key*/
    synchronized (ColumnProposalAdvisor.class) {
        collectingKeys.add(key);
        job.schedule();
    }
}