WebSVN - OpenConcerto - Diff - Rev 142 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/changer/convert/MergeTable.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
+ *
  * The contents of this file are subject to the terms of the GNU General Public License Version 3
  * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
  * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
  * language governing permissions and limitations under the License.
  */
  package org.openconcerto.sql.changer.convert;
 import static org.openconcerto.utils.CollectionUtils.substract;
 import org.openconcerto.sql.changer.Changer;
 import org.openconcerto.sql.model.AliasedTable;
 import org.openconcerto.sql.model.ConnectionHandlerNoSetup;
 import org.openconcerto.sql.model.DBStructureItem;
 import org.openconcerto.sql.model.DBSystemRoot;
 import org.openconcerto.sql.model.SQLName;
 import org.openconcerto.sql.model.SQLRowValues;
 import org.openconcerto.sql.model.SQLSchema;
 import org.openconcerto.sql.model.SQLSelect;
 import org.openconcerto.sql.model.SQLSyntax;
+import org.openconcerto.sql.model.SQLSystem;
 import org.openconcerto.sql.model.SQLTable;
 import org.openconcerto.sql.model.Where;
 import org.openconcerto.sql.model.graph.DatabaseGraph;
 import org.openconcerto.sql.model.graph.Link;
 import org.openconcerto.sql.model.graph.TablesMap;
 import org.openconcerto.sql.request.UpdateBuilder;
 import org.openconcerto.sql.utils.AlterTable;
+import org.openconcerto.sql.utils.ChangeTable;
 import org.openconcerto.sql.utils.ChangeTable.FCSpec;
 import org.openconcerto.sql.utils.SQLCreateTable;
 import org.openconcerto.sql.utils.SQLUtils;
 import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.cc.ITransformer;
         final List<Number> oldIDs = getDS().executeCol(selOldIDs.asString());
         // if we copy no rows, no need to check constraints
         final boolean noRowsToMerge = oldIDs.size() == 0;
         final DatabaseGraph graph = t.getDBSystemRoot().getGraph();
-        // check that transferred data from t still points to the same rows
+        // Check that transferred data from t still points to the same rows, i.e. that each foreign
+        // key of t exists in this.destTable and points to the same table.
         final Set<Link> selfRefLinks = new HashSet<Link>();
         for (final Link l : graph.getForeignLinks(t)) {
             final Link destLink = graph.getForeignLink(this.destTable, l.getCols());
             if (destLink == null)
                 throw new IllegalStateException("No link for " + l.getCols() + " in " + this.destTable.getSQL());
                 getStream().println("WARNING: " + s);
                 getStream().println(CollectionUtils.join(reasonsToContinue, ";\n"));
+            }
+        }
+        if (this.isDryRun())
+            return;
         final SQLSyntax syntax = t.getDBSystemRoot().getSyntax();
