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

    }

}