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.element;

import org.openconcerto.sql.element.SQLElement.ReferenceAction;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLFieldRowProcessor;
import org.openconcerto.sql.model.SQLResultSet;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLSelect;
import org.openconcerto.sql.model.SQLSyntax;
import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.sql.model.SQLType;
import org.openconcerto.sql.model.Where;
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.model.graph.Step;
import org.openconcerto.utils.CollectionUtils;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import org.apache.commons.dbutils.ResultSetHandler;

import net.jcip.annotations.Immutable;

/**
 * A logical link between two elements. It can be a direct foreign {@link Link} or two links through
 * a {@link JoinSQLElement join}. The {@link #getOwner()} needs the {@link #getOwned()}, i.e. if the
 * owner is unarchived the owned will also be unarchived. The owner is responsible for
 * {@link SQLElement#setupLinks(org.openconcerto.sql.element.SQLElement.LinksSetup) setting up} the properties of
 * the link.
 * 
 * @author Sylvain
 */
public final class SQLElementLink {

    public static enum LinkType {
        /** One element is the parent of the other */
        PARENT,
        /** One element is part of the other */
        COMPOSITION,
        /** One element references the other */
        ASSOCIATION
    }

    private final SQLElement owner, owned;
    private final Path path;
    private final LinkType type;
    private final String name;
    // TODO final (see #setAction())
    private ReferenceAction action;

    protected SQLElementLink(SQLElement owner, Path path, SQLElement owned, final LinkType type, final String name, final ReferenceAction action) {
        super();
        final int length = path.length();
        if (length == 0)
            throw new IllegalArgumentException("Empty path");
        if (owner != null && owner.getTable() != path.getFirst() || owned.getTable() != path.getLast())
            throw new IllegalArgumentException("Wrong path : " + path + " not from owner : " + owner + " to owned : " + owned);
        if (!path.isSingleLink())
            throw new IllegalArgumentException("Isn't single link : " + path);
        // either foreign key or join
        if (length > 2)
            throw new IllegalArgumentException("Path too long : " + path);
        final Step lastStep = path.getStep(-1);
        final boolean endsWithForeign = lastStep.getDirection().equals(Direction.FOREIGN);
        if (length == 1) {
            if (!endsWithForeign)
                throw new IllegalArgumentException("Single step path isn't foreign : " + path);
        } else {
            assert length == 2;
            if (!endsWithForeign || !path.getStep(0).getDirection().equals(Direction.REFERENT))
                throw new IllegalArgumentException("Two steps path isn't a join : " + path);
        }
        if (lastStep.getSingleField() == null)
            throw new IllegalArgumentException("Multi-field not yet supported : " + lastStep);
        this.path = path;
        this.owner = owner;
        this.owned = owned;
        if (type == null || action == null)
            throw new NullPointerException();
        this.type = type;
        if (name != null) {
            this.name = name;
        } else if (length == 1) {
            final SQLField singleField = lastStep.getSingleField();
            this.name = singleField != null ? singleField.getName() : lastStep.getSingleLink().getName();
        } else {
            this.name = lastStep.getFrom().getName();
        }
        assert this.getName() != null;
        this.action = action;
    }

    /**
     * The path from the {@link #getOwner() owner} to the {@link #getOwned() owned}. NOTE : the last
     * step is always {@link Direction#FOREIGN}.
     * 
     * @return the path of this link, its {@link Path#length() length} is 1 or 2 for a join.
     */
    public final Path getPath() {
        return this.path;
    }

    public final boolean isJoin() {
        return this.path.length() == 2;
    }

    /**
     * Return the single link.
     * 
     * @return the single foreign link, <code>null</code> if and only if this is a {@link #isJoin()
     *         join} as multi-link paths are invalid.
     */
    public final Link getSingleLink() {
        if (this.isJoin())
            return null;
        final Link res = this.path.getStep(0).getSingleLink();
        // checked in the constructor
        assert res != null;
        return res;
    }

    /**
     * Return the single field of this link.
     * 
     * @return the foreign field of this link, <code>null</code> if and only if this is a
     *         {@link #isJoin() join} as multi-field link are not yet supported.
     */
    public final SQLField getSingleField() {
        final Link l = this.getSingleLink();
        if (l == null)
            return null;
        final SQLField res = l.getSingleField();
        // checked in the constructor
        assert res != null;
        return res;
    }

    public final SQLElement getOwner() {
        return this.owner;
    }

    public final SQLElement getOwned() {
        return this.owned;
    }

    public final JoinSQLElement getJoinElement() {
        if (!this.isJoin())
            return null;
        return (JoinSQLElement) this.getOwner().getElement(this.getPath().getTable(1));
    }

    public final boolean isOwnerTheParent() {
        final boolean owner;
        if (this.getLinkType().equals(LinkType.COMPOSITION))
            owner = true;
        else if (this.getLinkType().equals(LinkType.PARENT))
            owner = false;
        else
            throw new IllegalStateException("Invalid type : " + this.getLinkType());
        return owner;
    }

