protected  void flush(Collection rows,
    PreparedStatementManager psMgr) 
{
        if (rows.size() == 0)
            return;
        RowImpl row;
        for (Iterator itr = rows.iterator(); itr.hasNext(); ) {
            row = (RowImpl) itr.next();
            if (row.isValid() && !row.isDependent())
                psMgr.flush(row);
        }
}

Flush the given collection of secondary rows.

 protected Collection flush(RowManager rowMgr,
    PreparedStatementManager psMgr,
    Collection exceps) 
{
        RowManagerImpl rmimpl = (RowManagerImpl) rowMgr;
        // first take care of all secondary table deletes and 'all row' deletes
        // (which are probably secondary table deletes), since no foreign
        // keys ever rely on secondary table pks
        flush(rmimpl.getAllRowDeletes(), psMgr);
        flush(rmimpl.getSecondaryDeletes(), psMgr);
        // now do any 'all row' updates
        flush(rmimpl.getAllRowUpdates(), psMgr);
        // analyze foreign keys
        Collection inserts = rmimpl.getInserts();
        Collection updates = rmimpl.getUpdates();
        Collection deletes = rmimpl.getDeletes();
        Graph[] graphs = new Graph[2];    // insert graph, delete graph
        analyzeForeignKeys(inserts, updates, deletes, rmimpl, graphs);
        // flush insert graph, if any
        boolean autoAssign = rmimpl.hasAutoAssignConstraints();
        try {
            flushGraph(graphs[0], psMgr, autoAssign);
        } catch (SQLException se) {
            exceps = addException(exceps, SQLExceptions.getStore(se, dict));
        } catch (OpenJPAException ke) {
            exceps = addException(exceps, ke);
        }
        // flush the rest of the inserts and updates; inserts before updates
        // because some update fks might reference pks that have to be inserted
        flush(inserts, psMgr);
        flush(updates, psMgr);
        // flush the delete graph, if any
        try {
            flushGraph(graphs[1], psMgr, autoAssign);
        } catch (SQLException se) {
            exceps = addException(exceps, SQLExceptions.getStore(se, dict));
        } catch (OpenJPAException ke) {
            exceps = addException(exceps, ke);
        }
        // put the remainder of the deletes after updates because some updates
        // may be nulling fks to rows that are going to be deleted
        flush(deletes, psMgr);
        // take care of all secondary table inserts and updates last, since
        // they may rely on previous inserts or updates, but nothing relies
        // on them
        flush(rmimpl.getSecondaryUpdates(), psMgr);
        // flush any left over prepared statements
        psMgr.flush();
        return exceps;
}

 protected  void flushGraph(Graph graph,
    PreparedStatementManager psMgr,
    boolean autoAssign) throws SQLException 
{
        if (graph == null)
            return;
        DepthFirstAnalysis dfa = newDepthFirstAnalysis(graph, autoAssign);
        Collection insertUpdates = new LinkedList();
        Collection deleteUpdates = new LinkedList();
        boolean recalculate;
        // Handle circular constraints:
        // - if deleted row A has a ciricular fk to deleted row B, 
        //   then use an update statement to null A's fk to B before flushing, 
        //   and then flush
        // - if inserted row A has a circular fk to updated/inserted row B,
        //   then null the fk in the B row object, then flush,
        //   and after flushing, use an update to set the fk back to A
        // Depending on where circular dependencies are broken, the  
        // topological order of the graph nodes has to be re-calculated.
        recalculate = resolveCycles(graph, dfa.getEdges(Edge.TYPE_BACK),
                deleteUpdates, insertUpdates);
        recalculate |= resolveCycles(graph, dfa.getEdges(Edge.TYPE_FORWARD),
                deleteUpdates, insertUpdates);
        if (recalculate) {
            dfa = recalculateDepthFirstAnalysis(graph, autoAssign);
        }
        // flush delete updates to null fks, then all rows in order, then
        // the insert updates to set circular fk values
        flush(deleteUpdates, psMgr);
        Collection nodes = dfa.getSortedNodes();
        for (Iterator itr = nodes.iterator(); itr.hasNext();)
            psMgr.flush((RowImpl) itr.next());
        flush(insertUpdates, psMgr);
}

Flush the given graph of rows in the proper order.

 protected DepthFirstAnalysis newDepthFirstAnalysis(Graph graph,
    boolean autoAssign) 
{
        return new DepthFirstAnalysis(graph);
}

Create a new DepthFirstAnalysis suitable for the given graph and auto-assign settings.

 protected PreparedStatementManager newPreparedStatementManager(JDBCStore store,
    Connection conn) 
{
        return new PreparedStatementManagerImpl(store, conn);
}

 protected RowManager newRowManager() 
{
        return new RowManagerImpl(false);
}

 public boolean orderDirty() 
{
       
        return false;
}