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

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 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 static org.openconcerto.sql.TM.getTM;

import org.openconcerto.sql.Configuration;

import org.openconcerto.sql.FieldExpander;

import org.openconcerto.sql.Log;

import org.openconcerto.sql.PropsConfiguration;

import org.openconcerto.sql.TM;

import org.openconcerto.sql.element.SQLElementLink.LinkType;

import org.openconcerto.sql.element.TreesOfSQLRows.LinkToCut;

import org.openconcerto.sql.model.DBStructureItemNotFound;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowMode;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLRowValues.CreateMode;

import org.openconcerto.sql.model.SQLRowValues.ForeignCopyMode;

import org.openconcerto.sql.model.SQLRowValuesCluster;

import org.openconcerto.sql.model.SQLRowValuesCluster.DiffResult;

import org.openconcerto.sql.model.SQLRowValuesCluster.State;

import org.openconcerto.sql.model.SQLRowValuesCluster.StopRecurseException;

import org.openconcerto.sql.model.SQLRowValuesCluster.StoreMode;

import org.openconcerto.sql.model.SQLRowValuesCluster.WalkOptions;

import org.openconcerto.sql.model.SQLRowValuesListFetcher;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLSelect.ArchiveMode;

import org.openconcerto.sql.model.SQLSelect.LockStrength;

import org.openconcerto.sql.model.SQLSyntax;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.SQLTable.FieldGroup;

import org.openconcerto.sql.model.SQLTable.VirtualFields;

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

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

import org.openconcerto.sql.model.graph.SQLKey.Type;

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

import org.openconcerto.sql.request.ComboSQLRequest;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.sql.request.SQLCache;

import org.openconcerto.sql.request.SQLFieldTranslator;

import org.openconcerto.sql.sqlobject.SQLTextCombo;

import org.openconcerto.sql.ui.light.CustomRowEditor;

import org.openconcerto.sql.ui.light.GroupToLightUIConvertor;

import org.openconcerto.sql.ui.light.LightEditFrame;

import org.openconcerto.sql.ui.light.LightUIPanelFiller;

import org.openconcerto.sql.users.rights.UserRightsManager;

import org.openconcerto.sql.utils.SQLUtils;

import org.openconcerto.sql.utils.SQLUtils.SQLFactory;

import org.openconcerto.sql.view.EditFrame;

import org.openconcerto.sql.view.EditPanel.EditMode;

import org.openconcerto.sql.view.list.IListeAction;

import org.openconcerto.sql.view.list.SQLTableModelColumn;

import org.openconcerto.sql.view.list.SQLTableModelColumnPath;

import org.openconcerto.sql.view.list.SQLTableModelSource;

import org.openconcerto.sql.view.list.SQLTableModelSourceOffline;

import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;

import org.openconcerto.ui.group.Group;

import org.openconcerto.ui.light.ComboValueConvertor;

import org.openconcerto.ui.light.IntValueConvertor;

import org.openconcerto.ui.light.LightUIComboBox;

import org.openconcerto.ui.light.LightUIElement;

import org.openconcerto.ui.light.LightUIFrame;

import org.openconcerto.ui.light.LightUIPanel;

import org.openconcerto.ui.light.StringValueConvertor;

import org.openconcerto.utils.CollectionMap2Itf.SetMapItf;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.CompareUtils;

import org.openconcerto.utils.ExceptionHandler;

import org.openconcerto.utils.ExceptionUtils;

import org.openconcerto.utils.LinkedListMap;

import org.openconcerto.utils.ListMap;

import org.openconcerto.utils.NumberUtils;

import org.openconcerto.utils.RTInterruptedException;

import org.openconcerto.utils.RecursionType;

import org.openconcerto.utils.ReflectUtils;

import org.openconcerto.utils.SetMap;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.Value;

import org.openconcerto.utils.cache.CacheResult;

import org.openconcerto.utils.cc.IClosure;

import org.openconcerto.utils.cc.ITransformer;

import org.openconcerto.utils.cc.Transformer;

import org.openconcerto.utils.change.ListChangeIndex;

import org.openconcerto.utils.change.ListChangeRecorder;

import org.openconcerto.utils.i18n.Grammar;

import org.openconcerto.utils.i18n.Grammar_fr;

import org.openconcerto.utils.i18n.NounClass;

import org.openconcerto.utils.i18n.Phrase;

import java.awt.Component;

import java.lang.reflect.Constructor;

