Package org.apache.calcite.util.mapping

Class Mappings

java.lang.Object
org.apache.calcite.util.mapping.Mappings
public abstract class Mappings extends Object
Utility functions related to mappings.
See Also:

  • Method Details

    • create

      public static Mapping create(MappingType mappingType, int sourceCount, int targetCount)
      Creates a mapping with required properties.

    • createIdentity

      public static Mappings.IdentityMapping createIdentity(int fieldCount)
      Creates the identity mapping.

      For example, createIdentity(2) returns the mapping {0:0, 1:1, 2:2}.

      Parameters:
      fieldCount - Number of sources/targets
      Returns:
      Identity mapping

    • invert

      public static Mapping invert(Mapping mapping)
      Converts a mapping to its inverse.

    • divide

      public static Mapping divide(Mapping mapping1, Mapping mapping2)
      Divides one mapping by another.

      divide(A, B) returns a mapping C such that B . C (the mapping B followed by the mapping C) is equivalent to A.

      Parameters:
      mapping1 - First mapping
      mapping2 - Second mapping
      Returns:
      Mapping mapping3 such that mapping1 = mapping2 . mapping3

    • multiply

      public static Mapping multiply(Mapping mapping1, Mapping mapping2)
      Multiplies one mapping by another.

      multiply(A, B) returns a mapping C such that A . B (the mapping A followed by the mapping B) is equivalent to C.

      Parameters:
      mapping1 - First mapping
      mapping2 - Second mapping
      Returns:
      Mapping mapping3 such that mapping1 = mapping2 . mapping3

    • apply

      public static BitSet apply(Mapping mapping, BitSet bitSet)
      Applies a mapping to a BitSet.

      If the mapping does not affect the bit set, returns the original. Never changes the original.

      Parameters:
      mapping - Mapping
      bitSet - Bit set
      Returns:
      Bit set with mapping applied

    • apply

      public static ImmutableBitSet apply(Mapping mapping, ImmutableBitSet bitSet)
      Applies a mapping to an ImmutableBitSet.

      If the mapping does not affect the bit set, returns the original. Never changes the original.

      Parameters:
      mapping - Mapping
      bitSet - Bit set
      Returns:
      Bit set with mapping applied

    • apply2

      public static com.google.common.collect.ImmutableList<ImmutableBitSet> apply2(Mapping mapping, Iterable<ImmutableBitSet> bitSets)
      Applies a mapping to a collection of ImmutableBitSets.
      Parameters:
      mapping - Mapping
      bitSets - Collection of bit sets
      Returns:
      Sorted bit sets with mapping applied

    • apply

      public static <T> List<T> apply(Mapping mapping, List<T> list)
      Applies a mapping to a list.
      Type Parameters:
      T - Element type
      Parameters:
      mapping - Mapping
      list - List
      Returns:
      List with elements permuted according to mapping

    • apply2

      public static List<Integer> apply2(Mapping mapping, List<Integer> list)

    • apply3

      public static <T> List<T> apply3(Mapping mapping, List<T> list)
      Creates a view of a list, permuting according to a mapping.
      Type Parameters:
      T - Element type
      Parameters:
      mapping - Mapping
      list - List
      Returns:
      Permuted view of list

    • permute

      public static <T> List<T> permute(List<T> list, Mappings.TargetMapping mapping)
      Creates a view of a list, permuting according to a target mapping.
      Type Parameters:
      T - Element type
      Parameters:
      list - List
      mapping - Mapping
      Returns:
      Permuted view of list

    • asList

      @CheckReturnValue public static List<@Nullable Integer> asList(Mappings.TargetMapping mapping)
      Returns a mapping as a list such that list.get(source) is mapping.getTarget(source) and list.size() is mapping.getSourceCount().

      Converse of target(List, int).

      See Also:

    • asListNonNull

      @CheckReturnValue public static List<Integer> asListNonNull(Mappings.TargetMapping mapping)
      Returns a mapping as a list such that list.get(source) is mapping.getTarget(source) and list.size() is mapping.getSourceCount().

      The resulting list never contains null elements.

      Converse of target(List, int).

      See Also:

    • target

      public static Mappings.TargetMapping target(Map<Integer,Integer> map, int sourceCount, int targetCount)
      Converts a Map of integers to a Mappings.TargetMapping.

    • target

      public static Mappings.TargetMapping target(IntFunction<? extends @Nullable Integer> function, int sourceCount, int targetCount)

    • target

      public static Mapping target(Iterable<IntPair> pairs, int sourceCount, int targetCount)

    • source

      public static Mapping source(List<Integer> targets, int targetCount)

    • target

      public static Mapping target(List<Integer> sources, int sourceCount)

    • bijection

      public static Mapping bijection(List<Integer> targets)
      Creates a bijection.

      Throws if sources and targets are not one to one.

    • bijection

      public static Mapping bijection(Map<Integer,Integer> targets)
      Creates a bijection.

      Throws if sources and targets are not one to one.

    • isIdentity

      public static boolean isIdentity(Mappings.TargetMapping mapping)
      Returns whether a mapping is the identity.

    • keepsOrdering

      public static boolean keepsOrdering(Mappings.TargetMapping mapping)
      Returns whether a mapping keeps order.

      For example, {0:0, 1:1} and {0:1, 1:1} keeps order, and {0:1, 1:0} breaks the initial order.

    • createShiftMapping

      public static Mappings.TargetMapping createShiftMapping(int sourceCount, int... ints)
      Creates a mapping that consists of a set of contiguous ranges.

      For example, 

      createShiftMapping(60,
     100, 0, 3,
     200, 50, 5);

      creates

      Example mapping
      SourceTarget
      0100
      1101
      2102
      3-1
      ...-1
      50200
      51201
      52202
      53203
      54204
      55-1
      ...-1
      59-1
      Parameters:
      sourceCount - Maximum value of source
      ints - Collection of ranges, each (target, source, count)
      Returns:
      Mapping that maps from source ranges to target ranges

    • append

      public static Mappings.TargetMapping append(Mappings.TargetMapping mapping0, Mappings.TargetMapping mapping1)
      Creates a mapping by appending two mappings.

      Sources and targets of the second mapping are shifted to the right.

      For example, 

      append({0:0, 1:1}, {0:0, 1:1, 2:2})
      yields 
      {0:0, 1:1, 2:2, 3:3, 4:4}
      .
      See Also:

    • merge

      public static Mappings.TargetMapping merge(Mappings.TargetMapping mapping0, Mappings.TargetMapping mapping1)
      Creates a mapping by merging two mappings. There must be no clashes.

      Unlike append(org.apache.calcite.util.mapping.Mappings.TargetMapping, org.apache.calcite.util.mapping.Mappings.TargetMapping), sources and targets are not shifted.

      For example, merge({0:0, 1:1}, {2:2, 3:3, 4:4}) yields {0:0, 1:1, 2:2, 3:3, 4:4}. merge({0:0, 1:1}, {1:2, 2:3}) throws, because there are two entries with source=1.

    • offsetSource

      public static Mappings.TargetMapping offsetSource(Mappings.TargetMapping mapping, int offset)
      Returns a mapping that shifts a given mapping's source by a given offset, incrementing the number of sources by the minimum possible.
      Parameters:
      mapping - Input mapping
      offset - Offset to be applied to each source
      Returns:
      Shifted mapping

    • offsetSource

      public static Mappings.TargetMapping offsetSource(Mappings.TargetMapping mapping, int offset, int sourceCount)
      Returns a mapping that shifts a given mapping's source by a given offset.

      For example, given mapping with sourceCount=2, targetCount=8, and (source, target) entries {[0: 5], [1: 7]}, offsetSource(mapping, 3) returns a mapping with sourceCount=5, targetCount=8, and (source, target) entries {[3: 5], [4: 7]}.

      Parameters:
      mapping - Input mapping
      offset - Offset to be applied to each source
      sourceCount - New source count; must be at least mapping's source count plus offset
      Returns:
      Shifted mapping

    • offsetTarget

      public static Mappings.TargetMapping offsetTarget(Mappings.TargetMapping mapping, int offset)
      Returns a mapping that shifts a given mapping's target by a given offset, incrementing the number of targets by the minimum possible.
      Parameters:
      mapping - Input mapping
      offset - Offset to be applied to each target
      Returns:
      Shifted mapping

    • offsetTarget

      public static Mappings.TargetMapping offsetTarget(Mappings.TargetMapping mapping, int offset, int targetCount)
      Returns a mapping that shifts a given mapping's target by a given offset.

      For example, given mapping with sourceCount=2, targetCount=8, and (source, target) entries {[0: 5], [1: 7]}, offsetTarget(mapping, 3) returns a mapping with sourceCount=2, targetCount=11, and (source, target) entries {[0: 8], [1: 10]}.

      Parameters:
      mapping - Input mapping
      offset - Offset to be applied to each target
      targetCount - New target count; must be at least mapping's target count plus offset
      Returns:
      Shifted mapping

    • offset

      public static Mappings.TargetMapping offset(Mappings.TargetMapping mapping, int offset, int sourceCount)
      Returns a mapping that shifts a given mapping's source and target by a given offset.

      For example, given mapping with sourceCount=2, targetCount=8, and (source, target) entries {[0: 5], [1: 7]}, offsetSource(mapping, 3) returns a mapping with sourceCount=5, targetCount=8, and (source, target) entries {[3: 8], [4: 10]}.

      Parameters:
      mapping - Input mapping
      offset - Offset to be applied to each source
      sourceCount - New source count; must be at least mapping's source count plus offset
      Returns:
      Shifted mapping

    • isIdentity

      public static boolean isIdentity(List<Integer> list, int count)
      Returns whether a list of integers is the identity mapping [0, ..., n - 1].

    • invert

      public static Iterable<IntPair> invert(Iterable<IntPair> pairs)
      Inverts an Iterable over IntPairs.

    • invert

      public static Iterator<IntPair> invert(Iterator<IntPair> pairs)
      Inverts an Iterator over IntPairs.

    • apply

      public static int apply(Mappings.TargetMapping mapping, int i)
      Applies a mapping to an optional integer, returning an optional result.

    • concatenateMappings

      public static Mapping concatenateMappings(List<Mapping> inputMappings)
      Concatenates multiple mappings. 
       [ 1:0, 2:1] // sourceCount:100
 [ 1:0, 2:1] // sourceCount:100
 output:
 [ 1:0, 2:1, 101:2, 102:3 ] ; sourceCount:200