Ejemplo n.º 1
0
  /**
   * Checks if the given <code>InsertRow</code>s contain cyclic fk constraints.
   *
   * @param rows
   * @return steps of the cycle, or null if there is none
   */
  private static Collection<InsertRow> findCycle(Collection<InsertRow> rows) {

    Iterator<InsertRow> rowsIter = rows.iterator();
    while (rowsIter.hasNext()) {
      InsertRow begin = rowsIter.next();
      Iterator<InsertRow> refIter = begin.getReferencedRows().iterator();
      while (refIter.hasNext()) {
        InsertRow referencedRow = refIter.next();
        List<InsertRow> cycle =
            findCycleRecursion(referencedRow, begin, new ArrayList<InsertRow>());
        if (cycle != null) {
          return cycle;
        }
      }
    }
    return null;
  }
Ejemplo n.º 2
0
  private static List<InsertRow> findCycleRecursion(
      InsertRow next, InsertRow begin, List<InsertRow> steps) {

    if (steps.contains(next)) {
      steps.add(next);
      return steps;
    }
    steps.add(next);

    Iterator<InsertRow> refIter = next.getReferencedRows().iterator();
    while (refIter.hasNext()) {
      InsertRow referencedRow = refIter.next();
      List<InsertRow> cycle = findCycleRecursion(referencedRow, begin, steps);
      if (cycle != null) {
        return cycle;
      }
    }
    steps.remove(steps.size() - 1);
    return null;
  }
Ejemplo n.º 3
0
  /**
   * Sorts the given <code>InsertRow</code>s topologically (respecting the foreign key constraints),
   * so they can be inserted in the resulting order without causing foreign key violations.
   *
   * <p>Number of precedessors (pre): number of fields that *are referenced by* this row Number of
   * successors (post) : number of fields that *reference* this row
   *
   * @param inserts insert rows to sort
   * @return the nodes of the graph in topological order if no cycle is present, else in arbitrary
   *     order
   */
  public static List<InsertRow> getInsertOrder(List<InsertRow> inserts) {

    List<InsertRow> result = new ArrayList<InsertRow>();

    // key: inserts, value: number of fields that are referenced by this row
    Map<InsertRow, Integer> preMap = new HashMap<InsertRow, Integer>();

    // key: inserts with no foreign key constraints
    List<InsertRow> noPre = new ArrayList<InsertRow>();

    // build map
    Iterator<InsertRow> insertIter = inserts.iterator();
    while (insertIter.hasNext()) {
      InsertRow insertRow = insertIter.next();
      int pre = insertRow.getReferencedFields().size();
      LOG.logDebug("Adding row to preMap: " + insertRow);
      preMap.put(insertRow, pre);
      if (pre == 0) {
        noPre.add(insertRow);
      }
    }

    while (!noPre.isEmpty()) {
      // select an insert row that has no open fk constraints
      InsertRow insertRow = noPre.get(0);
      noPre.remove(0);
      result.add(insertRow);

      // decrease the number of pending fk constraints for all insert rows that
      // reference the currently processed insert row
      Collection<InsertField> postList = insertRow.getReferencingFields();
      Iterator<InsertField> iter = postList.iterator();
      while (iter.hasNext()) {
        InsertField postField = iter.next();
        if (preMap.get(postField.getRow()) == null) {
          LOG.logDebug("No pre info for: " + postField.getRow());
        }
        int pre = preMap.get(postField.getRow());
        preMap.put(postField.getRow(), --pre);
        if (pre == 0) {
          noPre.add(postField.getRow());
        }
      }
    }

    if (result.size() != inserts.size()) {
      Collection<InsertRow> cycle = InsertRow.findCycle(inserts);
      Iterator<InsertRow> cycleIter = cycle.iterator();
      StringBuffer sb = new StringBuffer();
      while (cycleIter.hasNext()) {
        sb.append(cycleIter.next());
        if (cycle.iterator().hasNext()) {
          sb.append(" -> ");
        }
      }
      String msg = Messages.getMessage("DATASTORE_FK_CYCLE", sb.toString());
      LOG.logWarning(msg);
      result.clear();
      result.addAll(inserts);
    }
    return result;
  }