WebSVN - OpenConcerto - Diff - Rev 177 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLTable.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.
 import org.openconcerto.sql.Log;
 import org.openconcerto.sql.model.SQLSelect.ArchiveMode;
 import org.openconcerto.sql.model.SQLSelect.LockStrength;
 import org.openconcerto.sql.model.SQLSyntax.ConstraintType;
 import org.openconcerto.sql.model.SQLTableEvent.Mode;
+import org.openconcerto.sql.model.Where.RowComparison;
 import org.openconcerto.sql.model.graph.DatabaseGraph;
 import org.openconcerto.sql.model.graph.Link;
 import org.openconcerto.sql.model.graph.Link.Rule;
 import org.openconcerto.sql.model.graph.SQLKey;
 import org.openconcerto.sql.model.graph.SQLKey.Type;
 import org.openconcerto.sql.model.graph.TablesMap;
 import org.openconcerto.sql.request.UpdateBuilder;
 import org.openconcerto.sql.utils.ChangeTable;
 import org.openconcerto.sql.utils.PartialUniqueTrigger;
 import org.openconcerto.sql.utils.SQLCreateMoveableTable;
+import org.openconcerto.sql.utils.SQLUtils;
 import org.openconcerto.sql.utils.UniqueConstraintCreatorHelper;
 import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.CompareUtils;
 import org.openconcerto.utils.ExceptionUtils;
 import org.openconcerto.utils.ListMap;
 import java.math.BigDecimal;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.commons.dbutils.ResultSetHandler;
             return res;
+        }
     };
     @SuppressWarnings("unchecked")
-    public static final Map<String, Number> getUndefIDs(final SQLSchema schema) {
+    private static final Map<String, Number> getUndefIDs(final SQLSchema schema) {
         assert Thread.holdsLock(UNDEFINED_IDs);
         if (!UNDEFINED_IDs.containsKey(schema)) {
             final Map<String, Number> r;
             if (schema.contains(undefTable)) {
                 final SQLBase b = schema.getBase();
                     schema.getDBSystemRoot().getDataSource().execute(update.asString());
+                }
+            }
             final int res = toInsert.size() + toUpdate.size();
             if (res > 0) {
-                undefT.fireTableModified(SQLRow.NONEXISTANT_ID);
+                undefT.fireTableModified();
+            }
             return res;
+        }
+    }
+    public static final boolean unsetUndefIDs(SQLSchema schema, Set<String> tableNames) throws SQLException {
+        final boolean tableLoaded = schema.getTable(undefTable) != null;
+        final boolean tableExists = unsetUndefIDs(schema.getDBSystemRoot(), schema.getDBRoot().getName(), tableNames);
+        if (tableLoaded != tableExists)
+            throw new IllegalStateException("Root not up to date, table loaded : " + tableLoaded + ", table exists : " + tableExists);
+        return tableExists;
+    }
+    public static final boolean unsetUndefIDs(final DBSystemRoot sysRoot, final String rootName, Set<String> tableNames) throws SQLException {
+        final SQLName undefSQLName = new SQLName(Objects.requireNonNull(rootName, "Missing root name"), undefTable);
+        final int deletedCount;
+        try {
+            // If already in a transaction, don't risk aborting it if a table doesn't exist.
+            // (it's not strictly required for H2 and MySQL, since the transaction is *not*
+            // aborted)
+            deletedCount = SQLUtils.executeAtomic(sysRoot.getDataSource(), (ds) -> {
+                try (final Statement stmt = ds.getConnection().createStatement()) {
+                    final int res = stmt.executeUpdate("DELETE FROM " + undefSQLName + " WHERE "
+                            + Where.getCompareValuesClause(SQLBase.quoteIdentifier(UNDEF_TABLE_TABLENAME_FIELD), RowComparison.IN, tableNames, SQLType.getFromSyntax(sysRoot.getSyntax(), Types.VARCHAR, 250)));
+                    assert res >= 0;
+                    return res;
+                }
+            });
+        } catch (SQLException e) {
+            // nothing to unset
+            if (sysRoot.getSyntax().isTableNotFoundException(e))
+                return false;
+            throw e;
+        }
+        if (deletedCount > 0) {
+            // rootName might exist and thus the above query might succeed, but the root might not
+            // be loaded or up to date.
+            final SQLTable undefT = sysRoot.getDescLenient(undefSQLName, SQLTable.class);
+            if (undefT != null)
+                undefT.fireTableModified();
+        }
+        return true;
+    }
     static private boolean AFTER_TX_DEFAULT = true;
     static public void setDefaultAfterTransaction(final boolean val) {
         AFTER_TX_DEFAULT = val;
+    }
             throw new IllegalStateException(this + " has more than 1 primary key: " + this.getPrimaryKeys());
         return this.primaryKey;
+    }
     /**
-     * Return the primary keys of this table.
+     * Return the fields of the primary key.
+     *
-     * @return the fields (SQLField) which are the keys of this table, can be empty.
+     * @return the fields of the primary key of this table, can be empty.
      */
