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

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

import java.util.Objects;

import java.util.Set;

import org.apache.commons.dbutils.ResultSetHandler;

import net.jcip.annotations.Immutable;

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

    }