Example #1
0
  /**
   * ** Returns an array of root DBFactoryTree nodes based on the specified top-level DBFactory.
   * ** @param initialFactories The root DBFactories which are traversed to create the
   * DBFactoryTree. If null ** all root DBFactories will be traversed. ** @return An array of rot
   * DBFactoryTree nodes.
   */
  public static DBFactoryTree[] getDBFactoryTree(DBFactory<? extends DBRecord> initialFactories[]) {
    Set<String> addedTables = new HashSet<String>();
    DBFactoryTree rootNode = new DBFactoryTree();

    /* start with initial factories */
    if (initialFactories != null) {
      for (int i = 0; i < initialFactories.length; i++) {
        DBFactory<? extends DBRecord> dbf = initialFactories[i];
        DBFactoryTree._traverseDBFactoryTree(0, dbf, rootNode, addedTables);
      }
    }

    /* traverse remaining DBFactories, if any */
    OrderedMap<String, DBFactory<? extends DBRecord>> dbFactMap =
        new OrderedMap<String, DBFactory<? extends DBRecord>>(DBAdmin.getTableFactoryMap());
    for (Iterator<String> i = dbFactMap.keyIterator(); i.hasNext(); ) {
      String tn = i.next();
      DBFactory<? extends DBRecord> dbFact = (DBFactory<? extends DBRecord>) dbFactMap.get(tn);
      DBFactoryTree._traverseDBFactoryTree(0, dbFact, rootNode, addedTables);
    }

    /* return list of root children */
    DBFactoryTree roots[] = rootNode.getChildren();
    if (roots != null) {
      // clear our temporary root node from the table factory roots
      for (int i = 0; i < roots.length; i++) {
        roots[i].setParentNode(null);
      }
    }
    return roots;
  }
Example #2
0
 /**
  * ** Returns an array of root DBFactoryTree nodes based on the specified top-level DBFactory.
  * ** @param initialFactory The root DBFactory which is traversed to create the DBFactoryTree. If
  * null ** all root DBFactories will be traversed. ** @return An array of rot DBFactoryTree nodes.
  * If the 'initialFactory' is null, the returned ** DBFactoryTree array will have at most 1
  * element.
  */
 @SuppressWarnings("unchecked")
 public static DBFactoryTree[] getDBFactoryTree(DBFactory<? extends DBRecord> initialFactory) {
   if (initialFactory != null) {
     return DBFactoryTree.getDBFactoryTree(
         new DBFactory[] {initialFactory}); // "unchecked conversion"
   } else {
     return DBFactoryTree.getDBFactoryTree((DBFactory<? extends DBRecord>[]) null);
   }
 }
Example #3
0
  /**
   * ** Traverses the DBFactory dependency tree, creating a DBFactoryTree ** @param level The
   * current tree level ** @param dbFact The current DBFactory to add ** @param parentNode The
   * parent node to which a new DBFactoryNode child will be added ** @param addedTables A set of
   * table names added to the current DBFactoryTree *
   */
  private static void _traverseDBFactoryTree(
      int level,
      DBFactory<? extends DBRecord> dbFact,
      DBFactoryTree parentNode,
      Set<String> addedTables) {

    /* no DBFactory? */
    if (dbFact == null) {
      Print.logError("Null DBFactory!");
      return;
    }
    String utableName = dbFact.getUntranslatedTableName();

    /* already added? */
    if (addedTables.contains(utableName)) {
      return;
    }
    addedTables.add(utableName);

    /* add this node */
    // Print.logInfo(StringTools.replicateString("  ",level) + dbFact.getUntranslatedTableName());
    DBFactoryTree dbFactNode = new DBFactoryTree(level, parentNode, dbFact);
    parentNode.addChild(dbFactNode);

    /* find dependent children */
    DBFactory<? extends DBRecord> childFact[] = dbFact.getChildFactories();
    for (int i = 0; i < childFact.length; i++) {
      int index = childFact[i].getParentTables().indexOf(utableName);
      if (level == index) {
        DBFactoryTree._traverseDBFactoryTree(level + 1, childFact[i], dbFactNode, addedTables);
      } else if (!addedTables.contains(childFact[i].getUntranslatedTableName())) {
        Print.logWarn(
            "Skipping table in heiarchy: "
                + utableName
                + " ==> "
                + childFact[i].getUntranslatedTableName());
      }
    }
  }
Example #4
0
 /** ** Returns an OrderedMap of defined primary keys ** @return map of defined primary keys */
 public Map<DBField, Object> getKeyMap() {
   Map<DBField, Object> keyMap = new OrderedMap<DBField, Object>(); // ordered key list
   if (this.dbFactory != null) {
     DBField keyField[] = this.dbFactory.getKeyFields();
     for (int i = 0; i < keyField.length; i++) {
       String key = keyField[i].getName();
       Object val = null;
       if (this.dbRecord != null) {
         // all key values will be defined
         val = this.dbRecord.getFieldValue(key);
       } else {
         // use parent keys
         DBFactoryTree parent = this.getParentNode();
         for (; (parent != null) && (val == null); parent = parent.getParentNode()) {
           DBRecord dbr = parent.getDBRecord();
           if (dbr == null) {
             // stop at the first undefined ancestor
             break;
           } else if (dbr.hasField(key)) {
             // try getting key value from ancestor
             DBField parFld = dbr.getField(key);
             if ((parFld != null) && parFld.isPrimaryKey()) {
               // primary key fields only
               val = dbr.getFieldValue(key);
             }
           }
         }
       }
       // save key DBField and value
       if (val != null) {
         keyMap.put(keyField[i], val);
       } else {
         keyMap.put(keyField[i], null);
       }
     }
   }
   return keyMap;
 }