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 org.openconcerto.sql.Configuration;

import org.openconcerto.sql.model.SQLDataSource;

import org.openconcerto.sql.model.SQLFilter;

import org.openconcerto.sql.model.SQLFilterListener;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLRowValuesListFetcher;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.TableRef;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.model.graph.Path;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.CompareUtils;

import org.openconcerto.utils.Tuple2;

import java.util.Collection;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.ThreadSafe;

// une fill request qui utilise le filtre

@ThreadSafe

public abstract class FilteredFillSQLRequest extends BaseFillSQLRequest {

    // make sure that all rows are from the same table

    static protected final Tuple2<SQLTable, Set<Number>> rows2ids(final Collection<SQLRow> rows) {

        final Set<SQLTable> tables = new HashSet<SQLTable>();

        final Set<Number> ids = new HashSet<Number>(rows.size());

        for (final SQLRow r : rows) {

            tables.add(r.getTable());

            ids.add(r.getIDNumber());

        }

        final SQLTable filterTable = CollectionUtils.getSole(tables);

        if (filterTable == null)

            throw new IllegalStateException("not 1 table: " + rows);

        return Tuple2.create(filterTable, ids);

    }

    static protected final SQLFilter getDefaultFilter() {

        final Configuration conf = Configuration.getInstance();

        return conf == null ? null : conf.getFilter();

    }

    static protected final int getRowCount(final SQLRowValuesListFetcher fetcher) {

        final SQLTable primaryT = fetcher.getGraph().getTable();

        return getRowCount(fetcher.getReq(), primaryT.getDBSystemRoot().getDataSource());

    }

    static public final int getRowCount(final SQLSelect sel, final SQLDataSource ds) {

        return ((Number) ds.executeScalar(sel.getForRowCount())).intValue();

    }

    // never null (but can be <null, null>)

    @GuardedBy("this")

    private Tuple2<Set<SQLRow>, Path> filterInfo;

    private final SQLFilter filter;

    // initially false since we don't listen to filter before calling setFilterEnabled()

    @GuardedBy("this")

    private boolean filterEnabled = false;

    private final SQLFilterListener filterListener;

    {

        this.filterListener = new SQLFilterListener() {

            public void filterChanged(Collection<SQLTable> tables) {

                // when we remove the listener in wasFrozen(), there might already be threads

                // waiting for our lock to notify us. So we must ignore these last few events.

                if (!isFrozen() && CollectionUtils.containsAny(getTables(), tables))

                    updateFilterWhere(true);

            }

        };

    }

    public FilteredFillSQLRequest(final SQLRowValues graph, Where w) {

        super(graph, w);

        this.filter = getDefaultFilter();

        this.filterInfo = Tuple2.create(null, null);

        this.setFilterEnabled(true);

    }

    // ATTN if freeze is true freeze() must be called right after (cannot be called here since

    // subclasses aren't finished)

    protected FilteredFillSQLRequest(FilteredFillSQLRequest req, final boolean freeze) {

        super(req);

        // otherwise each superclass will lock the source, resulting in an inconsistent view

        assert Thread.holdsLock(req);

        this.filter = req.filter;

        this.filterInfo = req.filterInfo;

        // don't add listener and update our info (which leave us inconsistent until

        // freeze() is called)

        if (freeze)

            this.filterEnabled = req.filterEnabled;

        else

            this.setFilterEnabled(req.filterEnabled);

    }

    @Override

    protected void wasFrozen() {

        super.wasFrozen();

        this.getFilter().rmListener(this.filterListener);

    }

    protected final SQLFilter getFilter() {

        return this.filter;

    }

