WebSVN - OpenConcerto - Diff - Rev 142 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/request/UpdateBuilder.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.SQLSyntax;
 import org.openconcerto.sql.model.SQLSystem;
 import org.openconcerto.sql.model.SQLTable;
 import org.openconcerto.sql.model.TableRef;
 import org.openconcerto.sql.model.Where;
-import org.openconcerto.utils.Tuple3.List3;
+import org.openconcerto.sql.users.User;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
+ *
  * @author Sylvain
  */
 public class UpdateBuilder {
+    public final class VirtualJoin {
+        private final String alias, definition, updateTableField, op, joinedTableField;
+        protected VirtualJoin(final String alias, final String definition, final String updateTableField, final String op, final String joinedTableField) {
+            super();
+            this.alias = alias;
+            this.definition = definition;
+            this.updateTableField = updateTableField;
+            this.op = op;
+            this.joinedTableField = joinedTableField;
+        }
+        public final String getAlias() {
+            return this.alias;
+        }
+        public final String getDefinition() {
+            return this.definition;
+        }
+        public final String getUpdateTableField() {
+            return this.updateTableField;
+        }
+        public final String getJoinedTableField() {
+            return this.joinedTableField;
+        }
+        protected final String getWhere() {
+            final SQLName joinedTableFieldName = new SQLName(getAlias(), this.getJoinedTableField());
+            return Where.comparison(getSyntax(), getTable().getField(this.getUpdateTableField()).getSQLNameUntilDBRoot(false).quote(), this.op, joinedTableFieldName.quote());
+        }
+        protected final String getSelect(final String value) {
+            return "( select " + value + " from " + this.getDefinition() + " where " + this.getWhere() + " )";
+        }
+    }
     private final SQLTable t;
     private final Map<String, String> fields;
+    private boolean addMetaData;
+    private User user;
     private final List<String> tables;
     private Where where;
-    // alias -> definition, t field, field of the joined table
+    // alias -> VirtualJoin
-    private final Map<String, List3<String>> virtualJoins;
+    private final Map<String, VirtualJoin> virtualJoins;
     private final Map<String, Boolean> virtualJoinsOptimized;
-    public UpdateBuilder(SQLTable t) {
+    public UpdateBuilder(final SQLTable t) {
         super();
         this.t = t;
-        this.fields = new LinkedHashMap<String, String>();
+        this.fields = new LinkedHashMap<>();
+        // this class is low-level and callers don't expect it to automatically add fields
+        this.addMetaData = false;
+        this.user = null;
-        this.tables = new ArrayList<String>();
+        this.tables = new ArrayList<>();
-        this.virtualJoins = new HashMap<String, List3<String>>(4);
+        this.virtualJoins = new HashMap<>(4);
-        this.virtualJoinsOptimized = new HashMap<String, Boolean>(4);
+        this.virtualJoinsOptimized = new HashMap<>(4);
+    }
     public final SQLTable getTable() {
         return this.t;
+    }
+    public final UpdateBuilder setAddMetaData(final boolean addMetaData) {
+        this.addMetaData = addMetaData;
+        return this;
+    }
+    public final UpdateBuilder setUser(final User user) {
+        this.setAddMetaData(true);
+        this.user = user;
+        return this;
+    }
     public final SQLSyntax getSyntax() {
         return SQLSyntax.get(this.getTable());
+    }
     private final void checkField(final String field) {
      * @see #addVirtualJoin(String, String, boolean, String, String, boolean)
      */
     public final UpdateBuilder setFromVirtualJoin(final String field, final String joinAlias, final String value) {
         final String val;
         if (this.isJoinVirtual(joinAlias)) {
-            final List3<String> virtualJoin = this.virtualJoins.get(joinAlias);
+            final VirtualJoin virtualJoin = this.virtualJoins.get(joinAlias);
-            val = "( select " + value + " from " + virtualJoin.get0() + " where " + getWhere(joinAlias, virtualJoin) + " )";
+            val = virtualJoin.getSelect(value);
         } else {
             val = value;
+        }
         return this.set(field, val);
+    }
-    private final String getWhere(final String joinAlias, final List3<String> virtualJoin) {
-        assert this.virtualJoins.get(joinAlias) == virtualJoin;
-        final SQLName joinedTableFieldName = new SQLName(joinAlias, virtualJoin.get2());
-        return getTable().getField(virtualJoin.get1()).getSQLNameUntilDBRoot(false) + " = " + joinedTableFieldName.quote();
-    }
     public final Set<String> getFieldsNames() {
         return this.fields.keySet();
+    }
     public final boolean isEmpty() {
         return this.fields.isEmpty();
+    }
-    public final void setWhere(Where where) {
+    public final void setWhere(final Where where) {
         this.where = where;
+    }
     public final Where getWhere() {
         return this.where;
     /**
      * Add table to this UPDATE.
+     *
      * @param definition the table to add, ie either a table name or a sub-select.
      * @param rawAlias the SQL alias, can be <code>null</code>, e.g. <code>"t"</code>.
+     * @see #addVirtualJoin(String, String, boolean, String, String, boolean)
      */
     public final void addRawTable(final String definition, final String rawAlias) {
         this.tables.add(definition + (rawAlias == null ? "" : " " + rawAlias));
+    }
     public final void addVirtualJoin(final String definition, final String alias, final String joinedTableField) {
         this.addVirtualJoin(definition, alias, false, joinedTableField, getTable().getKey().getName());
+    }
     public final void addVirtualJoin(final String definition, final String alias, final boolean aliasAlreadyDefined, final String joinedTableField, final String field) {
-        this.addVirtualJoin(definition, alias, aliasAlreadyDefined, joinedTableField, field, true);
+        this.addVirtualJoin(definition, alias, aliasAlreadyDefined, joinedTableField, "=", field, true);
+    }
+    public final VirtualJoin addVirtualJoin(final TableRef t, final String joinedTableField, final String op, final String field) {
+        return this.addVirtualJoin(t.getSQL(), t.getAlias(), true, joinedTableField, op, field, true);
+    }
+    public final VirtualJoin addVirtualJoin(final String definition, final String alias, final boolean aliasAlreadyDefined, final String joinedTableField, final String op, final String field) {
+        return this.addVirtualJoin(definition, alias, aliasAlreadyDefined, joinedTableField, op, field, true);
+    }
     /**
      * Add a virtual join to this UPDATE. Some systems don't support
      * {@link #addRawTable(String, String) multiple tables}, this method is virtual in the sense
      *        the <code>definition</code>. Needed for
      *        {@link SQLSyntax#getConstantTable(List, String, List) constant tables} since the alias
      *        is already inside the definition, e.g. ( VALUES ... ) as "constTable"(field1, ...) .
      * @param joinedTableField the field in the joined table that will match <code>field</code> of
      *        the update {@link #getTable() table}.
+     * @param op the operator to compare <code>joinedTableField</code> and <code>field</code>.
      * @param field the field in the update {@link #getTable() table}.
      * @param optimize if <code>true</code> and if the system supports it, the virtual join will use
      *        the multiple table support.
+     * @return the new join.
      */
-    public final void addVirtualJoin(final String definition, final String alias, final boolean aliasAlreadyDefined, final String joinedTableField, final String field, final boolean optimize) {
+    public final VirtualJoin addVirtualJoin(final String definition, final String alias, final boolean aliasAlreadyDefined, final String joinedTableField, final String op, final String field,
+            final boolean optimize) {
         if (alias == null)
             throw new NullPointerException("No alias");
         if (this.virtualJoins.containsKey(alias))
             throw new IllegalStateException("Alias already exists : " + alias);
         this.checkField(field);
         final String completeDef = aliasAlreadyDefined ? definition : definition + ' ' + SQLBase.quoteIdentifier(alias);
-        this.virtualJoins.put(alias, new List3<String>(completeDef, field, joinedTableField));
+        final VirtualJoin res = new VirtualJoin(alias, completeDef, field, op, joinedTableField);
+        this.virtualJoins.put(alias, res);
         this.virtualJoinsOptimized.put(alias, optimize);
+        return res;
+    }
     public final String asString() {
         // add tables and where for virtual joins
         Where computedWhere = this.where;
-        final List<String> computedTables = new ArrayList<String>(this.tables);
+        final List<String> computedTables = new ArrayList<>(this.tables);
-        for (final Entry<String, List3<String>> e : this.virtualJoins.entrySet()) {
+        for (final Entry<String, VirtualJoin> e : this.virtualJoins.entrySet()) {
             final String joinAlias = e.getKey();
-            final List3<String> virtualJoin = e.getValue();
+            final VirtualJoin virtualJoin = e.getValue();
             final Where w;
             if (this.isJoinVirtual(joinAlias)) {
+                // use same WHERE as setFromVirtualJoin()
-                w = Where.createRaw(SQLBase.quoteIdentifier(virtualJoin.get1()) + " in ( select " + SQLBase.quoteIdentifier(virtualJoin.get2()) + " from " + virtualJoin.get0() + " )");
+                w = Where.createRaw("EXISTS " + virtualJoin.getSelect("1"));
             } else {
-                w = Where.createRaw(getWhere(joinAlias, virtualJoin));
+                w = Where.createRaw(virtualJoin.getWhere());
-                computedTables.add(virtualJoin.get0());
+                computedTables.add(virtualJoin.getDefinition());
+            }
             computedWhere = w.and(computedWhere);
+        }
         final String w = computedWhere == null ? "" : "\nWHERE " + computedWhere.getClause();
+        final Map<String, String> execFields;
+        if (this.addMetaData) {
+            execFields = new HashMap<>(this.fields);
+            setFieldValue(execFields, this.getTable().getModifUserField(), this.user == null ? null : this.user.getId());
+            setFieldValue(execFields, this.getTable().getModifDateField(), System.currentTimeMillis());
+        } else {
+            execFields = unmodifiableMap(this.fields);
+        }
-        return "UPDATE " + this.getSyntax().getUpdate(this.getTable(), unmodifiableList(computedTables), unmodifiableMap(this.fields)) + w;
+        return "UPDATE " + this.getSyntax().getUpdate(this.getTable(), unmodifiableList(computedTables), execFields) + w;
+    }
+    static private void setFieldValue(final Map<String, String> vals, final SQLField f, final Object val) {
+        if (f == null)
+            return;
+        vals.put(f.getName(), val == null ? "DEFAULT" : f.getType().toString(val));
+    }
     @Override
     public String toString() {
         return this.getClass().getSimpleName() + ": " + this.asString();

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/request/UpdateBuilder.java - Rev 142 → 182