import java.math.BigDecimal;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.IdentityHashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.SortedMap;

import java.util.concurrent.atomic.AtomicReference;

import java.util.logging.Level;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.text.JTextComponent;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.Immutable;

/**

 * Décrit comment manipuler un élément de la BD (pas forcément une seule table, voir

 * privateForeignField).

 *

 * @author ilm

 */

public abstract class SQLElement {

    private static Phrase createPhrase(String singular, String plural) {

        final NounClass nounClass;

        final String base;

        if (singular.startsWith("une ")) {

            nounClass = NounClass.FEMININE;

            base = singular.substring(4);

        } else if (singular.startsWith("un ")) {

            nounClass = NounClass.MASCULINE;

            base = singular.substring(3);

        } else {

            nounClass = null;

            base = singular;

        }

        final Phrase res = new Phrase(Grammar_fr.getInstance(), base, nounClass);

        if (nounClass != null)

            res.putVariantIfDifferent(Grammar.INDEFINITE_ARTICLE_SINGULAR, singular);

        res.putVariantIfDifferent(Grammar.PLURAL, plural);

        return res;

    }

    // from the most loss of information to the least.

    public static enum ReferenceAction {

        /** If a referenced row is archived, empty the foreign field */

        SET_EMPTY,

        /** If a referenced row is archived, archive this row too */

        CASCADE,

        /** If a referenced row is to be archived, abort the operation */

        RESTRICT

    }

    static final public String DEFAULT_COMP_ID = "default component code";

    /**

     * If this value is passed to the constructor, {@link #createCode()} will only be called the

     * first time {@link #getCode()} is. This allow the method to use objects passed to the

     * constructor of a subclass.

     */

    static final public String DEFERRED_CODE = new String("deferred code");

    @GuardedBy("this")

    private SQLElementDirectory directory;

    private Phrase defaultName;

    private final SQLTable primaryTable;

    // used as a key in SQLElementDirectory so it should be immutable

    private String code;

    private ComboSQLRequest combo;

    private ListSQLRequest list;

    private SQLTableModelSourceOnline tableSrc;

    private final ListChangeRecorder<IListeAction> rowActions;

    private final LinkedListMap<String, ITransformer<Tuple2<SQLElement, String>, SQLComponent>> components;

    // links

    private SQLElementLinks ownedLinks;

    private SQLElementLinks otherLinks;

    // keep it for now as joins are disallowed (see initFF())

    private String parentFF;

    // lazy creation

    @GuardedBy("this")

    private SQLCache<SQLRow, Object> modelCache;

    private final Map<String, JComponent> additionalFields;

    private final List<SQLTableModelColumn> additionalListCols;

    @GuardedBy("this")

    private List<String> mdPath;

    private Group defaultGroup;

    private Group groupForCreation;

    private Group groupForModification;

    @Deprecated

    public SQLElement(String singular, String plural, SQLTable primaryTable) {

        this(primaryTable, createPhrase(singular, plural));

    }

    public SQLElement(SQLTable primaryTable) {

        this(primaryTable, null);

    }

    public SQLElement(final SQLTable primaryTable, final Phrase name) {

        this(primaryTable, name, null);

    }

    public SQLElement(final SQLTable primaryTable, final Phrase name, final String code) {

        super();

        if (primaryTable == null) {

            throw new DBStructureItemNotFound("table is null for " + this.getClass());

        }

        this.primaryTable = primaryTable;

        this.setDefaultName(name);

        this.code = code == null ? createCode() : code;

        this.combo = null;

        this.list = null;

        this.rowActions = new ListChangeRecorder<IListeAction>(new ArrayList<IListeAction>());

        this.resetRelationships();

        this.components = new LinkedListMap<String, ITransformer<Tuple2<SQLElement, String>, SQLComponent>>();

        this.modelCache = null;

        // the components should always be in the same order

        this.additionalFields = new LinkedHashMap<String, JComponent>();

        this.additionalListCols = new ArrayList<SQLTableModelColumn>();

        this.mdPath = Collections.emptyList();

    }

    public void destroy() {

    }

    /**

     * Should return the code for this element. This method is only called if the <code>code</code>

     * parameter of the constructor is <code>null</code>. This implementation returns a string

     * containing the {@link Class#getName() full name} of the class and the {@link #getTable()

     * table} name to handle a single class being used for multiple tables. NOTE: this method is

     * also needed, since a subclass constructor cannot pass <code>this.getClass().getName()</code>

     * as the code parameter to <code>super</code>.

     *

     * @return the default code for this element.

     */

