WebSVN - OpenConcerto - Diff - Rev 156 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRow.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.model.SQLSelect.LockStrength;
 import org.openconcerto.sql.model.SQLTable.VirtualFields;
 import org.openconcerto.sql.model.graph.Link;
 import org.openconcerto.sql.model.graph.Link.Direction;
 import org.openconcerto.sql.model.graph.Path;
+import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.ListMap;
 import org.openconcerto.utils.SetMap;
 import org.openconcerto.utils.Tuple2.List2;
 import java.sql.ResultSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.function.BiFunction;
 import java.util.logging.Level;
 import org.apache.commons.dbutils.ResultSetHandler;
 /**
      * @return la ligne correspondante.
      * @throws SQLException si problème lors de l'accès au ResultSet.
      * @see SQLRow#SQLRow(SQLTable, Map)
      * @deprecated use {@link SQLRowListRSH} or {@link SQLRowValuesListFetcher} instead or if you
      *             must use a {@link ResultSet} call
-     *             {@link #createFromRS(SQLTable, ResultSet, ResultSetMetaData, boolean)} thus
+     *             {@link #createListFromRS(SQLTable, ResultSet, boolean)} thus avoiding the
-     *             avoiding the potentially costly {@link ResultSet#getMetaData()}
+     *             potentially costly {@link ResultSet#getMetaData()}
      */
     public static final SQLRow createFromRS(SQLTable table, ResultSet rs, final boolean onlyTable) throws SQLException {
         return createFromRS(table, rs, rs.getMetaData(), onlyTable);
+    }
+    // see createListFromRS()
+    @Deprecated
     public static final SQLRow createFromRS(SQLTable table, ResultSet rs, final ResultSetMetaData rsmd, final boolean onlyTable) throws SQLException {
-        return createFromRS(table, rs, getFieldNames(table, rsmd, onlyTable));
+        return createFromRS(table, rs, new SQLFieldRowProcessor(table, getFieldNames(table, rsmd, onlyTable)), true);
+    }
     private static final List<String> getFieldNames(SQLTable table, final ResultSetMetaData rsmd, final boolean tableOnly) throws SQLException {
         final int colCount = rsmd.getColumnCount();
         final List<String> names = new ArrayList<String>(colCount);
+        }
         return names;
