Package org.nuxeo.ecm.core.storage.sql

Class Selection

java.lang.Object
org.nuxeo.ecm.core.storage.sql.Selection
public class Selection extends Object
A Selection holds information about row ids corresponding to a fixed clause for a given table.

A clause has the form: column = fixed value. The column can be the parent id, the versionable id, the target id.

The internal state of a Selection instance reflects:

  • corresponding rows known to exist in the database,
  • corresponding created rows not yet flushed to database,
  • corresponding rows not yet flushed to database.
Information about rows in the database may be complete, or just partial if only individual rows corresponding to the clause have been retrieved from the database.

Row ids are stored in no particular order.

When this structure holds information all flushed to the database, then it can safely be GC'ed, so it lives in a memory-sensitive map (softMap), otherwise it's moved to a normal map (hardMap).

This class is not thread-safe and should be used only from a single-threaded session.

  • Field Details

    • context

      protected final PersistenceContext context
      The context used to fetch fragments.

    • filterKey

      protected final String filterKey
      The key to use to filter.

      For instance for a children selection this is the child name.

    • complete

      protected boolean complete
      This is true when complete information about the existing ids is known.

      This is the case when a query to the database has been made to fetch all rows with the clause, or when a new value for the clause has been created (applies for instance to a new parent id appearing when a folder is created).

    • existing

      protected Set<Serializable> existing
      The row ids known in the database and not deleted.

    • created

      protected Set<Serializable> created
      The row ids created and not yet flushed to database.

    • deleted

      protected Set<Serializable> deleted
      The row ids deleted (or for which the clause column changed value) and not yet flushed to database.

  • Constructor Details

    • Selection

      public Selection(Serializable selId, String tableName, boolean empty, String filterKey, PersistenceContext context, Map<Serializable,Selection> softMap, Map<Serializable,Selection> hardMap)
      Constructs a Selection for the given selection id.

      It is automatically put in the soft map.

      Parameters:
      selId - the selection key (used in the soft/hard maps)
      tableName - the table name to fetch fragments
      empty - if the new instance is created empty
      filterKey - the key to use to additionally filter on fragment values
      context - the context from which to fetch fragments
      softMap - the soft map, when the selection is pristine
      hardMap - the hard map, when there are modifications to flush

  • Method Details

    • getIds

      public Set<Serializable> getIds()
      Gets the ids in that fragment, if complete (otherwise returns null).
      Since:
      9.2

    • fragmentValue

      protected Serializable fragmentValue(SimpleFragment fragment)

    • addExisting

      public void addExisting(Serializable id)
      Adds a known row corresponding to the clause.
      Parameters:
      id - the fragment id

    • addCreated

      public void addCreated(Serializable id)
      Adds a created row corresponding to the clause.
      Parameters:
      id - the fragment id

    • addExistingComplete

      public void addExistingComplete(List<Serializable> actualExisting)
      Adds ids actually read from the backend, and mark this complete.

      Note that when adding a complete list of ids retrieved from the database, the deleted ids have already been removed in the result set.

      Parameters:
      actualExisting - the existing database ids (the list must be mutable)

    • setIncomplete

      public void setIncomplete()
      Marks as incomplete.

      Called after a database operation added rows corresponding to the clause with unknown ids (restore of complex properties).

    • remove

      public void remove(Serializable id)
      Removes a known child id.
      Parameters:
      id - the id to remove

    • flush

      public void flush()
      Flushes to database. Clears created and deleted map.

      Puts this in the soft map. Caller must remove from hard map.

    • warnIfBig

      protected void warnIfBig(int added)

    • isFlushed

      public boolean isFlushed()

    • getFragmentByValue

      public SimpleFragment getFragmentByValue(Serializable filter)
      Gets a fragment given its filtered value.

      Returns null if there is no such fragment.

      Returns SimpleFragment.UNKNOWN if there's no info about it.

      Parameters:
      filter - the value to filter on (cannot be null)
      Returns:
      the fragment, or null, or SimpleFragment.UNKNOWN

    • getFragmentsByValue

      public List<SimpleFragment> getFragmentsByValue(Serializable filter)
      Gets all the fragments, if the selection is complete.
      Parameters:
      filter - the value to filter on, or null for the whole selection
      Returns:
      the fragments, or null if the list is not known to be complete