Class 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 Detail

      • 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).

      • deleted

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

      • 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.

        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 Detail

      • getIds

        public Set<SerializablegetIds()
        Gets the ids in that fragment, if complete (otherwise returns null).
      • addExisting

        public void addExisting​(Serializable id)
        Adds a known row corresponding to the clause.
        id - the fragment id
      • addCreated

        public void addCreated​(Serializable id)
        Adds a created row corresponding to the clause.
        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.

        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.
        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)
      • getFragmentsByValue

        public List<SimpleFragmentgetFragmentsByValue​(Serializable filter)
        Gets all the fragments, if the selection is complete.
        filter - the value to filter on, or null for the whole selection
        the fragments, or null if the list is not known to be complete