    public final void setFilterEnabled(boolean b) {

        final SQLFilter filter = this.getFilter();

        b = filter == null ? false : b;

        final boolean changed;

        synchronized (this) {

            checkFrozen();

            if (this.filterEnabled != b) {

                // since filter is final and filterEnabled is initially false

                assert filter != null;

                this.filterEnabled = b;

                if (this.filterEnabled)

                    filter.addWeakListener(this.filterListener);

                else

                    filter.rmListener(this.filterListener);

                changed = updateFilterWhere(false);

            } else {

                changed = false;

            }

        }

        if (changed)

            fireWhereChange();

    }

    // fire=false allow to call this method with our lock

    private boolean updateFilterWhere(final boolean fire) {

        final boolean changed;

        synchronized (this) {

            if (this.filterEnabled) {

                changed = this.setFilterWhere(getFilter().getLeaf(), getFilter().getPath(getPrimaryTable()));

            } else {

                changed = this.setFilterWhere(null, null);

            }

        }

        if (fire && changed)

            fireWhereChange();

        return changed;

    }

    private synchronized boolean setFilterWhere(final Set<SQLRow> w, final Path p) {

        checkFrozen();

        final boolean changed = !CompareUtils.equals(this.filterInfo.get0(), w) || !CompareUtils.equals(this.filterInfo.get1(), p);

        if (changed) {

            // shall we filter : w==null => no filter selected, p==null => filter doesn't affect us

            if (w == null || p == null) {

                this.filterInfo = Tuple2.create(null, null);

            } else {

                this.filterInfo = Tuple2.create((Set<SQLRow>) new HashSet<SQLRow>(w), p);

            }

        }

        return changed;

    }

    public final SQLRowValues getValues(int id) {

        final List<SQLRowValues> res = getValues(new Where(this.getPrimaryTable().getKey(), "=", id));

        return getSole(res, id);

    }

    public final List<SQLRowValues> getValuesFromIDs(Collection<? extends Number> ids) {

        return getValues(ids == null ? null : Where.inValues(this.getPrimaryTable().getKey(), ids));

    }

    protected final <T> T getSole(final List<T> res, int id) {

        if (res.size() > 1)

            throw new IllegalStateException("there's more than one line which has ID " + id + " for " + this + " : " + res);

        return CollectionUtils.getFirst(res);

    }

    public int getValuesCount() {

        return getRowCount(this.getFetcher());

    }

    public final List<SQLRowValues> getValues() {

        return this.getValues(null);

    }

    protected List<SQLRowValues> getValues(final Where w) {

        return getFetcher().fetch(w);

    }

    protected final List<SQLRowValues> fetchValues(final SQLRowValuesListFetcher f, final Where w) {

        return this.setupFetcher(f).fetch(w);

    }

    @Override

    protected SQLSelect transformSelect(SQLSelect sel) {

        final Tuple2<Set<SQLRow>, Path> filterInfo = getFilterInfo();

        // the filter is not empty and it concerns us

        if (filterInfo.get1() != null) {

            final Tuple2<SQLTable, Set<Number>> tableNids = rows2ids(filterInfo.get0());

            final SQLTable filterTable = tableNids.get0();

            final Path path = filterInfo.get1();

            final TableRef lastAlias = sel.assurePath(getPrimaryTable().getName(), path);

            if (filterTable != lastAlias.getTable())

                throw new IllegalStateException("table mismatch: " + filterTable + " is not from " + lastAlias + ": " + lastAlias.getTable());

            sel.andWhere(new Where(lastAlias.getKey(), tableNids.get1()));

        }

        return super.transformSelect(sel);

    }

    /**

     * The filter row acting on this request.

     *

     * @return the row or <code>null</code> if there's no filter or the filter do not affect this.

     */

    public final Set<SQLRow> getFilterRows() {

        return this.getFilterInfo().get0();

    }

    // when the filter doesn't affect us, do not return the filter row

    private synchronized final Tuple2<Set<SQLRow>, Path> getFilterInfo() {

        return this.filterInfo;

    }

    // the where applied to all request (as opposed to the one passed to getFillRequest())

    public final Where getInstanceWhere() {

        return this.getFetcher().getReq().getWhere();

    }

}