    public final SQLElement getParent() {
        return this.getParentOrChild(true);
    }

    private final SQLElement getParentOrChild(final boolean parent) {
        return parent == isOwnerTheParent() ? this.getOwner() : this.getOwned();
    }

    public final SQLElement getChild() {
        return this.getParentOrChild(false);
    }

    public final Path getPathToParent() {
        return this.getPathToParentOrChild(true);
    }

    public final Step getStepToParent() {
        return this.getPathToParent().getStep(-1);
    }

    private final Path getPathToParentOrChild(final boolean toParent) {
        return toParent == isOwnerTheParent() ? this.getPath().reverse() : this.getPath();
    }

    public final Path getPathToChild() {
        return this.getPathToParentOrChild(false);
    }

    public final Step getStepToChild() {
        return this.getPathToChild().getStep(-1);
    }

    public final List<SQLRow> getRowsUntilRoot(final Number id) {
        return this.getRowsUntilRoot(id, null).getRows();
    }

    /**
     * Get all rows above the passed row (including it).
     * 
     * @param id the first row.
     * @param fields which fields to fetch, <code>null</code> to fetch all.
     * @return all rows from the passed one to the root.
     */
    public final RecursiveRows getRowsUntilRoot(final Number id, Set<String> fields) {
        return getRecursiveRows(true, id, fields, -1, null);
    }

    public final List<SQLRow> getSubTreeRows(final Number id) {
        return this.getSubTreeRows(id, null).getRows();
    }

    public final RecursiveRows getSubTreeRows(final Number id, final Set<String> fields) {
        return getSubTreeRows(id, fields, -1);
    }

    /**
     * Get all rows beneath the passed root (including it).
     * 
     * @param id the root row.
     * @param fields which fields to fetch, <code>null</code> to fetch all.
     * @param maxLevel the max number of times to go through the link.
     * @return all rows are deterministically ordered (by level, parent order, order ; i.e. root
     *         first).
     */
    public final RecursiveRows getSubTreeRows(final Number id, final Set<String> fields, final int maxLevel) {
        return getRecursiveRows(false, id, fields, maxLevel, getOwned().getTable().getOrderField());
    }

    static private final String findUnusedName(final Collection<String> usedNames, final String base) {
        String res = base;
        int i = 0;
        while (usedNames.contains(res)) {
            res = base + i++;
        }
        return res;
    }

    @Immutable
    static public final class RecursiveRows {

        static public final RecursiveRows ZERO_LEVEL = new RecursiveRows(0, Collections.emptyList(), Collections.emptyMap());

        private final int maxLevel;
        private final List<SQLRow> rows;
        private final Map<SQLRow, List<Number>> cycles;

        RecursiveRows(final int maxLevel, final List<SQLRow> rows, final Map<SQLRow, List<Number>> cycles) {
            super();
            this.maxLevel = maxLevel;
            this.rows = Collections.unmodifiableList(rows);
            // OK since List<Number> are already immutable
            this.cycles = Collections.unmodifiableMap(cycles);
        }

        public final int getMaxLevelRequested() {
            return this.maxLevel;
        }

        public final List<SQLRow> getRows() {
            if (this.getCycles().isEmpty())
                return this.getPartialRows();
            else
                throw new IllegalStateException("Cycle detected : " + this.getCycles());
        }

        public final List<SQLRow> getPartialRows() {
            return this.rows;
        }

        public final Map<SQLRow, List<Number>> getCycles() {
            return this.cycles;
        }
    }

