Interface Window<T>

All Superinterfaces:
Collectable<T>

public interface Window<T> extends Collectable<T>
A window containing the data for its partition, to perform calculations upon.

Window functions as exposed in this type are inspired by their counterparts in SQL. They include:

Ranking functions

Ranking functions are useful to determine the "rank" of any given row within the partition, given a specific ordering. The following table explains individual ranking functions:
FunctionDescription
rowNumber()The distinct row number of the row within the partition, counting from 0.
rank()The rank with gaps of a row within the partition, counting from 0.
denseRank()The rank without gaps of a row within the partition, counting from 0.
percentRank()Relative rank of a row: rank() / Collectable.count().
ntile(long)Divides the partition in equal buckets and assigns values between 0 and buckets - 1.
lead()Gets the value after the current row.
lag()Gets the value before the current row.
firstValue()Gets the first value in the window.
lastValue()Gets the last value in the window.
nthValue(long)Gets the nth value in the window, counting from 0.

Note: In Java, indexes are always counted from 0, not from 1 as in SQL. This means that the above ranking functions also rank rows from zero. This is particularly true for:

Aggregate functions

Each aggregate function from Seq or from Agg is also available as an aggregate function on the window. For instance, Collectable.count() is the same as calling Seq.count() on window()
Author:
Lukas Eder
  • Method Details

    • of

      static <T> WindowSpecification<T> of()
    • of

      static <T> WindowSpecification<T> of(long lower, long upper)
    • of

      static <T> WindowSpecification<T> of(Comparator<? super T> orderBy)
    • of

      static <T> WindowSpecification<T> of(Comparator<? super T> orderBy, long lower, long upper)
    • of

      static <T, U> WindowSpecification<T> of(Function<? super T,? extends U> partitionBy)
    • of

      static <T, U> WindowSpecification<T> of(Function<? super T,? extends U> partitionBy, long lower, long upper)
    • of

      static <T, U> WindowSpecification<T> of(Function<? super T,? extends U> partitionBy, Comparator<? super T> orderBy)
    • of

      static <T, U> WindowSpecification<T> of(Function<? super T,? extends U> partitionBy, Comparator<? super T> orderBy, long lower, long upper)
    • value

      T value()
      The value of the current row in the window.
    • window

      Seq<T> window()
      Stream all elements in the window.
    • rowNumber

      long rowNumber()
      The row number of the current row within the partition.

      
       // (1, 2, 3, 4, 5)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.rowNumber());
       
    • rank

      long rank()
      The rank of the current row within the partition.

      
       // (1, 2, 2, 4, 5)
       Seq.of(1, 2, 2, 3, 4).window(naturalOrder()).map(w -> w.rank());
       
    • denseRank

      long denseRank()
      The dense rank of the current row within the partition.

      
       // (1, 2, 2, 3, 4)
       Seq.of(1, 2, 2, 3, 4).window(naturalOrder()).map(w -> w.denseRank());
       
    • percentRank

      double percentRank()
      The precent rank of the current row within the partition.

      
       // (0.0, 0.25, 0.25, 0.75, 1.0)
       Seq.of(1, 2, 2, 3, 4).window(naturalOrder()).map(w -> w.percentRank());
       
    • ntile

      long ntile(long buckets)
      The bucket number ("ntile") of the current row within the partition.

      
       // (0, 0, 1, 1, 2)
       Seq.of(1, 2, 2, 3, 4).window(naturalOrder()).map(w -> w.ntile(3));
       
    • lead

      Optional<T> lead()
      The next value in the window.

      This is the same as calling lead(1)

      
       // (2, 2, 3, 4, empty)
       Seq.of(1, 2, 2, 3, 4).window().map(w -> w.lead());
       
    • lead

      Optional<T> lead(long lead)
      The next value by lead in the window.

      
       // (2, 2, 3, 4, empty)
       Seq.of(1, 2, 2, 3, 4).window().map(w -> w.lead());
       
    • lag

      Optional<T> lag()
      The previous value in the window.

      This is the same as calling lag(1)

      
       // (empty, 1, 2, 2, 3)
       Seq.of(1, 2, 2, 3, 4).window().map(w -> w.lag());
       
    • lag

      Optional<T> lag(long lag)
      The previous value by lag in the window.

      
       // (empty, 1, 2, 2, 3)
       Seq.of(1, 2, 2, 3, 4).window().map(w -> w.lag());
       
    • firstValue

      Optional<T> firstValue()
      The first value in the window.

      
       // (1, 1, 1, 1, 1)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.firstValue());
       
    • firstValue

      <U> Optional<U> firstValue(Function<? super T,? extends U> function)
      The first value in the window.

      
       // (1, 1, 1, 1, 1)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.firstValue());
       
    • lastValue

      Optional<T> lastValue()
      The last value in the window.

      
       // (3, 3, 3, 3, 3)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.lastValue());
       
    • lastValue

      <U> Optional<U> lastValue(Function<? super T,? extends U> function)
      The last value in the window.

      
       // (3, 3, 3, 3, 3)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.lastValue());
       
    • nthValue

      Optional<T> nthValue(long n)
      The nth value in the window.

      
       // (4, 4, 4, 4, 4)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.nthValue(2));
       
    • nthValue

      <U> Optional<U> nthValue(long n, Function<? super T,? extends U> function)
      The nth value in the window.

      
       // (4, 4, 4, 4, 4)
       Seq.of(1, 2, 4, 2, 3).window().map(w -> w.nthValue(2));