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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * 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.request;

import static java.util.Collections.unmodifiableList;
import static java.util.Collections.unmodifiableMap;

import org.openconcerto.sql.model.SQLBase;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLName;
import org.openconcerto.sql.model.SQLSelect;
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.sql.users.User;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * Allow to build an UPDATE statement.
 * 
 * @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 -> VirtualJoin
    private final Map<String, VirtualJoin> virtualJoins;
    private final Map<String, Boolean> virtualJoinsOptimized;

    public UpdateBuilder(final SQLTable t) {
        super();
        this.t = t;
        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<>();
        this.virtualJoins = new HashMap<>(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) {
        checkField(field, getTable());
    }

    private final void checkField(final String field, final TableRef t) {
        if (!t.getTable().contains(field))
            throw new IllegalArgumentException("unknown " + field + " in " + t.getSQL());
    }

    private final void checkField(final SQLField field) {
        if (this.getTable() != field.getTable())
            throw new IllegalArgumentException(field + " not in " + this.getTable().getSQLName());
    }

    public final UpdateBuilder set(final String field, final String value) {
        this.checkField(field);
        this.fields.put(field, value);
        return this;
    }

    public final UpdateBuilder setObject(final String fieldName, final Object value) {
        this.fields.put(fieldName, getTable().getField(fieldName).getType().toString(value));
        return this;
    }

    public final UpdateBuilder setObject(final SQLField field, final Object value) {
        this.checkField(field);
        this.fields.put(field.getName(), field.getType().toString(value));
        return this;
    }

    private final boolean isJoinVirtual(final String alias) {
        if (!this.virtualJoins.containsKey(alias))
            throw new IllegalArgumentException("Not a join " + alias);
        return getTable().getServer().getSQLSystem() == SQLSystem.H2 || this.virtualJoinsOptimized.get(alias) == Boolean.FALSE;
    }

    /**
     * Set the passed field to the value of a field from a virtual join.
     * 
     * @param field a field in the {@link #getTable() table} to update.
     * @param joinAlias the alias of the virtual join.
     * @param joinedTableField a field from the joined table.
     * @return this.
     * @see #setFromVirtualJoin(String, String, String)
     */
    public final UpdateBuilder setFromVirtualJoinField(final String field, final String joinAlias, final String joinedTableField) {
        return this.setFromVirtualJoin(field, joinAlias, new SQLName(joinAlias, joinedTableField).quote());
    }

    /**
     * Set the passed field to the passed SQL value from a virtual join.
     * 
     * @param field a field in the {@link #getTable() table} to update.
     * @param joinAlias the alias of the virtual join.
     * @param value the SQL, e.g. a quoted field from the joined table or an arbitrary expression.
     * @return this.
     * @see #setFromVirtualJoinField(String, String, String)
     * @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 VirtualJoin virtualJoin = this.virtualJoins.get(joinAlias);
            val = virtualJoin.getSelect(value);
        } else {
            val = value;
        }
        return this.set(field, val);
    }

    public final Set<String> getFieldsNames() {
        return this.fields.keySet();
    }

    public final boolean isEmpty() {
        return this.fields.isEmpty();
    }

    public final void setWhere(final Where where) {
        this.where = where;
    }

    public final Where getWhere() {
        return this.where;
    }

    public final void addTable(final TableRef t) {
        this.tables.add(t.getSQL());
    }

    /**
     * Add table to this UPDATE.
     * 
     * @param sel the select to add.
     * @param alias the alias, cannot be <code>null</code>, e.g. <code>t</code>.
     */
    public final void addTable(final SQLSelect sel, final String alias) {
        this.addRawTable("( " + sel.asString() + " )", SQLBase.quoteIdentifier(alias));
    }

    /**
     * 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 addBackwardVirtualJoin(final TableRef t, final String joinedTableField) {
        checkField(joinedTableField, t);
        this.addVirtualJoin(t.getSQL(), t.getAlias(), true, joinedTableField, getTable().getKey().getName());
    }

    public final void addForwardVirtualJoin(final TableRef t, final String joinField) {
        checkField(joinField, getTable());
        this.addVirtualJoin(t.getSQL(), t.getAlias(), true, t.getKey().getField().getName(), joinField);
    }

    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);
    }

    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
     * that it emulates the behaviour using sub-queries.
     * 
     * @param definition the definition of a table, e.g. simply "root"."t" or a VALUES expression.
     * @param alias the alias, cannot be <code>null</code>.
     * @param aliasAlreadyDefined if <code>true</code> the <code>alias</code> won't be appended to
     *        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 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);
        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<>(this.tables);
        for (final Entry<String, VirtualJoin> e : this.virtualJoins.entrySet()) {
            final String joinAlias = e.getKey();
            final VirtualJoin virtualJoin = e.getValue();
            final Where w;
            if (this.isJoinVirtual(joinAlias)) {
                // use same WHERE as setFromVirtualJoin()
                w = Where.createRaw("EXISTS " + virtualJoin.getSelect("1"));
            } else {
                w = Where.createRaw(virtualJoin.getWhere());
                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), 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();
    }
}