    private final RecursiveRows getRecursiveRows(final boolean foreign, final Number id, Set<String> fields, final int maxLevel, final SQLField orderField) {
        if (this.getOwner() != this.getOwned() || this.isJoin())
            throw new IllegalStateException("Not a recurive link : " + this);
        final SQLTable t = getOwned().getTable();
        final Link singleLink = this.getSingleLink();
        final SQLField singleField = singleLink.getSingleField();
        if (singleField == null)
            throw new UnsupportedOperationException("Multiple fields not yet supported : " + singleLink);
        Objects.requireNonNull(id, "id is null");

        if (maxLevel == 0)
            return RecursiveRows.ZERO_LEVEL;

        final SQLSyntax syntax = t.getDBSystemRoot().getSyntax();

        if (fields == null)
            fields = t.getFieldsName();
        final String recursiveT = "recT";
        // use array to prevent infinite loop
        final String visitedIDsF = findUnusedName(fields, "visitedIDs");
        final String visitedIDsRef = recursiveT + '.' + visitedIDsF;
        final String visitedIDsCount = syntax.getSQLArrayLength(visitedIDsRef);
        // boolean to know about endless loops : we don't stop before visiting a row a second time,
        // but just after
        final String loopF = findUnusedName(fields, "loop");

        // firstly visitedIDsF, secondly optional order, then the asked fields
        final SQLSelect selNonRec = new SQLSelect();
        selNonRec.addRawSelect(syntax.getSQLArray(Collections.singletonList(t.getKey().getFieldRef())), visitedIDsF);
        selNonRec.addRawSelect(SQLType.getBoolean(syntax).toString(Boolean.FALSE), loopF);
        final boolean useOrder = !foreign && orderField != null;
        if (useOrder)
            selNonRec.addRawSelect(syntax.cast("null", orderField.getType().getJavaType()), "parentOrder");
        selNonRec.addAllSelect(t, fields);
        if (!fields.contains(singleField.getName()))
            selNonRec.addSelect(singleField);
        // need PK for SQLRow
        if (!fields.contains(t.getKey().getName()))
            selNonRec.addSelect(t.getKey());
        selNonRec.setWhere(new Where(t.getKey(), "=", id));

        // recursive SELECT
        final StringBuilder recSelect = new StringBuilder("SELECT ");
        recSelect.append(syntax.getSQLArrayAppend(visitedIDsRef, t.getKey().getFieldRef())).append(", ");
        recSelect.append(syntax.getSQLArrayContains(visitedIDsRef, t.getKey().getFieldRef())).append(", ");
        final int index;
        if (useOrder) {
            recSelect.append(recursiveT).append('.').append(orderField.getName()).append(", ");
            index = 3;
        } else {
            index = 2;
        }
        recSelect.append(CollectionUtils.join(selNonRec.getSelect().subList(index, selNonRec.getSelect().size()), ", "));
        recSelect.append("\nFROM ").append(t.getSQLName().quote()).append(", ").append(recursiveT);
        recSelect.append("\nWHERE ");
        if (foreign) {
            recSelect.append(t.getKey().getFieldRef()).append(" = ").append(recursiveT + '.' + singleField.getName());
        } else {
            recSelect.append(singleField.getFieldRef()).append(" = ").append(recursiveT + '.' + t.getKey().getName());
        }
        // avoid infinite loop
        recSelect.append(" and not (").append(recursiveT).append('.').append(loopF).append(')');
        if (t.getUndefinedIDNumber() != null) {
            recSelect.append(" and ").append(new Where(t.getKey(), "!=", t.getUndefinedID()).getClause());
        }
        if (maxLevel > 0) {
            recSelect.append(" and ").append(visitedIDsCount).append(" < ").append(maxLevel);
        }

        String cte = "with recursive " + recursiveT + "(" + CollectionUtils.join(selNonRec.getSelectNames(), ", ") + ") as (\n" + selNonRec.asString() + "\nunion all\n" + recSelect
                + ")\nSELECT * from " + recursiveT + " ORDER BY " + visitedIDsCount;
        if (useOrder) {
            cte += ", 2, " + recursiveT + '.' + orderField.getName();
        }

        final List<String> rsNames = new ArrayList<>(selNonRec.getSelectNames());
        // int[] visited IDs
        rsNames.set(0, null);
        // boolean loop
        rsNames.set(1, null);
        if (useOrder)
            rsNames.set(2, null);

        final List<SQLRow> res = new ArrayList<>();
        final Map<SQLRow, List<Number>> cycleRows = new HashMap<>();
        final Class<? extends Number> keyType = t.getKey().getType().getJavaType().asSubclass(Number.class);
        t.getDBSystemRoot().getDataSource().execute(cte, new ResultSetHandler() {
            @Override
            public Object handle(ResultSet rs) throws SQLException {
                final SQLFieldRowProcessor rowProc = new SQLFieldRowProcessor(t, rsNames);
                while (rs.next()) {
                    final SQLRow row = SQLRow.createFromRS(t, rs, rowProc, true);
                    final boolean looped = rs.getBoolean(2);
                    if (looped) {
                        cycleRows.put(row, SQLResultSet.getList(rs, 1, keyType));
                    } else {
                        res.add(row);
                    }
                }
                return null;
            }
        });
        return new RecursiveRows(maxLevel, res, cycleRows);
    }

    public final LinkType getLinkType() {
        return this.type;
    }

    public final String getName() {
        return this.name;
    }

    public final ReferenceAction getAction() {
        return this.action;
    }

    // use SQLElementLinkSetup
    @Deprecated
    public final void setAction(ReferenceAction action) {
        final List<ReferenceAction> possibleActions = getOwner().getPossibleActions(this.getLinkType(), this.getOwned());
        if (!possibleActions.contains(action))
            throw new IllegalArgumentException("Not allowed : " + action);
        this.action = action;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + this.action.hashCode();
        result = prime * result + this.path.hashCode();
        result = prime * result + this.type.hashCode();
        return result;
    }

    // don't use SQLElement to avoid walking the graph
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final SQLElementLink other = (SQLElementLink) obj;
        return this.action.equals(other.action) && this.path.equals(other.path) && this.type.equals(other.type);
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName() + " '" + this.getName() + "' " + this.getLinkType() + " " + this.getPath();
    }
}