    protected String createCode() {

        return getClass().getName() + "-" + getTable().getName();

    }

    public Group getGroupForCreation() {

        if (this.groupForCreation != null) {

            return this.groupForCreation;

        }

        return getDefaultGroup();

    }

    public Group getGroupForModification() {

        if (this.groupForModification != null) {

            return this.groupForModification;

        }

        return getDefaultGroup();

    }

    public Group getDefaultGroup() {

        return this.defaultGroup;

    }

    public void setDefaultGroup(Group defaultGroup) {

        this.defaultGroup = defaultGroup;

    }

    /**

     * Get the group based on the edit mode

     *

     * @param editMode

     * @return

     */

    public Group getEditGroup(final EditMode editMode) {

        if (editMode.equals(EditMode.CREATION)) {

            return this.getGroupForCreation();

        } else {

            return this.getGroupForModification();

        }

    }

    /**

     * Override this function in an element to show default values in edit frame

     *

     * @param token - The security token of session

     *

     * @return a default SQLRowValues

     */

    public SQLRowValues createDefaultRowValues(final String token) {

        return new SQLRowValues(getTable());

    }

    /**

     * Create the edition frame for this SQLElement

     *

     * @param configuration current configuration

     * @param parentFrame parent frame of the edit frame

     * @param editMode edition mode (CREATION, MODIFICATION, READONLY)

     * @param sqlRow SQLRowAccessor use for fill the edition frame

     * @param sessionSecurityToken String, use for find session with an instance of LightServer

     * @return the edition frame of this SQLElement

     */

    public LightEditFrame createEditFrame(final PropsConfiguration configuration, final LightUIFrame parentFrame, final EditMode editMode, final SQLRowAccessor sqlRow,

            final String sessionSecurityToken) {

        final Group editGroup = this.getEditGroup(editMode);

        if (editGroup == null) {

            Log.get().severe("The edit group is null for this element : " + this);

            return null;

        }

        final GroupToLightUIConvertor convertor = this.getGroupToLightUIConvertor(configuration, editMode, sqlRow, sessionSecurityToken);

        final LightEditFrame editFrame = convertor.convert(editGroup, sqlRow, parentFrame, editMode);

        if (editMode.equals(EditMode.CREATION)) {

            editFrame.createTitlePanel(this.getCreationFrameTitle());

        } else if (editMode.equals(EditMode.MODIFICATION)) {

            editFrame.createTitlePanel(this.getModificationFrameTitle(sqlRow));

            new LightUIPanelFiller(editFrame.getContentPanel()).fillFromRow(configuration, this, sqlRow, sessionSecurityToken);

        } else if (editMode.equals(EditMode.READONLY)) {

            editFrame.createTitlePanel(this.getReadOnlyFrameTitle(sqlRow));

            new LightUIPanelFiller(editFrame.getContentPanel()).fillFromRow(configuration, this, sqlRow, sessionSecurityToken);

        }

        this.setEditFrameModifiers(editFrame, sessionSecurityToken);

        return editFrame;

    }

    /**

     * Get title for read only mode

     *

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @return The title for read only mode

     */

    protected String getReadOnlyFrameTitle(final SQLRowAccessor sqlRow) {

        return EditFrame.getReadOnlyMessage(this);

    }

    /**

     * Get title for modification mode

     *

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @return The title for read only mode

     */

    protected String getModificationFrameTitle(final SQLRowAccessor sqlRow) {

        return EditFrame.getModifyMessage(this);

    }

    /**

     * Get title for creation mode

     *

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @return The title for read only mode

     */

    protected String getCreationFrameTitle() {

        return EditFrame.getCreateMessage(this);

    }

    /**

     *

     * @param configuration - The user SQL configuration

     * @param editMode - Edit mode of the frame

     * @param sqlRow - The row to update

     * @param token - The session security token

     *

     * @return An initialized GroupToLightUIConvertor

     */

    public GroupToLightUIConvertor getGroupToLightUIConvertor(final PropsConfiguration configuration, final EditMode editMode, final SQLRowAccessor sqlRow, final String token) {

        final GroupToLightUIConvertor convertor = new GroupToLightUIConvertor(configuration);

        // if (editMode.equals(EditMode.CREATION)) {

        convertor.putAllCustomEditorProvider(this.getCustomRowEditors(configuration, token));

        // } else {

        // convertor.putAllCustomEditorProvider(this.getCustomRowEditors(configuration, sqlRow,

        // token));

        // }

        return convertor;

    }