+    }
-    // MAYBE create an opaque class holding names so that we can make this method, getFieldNames()
-    // and createListFromRS() public
+    // ATTN doesn't check that names are fields of table
-    static final SQLRow createFromRS(SQLTable table, ResultSet rs, final List<String> names) throws SQLException {
+    public static final SQLRow createFromRS(SQLTable table, ResultSet rs, final SQLFieldRowProcessor rowProc, final boolean immutable) throws SQLException {
-        final int indexCount = names.size();
-        final Map<String, Object> m = new HashMap<String, Object>(indexCount);
+        final Map<String, Object> m = rowProc.toMap(rs);
-        for (int i = 0; i < indexCount; i++) {
-            final String colName = names.get(i);
-            if (colName != null)
-                m.put(colName, rs.getObject(i + 1));
-        }
         final Number id = getID(m, table, true);
         // e.g. LEFT JOIN : missing values are null
         if (id == null)
             return null;
         // pass already found ID
+        final SQLRow res = new SQLRow(table, id, Collections.unmodifiableMap(m));
+        if (immutable)
+            res.freeze();
-        return new SQLRow(table, id, m);
+        return res;
+    }
     /**
      * Create a list of rows using the metadata to find the columns' names.
+     *
      *        <code>table</code>.
      * @return the data of the result set as SQLRows.
      * @throws SQLException if an error occurs while reading <code>rs</code>.
      */
     public static final List<SQLRow> createListFromRS(SQLTable table, ResultSet rs, final boolean tableOnly) throws SQLException {
-        return createListFromRS(table, rs, getFieldNames(table, rs.getMetaData(), tableOnly));
+        return createListFromRS(table, rs, getFieldNames(table, rs.getMetaData(), tableOnly), true);
+    }
     /**
      * Create a list of rows without using the metadata.
+     *
      * @param table the table of the rows.
      * @param rs the result set.
      * @param names the name of the field for each column, nulls are ignored, e.g. ["DESIGNATION",
      *        null, "ID"].
+     * @param immutable <code>true</code> if the result should be immutable.
      * @return the data of the result set as SQLRows.
      * @throws SQLException if an error occurs while reading <code>rs</code>.
      */
-    static final List<SQLRow> createListFromRS(SQLTable table, ResultSet rs, final List<String> names) throws SQLException {
+    static final List<SQLRow> createListFromRS(SQLTable table, ResultSet rs, final List<String> names, final boolean immutable) throws SQLException {
         final List<SQLRow> res = new ArrayList<SQLRow>();
+        final SQLFieldRowProcessor rowProc = new SQLFieldRowProcessor(table, names);
         while (rs.next()) {
-            final SQLRow row = createFromRS(table, rs, names);
+            final SQLRow row = createFromRS(table, rs, rowProc, immutable);
             if (row != null)
                 res.add(row);
+        }
-        return res;
+        return immutable ? Collections.unmodifiableList(res) : res;
+    }
     static final SQLRow createFromSelect(final SQLTable t, final VirtualFields vfs, final int id, final LockStrength l) {
         final SQLSelect sel = new SQLSelect(true).addAllSelect(t.getFields(vfs));
         sel.setLockStrength(l);
         sel.setWhere(new Where(t.getKey(), "=", id));
         @SuppressWarnings("unchecked")
-        final Map<String, ?> map = (Map<String, ?>) t.getDBSystemRoot().getDataSource().execute(sel.asString(), new IResultSetHandler(SQLDataSource.MAP_HANDLER, l.equals(LockStrength.NONE)));
+        final Map<String, Object> map = (Map<String, Object>) t.getDBSystemRoot().getDataSource().execute(sel.asString(),
+                new IResultSetHandler(SQLDataSource.MAP_HANDLER, l.equals(LockStrength.NONE)));
-        return new SQLRow(t, id, map);
+        return new SQLRow(t, id, map == null ? null : Collections.unmodifiableMap(map));
+    }
     /**
      * Create an empty existing row (without checking the DB).
+     *
      * @param t the table.
      * @param id the ID.
-     * @return a new {@link #exists() existing} {@link #isFilled() filled} {@link #getFields()
+     * @return a new {@link #exists() existing} {@link #isFilled() filled} {@link #isFrozen()
-     *         empty} row.
+     *         frozen} {@link #getFields() empty} row.
      */
-    static final SQLRow createEmpty(final SQLTable t, final int id) {
+    public static final SQLRow createEmpty(final SQLTable t, final int id) {
-        return new SQLRow(t, id, Collections.<String, Object> emptyMap());
+        final SQLRow res = new SQLRow(t, id, Collections.<String, Object> emptyMap());
+        res.freeze();
+        return res;
+    }
+    public static final <R extends SQLRowAccessor, A> SQLRow trim(final R r, final BiFunction<? super R, ? super A, ? extends Map<String, Object>> getVals, final A arg) {
+        final SQLRow res = new SQLRow(r.getTable(), null, CollectionUtils.toImmutableMap(getVals.apply(r, arg)));
+        res.freeze();
+        return res;
+    }
     private final int ID;
     private final Number idNumber;
     private Map<String, Object> values;
     private boolean fetched;
+    private boolean frozen = false;
     private SQLRow(SQLTable table, Number id) {
         super(table);
         this.fetched = false;
         this.ID = id.intValue();
      * @param table la table.
      * @param values les valeurs de la lignes.
      * @throws IllegalArgumentException si values ne contient pas la clef de la table.
      */
     public SQLRow(SQLTable table, Map<String, ?> values) {
-        this(table, null, values);
+        this(table, null, values == null ? null : CollectionUtils.toImmutableMap(values));
+    }
     // allow to call getID() only once
+    // Private since it doesn't make sure the map is immutable.
-    private SQLRow(SQLTable table, final Number id, Map<String, ?> values) {
+    private SQLRow(SQLTable table, final Number id, Map<String, Object> values) {
         this(table, id == null ? getID(values, table, false) : id);
-        // faire une copie, sinon backdoor pour changer les valeurs sans qu'on s'en aperçoive
-        this.setValues(values == null ? null : new HashMap<String, Object>(values));
+        this.setValues(values);
+    }
     // return ID, must always be present but may be null if <code>nullAllowed</code>
     private static Number getID(Map<String, ?> values, final SQLTable table, final boolean nullAllowed) {
         final String keyName = table.getKey().getName();
             final String valS = keyValue == null ? "' is null" : "' isn't a Number : " + keyValue.getClass() + " " + keyValue;
             throw new IllegalArgumentException("The value of '" + keyName + valS);
+        }
+    }
+    public final SQLRow copy(final boolean freeze) {
+        final SQLRow res = new SQLRow(this.getTable(), this.getIDNumber());
+        if (this.isFilled())
+            // safe to share map, since it is immutable
+            res.setValues(this.getValues());
+        assert res.isFilled() == this.isFilled();
+        if (freeze)
+            res.freeze();
+        assert res.isFrozen() == freeze;
+        return res;
+    }
+    @Override
+    public final boolean isFrozen() {
+        return this.frozen;
+    }
+    private void checkFrozen() {
+        if (this.isFrozen())
+            throw new IllegalStateException("SQLRow is not modifiable");
+    }
+    /**
+     * Freeze this instance so that no modification can be made. Once this method returns, this
+     * instance can be safely published (e.g. stored into a field that is properly guarded by a
+     * lock) to other threads without further synchronizations.
+     *
+     * @return <code>true</code> if this call changed the frozen status.
+     */
+    public final boolean freeze() {
+        if (this.frozen)
+            return false;
+        this.frozen = true;
+        return true;
+    }
+    @Override
+    public final SQLRow toImmutable() {
+        if (this.isFrozen())
+            return this;
+        return this.copy(true);
+    }
     /**
      * Whether this contains values or just the {@link #getIDNumber() id}. NOTE that
      * {@link #getObject(String)} (and thus any other methods that call it) will access the DB if
      * the requested field is {@link #getFields() missing} even if this returns <code>true</code>.
+     *
+     *
      * @param useCache <code>true</code> to use the {@link SQLDataSource#isCacheEnabled() cache}.
      * @return a new instance.
      */
     public final SQLRow fetchNew(final boolean useCache) {
-        return new SQLRow(this.getTable(), this.getIDNumber()).fetchValues(useCache);
+        return this.fetchNewRow(useCache);
+    }
     @SuppressWarnings("unchecked")
     SQLRow fetchValues(final boolean readCache, final boolean writeCache) {
+        // not necessary here, but allows to fail early and avoid a request
+        // implique trop de regression dans la branche : checkFrozen();
         final IResultSetHandler handler = new IResultSetHandler(SQLDataSource.MAP_HANDLER, readCache, writeCache) {
             @Override
             public Set<SQLRow> getCacheModifiers() {
                 return Collections.singleton(SQLRow.this);
+            }
         };
-        this.setValues((Map<String, Object>) this.getTable().getBase().getDataSource().execute(this.getQuery(), handler, false));
+        final Map<String, Object> values = (Map<String, Object>) this.getTable().getBase().getDataSource().execute(this.getQuery(), handler, false);
+        this.setValues(values == null ? null : Collections.unmodifiableMap(values));
         return this;
+    }
-    // attention ne vérifie pas que tous les champs soient présents
+    // Attention ne vérifie pas que tous les champs soient présents.
+    // Private since it doesn't make sure the map is immutable.
     private final void setValues(Map<String, Object> values) {
+        // implique trop de regression dans la branche : checkFrozen();
         this.values = values;
         if (!this.fetched)
             this.fetched = true;
+    }
+     *
      * @return les noms des champs qui ont été chargé depuis la base.
      */
     @Override
     public Set<String> getFields() {
-        return this.fetched ? Collections.unmodifiableSet(this.getValues().keySet()) : Collections.<String> emptySet();
+        return this.isFilled() ? this.getValues().keySet() : Collections.<String> emptySet();
+    }
     // avoid Collections.unmodifiableSet() allocation
     @Override
     public boolean contains(String fieldName) {
-        return this.fetched ? this.getValues().containsKey(fieldName) : false;
+        return this.isFilled() ? this.getValues().containsKey(fieldName) : false;
+    }
     private String getQuery() {
         return "SELECT * FROM " + this.getTable().getSQLName().quote() + " WHERE " + this.getWhere().getClause();
+    }
+        }
         assert this.getValues().containsKey(field);
         return this.getValues().get(field);
+    }
+    @Override
+    public final Object getObjectNoCheck(String field) {
+        return this.values.get(field);
+    }
     /**
      * Fetch from the DB this row and the next/previous one. ATTN the rows are locked
      * {@link LockStrength#UPDATE for update}, but if this method is not called from within a
      * transaction, they will immediately be obsolete.
+     *
      * @see #getAllValues()
      * @see #getObject(String)
      */
     @Override
     public Map<String, Object> getAbsolutelyAll() {
-        return Collections.unmodifiableMap(this.getValues());
+        return this.getValues();
+    }
     private static final VirtualFields ALL_VALUES_FIELDS = VirtualFields.ALL.difference(VirtualFields.KEYS, VirtualFields.ARCHIVE, VirtualFields.ORDER);
     /**
     public Number getIDNumber() {
         return this.idNumber;
+    }
     @Override
-    public SQLRow asRow() {
+    public SQLRow asRow(final Boolean immutable) {
+        if (immutable == null || this.isFrozen() == immutable)
-        return this;
+            return this;
+        else
+            return this.copy(immutable);
+    }
     @Override
-    public final SQLRowValues asRowValues() {
+    public final SQLRowValues asRowValues(final Boolean immutable) {
-        return this.createUpdateRow();
+        final SQLRowValues res = this.createUpdateRow();
+        if (Boolean.TRUE.equals(immutable))
+            res.getGraph().freeze();
+        return res;
+    }
     /**
      * Note : ne compare pas les valeurs des champs de cette ligne.
+     *

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

svn://code.openconcerto.org/openconcerto

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