代码之家  ›  专栏  ›  技术社区  ›  javydreamercsw

JPA 2从元模型中删除/插入订单

  •  3
  • javydreamercsw  · 技术社区  · 14 年前

    我试图使用JPA2元数据来确定从数据库插入/删除行的顺序,因此约束不是问题(稍后要在Java代码中使用)。这是使用JPA的备份/恢复方法的一部分。

    我的方法是:

    1. 按关系/约束数量对表进行分组(只考虑一对多和一对一)
    2. 没有实例的表(根据1)可以无问题地添加/删除记录
    3. 只要相关表已经“就绪”,具有一个实例的表就可以无问题地添加/删除记录。

    准备好 我的意思是,它的所有相关表记录都是填充的,所以外键对insert有效,或者没有其他表引用这个表中的记录。

    我肯定这会是某种递归方法,但我被卡住了。任何帮助都是受欢迎的。

    到目前为止,代码如下:

    /**
     * Get the execution order from the EntityManager meta data model.
     *
     * This will fail if the EntityManager is not JP2 compliant
     * @param em EntityManager to get the metadata from
     * @return ArrayList containing the order to process tables
     */
    protected static ArrayList<String> getProcessingOrder(EntityManager em) {
        ArrayList<String> tables = new ArrayList<String>();
        //This holds the amount of relationships and the tables with that same amount
        HashMap<Integer, ArrayList<String>> tableStats = new HashMap<Integer, ArrayList<String>>();
        //This holds the table and the tables referenced by it
        HashMap<String, ArrayList<String>> references = new HashMap<String, ArrayList<String>>();
        for (EntityType et : em.getMetamodel().getEntities()) {
            Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.FINER, et.getName());
            int amount = 0;
            Iterator<SingularAttribute> sIterator = et.getSingularAttributes().iterator();
            while (sIterator.hasNext()) {
                SingularAttribute next = sIterator.next();
                switch (next.getPersistentAttributeType()) {
                    case BASIC:
                    case ELEMENT_COLLECTION:
                    case EMBEDDED:
                    case ONE_TO_MANY:
                    case ONE_TO_ONE:
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.FINER,
                                "Ignoring: {0}", next.getName());
                        break;
                    case MANY_TO_MANY:
                    case MANY_TO_ONE:
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.INFO,
                                "{3} has a {2} relationship: {0} with: {1}",
                                new Object[]{next.getName(), next.getBindableJavaType(),
                                    next.getPersistentAttributeType().name(), et.getName()});
                        if (!references.containsKey(et.getName())) {
                            references.put(et.getName(), new ArrayList<String>());
                        }
                        references.get(et.getName()).add(next.getBindableJavaType().getSimpleName());
                        amount++;
                        break;
                    default:
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.SEVERE,
                                "Unexpected value: {0}", next.getName());
                        break;
                }
            }
            Iterator<PluralAttribute> pIterator = et.getPluralAttributes().iterator();
            while (pIterator.hasNext()) {
                PluralAttribute next = pIterator.next();
                switch (next.getPersistentAttributeType()) {
                    case BASIC:
                    case ELEMENT_COLLECTION:
                    case EMBEDDED:
                    case ONE_TO_MANY:
                    case MANY_TO_MANY:
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.FINER,
                                "Ignoring: {0}", next.getName());
                        break;
                    case MANY_TO_ONE:
                    case ONE_TO_ONE:
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.INFO,
                                "{3} has a {2} relationship: {0} with: {1}",
                                new Object[]{next.getName(), next.getBindableJavaType(),
                                    next.getPersistentAttributeType().name(), et.getName()});
                        if (!references.containsKey(et.getName())) {
                            references.put(et.getName(), new ArrayList<String>());
                        }
                        references.get(et.getName()).add(next.getBindableJavaType().getSimpleName());
                        amount++;
                        break;
                    default:
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.SEVERE,
                                "Unexpected value: {0}", next.getName());
                        break;
                }
            }
            if (!tableStats.containsKey(amount)) {
                tableStats.put(amount, new ArrayList<String>());
            }
            tableStats.get(amount).add(et.getName());
        }
        Iterator<String> iterator = references.keySet().iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            Iterator<String> iterator1 = references.get(next).iterator();
            StringBuilder refs = new StringBuilder();
            while (iterator1.hasNext()) {
                refs.append(iterator1.next()).append("\n");
            }
            Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.FINER, "References for {0}:\n{1}", new Object[]{next, refs.toString()});
        }
        //Need to sort entities with relationships even further
        ArrayList<String> temp = new ArrayList<String>();
        for (Entry<Integer, ArrayList<String>> e : tableStats.entrySet()) {
            if (e.getKey() > 0) {
                Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.INFO, "Tables with {0} references", e.getKey());
                for (String t : e.getValue()) {
                    //Check the relationships of the tables
                    //Here's where I need help
                    boolean ready = true;
                    for (String ref : references.get(t)) {
                        if (!temp.contains(ref)) {
                            Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.INFO,
                                    "{0} is not ready. Referenced table {1} is not ready yet", new Object[]{t, ref});
                            ready = false;
                        }
                    }
                    if (ready) {
                        Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.INFO, "{0} is ready.", t);
                        temp.add(t);
                    }
                }
                //-------------------------------------------------------
            } else {
                temp.addAll(e.getValue());
            }
        }
        for (Entry<Integer, ArrayList<String>> e : tableStats.entrySet()) {
            Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.FINER,
                    "Amount of relationships: {0}", e.getKey());
            StringBuilder list = new StringBuilder();
            for (String t : e.getValue()) {
                list.append(t).append("\n");
            }
            Logger.getLogger(XincoBackupManager.class.getSimpleName()).log(Level.FINER, list.toString());
        }
        tables.addAll(temp);
        return tables;
    }
    
    1 回复  |  直到 14 年前
        1
  •  1
  •   Timo Westkämper    14 年前

    我将使用JDBC中的数据库元数据来处理这个问题。

    以下方法来自 java.sql.DatabaseMetadata 此处使用:

    // to get the tables
    getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types) 
    
    // to get the reference to the table
    public ResultSet getExportedKeys(String catalog,
                                     String schema,
                                     String table)
                              throws SQLException
    

    我在一些应用程序中使用了这种方法,它工作得很好。

    虽然这种方法不遵循JPA元模型的用法,但我相信,考虑到您的问题,在JDBC元数据级别上操作更合适。

    因为可能存在循环依赖关系,很难通过这样一个外键依赖关系图来处理这些依赖关系,所以您也可以选择

    删除

    • 禁用约束
    • 删除内容
    • 启用约束

    用于添加

    • 禁用约束
    • 添加内容
    • 启用约束