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

我试图使用JPA2元数据来确定从数据库中插入/删除行的顺序，这样约束就不会成为问题（稍后将在Java代码中使用）。这是使用JPA的备份/恢复方法的一部分

以下是我的方法：

按关系/约束的数量对表进行分组（仅考虑一对多和一对一）

具有零实例的表（根据#1）可以添加/删除记录而不会出现问题

具有一个实例的表可以添加/删除记录，只要相关表已“就绪”

Ready通过Ready，我的意思是填充其所有相关的表记录，以便外键对插入有效，或者没有其他表引用此表中的记录

我确信这将是某种递归方法，但我被卡住了。任何帮助都是非常受欢迎的

以下是迄今为止的代码：

/**
 * 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;
}

/**
*从EntityManager元数据模型获取执行顺序。
*
*如果EntityManager不符合JP2，则此操作将失败
*@param em EntityManager从中获取元数据
*@return ArrayList包含处理表的顺序
*/
受保护的静态阵列列表getProcessingOrder（EntityManager em）{
ArrayList tables=新的ArrayList（）；
//这将保存具有相同数量的关系和表的数量
HashMap tableStats=新HashMap（）；
//这将保存表及其引用的表
HashMap references=新的HashMap（）；
对于（EntityType et:em.getMetamodel（）.getEntities（））{
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.FINER，et.getName（））；
整数金额=0；
迭代器sIterator=et.getSingularAttributes（）.Iterator（）；
while（sIterator.hasNext（））{
SingularAttribute next=sIterator.next（）；
开关（next.getPersistentAttributeType（））{
案例基础：
案例元素集合：
嵌入案例：
案例一对多：
案例一至案例一：
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.FINER，
“忽略：{0}”，next.getName（））；
打破
案例多对多：
案例多对案例一：
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.INFO，
“{3}具有{2}关系：{0}与：{1}”，
新对象[]{next.getName（），next.getBindableJavaType（），
next.getPersistentAttributeType（）.name（），et.getName（）}）；
如果（！references.containsKey（et.getName（）））{
references.put（et.getName（），newarraylist（））；
}
references.get（et.getName（））.add（next.getBindableJavaType（）.getSimpleName（））；
金额++；
打破
违约：
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.SEVERE，
“意外值：{0}”，next.getName（））；
打破
}
}
迭代器pIterator=et.getPluralAttributes（）.Iterator（）；
while（pIterator.hasNext（））{
PluralAttribute next=pIterator.next（）；
开关（next.getPersistentAttributeType（））{
案例基础：
案例元素集合：
嵌入案例：
案例一对多：
案例多对多：
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.FINER，
“忽略：{0}”，next.getName（））；
打破
案例多对案例一：
案例一至案例一：
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.INFO，
“{3}具有{2}关系：{0}与：{1}”，
新对象[]{next.getName（），next.getBindableJavaType（），
next.getPersistentAttributeType（）.name（），et.getName（）}）；
如果（！references.containsKey（et.getName（）））{
references.put（et.getName（），newarraylist（））；
}
references.get（et.getName（））.add（next.getBindableJavaType（）.getSimpleName（））；
金额++；
打破
违约：
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.SEVERE，
“意外值：{0}”，next.getName（））；
打破
}
}
如果（！tableStats.containsKey（金额））{
tableStats.put（amount，new ArrayList（））；
}
get（amount）.add（et.getName（））；
}
迭代器迭代器=references.keySet（）.Iterator（）；
while（iterator.hasNext（））{
String next=迭代器.next（）；
迭代器迭代器1=references.get（next.Iterator（）；
StringBuilder refs=新的StringBuilder（）；
while（iterator1.hasNext（））{
append（iterator1.next（））.append（“\n”）；
}
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.FINER，“对{0}:\n{1}的引用”，新对象[]{next，refs.toString（）}）；
}
//需要进一步对具有关系的实体进行排序
ArrayList temp=新的ArrayList（）；
for（条目e:tableStats.entrySet（））{
如果（如getKey（）>0）{
Logger.getLogger（XincoBackupManager.class.getSimpleName（））.log（Level.INFO，“具有{0}个引用的表”，e.getKey（））；
for（字符串t:e.getValue（））{
//检查表之间的关系
//这是我需要帮助的地方
布尔就绪=真；
for（字符串引用：references.get（t
// 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