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

import org.openconcerto.sql.model.SQLRowValuesCluster.Insert;
import org.openconcerto.sql.model.graph.DatabaseGraph;
import org.openconcerto.sql.model.graph.TablesMap;
import org.openconcerto.sql.request.UpdateBuilder;
import org.openconcerto.sql.utils.AlterTable;
import org.openconcerto.sql.utils.ChangeTable;
import org.openconcerto.sql.utils.ChangeTable.ConcatStep;
import org.openconcerto.sql.utils.ChangeTable.FCSpec;
import org.openconcerto.sql.utils.ReOrder;
import org.openconcerto.sql.utils.SQLCreateRoot;
import org.openconcerto.sql.utils.SQLCreateTableBase;
import org.openconcerto.sql.utils.SQLUtils;
import org.openconcerto.sql.utils.SQL_URL;
import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.Tuple2.List2;

import java.net.URISyntaxException;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import net.jcip.annotations.ThreadSafe;

/**
 * The root of a database, in mysql a SQLBase, in postgresql a SQLSchema.
 * 
 * @author Sylvain
 */
@ThreadSafe
public final class DBRoot extends DBStructureItemDB {

    static DBRoot get(SQLBase b, String n) {
        final DBRoot ancestor = b.getDBRoot();
        final DBStructureItemDB parent = ancestor == null ? b.getDB() : ancestor.getParent();
        return (DBRoot) parent.getChild(n);
    }

    DBRoot(DBStructureItemJDBC delegate) {
        super(delegate);
    }

    public final SQLBase getBase() {
        return this.getJDBC().getAncestor(SQLBase.class);
    }

    public SQLTable getTable(String name) {
        return (SQLTable) getJDBC(this.getChild(name));
    }

    protected final Map<String, SQLTable> getTablesMap() {
        return this.getSchema().getChildrenMap();
    }

    public SQLTable getTableDesc(String name) {
        return this.getDescLenient(name, SQLTable.class);
    }

    public SQLTable findTable(String name) {
        return this.findTable(name, false);
    }

    public SQLTable findTable(String name, final boolean mustExist) {
        final SQLTable res = this.getTable(name);
        if (res != null)
            return res;
        else
            return this.getDBSystemRoot().findTable(name, mustExist);
    }

    /**
     * Return the tables of this root.
     * 
     * @return our tables.
     */
    public Set<SQLTable> getTables() {
        return getJDBC().getDescendants(SQLTable.class);
    }

    /**
     * Create the passed table in this root.
     * 
     * @param createTable how to create the table.
     * @return the newly created table.
     * @throws SQLException if an error occurs.
     */
    public final SQLTable createTable(final SQLCreateTableBase<?> createTable) throws SQLException {
        return this.createTable(createTable, null);
    }

    public final SQLTable createTable(final SQLCreateTableBase<?> createTable, final Map<String, ?> undefinedNonDefaultValues) throws SQLException {
        synchronized (this.getDBSystemRoot().getTreeMutex()) {
            this.createTables(Collections.<SQLCreateTableBase<?>, Map<String, ?>> singletonMap(createTable, undefinedNonDefaultValues));
            return this.getTable(createTable.getName());
        }
    }

    public final void createTables(final SQLCreateTableBase<?>... createTables) throws SQLException {
        this.createTables(Arrays.asList(createTables));
    }

    public final void createTables(final Collection<? extends SQLCreateTableBase<?>> createTables) throws SQLException {
        this.createTables(CollectionUtils.fillMap(new HashMap<SQLCreateTableBase<?>, Map<String, ?>>(), createTables), false);
    }

    /**
     * Create the passed tables and undefined rows, then {@link #refetch()}.
     * 
     * @param undefinedNonDefaultValues the undefined row for each table, if the value is
     *        <code>null</code> then no undefined row will be created.
     * @throws SQLException if an error occurs.
     */
    public final void createTables(final Map<? extends SQLCreateTableBase<?>, ? extends Map<String, ?>> undefinedNonDefaultValues) throws SQLException {
        this.createTables(undefinedNonDefaultValues, !Collections.singleton(null).containsAll(undefinedNonDefaultValues.values()));
    }

