WebSVN - OpenConcerto - Diff - Rev 174 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRowListRSH.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.
  * When distributing the software, include this License Header Notice in each file.
  */
  package org.openconcerto.sql.model;
-import org.openconcerto.sql.model.SQLSelect.LockStrength;
 import org.openconcerto.utils.Tuple2;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.commons.dbutils.ResultSetHandler;
 public final class SQLRowListRSH implements ResultSetHandler {
     // hashCode()/equals() needed for data source cache
     public static final class RSH implements ResultSetHandler {
         private final Tuple2<SQLTable, List<String>> names;
+        private final boolean immutableRows;
         // allow to create rows from arbitrary columns (and not just directly from actual fields of
         // the same table)
         // ATTN doesn't check that the types of columns are coherent with the types of the fields
         public RSH(final SQLTable t, final List<String> names) {
-            this(Tuple2.create(t, names));
+            this(Tuple2.create(t, names), true);
             // null are OK (they're ignored)
             final List<String> unknown = names.stream().filter(n -> n != null && !t.getFieldsName().contains(n)).collect(Collectors.toList());
             if (!unknown.isEmpty())
                 throw new IllegalArgumentException("Not all names are fields of " + t + " : " + unknown);
+        }
-        private RSH(final Tuple2<SQLTable, List<String>> names) {
+        private RSH(final Tuple2<SQLTable, List<String>> names, final boolean immutableRows) {
             this.names = names;
+            this.immutableRows = immutableRows;
+        }
         @Override
         public List<SQLRow> handle(final ResultSet rs) throws SQLException {
             // since the result will be cached, disallow its modification (e.g.avoid
             // ConcurrentModificationException)
-            return Collections.unmodifiableList(SQLRow.createListFromRS(this.names.get0(), rs, this.names.get1()));
+            return SQLRow.createListFromRS(this.names.get0(), rs, this.names.get1(), this.immutableRows);
+        }
         @Override
         public int hashCode() {
             return this.names.hashCode();
      * @return a handler creating a list of {@link SQLRow}.
      * @deprecated use {@link SQLSelectHandlerBuilder}
      */
     @Deprecated
     static public ResultSetHandler createFromSelect(final SQLSelect sel) {
-        return create(getIndexes(sel, null, true));
+        return create(getIndexes(sel, null, true), false);
+    }
     /**
      * Create a handler that don't need metadata. Useful since some JDBC drivers perform queries for
      * each metadata.
      * @return a handler creating a list of {@link SQLRow}.
      * @deprecated use {@link SQLSelectHandlerBuilder}
      */
     @Deprecated
     static public ResultSetHandler createFromSelect(final SQLSelect sel, final TableRef t) {
-        return create(getIndexes(sel, t, false));
+        return create(getIndexes(sel, t, false), false);
+    }
-    static ResultSetHandler create(final Tuple2<SQLTable, List<String>> names) {
+    static ResultSetHandler create(final Tuple2<SQLTable, List<String>> names, final boolean immutableRows) {
+        return new RSH(names, immutableRows);
+    }
+    static public List<SQLRow> fetch(final SQLTable t) throws IllegalArgumentException {
-        return new RSH(names);
+        return fetch(t, null);
+    }
     static public List<SQLRow> fetch(final SQLTable t, final Collection<? extends Number> ids) throws IllegalArgumentException {
         return fetch(t, ids, null);
+    }
         final SQLSelect sel = new SQLSelect();
         if (fields == null)
             sel.addSelectStar(t);
         else
             sel.addAllSelect(t, fields);
+        // deterministic
+        sel.addOrder(t, false);
+        if (ids != null)
-        sel.setWhere(new Where(t.getKey(), ids));
+            sel.setWhere(new Where(t.getKey(), ids));
         return execute(sel);
+    }
     /**
      */
     static public List<SQLRow> execute(final SQLSelect sel, final TableRef t) throws NullPointerException {
         return new SQLSelectHandlerBuilder(sel).setTableRef(t).execute();
+    }
-    static IResultSetHandler createFromSelect(final SQLSelect sel, final Tuple2<SQLTable, List<String>> indexes, final boolean readCache, final boolean writeCache) {
-        final Set<SQLTable> tables = new HashSet<SQLTable>();
-        // not just tables of the fields of the SELECT clause since inner joins can change the rows
-        // returned
-        for (final TableRef ref : sel.getTableRefs().values()) {
-            tables.add(ref.getTable());
-        }
-        // the SELECT requesting a lock means the caller expects the DB to be accessed
-        final boolean acquireLock = sel.getLockStrength() != LockStrength.NONE;
-        return new IResultSetHandler(create(indexes), readCache && !acquireLock, writeCache && !acquireLock) {
-            @Override
-            public Set<? extends SQLData> getCacheModifiers() {
-                return tables;
-            }
-        };
-    }
     private final SQLTable t;
     private final boolean tableOnly;
     public SQLRowListRSH(final SQLTable t) {
         this(t, false);

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

svn://code.openconcerto.org/openconcerto

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