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

 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.sql.utils.ReOrder;
-import org.openconcerto.utils.DecimalUtils;
 import org.openconcerto.utils.ListMap;
 import org.openconcerto.utils.SetMap;
+import org.openconcerto.utils.Tuple2.List2;
-import java.math.BigDecimal;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Arrays;
      */
     public final void fetchValues() {
         this.fetchValues(true);
+    }
+    /**
+     * Fetch up-to-date values from the DB.
+     *
+     * @param useCache <code>true</code> to use the {@link SQLDataSource#isCacheEnabled() cache}.
+     * @return this.
+     */
     public final SQLRow fetchValues(final boolean useCache) {
         return this.fetchValues(useCache, useCache);
+    }
+    /**
+     * Return a new instance with up-to-date values.
+     *
+     * @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);
+    }
     @SuppressWarnings("unchecked")
     SQLRow fetchValues(final boolean readCache, final boolean writeCache) {
         final IResultSetHandler handler = new IResultSetHandler(SQLDataSource.MAP_HANDLER, readCache, writeCache) {
             @Override
             public Set<SQLRow> getCacheModifiers() {
+        }
         assert this.getValues().containsKey(field);
         return this.getValues().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.
+     *
+     * @param after <code>true</code> to return the next row, <code>false</code> to return the
+     *        previous.
+     * @return {@link List2#get0() this row} and the next/previous one with only
+     *         {@link SQLTable#getOrderField()} and {@link SQLTable#getArchiveField()} fetched,
+     *         <code>null</code> if this row doesn't exist, the {@link List2#get1() next/previous
+     *         row} is <code>null</code> if this is the last/first row of the table or has
+     *         <code>null</code> order.
+     * @throws IllegalStateException if this is the {@link #isUndefined() undefined} row.
+     */
-    public final SQLRow getRow(boolean after) {
+    public final List2<SQLRow> fetchThisAndSequentialRow(boolean after) throws IllegalStateException {
+        if (this.isUndefined())
+            throw new IllegalStateException("Cannot order against the undefined");
         final SQLTable t = this.getTable();
-        final BigDecimal destOrder = this.getOrder();
         final int diff = (!after) ? -1 : 1;
+        // this is one statement (subquery included) and thus atomic : the inner FOR UPDATE ensures
+        // that the ORDER doesn't change by the time the outer query is executed
+        // SELECT * FROM "test"."BATIMENT"
+        // WHERE "ORDRE" >= (SELECT "ORDRE" FROM "test"."BATIMENT" WHERE "ID" = 3 FOR UPDATE)
+        // ORDER BY "ORDRE"
+        // LIMIT 2
+        // FOR UPDATE;
+        final SQLSelect selOrder = new SQLSelect();
+        // OK to order against an archived
+        selOrder.setArchivedPolicy(SQLSelect.BOTH);
+        selOrder.addSelect(t.getOrderField());
+        selOrder.setWhere(this.getWhere());
+        selOrder.setLockStrength(LockStrength.UPDATE);
         final SQLSelect sel = new SQLSelect();
-        // undefined must not move
+        // don't ignore undefined or the caller might want to use its order
-        sel.setExcludeUndefined(true);
+        sel.setExcludeUndefined(false);
         // unique index prend aussi en compte les archivés
         sel.setArchivedPolicy(SQLSelect.BOTH);
         sel.addSelect(t.getKey());
         sel.addSelect(t.getOrderField());
         if (t.isArchivable())
             sel.addSelect(t.getArchiveField());
-        sel.setWhere(new Where(t.getOrderField(), diff < 0 ? "<" : ">", destOrder));
+        final Where orderWhere = Where.createRaw(t.getOrderField().getFieldRef() + (diff < 0 ? "<=" : ">=") + "(" + selOrder + ")", t.getOrderField());
+        // this.getWhere() needed when ORDER is null
+        sel.setWhere(orderWhere.or(this.getWhere()));
         sel.addFieldOrder(t.getOrderField(), diff < 0 ? Order.desc() : Order.asc());
-        sel.setLimit(1);
+        sel.setLimit(2);
+        sel.setLockStrength(LockStrength.UPDATE);
-        final SQLDataSource ds = t.getBase().getDataSource();
+        final List<SQLRow> rows = SQLRowListRSH.execute(sel);
-        @SuppressWarnings("unchecked")
+        assert rows.size() <= 2;
-        final Map<String, Object> otherMap = ds.execute1(sel.asString());
-        if (otherMap != null) {
+        if (rows.isEmpty()) {
-            return new SQLRow(t, otherMap);
-        } else {
             return null;
-        }
-    }
-    /**
-     * The free order just after or before this row.
-     *
-     * @param after whether to look before or after this row.
-     * @return a free order, or <code>null</code> if there's no room left.
-     */
-    public final BigDecimal getOrder(boolean after) {
-        final BigDecimal destOrder = this.getOrder();
-        final SQLRow otherRow = this.getRow(after);
-        final BigDecimal otherOrder;
-        if (otherRow != null) {
-            otherOrder = otherRow.getOrder();
-        } else if (after) {
-            // dernière ligne de la table
-            otherOrder = destOrder.add(ReOrder.DISTANCE);
         } else {
-            // première ligne
-            otherOrder = ReOrder.MIN_ORDER;
+            assert rows.get(0).equals(this);
-        }
-        final int decDigits = this.getTable().getOrderDecimalDigits();
-        final BigDecimal least = BigDecimal.ONE.scaleByPowerOfTen(-decDigits);
-        final BigDecimal distance = destOrder.subtract(otherOrder).abs();
-        if (distance.compareTo(least) <= 0)
-            return null;
-        else {
-            final BigDecimal mean = destOrder.add(otherOrder).divide(BigDecimal.valueOf(2));
-            return DecimalUtils.round(mean, decDigits);
+            return new List2<>(rows.get(0), rows.size() == 1 ? null : rows.get(1));
+        }
+    }
     @Override
     public SQLRow getForeign(String fieldName) {

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 151 → 156