WebSVN - OpenConcerto - Diff - Rev 144 and 151 - /trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRowValuesCluster.java

     private final DBSystemRoot getSystemRoot() {
         return this.getHead().getTable().getDBSystemRoot();
+    }
+    public final int getLinksCount() {
+        return this.links.size();
+    }
     /**
      * All the rowValues in this cluster.
+     *
      * @return the set of SQLRowValues.
      */
     final SQLRowValues deepCopy(SQLRowValues v, final boolean freeze) {
         return deepCopy(freeze).get(v);
+    }
     public final Map<SQLRowValues, SQLRowValues> deepCopy(final boolean freeze) {
+        return this.copy(null, false, freeze);
+    }
+    /**
+     * Copy a subset of this graph. For each link to copy, if the destination was copied then the
+     * new row will point to it, otherwise the new row will point to the original row. For example,
+     * if
+     *
+     * <pre>
+     * start is CONTAINER <-- *ITEM [F1, F2]* --> PRIVATE
+     * and graph is ITEM [F2, ID_PRIVATE]
+     * then after this method :
+     *  CONTAINER <-- ITEM [F1, F2] --> PRIVATE
+     *            \-- ITEM [F2]     --> PRIVATE
+     * </pre>
+     *
+     * @param start where to start copying.
+     * @param graph which rows and which fields to copy, not <code>null</code>.
+     * @return the new rows, indexed by the original rows in this instance.
+     */
+    public final Map<SQLRowValues, SQLRowValues> copy(final SQLRowValues start, final SQLRowValues graph) {
+        return this.copy(computeToRetain(start, graph, true), true, false);
+    }
+    /**
+     * Copy rows of this graph.
+     *
+     * @param subset which rows and which fields to copy, <code>null</code> to copy all rows.
+     * @param allowSameGraph used when copied rows point to rows which weren't copied,
+     *        <code>true</code> to point to the original rows (and thus linking the new rows into
+     *        the existing graph), <code>false</code> to flatten the link (like
+     *        {@link ForeignCopyMode#COPY_ID_OR_RM}).
+     * @param freeze <code>true</code> if the copied rows should be frozen.
+     * @return the new rows, indexed by the original rows in this instance.
+     */
+    private final Map<SQLRowValues, SQLRowValues> copy(final SetMap<SQLRowValues, String> subset, final boolean allowSameGraph, final boolean freeze) {
+        assert !allowSameGraph || !freeze;
         // copy all rowValues of this graph
         final Map<SQLRowValues, SQLRowValues> noLinkCopy = new IdentityHashMap<SQLRowValues, SQLRowValues>();
         // don't copy foreigns, but we want to preserve the order of all fields. This works because
         // the second put() with the actual foreign row doesn't change the order.
         final ForeignCopyMode copyMode = ForeignCopyMode.COPY_NULL;
         for (final SQLRowValues n : this.getItems()) {
             final SQLRowValues copy;
+            if (subset == null || subset.containsKey(n)) {
-            // might as well use the minimum memory if the values won't change
+                // might as well use the minimum memory if the values won't change
-            if (freeze) {
+                if (freeze) {
-                copy = new SQLRowValues(n.getTable(), n.size(), n.getForeignsSize(), n.getReferents().size());
+                    copy = new SQLRowValues(n.getTable(), n.size(), n.getForeignsSize(), n.getReferents().size());
-                copy.setAll(n.getAllValues(copyMode));
+                    copy.setAll(n.getAllValues(copyMode));
-            } else {
+                } else {
-                copy = new SQLRowValues(n, copyMode);
+                    copy = new SQLRowValues(n, copyMode);
+                    if (subset != null) {
+                        copy.retainAll(subset.get(n));
+                    }
+                }
-            noLinkCopy.put(n, copy);
+                noLinkCopy.put(n, copy);
+            }
+        }
         // and link them together in order
+        final List<Link> iterableLinks = subset == null ? this.links : new ArrayList<Link>(this.links);
-        for (final Link l : this.links) {
+        for (final Link l : iterableLinks) {
             if (l.getField() != null) {
+                final SQLRowValues sourceCopy = noLinkCopy.get(l.getSrc());
+                if (subset == null || (sourceCopy != null && sourceCopy.contains(l.getField().getName()))) {
+                    assert l.getDest() != null;
-                noLinkCopy.get(l.getSrc()).put(l.getField().getName(), noLinkCopy.get(l.getDest()));
+                    final SQLRowValues destCopy = noLinkCopy.get(l.getDest());
+                    final Object dest;
+                    if (destCopy != null)
+                        dest = destCopy;
+                    else if (allowSameGraph)
+                        dest = l.getDest();
+                    else if (l.getDest().hasID())
+                        dest = l.getDest().getIDNumber();
+                    else
+                        dest = null;
+                    if (dest != null) {
+                        sourceCopy.put(l.getField().getName(), dest);
+                    } else {
+                        // ForeignCopyMode.COPY_ID_OR_RM like pruneWithoutCopy() (avoids
+                        // leaving nulls)
+                        sourceCopy.remove(l.getField().getName());
+                    }
+                }
             } else {
-                assert noLinkCopy.containsKey(l.getSrc());
+                assert subset != null || noLinkCopy.containsKey(l.getSrc());
+            }
+        }
         final SQLRowValues res = noLinkCopy.values().iterator().next();
         // only force graph creation if needed
         if (freeze)
             res.getGraph().freeze();
         assert res.isFrozen() == freeze;
+        assert allowSameGraph || res.getGraph() != this;
         return noLinkCopy;
+    }
     public final StoreResult insert() throws SQLException {
      */
     public final SQLRowValues prune(final SQLRowValues start, final SQLRowValues graph, final boolean keepUnionOfFields) {
         return pruneMap(start, graph, keepUnionOfFields).get(start);
+    }
-    // private since result isn't trimmed, the values are still all there, not all in the pruned
-    // graph
-    private final Map<SQLRowValues, SQLRowValues> pruneMap(final SQLRowValues start, final SQLRowValues graph, final boolean keepUnionOfFields) {
+    public final Map<SQLRowValues, SQLRowValues> pruneMap(final SQLRowValues start, final SQLRowValues graph, final boolean keepUnionOfFields) {
         this.containsCheck(start);
+        return this.copy(computeToRetain(start, graph, keepUnionOfFields), false, false);
+    }
+    static SetMap<SQLRowValues, String> computeToRetain(final SQLRowValues start, final SQLRowValues graph, final boolean keepUnionOfFields) {
         if (!start.getTable().equals(graph.getTable()))
             throw new IllegalArgumentException(start + " is not from the same table as " + graph);
         // there's no way to tell apart 2 referents
         if (!graph.getGraph().hasOneRowPerPath())
             throw new IllegalArgumentException("More than one row for " + graph.printGraph());
-        final Map<SQLRowValues, SQLRowValues> map = start.getGraph().deepCopy(false);
-        final SQLRowValues res = map.get(start);
         final SetMap<SQLRowValues, String> toRetain = new SetMap<SQLRowValues, String>(new IdentityHashMap<SQLRowValues, Set<String>>(), Mode.NULL_FORBIDDEN);
         // BREADTH_FIRST to stop as soon as this no longer have rows in the graph
         // CycleAllowed since we need to go through every path (e.g. what is a cycle in graph might
         // not be in this :
         // SITE1 -> CONTACT1 -> SITE1 for graph and
         graph.getGraph().walk(graph, null, new ITransformer<State<Object>, Object>() {
             @Override
             public Object transformChecked(State<Object> input) {
                 final SQLRowValues r = input.getCurrent();
                 // since we allowed cycles in graph, allow it here
-                final Collection<SQLRowValues> rows = res.followPath(input.getPath(), CreateMode.CREATE_NONE, false, true);
+                final Collection<SQLRowValues> rows = start.followPath(input.getPath(), CreateMode.CREATE_NONE, false, true);
                 // since we're using BREADTH_FIRST, the next path will be longer so no need to
                 // continue if there's already no row
                 if (rows.isEmpty())
                     throw new StopRecurseException().setCompletely(false);
                 for (final SQLRowValues row : rows) {
                         toRetain.getCollection(row).retainAll(r.getFields());
+                }
                 return null;
+            }
         }, walkOptions);
+        return toRetain;
+    }
+    public final SQLRowValues pruneWithoutCopy(final SQLRowValues start, final SQLRowValues graph) {
+        return this.pruneWithoutCopy(start, graph, true);
+    }
+    public final SQLRowValues pruneWithoutCopy(final SQLRowValues start, final SQLRowValues graph, final boolean keepUnionOfFields) {
+        this.containsCheck(start);
+        final SetMap<SQLRowValues, String> toRetain = computeToRetain(start, graph, keepUnionOfFields);
+        assert toRetain.containsKey(start);
         // remove extra fields and flatten if necessary
         for (final Entry<SQLRowValues, Set<String>> e : toRetain.entrySet()) {
             final SQLRowValues r = e.getKey();
             r.retainAll(e.getValue());
             for (final String fieldToFlatten : toFlatten) {
                 r.flatten(fieldToFlatten, ForeignCopyMode.COPY_ID_OR_RM);
+            }
+        }
         // now, remove referents that aren't in the graph
-        for (final SQLRowValues r : new ArrayList<SQLRowValues>(res.getGraph().getItems())) {
+        for (final SQLRowValues r : new ArrayList<SQLRowValues>(start.getGraph().getItems())) {
             if (!toRetain.containsKey(r)) {
                 // only remove links at the border and even then, only remove links to the result :
                 // avoid creating a myriad of graphs
                 final Set<String> toFlatten = new HashSet<String>();
                 for (final Entry<String, SQLRowValues> e2 : r.getForeigns().entrySet()) {
+                    }
+                }
                 r.removeAll(toFlatten);
+            }
+        }
-        assert res.getGraph().getItems().equals(toRetain.keySet());
+        assert start.getGraph().getItems().equals(toRetain.keySet());
+        // NOTE this instance no longer the graph of start if referents were removed
-        return map;
+        return start;
+    }
     // TODO handle referents (and decide how to handle multiple paths to the same node)
-    final void grow(final SQLRowValues start, final SQLRowValues toGrow, final boolean checkFields) {
+    final void grow(final SQLRowValues start, final SQLRowValues toGrow, final boolean checkFields, final boolean growUndefined) {
         this.containsCheck(start);
         if (!start.getTable().equals(toGrow.getTable()))
             throw new IllegalArgumentException(start + " is not from the same table as " + toGrow);
-        this.walk(start, null, new ITransformer<State<Object>, Object>() {
+        this.walk(start, toGrow, new ITransformer<State<SQLRowValues>, SQLRowValues>() {
             @Override
-            public Object transformChecked(State<Object> input) {
+            public SQLRowValues transformChecked(State<SQLRowValues> input) {
                 final SQLRowValues existing = toGrow.followPath(input.getPath());
+                // don't add undefined row if there's none or if don't want
+                if (existing == null && input.getAcc().isForeignEmpty(input.getFrom().getName()) && (input.getPath().getLast().getUndefinedIDNumber() == null || !growUndefined))
+                    throw new StopRecurseException().setCompletely(false);
                 if (existing == null || (checkFields && !existing.getFields().containsAll(input.getCurrent().getFields()))) {
                     final SQLRowValues leaf = toGrow.assurePath(input.getPath());
                     if (leaf.hasID()) {
                         final SQLRowValuesListFetcher fetcher = new SQLRowValuesListFetcher(input.getCurrent());
+                        // don't exclude undef otherwise cannot grow eg
+                        // LOCAL.ID_FAMILLE_2 = 1
+                        if (growUndefined) {
-                        fetcher.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {
+                            fetcher.setSelTransf(new ITransformer<SQLSelect, SQLSelect>() {
-                            @Override
+                                @Override
-                            public SQLSelect transformChecked(SQLSelect input) {
+                                public SQLSelect transformChecked(SQLSelect input) {
-                                // don't exclude undef otherwise cannot grow eg
-                                // LOCAL.ID_FAMILLE_2 = 1
-                                input.setExcludeUndefined(false);
+                                    input.setExcludeUndefined(false);
-                                return input;
+                                    return input;
+                                }
-                        });
+                            });
+                        }
                         final SQLRowValues fetched = fetcher.fetchOne(leaf.getIDNumber());
                         if (fetched == null)
                             throw new IllegalArgumentException("no row for " + fetcher);
                         leaf.load(fetched, null);
+                        // we already loaded all further rows
+                        throw new StopRecurseException().setCompletely(false);
-                    } else
+                    } else {
                         throw new IllegalArgumentException("cannot expand, missing ID in " + leaf + " at " + input.getPath());
+                    }
+                } else {
-                return null;
+                    return existing;
+                }
+            }
-        }, RecursionType.BREADTH_FIRST);
+        }, RecursionType.BREADTH_FIRST, Direction.FOREIGN);
+    }
     public final String contains(final SQLRowValues start, SQLRowValues graph) {
         return this.contains(start, graph, true);
+    }

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRowValuesCluster.java @ 182 - Rev 144 → 151