Package org.apache.jackrabbit.oak.segment

Class ClassicCompactor

  • Direct Known Subclasses:
    ParallelCompactor
    public class ClassicCompactor
extends Compactor
    Instances of this class can be used to compact a node state. I.e. to create a clone of a given node state without value sharing except for binaries. Binaries that are stored in a list of bulk segments will still value share the bulk segments (but not the list records). A node can either be compacted on its own or alternatively the difference between two nodes can be compacted on top of an already compacted node.

    • Constructor Detail

      • ClassicCompactor

        public ClassicCompactor​(@NotNull
                        @NotNull CompactionWriter writer,
                        @NotNull
                        @NotNull GCNodeWriteMonitor compactionMonitor)
        Create a new instance based on the passed arguments.
        Parameters:
        writer - segment writer used to serialise to segments
        compactionMonitor - notification call back for each compacted nodes, properties, and binaries

    • Method Detail

      • compactDown

        @Nullable
public @Nullable CompactedNodeState compactDown​(@NotNull
                                                @NotNull NodeState before,
                                                @NotNull
                                                @NotNull NodeState after,
                                                @NotNull
                                                @NotNull Canceller hardCanceller,
                                                @NotNull
                                                @NotNull Canceller softCanceller)
                                         throws IOException
        Description copied from class: Compactor
        compact the differences between after and before on top of after.
        Specified by:
        compactDown in class Compactor
        Parameters:
        before - the node state to diff against from after
        after - the node state diffed against before
        hardCanceller - the trigger for hard cancellation, will abandon compaction if cancelled
        softCanceller - the trigger for soft cancellation, will return partially compacted state if cancelled
        Returns:
        the compacted node state or null if hard-cancelled
        Throws:
        IOException - will throw exception if any errors occur during compaction

      • compact

        @Nullable
public @Nullable CompactedNodeState compact​(@NotNull
                                            @NotNull NodeState before,
                                            @NotNull
                                            @NotNull NodeState after,
                                            @NotNull
                                            @NotNull NodeState onto,
                                            @NotNull
                                            @NotNull Canceller canceller)
                                     throws IOException
        Description copied from class: Compactor
        compact the differences between after and before on top of onto.
        Specified by:
        compact in class Compactor
        Parameters:
        before - the node state to diff against from after
        after - the node state diffed against before
        onto - the node state to compact to apply the diff to
        canceller - the trigger for hard cancellation, will abandon compaction if cancelled
        Returns:
        the compacted node state or null if hard-cancelled
        Throws:
        IOException - will throw exception if any errors occur during compaction

      • compact

        @Nullable
protected @Nullable CompactedNodeState compact​(@NotNull
                                               @NotNull NodeState before,
                                               @NotNull
                                               @NotNull NodeState after,
                                               @NotNull
                                               @NotNull NodeState onto,
                                               @NotNull
                                               @NotNull Canceller hardCanceller,
                                               @Nullable
                                               @Nullable Canceller softCanceller)
                                        throws IOException
        Compact the differences between after and before on top of onto. The softCanceller must be null, unless after.equals(onto), i.e. if the method is called for a compactDown(NodeState, NodeState, Canceller, Canceller) scenario. .
        Parameters:
        before - The node state used as the baseline for the diff.
        after - The node state used as the target for the diff.
        onto - The node state to apply the diff to.
        hardCanceller - The trigger for hard cancellation, will abandon compaction if cancelled.
        softCanceller - The trigger for soft cancellation, will return partially compacted state if cancelled. Must be null unless after.equals(onto).
        Returns:
        The compacted node state or null if hard-cancelled.
        Throws:
        IOException - Will throw exception if any errors occur during compaction.