    private final void createTables(final Map<? extends SQLCreateTableBase<?>, ? extends Map<String, ?>> undefinedNonDefaultValues, final boolean atLeast1UndefRow) throws SQLException {
        final int size = undefinedNonDefaultValues.size();
        if (size == 0)
            return;

        final Set<String> tableNames = new HashSet<String>(size);
        for (final SQLCreateTableBase<?> ct : undefinedNonDefaultValues.keySet())
            tableNames.add(ct.getName());

        SQLUtils.executeAtomic(getDBSystemRoot().getDataSource(), new ConnectionHandlerNoSetup<Object, SQLException>() {
            @Override
            public Object handle(SQLDataSource ds) throws SQLException {
                // don't create foreign constraints now, so we can insert undefined with cycles
                final List<List<String>> createTablesSQL = ChangeTable.cat(undefinedNonDefaultValues.keySet(), getName(), EnumSet.of(ConcatStep.ADD_CONSTRAINT));
                for (final String sql : createTablesSQL.get(0))
                    ds.execute(sql);
                final Map<SQLCreateTableBase<?>, Number> newUndefIDs;
                final Map<SQLTable, SQLCreateTableBase<?>> newTables;
                if (atLeast1UndefRow) {
                    newUndefIDs = new HashMap<SQLCreateTableBase<?>, Number>();
                    newTables = new HashMap<SQLTable, SQLCreateTableBase<?>>();
                    refetch(tableNames);
                } else {
                    newUndefIDs = Collections.emptyMap();
                    newTables = null;
                }
                for (final Entry<? extends SQLCreateTableBase<?>, ? extends Map<String, ?>> e : undefinedNonDefaultValues.entrySet()) {
                    final SQLCreateTableBase<?> createTable = e.getKey();
                    final String tableName = createTable.getName();
                    final Map<String, ?> m = e.getValue();
                    // insert undefined row if requested and record its ID
                    if (m == null) {
                        SQLTable.setUndefID(getSchema(), tableName, null);
                    } else {
                        final SQLTable t = getTable(tableName);
                        newUndefIDs.put(createTable, null);
                        newTables.put(t, createTable);
                        if (t.isRowable()) {
                            final SQLRowValues vals = new SQLRowValues(t, m);
                            if (t.isOrdered())
                                vals.put(t.getOrderField().getName(), ReOrder.MIN_ORDER);
                            for (final SQLField f : t.getContentFields()) {
                                if (!vals.getFields().contains(f.getName()) && f.isNullable() != Boolean.TRUE && f.getDefaultValue() == null) {
                                    final Class<?> javaType = f.getType().getJavaType();
                                    final Object o;
                                    if (String.class.isAssignableFrom(javaType))
                                        o = "";
                                    else if (Number.class.isAssignableFrom(javaType))
                                        o = 0;
                                    else if (Boolean.class.isAssignableFrom(javaType))
                                        o = Boolean.FALSE;
                                    else if (Date.class.isAssignableFrom(javaType))
                                        o = new Date(0);
                                    else
                                        throw new UnsupportedOperationException("cannot find value for " + f.getSQLName());
                                    vals.put(f.getName(), o);
                                }
                            }
                            // PK from the DB, but use our order
                            // don't try to validate since table has neither undefined row nor
                            // constraints
                            final SQLRow undefRow = vals.getGraph().store(new Insert(false, true), false).getStoredRow(vals);
                            SQLTable.setUndefID(getSchema(), tableName, undefRow.getID());
                            newUndefIDs.put(createTable, undefRow.getIDNumber());
                        }
                    }
                }
                // update undefined rows pointing to other undefined rows
                // set default value for created foreign fields
                for (final Entry<SQLCreateTableBase<?>, Number> e : newUndefIDs.entrySet()) {
                    final SQLCreateTableBase<?> createTable = e.getKey();
                    final SQLTable t = getTable(createTable.getName());

                    final Number undefID = e.getValue();
                    final UpdateBuilder update;
                    if (undefID != null) {
                        update = new UpdateBuilder(t);
                        update.setWhere(new Where(t.getKey(), "=", undefID));
                    } else {
                        update = null;
                    }

                    final AlterTable alterTable = new AlterTable(t);
                    for (final FCSpec fc : createTable.getForeignConstraints()) {
                        if (fc.getCols().size() == 1) {
                            final SQLTable targetT = t.getDescLenient(fc.getRefTable(), SQLTable.class);
                            final Number foreignUndefID = newUndefIDs.get(newTables.get(targetT));
                            if (foreignUndefID != null) {
                                final String ffName = fc.getCols().get(0);
                                final String foreignUndefIDSQL = t.getField(ffName).getType().toString(foreignUndefID);
                                alterTable.alterColumnDefault(ffName, foreignUndefIDSQL);
                                update.set(ffName, foreignUndefIDSQL);
                            }
                        }
                    }

                    if (update != null && !update.isEmpty())
                        ds.execute(update.asString());
                    if (!alterTable.isEmpty())
                        ds.execute(alterTable.asString());
                }
                for (final String sql : createTablesSQL.get(1))
                    ds.execute(sql);
                // always execute updateVersion() after setUndefID() to avoid DB transactions
                // deadlock since setUndefID() itself ends with updateVersion().
                getSchema().updateVersion();
                return null;
            }
        });
        this.refetch(tableNames);
    }

    public SQLField getField(String name) {
        return this.getDesc(name, SQLField.class);
    }

    /**
     * Return the value of a metadata for this root.
     * 
     * @param name name of the metadata, eg "Customer".
     * @return value of the metadata or <code>null</code> if it doesn't exist, eg "ACME, inc".
     */
    public final String getMetadata(final String name) {
        return getSchema().getFwkMetadata(name);
    }

    // since by definition DBRoot is one level above SQLTable, there's only one schema below it
    public final SQLSchema getSchema() {
        return (SQLSchema) this.getJDBC().getNonNullDBParent();
    }