    /**

     * Override this function in an element and put new value in map for use ComboValueConvertor.

     * This one allow you to change value store in database by an other one.

     *

     * @return Map which contains all ComboValueConvertors use for this SQLElement edition. Key: ID

     *         of group item / Value: ComboValueConvertor

     */

    // TODO: use renderer instead of ValueConvertor

    public Map<String, ComboValueConvertor<?>> getComboConvertors() {

        return new HashMap<String, ComboValueConvertor<?>>();

    }

    /**

     * Override this function in an element and put new value in map for use ConvertorModifier. This

     * one allow you to apply some change on LightUIElement before send it to client

     *

     */

    // TODO: implement with IClosure

    public void setEditFrameModifiers(final LightEditFrame frame, final String sessionToken) {

    }

    public List<CustomRowEditor> getCustomRowEditors(final Configuration configuration, final String sessionToken) {

        final Map<String, ComboValueConvertor<?>> comboConvertors = this.getComboConvertors();

        final List<CustomRowEditor> result = new ArrayList<>();

        for (final Entry<String, ComboValueConvertor<?>> entry : comboConvertors.entrySet()) {

            final String itemId = entry.getKey();

            result.add(new CustomRowEditor(itemId) {

                final ComboValueConvertor<?> convertor = entry.getValue();

                @Override

                public LightUIElement createUIElement() {

                    final LightUIComboBox uiCombo = new LightUIComboBox(getItemId());

                    this.convertor.fillCombo(uiCombo, null);

                    return uiCombo;

                }

                @Override

                public void fillFrom(LightUIElement uiElement, SQLRowAccessor sqlRow) {

                    final LightUIComboBox uiCombo = (LightUIComboBox) uiElement;

                    final SQLField field = configuration.getFieldMapper().getSQLFieldForItem(getItemId());

                    if (this.convertor instanceof StringValueConvertor) {

                        ((StringValueConvertor) this.convertor).fillCombo(uiCombo, sqlRow.getString(field.getFieldName()));

                    } else if (this.convertor instanceof IntValueConvertor) {

                        if (sqlRow.getObject(field.getFieldName()) != null) {

                            ((IntValueConvertor) this.convertor).fillCombo(uiCombo, sqlRow.getInt(field.getFieldName()));

                        }

                    }

                }

                @Override

                public void store(LightUIElement uiElement, SQLRowValues sqlRow) {

                    final LightUIComboBox combobox = (LightUIComboBox) uiElement;

                    final String fieldName = configuration.getFieldMapper().getSQLFieldForItem(getItemId()).getName();

                    if (combobox.hasSelectedValue()) {

                        if (this.convertor instanceof StringValueConvertor) {

                            sqlRow.put(fieldName, ((StringValueConvertor) this.convertor).getIdFromIndex(combobox.getSelectedValue().getId()));

                        } else if (this.convertor instanceof IntValueConvertor) {

                            sqlRow.put(fieldName, combobox.getSelectedValue().getId());

                        } else {

                            throw new IllegalArgumentException("the save is not implemented for the class: " + this.convertor.getClass().getName() + " - ui id: " + getItemId());

                        }

                    } else {

                        sqlRow.put(fieldName, null);

                    }

                }

            });

        }

        return result;

    }

    /**

     * Override this function in an element to execute some code just after inserted new row in

     * database

     *

     * @param editFrame - The edit frame of this SQLRow

     * @param sqlRow - The row which was just inserted

     * @param sessionToken Security token of session which allow to find session in LightServer

     *        instance

     *

     * @throws Exception

     */

    public void doAfterLightInsert(final LightEditFrame editFrame, final SQLRow sqlRow, final String sessionToken) throws Exception {

    }

    /**

     * Override this function in an element to execute some code just after deleted a row in

     * database

     *

     * @param frame - The current frame

     * @param sqlRow - The row which was deleted

     * @param sessionToken Security token of session which allow to find session in LightServer

     *        instance

     *

     * @throws Exception

     */

    public void doAfterLightDelete(final LightUIFrame frame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    }

    /**

     * Override this function in an element to execute some code before inserted new row in database

     *

     * @param frame - The current frame

     * @param sqlRow - The row which will be deleted

     * @param sessionToken - Security token of session which allow to find session in LightServer

     *        instance

     *

     * @throws Exception

     */

