WebSVN - OpenConcerto - Diff - Rev 174 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRowValues.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.utils.ExceptionUtils;
 import org.openconcerto.utils.ListMap;
 import org.openconcerto.utils.RecursionType;
 import org.openconcerto.utils.SetMap;
 import org.openconcerto.utils.Tuple2;
+import org.openconcerto.utils.Value;
 import org.openconcerto.utils.cc.IClosure;
 import org.openconcerto.utils.cc.ITransformer;
 import org.openconcerto.utils.cc.IdentitySet;
 import org.openconcerto.utils.cc.LinkedIdentitySet;
 import org.openconcerto.utils.cc.TransformedMap;
          * Copy every SQLRowValues.
          */
         COPY_ROW
+    }
+    public static enum SQLDefaultCopyMode {
+        COPY, REMOVE, PARSE_ELSE_REMOVE, PARSE_ELSE_ERROR;
+    }
     static public enum CreateMode {
         /**
          * Never create rows.
          */
         CREATE_NONE,
         public String toString() {
             return SQLRowValues.class.getSimpleName() + ".SQL_EMPTY_LINK";
+        }
     };
+    public static final class SQLExpression {
+        private final String sql;
+        public SQLExpression(String sql) {
+            super();
+            this.sql = sql;
+        }
+        public final String getSQL() {
+            return this.sql;
+        }
+        @Override
+        public String toString() {
+            return this.getClass().getSimpleName() + " " + this.sql;
+        }
+    }
     static public enum ValidityCheck {
         /**
          * The check is never performed.
          */
         FORBIDDEN {
      * and all others connected to it and {@link SQLRowValuesCluster#freeze()} the copy. I.e. if the
      * result is to be shared among threads, it still needs to be safely published.
+     *
      * @return this if already frozen, otherwise a frozen copy of this.
      */
+    @Override
     public final SQLRowValues toImmutable() {
         if (this.isFrozen())
             return this;
         return this.getGraph().deepCopy(this, true);
+    }
+     *
      * @param fk a foreign key, eg "ID_FAMILLE_2".
      * @return the foreign row, eg FAMILLE[1].
      */
     public final SQLRowValues grow(String fk) {
+        // growUndefined to make sure we can cast (otherwise if fk is undefined
+        // getForeign() returns a row)
+        return (SQLRowValues) this.grow(fk, true);
+    }
+    public final SQLRowAccessor grow(String fk, final boolean growUndefined) {
         final Object val = this.getContainedObject(fk);
         // if fk is in our map with a null value, nothing to grow
         if (val != null && !(val instanceof SQLRowValues)) {
             final SQLRowValues vals = new SQLRowValues(this.getTable());
             vals.putRowValues(fk).setAllToNull();
-            this.grow(vals, true);
+            this.grow(vals, true, growUndefined);
+        }
-        return (SQLRowValues) this.getForeign(fk);
+        return this.getForeign(fk);
+    }
     public final SQLRowValues grow(SQLRowValues graph) {
         return this.grow(graph, true);
+    }
     @Override
     public final Object getObject(String fieldName) {
         return this.values.get(fieldName);
+    }
+    @Override
+    public final Object getObjectNoCheck(String fieldName) {
+        return this.values.get(fieldName);
+    }
+    public final Value<Object> getNonDefaultObject(String fieldName) {
+        return getNonDefaultObject(fieldName, Object.class);
+    }
+    /**
+     * Never return {@link #SQL_DEFAULT}.
+     *
+     * @param fieldName the name of the field.
+     * @param clazz the type of value expected.
+     * @return {@link Value#getNone()} if the field is DEFAULT and the
+     *         {@link SQLField#getParsedDefaultValue() default value} cannot be parsed, otherwise
+     *         either the non DEFAULT field value or the parsed DEFAULT.
+     */
+    public final <T> Value<T> getNonDefaultObject(String fieldName, Class<T> clazz) {
+        final Object res = this.getObject(fieldName);
+        if (res == SQL_DEFAULT) {
+            return this.getTable().getField(fieldName).getParsedDefaultValue().cast(clazz);
+        } else {
+            return Value.getSome(clazz.cast(res));
+        }
+    }
     @Override
     public Map<String, Object> getAbsolutelyAll() {
         return getAllValues(ForeignCopyMode.COPY_ROW);
+    }
     protected final Map<String, Object> getAllValues(ForeignCopyMode copyForeigns) {
+        return this.getAllValues(copyForeigns, SQLDefaultCopyMode.COPY);
+    }
+    public final Map<String, Object> getAllValues(ForeignCopyMode copyForeigns, SQLDefaultCopyMode copyDefaults) {
-        return this.getAllValues(copyForeigns, false);
+        return this.getAllValues(copyForeigns, copyDefaults, false);
+    }
-    private final Map<String, Object> getAllValues(ForeignCopyMode copyForeigns, final boolean copy) {
+    private final Map<String, Object> getAllValues(ForeignCopyMode copyForeigns, SQLDefaultCopyMode copyDefaults, final boolean copy) {
         final Map<String, Object> toAdd;
-        if (copyForeigns == ForeignCopyMode.COPY_ROW || this.foreigns.size() == 0) {
+        if ((copyForeigns == ForeignCopyMode.COPY_ROW || this.foreigns.size() == 0) && (copyDefaults == SQLDefaultCopyMode.COPY || !this.values.values().contains(SQL_DEFAULT))) {
             if (copy) {
                 toAdd = createLinkedHashMap(this.size());
                 toAdd.putAll(this.values);
             } else {
                 toAdd = this.values;
+            }
         } else {
             final Set<Entry<String, Object>> entrySet = this.values.entrySet();
             toAdd = createLinkedHashMap(entrySet.size());
             for (final Map.Entry<String, Object> e : entrySet) {
+                final String fieldName = e.getKey();
+                boolean add = true;
+                Object val = e.getValue();
+                if (e.getValue() == SQL_DEFAULT) {
+                    if (copyDefaults == SQLDefaultCopyMode.REMOVE) {
+                        add = false;
+                    } else if (copyDefaults == SQLDefaultCopyMode.COPY) {
+                        add = true;
+                    } else {
+                        final Value<Object> parsedDefaultValue = this.getTable().getField(fieldName).getParsedDefaultValue();
+                        if (parsedDefaultValue.hasValue()) {
+                            val = parsedDefaultValue.getValue();
+                        } else if (copyDefaults == SQLDefaultCopyMode.PARSE_ELSE_ERROR) {
+                            throw new IllegalStateException("Couldn't parse default for " + fieldName);
+                        } else {
+                            assert copyDefaults == SQLDefaultCopyMode.PARSE_ELSE_REMOVE;
+                            add = false;
+                        }
+                    }
-                if (!(e.getValue() instanceof SQLRowValues)) {
+                } else if (e.getValue() instanceof SQLRowValues) {
-                    toAdd.put(e.getKey(), e.getValue());
+                    if (copyForeigns == ForeignCopyMode.NO_COPY) {
+                        add = false;
-                } else if (copyForeigns == ForeignCopyMode.COPY_NULL) {
+                    } else if (copyForeigns == ForeignCopyMode.COPY_ROW) {
-                    toAdd.put(e.getKey(), null);
+                        add = true;
-                } else if (copyForeigns != ForeignCopyMode.NO_COPY) {
+                    } else if (copyForeigns == ForeignCopyMode.COPY_NULL) {
+                        val = null;
+                    } else {
-                    final SQLRowValues foreign = (SQLRowValues) e.getValue();
+                        final SQLRowValues foreign = (SQLRowValues) e.getValue();
-                    if (foreign.hasID())
+                        if (foreign.hasID())
-                        toAdd.put(e.getKey(), foreign.getIDNumber());
+                            val = foreign.getIDNumber();
-                    else if (copyForeigns == ForeignCopyMode.COPY_ID_OR_ROW)
+                        else if (copyForeigns == ForeignCopyMode.COPY_ID_OR_RM)
-                        toAdd.put(e.getKey(), foreign);
+                            add = false;
+                        else
+                            assert copyForeigns == ForeignCopyMode.COPY_ID_OR_ROW;
+                    }
+                }
+                if (add)
+                    toAdd.put(fieldName, val);
+            }
+        }
         return copy ? toAdd : Collections.unmodifiableMap(toAdd);
+    }
     public boolean contains(String fieldName) {
         return this.values.containsKey(fieldName);
+    }
     @Override
-    public final SQLRow asRow() {
+    public final SQLRow asRow(final Boolean immutable) {
         if (!this.hasID())
             throw new IllegalStateException(this + " has no ID");
+        // keep the most information without throwing an exception
-        return new SQLRow(this.getTable(), this.getAllValues(ForeignCopyMode.COPY_ID_OR_RM));
+        final SQLRow res = new SQLRow(this.getTable(), this.getAllValues(ForeignCopyMode.COPY_ID_OR_RM, SQLDefaultCopyMode.PARSE_ELSE_REMOVE, false));
+        // if the caller doesn't care about immutable, keep the same
+        if (Boolean.TRUE.equals(immutable) || (immutable == null && this.isFrozen()))
+            res.freeze();
+        return res;
+    }
     @Override
-    public final SQLRowValues asRowValues() {
+    public final SQLRowValues asRowValues(final Boolean immutable) {
+        if (immutable == null || this.isFrozen() == immutable)
-        return this;
+            return this;
+        else
+            return this.getGraph().deepCopy(this, immutable);
+    }
     // *** set
     /**
      * Whether this can be modified.
+     *
      * @return <code>true</code> if this (and its graph) is not modifiable.
      */
+    @Override
     public final boolean isFrozen() {
         final SQLRowValuesCluster g = this.getGraph(false);
         return g != null && g.isFrozen();
+    }
     // TODO support java.time.LocalDateTime in Java 8
     public static <T, U> U convert(final Class<T> source, final Object value, final Class<U> dest) {
         final ValueConvertor<T, U> conv = ValueConvertorFactory.find(source, dest);
         if (conv == null)
             throw new IllegalArgumentException("No convertor to " + dest + " from " + source);
-        assert source == value.getClass();
-        @SuppressWarnings("unchecked")
-        final T tVal = (T) value;
-        return conv.convert(tVal);
+        return conv.convert(source.cast(value));
+    }
     private void _put(String fieldName, Object value, final boolean checkName, final ValueOperation checkValue) {
         // table.contains() can take up to 35% of this method
         if (checkName && !this.getTable().contains(fieldName))
             throw new IllegalArgumentException(fieldName + " is not in table " + this.getTable());
         if (value == SQL_EMPTY_LINK) {
             // keep getForeignTable since it does the check
             value = this.getForeignTable(fieldName).getUndefinedIDNumber();
-        } else if (value != null && value != SQL_DEFAULT && checkValue != ValueOperation.PASS) {
+        } else if (value != null && value != SQL_DEFAULT && !(value instanceof SQLExpression) && checkValue != ValueOperation.PASS) {
             final SQLField field = this.getTable().getField(fieldName);
             if (value instanceof SQLRowValues) {
                 if (!field.isForeignKey())
                     throw new IllegalArgumentException("Since value is a SQLRowValues, expected a foreign key but got " + field);
             } else {
                 final Class<?> javaType = field.getType().getJavaType();
                 if (!javaType.isInstance(value)) {
                     if (checkValue == ValueOperation.CONVERT) {
+                        try {
-                        value = convert(value.getClass(), value, javaType);
+                            value = convert(value.getClass(), value, javaType);
+                        } catch (Exception e) {
+                            throw new IllegalArgumentException("Couldn't convert " + SQLBase.quoteIdentifier(fieldName) + " " + value + getClassName(value.getClass()) + " to " + javaType, e);
+                        }
                     } else {
                         throw new IllegalArgumentException("Wrong type for " + fieldName + ", expected " + javaType + " but got " + value.getClass());
+                    }
+                }
+            }
     public SQLRowValues putEmptyLink(String fieldName) {
         return this.put(fieldName, SQL_EMPTY_LINK);
+    }
     /**
+     * Put an SQL expression into this.
+     *
+     * @param fieldName the field name.
+     * @param sqlExpression an SQL expression, e.g. "now()" or "'a'".
+     * @return this.
+     */
+    public SQLRowValues putSQL(final String fieldName, final String sqlExpression) {
+        return this.put(fieldName, new SQLExpression(sqlExpression));
+    }
+    /**
      * Set a new {@link SQLRowValues} as the value of <code>fieldName</code>. ATTN contrary to many
      * methods this one do not return <code>this</code>.
+     *
      * @param fieldName the name of a foreign field.
      * @return the newly created values.
+    }
     /**
      * Create or follow the passed path and put the passed row at the end.
+     *
-     * @param p the {@link Path#isSingleLink() single link} path.
+     * @param p the {@link Path#isSingleLink() single link} path, can only be {@link Path#length()
+     *        empty} if <code>vals</code> is <code>null</code>.
      * @param createPath <code>true</code> if new rows must {@link #createPathToOne(Path) always be
      *        created}, <code>false</code> if existing rows can be {@link #assurePath(Path) used}.
      * @param vals the row to {@link #put(Step, SQLRowValues) put}, <code>null</code> to create a
      *        new one.
-     * @return the row that was added.
+     * @return the row at the end of the path.
      * @throws IllegalArgumentException if the path is invalid.
      */
     public final SQLRowValues put(final Path p, final boolean createPath, final SQLRowValues vals) throws IllegalArgumentException {
-        if (p.length() == 0)
+        if (p.length() == 0) {
+            if (vals == null) {
+                return this;
+            } else {
-            throw new IllegalArgumentException("Empty path");
+                throw new IllegalArgumentException("Empty path, won't merge " + vals + " into " + this);
+            }
+        }
         if (!p.isSingleLink())
             throw new IllegalArgumentException("Multi-link path " + p);
         // checks first table
         final SQLRowValues beforeLast = createPath ? this.createPathToOne(p.minusLast()) : this.assurePath(p.minusLast());
         // checks last table
     public final SQLRowValues putAll(Map<String, ?> m) {
         return this.putAll(m, null);
+    }
+    public final SQLRowValues putAllAbsent(Map<String, ?> m) {
+        return this.loadAll(m, FillMode.DONT_OVERWRITE);
+    }
     public final SQLRowValues putAll(Map<String, ?> m, final Collection<String> keys) {
         return this.putAll(m, keys, FillMode.OVERWRITE);
+    }
     final SQLRowValues putAll(Map<String, ?> m, final Collection<String> keys, final FillMode fillMode) {
                     // otherwise would have to check more than field
                     assert foreignLink.getCols().size() == 1;
                     // verifie l'intégrité (a rowValues is obviously correct, as is EMPTY,
                     // DEFAULT is the responsability of the DB)
                     final Object fieldVal = this.getObject(fieldName);
+                    if (fieldVal instanceof SQLExpression)
+                        return new Object[] { fieldName, null };
                     if (fieldVal != null && fieldVal != SQL_DEFAULT && !(fieldVal instanceof SQLRowValues)) {
                         final SQLRow pb = foreignTable.checkValidity(((Number) fieldVal).intValue());
                         if (pb != null)
                             return new Object[] { fieldName, pb };
+                    }
     @Override
     public String mapToString() {
         String result = this.getClass().getSimpleName() + " on " + this.getTable() + " : {";
         result += CollectionUtils.join(this.values.entrySet(), ", ", new ITransformer<Entry<String, ?>, String>() {
             public String transformChecked(final Entry<String, ?> e) {
+                final Object fieldVal = e.getValue();
-                final String className = e.getValue() == null ? "" : "(" + e.getValue().getClass() + ")";
+                final String className = getClassName(fieldVal);
                 final String value;
                 // avoid infinite loop (and overly verbose string)
-                if (e.getValue() instanceof SQLRowValues) {
+                if (fieldVal instanceof SQLRowValues) {
-                    final SQLRowValues foreignVals = (SQLRowValues) e.getValue();
+                    final SQLRowValues foreignVals = (SQLRowValues) fieldVal;
                     if (foreignVals == SQLRowValues.this) {
                         value = "this";
                     } else if (foreignVals.hasID()) {
                         value = foreignVals.getIDNumber().toString();
                     } else {
                         // so that if the same vals is referenced multiple times, we can see it
                         value = "@" + System.identityHashCode(foreignVals);
+                    }
-                } else
+                } else {
-                    value = String.valueOf(e.getValue());
+                    value = String.valueOf(fieldVal);
+                }
                 return e.getKey() + "=" + value + className;
+            }
         });
         result += "}";
         return result;
+    }
+    protected String getClassName(final Object val) {
+        // SQL_DEFAULT already has our class name in toString()
+        return val == null || val == SQL_DEFAULT || val instanceof SQLExpression ? "" : "(" + val.getClass() + ")";
+    }
     /**
      * Return a graphical representation (akin to the result of a query) of the tree rooted at
      * <code>this</code>.
+     *
      * @return a string representing the rows pointing to this.
             if (!this.values.keySet().equals(o.values.keySet()))
                 return false;
+        }
         // fields are already checked so if IDs are not wanted, just omit foreign rows
         final ForeignCopyMode copyMode = useForeignID ? ForeignCopyMode.COPY_ID_OR_RM : ForeignCopyMode.NO_COPY;
-        final Map<String, Object> thisVals = this.getAllValues(copyMode, !usePK);
+        final Map<String, Object> thisVals = this.getAllValues(copyMode, SQLDefaultCopyMode.COPY, !usePK);
-        final Map<String, Object> oVals = o.getAllValues(copyMode, !usePK);
+        final Map<String, Object> oVals = o.getAllValues(copyMode, SQLDefaultCopyMode.COPY, !usePK);
         if (!usePK) {
             final List<String> pk = this.getTable().getPKsNames();
             thisVals.keySet().removeAll(pk);
             oVals.keySet().removeAll(pk);
+        }
         final PreparedStatement pStmt;
         final String tableQuoted = table.getSQLName().quote();
         String req = (insert ? "INSERT INTO " : "UPDATE ") + tableQuoted + " ";
         if (insert) {
             assert fieldsNames.size() == values.size();
+            final List<String> insertValues = new ArrayList<>(values.size());
             // remove DEFAULT since they are useless and prevent us from using
             // INSERT INTO "TABLEAU_ELECTRIQUE" ("ID_OBSERVATION", ...) select DEFAULT, ?,
             // MAX("ORDRE") + 1 FROM "TABLEAU_ELECTRIQUE"
             for (int i = values.size() - 1; i >= 0; i--) {
                 if (values.get(i) == SQL_DEFAULT) {
                     fieldsNames.remove(i);
                     values.remove(i);
+                } else {
+                    insertValues.add(getFieldValue(values.get(i)));
+                }
+            }
             assert fieldsNames.size() == values.size();
             // ajout de l'ordre
-            final SQLField order = table.getOrderField();
+            final SQLField orderF = table.getOrderField();
             final boolean selectOrder;
-            if (order != null && !fieldsNames.contains(order.getName())) {
+            if (orderF != null && !fieldsNames.contains(orderF.getName())) {
                 // si l'ordre n'est pas spécifié, ajout à la fin
-                fieldsNames.add(order.getName());
+                fieldsNames.add(orderF.getName());
                 selectOrder = true;
             } else {
                 selectOrder = false;
+            }
                 req += "(" + CollectionUtils.join(fieldsNames, ", ", new ITransformer<String, String>() {
                     public String transformChecked(String input) {
                         return SQLBase.quoteIdentifier(input);
+                    }
                 }) + ")";
-                // no DEFAULT thus only ?
-                final String questionMarks = CollectionUtils.join(Collections.nCopies(values.size(), "?"), ", ");
+                final String questionMarks = CollectionUtils.join(insertValues, ", ");
                 if (selectOrder) {
                     // needed since VALUES ( (select MAX("ORDRE") from "LOCAL") ) on MySQL yield
                     // "You can't specify target table 'LOCAL' for update in FROM clause"
                     req += " select ";
                     req += questionMarks;
                     if (values.size() > 0)
                         req += ", ";
                     // COALESCE for empty tables, MIN_ORDER + 1 since MIN_ORDER cannot be moved
-                    req += "COALESCE(MAX(" + SQLBase.quoteIdentifier(order.getName()) + "), " + ReOrder.MIN_ORDER + ") + 1 FROM " + tableQuoted;
+                    req += "COALESCE(MAX(" + SQLBase.quoteIdentifier(orderF.getName()) + "), " + ReOrder.MIN_ORDER + ") + 1 FROM " + tableQuoted;
                 } else {
                     req += " VALUES (";
                     req += questionMarks;
                     req += ")";
+                }
+        }
         // set fields values
         int i = 0;
         for (final Object value : values) {
             // nothing to set if there's no corresponding '?'
-            if (value != SQL_DEFAULT) {
+            if (value != SQL_DEFAULT && !(value instanceof SQLExpression)) {
                 final Object toIns;
                 if (value instanceof SQLRowValues) {
                     // TODO if we already point to some row, archive it
                     toIns = ((SQLRowValues) value).insert().getIDNumber();
                 } else
+        }
         return Tuple2.create(pStmt, fieldsNames);
+    }
     private static String getFieldValue(final Object value) {
-        return value == SQL_DEFAULT ? "DEFAULT" : "?";
+        if (value == SQL_DEFAULT)
+            return "DEFAULT";
+        else if (value instanceof SQLExpression)
+            return ((SQLExpression) value).getSQL();
+        else
+            return "?";
+    }
     @Override
     public SQLTableModifiedListener createTableListener(SQLDataListener l) {
         return new SQLTableListenerData<SQLRowValues>(this, l);
+    }
     public static final SQLRowValues trim(final SQLRowValues r) {
         return new SQLRowValues(r, ForeignCopyMode.COPY_ID_OR_RM);
+    }
+    public static final List<SQLRowValues> toImmutableList(final Collection<SQLRowValues> rows) {
+        return toImmutableList(rows, new ArrayList<>(rows.size()));
+    }
+    public static final List<SQLRowValues> toImmutableList(final Collection<SQLRowValues> rows, final List<SQLRowValues> res) {
+        for (final SQLRowValues v : rows)
+            res.add(v.toImmutable());
+        return Collections.unmodifiableList(res);
+    }
+}

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

svn://code.openconcerto.org/openconcerto

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