-        final Set<SQLTable> toRefresh = new HashSet<SQLTable>();
+        final TablesMap tables = new TablesMap();
-        SQLUtils.executeAtomic(t.getDBSystemRoot().getDataSource(), new ConnectionHandlerNoSetup<Object, SQLException>() {
+        SQLUtils.executeAtomic(t.getDBSystemRoot().getDataSource(), new ConnectionHandlerNoSetup<Void, SQLException>() {
             @Override
-            public Object handle(final SQLDataSource ds) throws SQLException {
+            public Void handle(final SQLDataSource ds) throws SQLException {
+                final Set<SQLTable> toRefresh = new HashSet<SQLTable>();
                 // drop self reference links before inserting
                 final AlterTable dropSelfFK = new AlterTable(MergeTable.this.destTable);
                 for (final Link selfRef : selfRefLinks) {
                     dropSelfFK.dropForeignConstraint(selfRef.getName());
+                }
                 if (!dropSelfFK.isEmpty())
                     ds.execute(dropSelfFK.asString());
                 // copy all data of t into destTable
+                final List<Number> insertedIDs;
+                // In H2 v1.3 Statement.getGeneratedKeys() only returns the first ID
+                if (getSyntax().getSystem() == SQLSystem.H2) {
+                    final SQLField destPK = MergeTable.this.destTable.getKey();
+                    // null if table is empty
+                    final Number maxID = (Number) getDS().executeScalar(new SQLSelect().addSelect(destPK, "max").asString());
+                    final int insertedCount = SQLRowValues.insertCount(destPK.getTable(), fields + " " + sel.asString());
+                    final SQLSelect selNewIDs = createSelect(destPK.getTable());
+                    selNewIDs.addSelect(destPK);
+                    if (maxID != null)
+                        selNewIDs.setWhere(new Where(destPK, ">", maxID));
+                    insertedIDs = getDS().executeCol(selNewIDs.asString());
+                    if (insertedIDs.size() != insertedCount)
+                        throw new IllegalStateException("Expected " + insertedCount + " new IDs but got " + insertedIDs.size());
+                } else {
-                final List<Number> insertedIDs = SQLRowValues.insertIDs(MergeTable.this.destTable, fields + " " + sel.asString());
+                    insertedIDs = SQLRowValues.insertIDs(MergeTable.this.destTable, fields + " " + sel.asString());
+                }
                 // handle undefined
                 insertedIDs.add(0, MergeTable.this.destTable.getUndefinedIDNumber());
                 oldIDs.add(0, t.getUndefinedIDNumber());
                 final int size = insertedIDs.size();
                 if (size != oldIDs.size())
                 // all data has been copied, and every link removed
                 // we can now safely drop t
                 ds.execute(t.getBase().quote("DROP TABLE %f", t));
                 ds.execute("DROP TABLE " + mapName.quote());
+                SQLTable.unsetUndefIDs(t.getSchema(), CollectionUtils.createSet(t.getName(), mapName.getName()));
                 toRefresh.add(t);
                 toRefresh.add(mapT);
+                final Set<SQLSchema> schemas = new HashSet<SQLSchema>();
+                for (final SQLTable table : toRefresh) {
+                    tables.add(table.getDBRoot().getName(), table.getName());
+                    schemas.add(table.getSchema());
+                }
+                for (final SQLSchema schema : schemas) {
+                    schema.updateVersion();
+                }
                 return null;
+            }
             public SQLTable updateLink(final Link refLink, final SQLTable mapT) {
                 final SQLField refKey = refLink.getLabel();
+                }
                 // update the field using the map
                 final UpdateBuilder update = new UpdateBuilder(refTable);
                 final AliasedTable alias1 = new AliasedTable(mapT, "m");
+                // Where.NULL_IS_DATA_EQ since we want to be able to map a null undefined
-                update.addTable(alias1);
+                // ID, i.e. rows pointing to null into 1.
-                update.set(refKey.getName(), alias1.getField("NEW_ID").getFieldRef());
+                update.addVirtualJoin(alias1, "OLD_ID", Where.NULL_IS_DATA_EQ, refKey.getName());
-                update.setWhere(new Where(refKey, Where.NULL_IS_DATA_EQ, alias1.getField("OLD_ID")));
+                update.setFromVirtualJoinField(refKey.getName(), alias1.getAlias(), "NEW_ID");
                 if (selfLink) {
                     // only update new rows (old rows can have the same IDs but they point to old
                     // foreign rows, they must not be updated)
                     final AliasedTable onlyNew = new AliasedTable(mapT, "onlyNew");
-                    update.addTable(onlyNew);
+                    final Where w = new Where(refTable.getKey(), true, new SQLSelect().addSelect(onlyNew.getField("NEW_ID")))
-                    // we added the undefined to NEW_ID, but it wasn't copied from t so don't update
+                            // we added the undefined to NEW_ID, but it wasn't copied from t so
-                    final Where w = new Where(refTable.getKey(), Where.NULL_IS_DATA_EQ, onlyNew.getField("NEW_ID")).and(new Where(refTable.getKey(), Where.NULL_IS_DATA_NEQ, refTable
+                            // don't update
-                            .getUndefinedIDNumber()));
+                            .and(new Where(refTable.getKey(), Where.NULL_IS_DATA_NEQ, refTable.getUndefinedIDNumber()));
-                    update.setWhere(update.getWhere().and(w));
+                    update.setWhere(w.and(update.getWhere()));
+                }
                 ds.execute(update.asString());
                 // re-add constraint
                 final AlterTable addFK = new AlterTable(refTable);
                 // don't create an index : if there was one it's still there, if there wasn't
                 // don't alter the table silently (use AddFK if you want that)
                 addFK.addForeignConstraint(FCSpec.createFromLink(refLink, MergeTable.this.destTable), false);
+                // e.g. change from 'integer DEFAULT 1' to 'integer'
+                addFK.alterColumnDefault(refLink.getSingleField().getName(), ChangeTable.getForeignColumDefaultValue(MergeTable.this.destTable));
                 ds.execute(addFK.asString());
                 return refTable;
+            }
         });
-        final TablesMap tables = new TablesMap();
-        final Set<SQLSchema> schemas = new HashSet<SQLSchema>();
-        for (final SQLTable table : toRefresh) {
-            tables.add(table.getDBRoot().getName(), table.getName());
-            schemas.add(table.getSchema());
-        }
         t.getDBSystemRoot().refresh(tables, false);
-        for (final SQLSchema schema : schemas) {
-            schema.updateVersion();
-        }
+    }
     private final SQLSelect createSelect(final SQLTable t) {
         final SQLSelect sel = new SQLSelect(true);
         // undefined is not copied

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/changer/convert/MergeTable.java - Rev 142 → 182