    public void doBeforeLightDelete(final LightUIFrame frame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    }

    /**

     * Override this function in an element to execute some code before inserted new row in database

     *

     * @param editFrame - The edit frame of this SQLRowValues

     * @param sqlRow - The row which was just inserted

     * @param sessionToken - Security token of session which allow to find session in LightServer

     *        instance

     *

     * @throws Exception

     */

    public void doBeforeLightInsert(final LightEditFrame editFrame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    }

    /**

     * Get ShowAs values of this SQLElement

     *

     * @param id - The id which you want to expand

     *

     * @return A SQLRowValues with data

     */

    public SQLRowValues getValuesOfShowAs(final Number id) {

        final SQLRowValues tmp = new SQLRowValues(this.getTable());

        final ListMap<String, String> showAs = this.getShowAs();

        for (final List<String> listStr : showAs.values()) {

            tmp.putNulls(listStr);

        }

        this.getDirectory().getShowAs().expand(tmp);

        final SQLRowValues fetched = SQLRowValuesListFetcher.create(tmp).fetchOne(id);

        if (fetched == null) {

            throw new IllegalArgumentException("Impossible to find Row in database - table: " + this.getTable().getName() + ", id: " + id);

        }

        return fetched;

    }

    /**

     * Must be called if foreign/referent keys are added or removed.

     */

    public synchronized void resetRelationships() {

        if (this.areRelationshipsInited()) {

            // if we remove links, notify owned elements

            for (final SQLElementLink l : this.ownedLinks.getByPath().values()) {

                l.getOwned().resetRelationshipsOf(this);

            }

        }

        this.ownedLinks = this instanceof JoinSQLElement ? new SQLElementLinks(SetMap.<LinkType, SQLElementLink> empty()) : null;

        this.otherLinks = this instanceof JoinSQLElement ? new SQLElementLinks(SetMap.<LinkType, SQLElementLink> empty()) : null;

        this.parentFF = null;

    }

    private synchronized void resetRelationshipsOf(final SQLElement changed) {

        // MAYBE optimize and only remove links for the passed argument

        this.otherLinks = null;

    }

    protected synchronized final boolean areRelationshipsInited() {

        return this.ownedLinks != null;

    }

    // return Path from owner to owned

    private final Set<Path> createPaths(final boolean wantedOwned) {

        // joins cannot have SQLElementLink

        if (this instanceof JoinSQLElement)

            return Collections.emptySet();

        final SQLTable thisTable = this.getTable();

        final Set<Link> allLinks = thisTable.getDBSystemRoot().getGraph().getAllLinks(getTable());

        final Set<Path> res = new HashSet<Path>();

        for (final Link l : allLinks) {

            final boolean owned;

            final Path pathFromOwner;

            final SQLElement sourceElem = this.getElementLenient(l.getSource());

            if (sourceElem instanceof JoinSQLElement) {

                final JoinSQLElement joinElem = (JoinSQLElement) sourceElem;

                pathFromOwner = joinElem.getPathFromOwner();

                // ATTN when source == target, the same path will both owned and not

                owned = joinElem.getLinkToOwner().equals(l);

            } else if (l.getSource() == l.getTarget()) {

                owned = wantedOwned;

                pathFromOwner = new PathBuilder(l.getSource()).add(l, Direction.FOREIGN).build();

            } else {

                owned = l.getSource() == thisTable;

                pathFromOwner = new PathBuilder(l.getSource()).add(l).build();

            }

            if (owned == wantedOwned)

                res.add(pathFromOwner);

        }

        return res;

    }

    // this implementation uses getParentFFName() and assumes that links to privates are COMPOSITION

    final SetMap<LinkType, Path> getDefaultLinkTypes() {

        final Set<Path> ownedPaths = createPaths(true);

        final SetMap<LinkType, Path> res = new SetMap<LinkType, Path>();

        final String parentFFName = getParentFFName();

        if (parentFFName != null) {

            final Path pathToParent = new PathBuilder(getTable()).addForeignField(parentFFName).build();

            if (!ownedPaths.remove(pathToParent))

                throw new IllegalStateException("getParentFFName() " + pathToParent + " isn't in " + ownedPaths);

            res.add(LinkType.PARENT, pathToParent);

        }

        final List<String> privateFields = this.getPrivateFields();

        if (!privateFields.isEmpty())

            Log.get().warning("getPrivateFields() is deprecated use setupLinks(), " + this + " : " + privateFields);

        // links to private are COMPOSITION by default (normal links to privates are few)

        final Iterator<Path> iter = ownedPaths.iterator();

        while (iter.hasNext()) {

            final Path ownedPath = iter.next();

            if (getElement(ownedPath.getLast()).isPrivate()) {

                iter.remove();

                res.add(LinkType.COMPOSITION, ownedPath);

            } else if (ownedPath.length() == 1 && ownedPath.isSingleField() && privateFields.contains(ownedPath.getSingleField(0).getName())) {

                throw new IllegalStateException("getPrivateFields() contains " + ownedPath + " which points to an element which isn't private");

            }

        }

        res.addAll(LinkType.ASSOCIATION, ownedPaths);

        return res;

    }