-    public synchronized Set<SQLField> getPrimaryKeys() {
+    public synchronized Set<SQLField> getPrimaryKeyFields() {
         return this.primaryKeys;
+    }
+    @Deprecated
+    public final Set<SQLField> getPrimaryKeys() {
+        return this.getPrimaryKeyFields();
+    }
+    public final List<String> getPKsNames() {
+        return this.getPKsNames(new ArrayList<String>());
+    }
+    public final <C extends Collection<String>> C getPKsNames(C pks) {
+        for (final SQLField f : this.getPrimaryKeys()) {
+            pks.add(f.getName());
+        }
+        return pks;
+    }
+    public final RowRef createRowRef(final Object... pk) {
+        return this.createRowRef(Arrays.asList(pk));
+    }
+    public final RowRef createRowRef(final List<?> pk) {
+        return new RowRef(this, pk);
+    }
+    public final RowRef createRowRef(final Number id) {
+        return new RowRef(this, id);
+    }
     public final Set<Link> getForeignLinks() {
         return this.getDBSystemRoot().getGraph().getForeignLinks(this);
+    }
     /**
     public void removeTableListener(SQLTableListener l) {
         this.removeTableModifiedListener(new BridgeListener(l));
+    }
+    public final void fireTableModified() {
+        this.fireTableModified(SQLRow.NONEXISTANT_ID);
+    }
     /**
-     * Previent tous les listeners de la table qu'il y a eu une modification ou ajout si modif de
+     * Previent tous les listeners de la table qu'il y a eu une modification.
-     * d'une ligne particuliere.
+     *
-     * @param id -1 signifie tout est modifié.
+     * @param id which ID was modified, {@link SQLRow#NONEXISTANT_ID} meaning all rows.
      */
     public void fireTableModified(final int id) {
         this.fire(Mode.ROW_UPDATED, id);
+    }
     // equal)
     // if otherSystem isn't null, then this method is more lenient and return true if the two tables
     // are the closest possible. NOTE that otherSystem is not required to be the system of the other
     // table, it might be something else if the other table was loaded into a system different than
     // the one which created the dump.
-    public synchronized String equalsDesc(SQLTable o, SQLSystem otherSystem, boolean compareName) {
+    public synchronized String equalsDesc(SQLTable o, SQLSyntax otherSyntax, boolean compareName) {
         if (o == null)
             return "other table is null";
         final boolean name = !compareName || this.getName().equals(o.getName());
         if (!name)
             return "name unequal : " + this.getName() + " " + o.getName();
         // return "triggers unequal : " + this.getTriggers() + " " + o.getTriggers();
         // } else {
         // if (!this.getTriggers().keySet().equals(o.getTriggers().keySet()))
         // return "triggers names unequal : " + this.getTriggers() + " " + o.getTriggers();
         // }
-        final boolean checkComment = otherSystem == null || this.getServer().getSQLSystem().isTablesCommentSupported() && otherSystem.isTablesCommentSupported();
+        final boolean checkComment = otherSyntax == null || this.getServer().getSQLSystem().isTablesCommentSupported() && otherSyntax.getSystem().isTablesCommentSupported();
         if (checkComment && !CompareUtils.equals(this.getComment(), o.getComment()))
             return "comment unequal : " + SQLBase.quoteStringStd(this.getComment()) + " != " + SQLBase.quoteStringStd(o.getComment());
-        return this.equalsChildren(o, otherSystem);
+        return this.equalsChildren(o, otherSyntax);
+    }
-    private synchronized String equalsChildren(SQLTable o, SQLSystem otherSystem) {
+    private synchronized String equalsChildren(SQLTable o, SQLSyntax otherSyntax) {
         if (!this.getChildrenNames().equals(o.getChildrenNames()))
             return "fields differences: " + this.getChildrenNames() + "\n" + o.getChildrenNames();
-        final String noLink = equalsChildrenNoLink(o, otherSystem);
+        final String noLink = equalsChildrenNoLink(o, otherSyntax);
         if (noLink != null)
             return noLink;
         // foreign keys
         final Set<Link> thisLinks = this.getForeignLinks();
         final Set<Link> oLinks = o.getForeignLinks();
         if (thisLinks.size() != oLinks.size())
             return "different number of foreign keys " + thisLinks + " != " + oLinks;
         final SQLSystem thisSystem = this.getServer().getSQLSystem();
+        final SQLSystem otherSystem = otherSyntax == null ? null : otherSyntax.getSystem();
         for (final Link l : thisLinks) {
             final Link ol = o.getDBSystemRoot().getGraph().getForeignLink(o, l.getCols());
             if (ol == null)
                 return "no foreign key for " + l.getLabel();
             final SQLName thisPath = l.getTarget().getContextualSQLName(this);
+     *
      * @param o the table to compare.
      * @param otherSystem the system <code>o</code> originates from, can be <code>null</code>.
      * @return <code>null</code> if each fields of this exists in <code>o</code> and is equal to it.
      */
-    public synchronized final String equalsChildrenNoLink(SQLTable o, SQLSystem otherSystem) {
+    public synchronized final String equalsChildrenNoLink(SQLTable o, SQLSyntax otherSystem) {
         for (final SQLField f : this.getFields()) {
             final SQLField oField = o.getField(f.getName());
             final boolean isPrimary = this.getPrimaryKeys().contains(f);
             if (isPrimary != o.getPrimaryKeys().contains(oField))
                 return f + " is a primary not in " + o.getPrimaryKeys();
         if (this.getComment() != null)
             res.addOutsideClause(syntax.getSetTableComment(getComment()));
         return res;
+    }
-    public final List<String> getPKsNames() {
-        return this.getPKsNames(new ArrayList<String>());
-    }
-    public synchronized final <C extends Collection<String>> C getPKsNames(C pks) {
-        for (final SQLField f : this.getPrimaryKeys()) {
-            pks.add(f.getName());
-        }
-        return pks;
-    }
-    public final String[] getPKsNamesArray() {
-        return getPKsNames().toArray(new String[0]);
-    }
     /**
      * Return the indexes mapped by column names. Ie a key will have as value every index that
      * mentions it, and a multi-column index will be in several entries. Note: this is not robust
      * since {@link Index#getCols()} isn't.
+     *

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLTable.java - Rev 177 → 182