    /**
     * Set the value of a metadata.
     * 
     * @param name name of the metadata, eg "Customer".
     * @param value value of the metadata, eg "ACME, inc".
     * @return <code>true</code> if the value was set, <code>false</code> otherwise.
     * @throws SQLException if an error occurs while setting the value.
     */
    public final boolean setMetadata(final String name, final String value) throws SQLException {
        return getSchema().setFwkMetadata(name, getBase().quoteString(value));
    }

    public final DatabaseGraph getGraph() {
        return this.getDBSystemRoot().getGraph();
    }

    /**
     * Refresh this from the database.
     * 
     * @throws SQLException if an error occurs.
     */
    public void refetch() throws SQLException {
        this.refetch(null);
    }

    /**
     * Refetch one table.
     * 
     * @param tableName the name of the table, not <code>null</code>.
     * @return the refreshed table, <code>null</code> if it doesn't exist.
     * @throws SQLException if an error occurs.
     */
    public SQLTable refetchTable(final String tableName) throws SQLException {
        if (tableName == null) {
            throw new NullPointerException("Null table");
        } else {
            return this.getSchema().fetchTable(tableName);
        }
    }

    public void refetch(final Set<String> tableNames) throws SQLException {
        this.getBase().fetchTables(TablesMap.createFromTables(this.getSchema().getName(), tableNames));
    }

    public final SQLCreateRoot getDefinitionSQL() {
        return this.getDefinitionSQL(getDBSystemRoot().getSyntax());
    }

    public final SQLCreateRoot getDefinitionSQL(final SQLSyntax s) {
        return this.getDefinitionSQL(s, true);
    }

    public final SQLCreateRoot getDefinitionSQL(final SQLSyntax s, final boolean withTables) {
        final SQLCreateRoot res = new SQLCreateRoot(s, this.getName());
        if (withTables) {
            // order by name to be able to do diffs
            for (final SQLTable table : new TreeMap<String, SQLTable>(this.getTablesMap()).values()) {
                res.addTable(table.getCreateTable(s));
            }
        }
        return res;
    }

    public final String equalsDesc(final DBRoot o) {
        return this.equalsDesc(o, null);
    }

    public final String equalsDesc(final DBRoot o, final SQLSyntax otherSystem) {
        if (this == o)
            return null;
        if (null == o)
            return "other is null";

        final Map<String, SQLTable> thisTables = this.getTablesMap();
        final Map<String, SQLTable> oTables = o.getTablesMap();

        if (!thisTables.keySet().equals(oTables.keySet()))
            return "unequal table names: " + thisTables.keySet() + " != " + oTables.keySet();

        for (final Entry<String, SQLTable> e : thisTables.entrySet()) {
            final String name = e.getKey();
            final SQLTable t = e.getValue();
            final String eqDesc = t.equalsDesc(oTables.get(name), otherSystem, true);
            if (eqDesc != null)
                return "unequal " + name + ": " + eqDesc;
        }
        return null;
    }

    /**
     * Return the url pointing to this root.
     * 
     * @return the url or <code>null</code> if this cannot be represented as an {@link SQL_URL} (eg
     *         jdbc:h2:file:/a/b/c).
     */
    public final SQL_URL getURL() {
        // check that our name doesn't contain a path, otherwise we would lose it
        // e.g. dbserv:8084/~/sample
        final List2<String> hostAndPath = this.getServer().getHostnameAndPath();
        final String hostname = hostAndPath.get0();
        // TODO return JDBCUrl
        if (hostname == null || hostAndPath.get1() != null)
            return null;
        final SQLSystem system = this.getServer().getSQLSystem();
        String url = system.name().toLowerCase() + "://" + this.getDBSystemRoot().getDataSource().getUsername() + "@" + hostname + "/";
        // handle systems w/o systemRoot
        if (system.getDBLevel(DBSystemRoot.class) != HierarchyLevel.SQLSERVER) {
            url += this.getDBSystemRoot().getName() + "/";
        }
        url += this.getName();
        try {
            return SQL_URL.create(url);
        } catch (URISyntaxException e) {
            // should not happen
            throw new IllegalStateException("could not produce url for " + this, e);
        }
    }

    /**
     * A string with the content of this root.
     * 
     * <pre>
     *   /TYPE_COURANT/
     *   ID_TYPE_COURANT t: 4 def: null
     *   LABEL t: 12 def: 
     *   ARCHIVE t: 4 def: 0
     *   ORDRE t: 4 def: 1
     * </pre>
     * 
     * @return the content of this.
     */
    public String dump() {
        String res = "";
        for (final SQLTable table : new TreeMap<String, SQLTable>(this.getTablesMap()).values()) {
            res += table + "\n";
            for (final SQLField f : new TreeMap<String, SQLField>(table.getChildrenMap()).values()) {
                res += f.getName() + " t: " + f.getType() + " def: " + f.getDefaultValue() + "\n";
            }
            res += "\n";
        }
        return res;
    }
}