    final List<ReferenceAction> getPossibleActions(final LinkType lt, final SQLElement targetElem) {

        // MAYBE move required fields to SQLElement and use RESTRICT

        final List<ReferenceAction> res;

        if (lt == LinkType.PARENT) {

            // SET_EMPTY would create an orphan

            res = Arrays.asList(ReferenceAction.CASCADE, ReferenceAction.RESTRICT);

        } else if (lt == LinkType.COMPOSITION) {

            res = Arrays.asList(ReferenceAction.SET_EMPTY, ReferenceAction.RESTRICT);

        } else {

            assert lt == LinkType.ASSOCIATION;

            if (targetElem.isShared()) {

                res = Arrays.asList(ReferenceAction.RESTRICT, ReferenceAction.SET_EMPTY);

            } else {

                res = Arrays.asList(ReferenceAction.values());

            }

        }

        return res;

    }

    private synchronized void initFF() {

        if (areRelationshipsInited())

            return;

        final SQLElementLinksSetup paths = new SQLElementLinksSetup(this);

        setupLinks(paths);

        this.ownedLinks = new SQLElementLinks(paths.getResult());

        // try to fill old attributes

        final SQLElementLink parentLink = this.getParentLink();

        if (parentLink != null) {

            if (parentLink.getSingleField() != null)

                this.parentFF = parentLink.getSingleField().getName();

            else

                throw new UnsupportedOperationException("Parent field name not supported : " + parentLink);

        } else {

            this.parentFF = null;

        }

        assert assertPrivateDefaultValues();

        // if we added links, let the owned know

        final Set<SQLElement> toReset = new HashSet<SQLElement>();

        for (final SQLElementLink l : this.ownedLinks.getByPath().values()) {

            toReset.add(l.getOwned());

        }

        for (final SQLElement e : toReset) {

            e.resetRelationshipsOf(this);

        }

        this.ffInited();

    }

    // since by definition private cannot be shared, the default value must be empty

    private final boolean assertPrivateDefaultValues() {

        final Set<SQLElementLink> privates = this.getOwnedLinks().getByType(LinkType.COMPOSITION);

        for (final SQLElementLink e : privates) {

            if (!e.isJoin()) {

                final SQLField singleField = e.getSingleField();

                final Number privateDefault = (Number) singleField.getParsedDefaultValue().getValue();

                final Number foreignUndef = e.getPath().getLast().getUndefinedIDNumber();

                assert NumberUtils.areNumericallyEqual(privateDefault, foreignUndef) : singleField + " not empty : " + privateDefault;

            }

        }

        return true;

    }

    public boolean isPrivate() {

        return false;

    }

    /**

     * Set {@link LinkType type} and other information for each owned link of this element.

     *

     * @param links the setup object.

     */

    protected void setupLinks(SQLElementLinksSetup links) {

    }

    /**

     * Was used to set the action of an {@link SQLElementLink}.

     *

     * @deprecated use {@link SQLElementLinkSetup#setType(LinkType, ReferenceAction)}

     */

    protected void ffInited() {

        // MAYBE use DELETE_RULE of Link

    }

    private final Set<SQLField> getSingleFields(final SQLElementLinks links, final LinkType type) {

        final Set<SQLField> res = new HashSet<SQLField>();

        for (final SQLElementLink l : links.getByType(type)) {

            final SQLField singleField = l.getSingleField();

            if (singleField == null)

                throw new IllegalStateException("Not single field : " + l);

            res.add(singleField);

        }

        return res;

    }

    private synchronized void initRF() {

        if (this.otherLinks != null)

            return;

        final Set<Path> otherPaths = this.createPaths(false);

        if (otherPaths.isEmpty()) {

            this.otherLinks = SQLElementLinks.empty();

        } else {

            final SetMap<LinkType, SQLElementLink> tmp = new SetMap<LinkType, SQLElementLink>();

            for (final Path p : otherPaths) {

                final SQLElement refElem = this.getElementLenient(p.getFirst());

                final SQLElementLink elementLink;

                if (refElem == null) {

                    // RESTRICT : play it safe

                    elementLink = new SQLElementLink(null, p, this, LinkType.ASSOCIATION, null, ReferenceAction.RESTRICT);

                } else {

                    elementLink = refElem.getOwnedLinks().getByPath(p);

                    assert elementLink.getOwned() == this;

                }

                tmp.add(elementLink.getLinkType(), elementLink);

            }

            this.otherLinks = new SQLElementLinks(tmp);

        }

    }

    final void setDirectory(final SQLElementDirectory directory) {

        // since this method should only be called at the end of SQLElementDirectory.addSQLElement()

        assert directory == null || directory.getElement(this.getTable()) == this;

        synchronized (this) {

            if (this.directory != directory) {

                if (this.areRelationshipsInited())

                    this.resetRelationships();

                this.directory = directory;

            }

        }

    }

    public synchronized final SQLElementDirectory getDirectory() {

        return this.directory;

    }

    final SQLElement getElement(SQLTable table) {

        final SQLElement res = getElementLenient(table);

        if (res == null)

            throw new IllegalStateException("no element for " + table.getSQLName());

        return res;

    }

    final SQLElement getElementLenient(SQLTable table) {

        synchronized (this) {

            return this.getDirectory().getElement(table);

        }

    }

    public final SQLElement getForeignElement(String foreignField) {

        try {

            return this.getElement(this.getForeignTable(foreignField));

        } catch (RuntimeException e) {

            throw new IllegalStateException("no element for " + foreignField + " in " + this, e);

        }

    }

    private final SQLTable getForeignTable(String foreignField) {

        return this.getTable().getBase().getGraph().getForeignTable(this.getTable().getField(foreignField));

    }

    /**

     * Set the default name, used if no translations could be found.

     *

     * @param name the default name, if <code>null</code> the {@link #getTable() table} name will be

     *        used.

     */

    public final synchronized void setDefaultName(Phrase name) {

        this.defaultName = name != null ? name : Phrase.getInvariant(getTable().getName());

    }

    /**

     * The default name.

     *

     * @return the default name, never <code>null</code>.

     */

    public final synchronized Phrase getDefaultName() {

        return this.defaultName;

    }

    /**

     * The name of this element in the current locale.

     *

     * @return the name of this, {@link #getDefaultName()} if there's no {@link #getDirectory()

     *         directory} or if it hasn't a name for this.

     * @see SQLElementDirectory#getName(SQLElement)

     */

    public final Phrase getName() {

        final SQLElementDirectory dir = this.getDirectory();

        final SQLFieldTranslator trns = dir == null ? null : dir.getTranslator();

        final Phrase res = trns == null ? null : trns.getElementName(this);

        return res == null ? this.getDefaultName() : res;

    }

    public String getPluralName() {

        return this.getName().getVariant(Grammar.PLURAL);

    }

    public String getSingularName() {

        return this.getName().getVariant(Grammar.INDEFINITE_ARTICLE_SINGULAR);

    }

    public ListMap<String, String> getShowAs() {

        // nothing by default

        return null;

    }

    /**

     * Fields that can neither be inserted nor updated.

     *

     * @return fields that cannot be modified.

     */

    public Set<String> getReadOnlyFields() {

        return Collections.emptySet();

    }

    /**

     * Fields that can only be set on insertion.

     *

     * @return fields that cannot be modified.

     */

    public Set<String> getInsertOnlyFields() {

        return Collections.emptySet();

    }

    private synchronized final SQLCache<SQLRow, Object> getModelCache() {

        if (this.modelCache == null)

            this.modelCache = new SQLCache<SQLRow, Object>(60, -1, "modelObjects of " + this.getCode());

        return this.modelCache;

    }

    // *** update

    /**

     * Compute the necessary steps to transform <code>from</code> into <code>to</code>.

     *

     * @param from the row currently in the db.

     * @param to the new values.

     * @return the script transforming <code>from</code> into <code>to</code>.

     */

    public final UpdateScript update(SQLRowValues from, SQLRowValues to) {

        return this.update(from, to, false);

    }

    public final UpdateScript update(final SQLRowValues from, final SQLRowValues to, final boolean allowedToChangeTo) {

        return this.update(from, to, allowedToChangeTo, Transformer.<SQLRowValues> nopTransformer());

    }

    private final UpdateScript update(final SQLRowValues from, SQLRowValues to, boolean allowedToChangeTo, ITransformer<SQLRowValues, SQLRowValues> copy2originalRows) {

        check(from);

        check(to);

        for (final SQLRowValues v : from.getGraph().getItems()) {

            if (!v.hasID())

                throw new IllegalArgumentException("missing id in " + v + " : " + from.printGraph());

        }

        if (!to.hasID()) {

            if (!allowedToChangeTo) {

                final Map<SQLRowValues, SQLRowValues> copied = to.getGraph().deepCopy(false);

                to = copied.get(to);

                allowedToChangeTo = true;

                copy2originalRows = Transformer.fromMap(CollectionUtils.invertMap(new IdentityHashMap<SQLRowValues, SQLRowValues>(), copied));

            }

            // from already exists in the DB, so if we're re-using it for another row, all

            // non-provided fields must be reset

            to.fillWith(SQLRowValues.SQL_DEFAULT, false);

            to.setPrimaryKey(from);

        }

        if (from.getID() != to.getID())

            throw new IllegalArgumentException("not the same row: " + from + " != " + to);

        final UpdateScript res = new UpdateScript(this, from, copy2originalRows.transformChecked(to));

        // local values and foreign links

        for (final FieldGroup group : to.getFieldGroups()) {

            if (group.getKeyType() != Type.FOREIGN_KEY) {

                // i.e. primary key or normal field

                res.getUpdateRow().putAll(to.getAbsolutelyAll(), group.getFields());

            } else {

                final SQLKey k = group.getKey();

                if (k.getFields().size() > 1)

                    throw new IllegalStateException("Multi-field not supported : " + k);

                final String field = group.getSingleField();

                assert field != null;

                final Path p = new PathBuilder(getTable()).add(k.getForeignLink(), Direction.FOREIGN).build();

                final SQLElementLink elemLink = this.getOwnedLinks().getByPath(p);

                if (elemLink.getLinkType() == LinkType.COMPOSITION) {

                    final SQLElement privateElem = elemLink.getOwned();

                    final Object fromPrivate = from.getObject(field);

                    final Object toPrivate = to.getObject(field);

                    assert !from.isDefault(field) : "A row in the DB cannot have DEFAULT";

                    final boolean fromIsEmpty = from.isForeignEmpty(field);

                    // as checked in initFF() the default for a private is empty

                    final boolean toIsEmpty = to.isDefault(field) || to.isForeignEmpty(field);

                    if (fromIsEmpty && toIsEmpty) {

                        // nothing to do, don't add to v

                    } else if (fromIsEmpty) {

                        final SQLRowValues toPR = (SQLRowValues) toPrivate;

                        // insert, eg CPI.ID_OBS=1 -> CPI.ID_OBS={DES="rouillé"}

                        // clear referents otherwise we will merge the updateRow with the to

                        // graph (toPR being a private is pointed to by its owner, which itself

                        // points to others, but we just want the private)

                        assert CollectionUtils.getSole(toPR.getReferentRows(elemLink.getSingleField())) == to : "Shared private " + toPR.printGraph();

                        final SQLRowValues copy = toPR.deepCopy().removeReferents(elemLink.getSingleField());

                        res.getUpdateRow().put(field, copy);

                        res.mapRow(copy2originalRows.transformChecked(toPR), copy);

                    } else if (toIsEmpty) {

                        // cut and archive

                        res.getUpdateRow().putEmptyLink(field);

                        res.addToArchive(privateElem, from.getForeign(field));

                    } else {

                        // neither is empty

                        final Number fromForeignID = from.getForeignIDNumber(field);

                        if (fromForeignID == null)

                            throw new IllegalArgumentException("Non-empty private in old row, but null ID for " + elemLink);

                        if (toPrivate == null)

                            throw new IllegalArgumentException("Non-empty private in new row, but null value for " + elemLink);

                        assert toPrivate instanceof Number || toPrivate instanceof SQLRowValues;

                        // with the above check, toForeignID is null if and only if toPrivate is an

                        // SQLRowValues without ID

                        final Number toForeignID = to.getForeignIDNumber(field);

                        // if it's desired in the future, don't forget to only re-use ID if there's