Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator.window;
 
 
 import java.util.List;
 
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_WINDOW_FRAME;
 import static com.facebook.presto.sql.tree.FrameBound.Type.FOLLOWING;
 import static com.facebook.presto.sql.tree.FrameBound.Type.PRECEDING;
 import static com.facebook.presto.sql.tree.FrameBound.Type.UNBOUNDED_FOLLOWING;
 import static com.facebook.presto.sql.tree.FrameBound.Type.UNBOUNDED_PRECEDING;
 import static com.facebook.presto.sql.tree.WindowFrame.Type.RANGE;
 import static com.facebook.presto.util.Failures.checkCondition;
 import static com.google.common.base.Preconditions.checkState;
 
 public final class WindowPartition
 {
     private final PagesIndex pagesIndex;
     private final int partitionStart;
     private final int partitionEnd;
 
     private final int[] outputChannels;
     private final List<WindowFunctionwindowFunctions;
     private final FrameInfo frameInfo;
     private final PagesHashStrategy peerGroupHashStrategy;
 
     private int peerGroupStart;
     private int peerGroupEnd;
     private int frameStart;
     private int frameEnd;
 
     private int currentPosition;
 
     public WindowPartition(PagesIndex pagesIndex,
             int partitionStart,
             int partitionEnd,
             int[] outputChannels,
             List<WindowFunctionwindowFunctions,
             FrameInfo frameInfo,
             PagesHashStrategy peerGroupHashStrategy)
     {
         this. = pagesIndex;
         this. = partitionStart;
         this. = partitionEnd;
         this. = outputChannels;
         this. = windowFunctions;
         this. = frameInfo;
         this. = peerGroupHashStrategy;
 
         // reset functions for new partition
         WindowIndex windowIndex = new WindowIndex(pagesIndexpartitionStartpartitionEnd);
         for (WindowFunction windowFunction : windowFunctions) {
             windowFunction.reset(windowIndex);
         }
 
          = partitionStart;
         updatePeerGroup();
     }
 
     public int getPartitionEnd()
     {
         return ;
     }
 
     public boolean hasNext()
     {
         return  < ;
     }
 
     public void processNextRow(PageBuilder pageBuilder)
     {
         checkState(hasNext(), "No more rows in partition");
 
         // copy output channels
         pageBuilder.declarePosition();
         int channel = 0;
         while (channel < .) {
             .appendTo([channel], pageBuilder.getBlockBuilder(channel));
             channel++;
         }
 
         // check for new peer group
        if ( == ) {
            updatePeerGroup();
        }
        // compute window frame
        updateFrame();
        // process window functions
        for (WindowFunction function : ) {
            function.processRow(
                    pageBuilder.getBlockBuilder(channel),
                     - ,
                     -  - 1,
                    ,
                    );
            channel++;
        }
        ++;
    }
    private void updatePeerGroup()
    {
         = ;
        // find end of peer group
         =  + 1;
            ++;
        }
    }
    private void updateFrame()
    {
        int rowPosition =  - ;
        int endPosition =  -  - 1;
        // frame start
        if (.getStartType() == ) {
             = 0;
        }
        else if (.getStartType() == ) {
             = preceding(rowPositiongetStartValue());
        }
        else if (.getStartType() == ) {
             = following(rowPositionendPositiongetStartValue());
        }
        else if (.getType() == ) {
             =  - ;
        }
        else {
             = rowPosition;
        }
        // frame end
        if (.getEndType() == ) {
             = endPosition;
        }
        else if (.getEndType() == ) {
             = preceding(rowPositiongetEndValue());
        }
        else if (.getEndType() == ) {
             = following(rowPositionendPositiongetEndValue());
        }
        else if (.getType() == ) {
             =  -  - 1;
        }
        else {
             = rowPosition;
        }
        // handle empty frame
        if (emptyFrame(rowPositionendPosition)) {
             = -1;
             = -1;
        }
    }
    private boolean emptyFrame(int rowPositionint endPosition)
    {
        if (.getStartType() != .getEndType()) {
            return false;
        }
        FrameBound.Type type = .getStartType();
        if ((type != ) && (type != )) {
            return false;
        }
        long start = getStartValue();
        long end = getEndValue();
        if (type == ) {
            return (start < end) || ((start > rowPosition) && (end > rowPosition));
        }
        int positions = endPosition - rowPosition;
        return (start > end) || ((start > positions) && (end > positions));
    }
    private static int preceding(int rowPositionlong value)
    {
        if (value > rowPosition) {
            return 0;
        }
        return Ints.checkedCast(rowPosition - value);
    }
    private static int following(int rowPositionint endPositionlong value)
    {
        if (value > (endPosition - rowPosition)) {
            return endPosition;
        }
        return Ints.checkedCast(rowPosition + value);
    }
    private long getStartValue()
    {
        return getFrameValue(.getStartChannel(), "starting");
    }
    private long getEndValue()
    {
        return getFrameValue(.getEndChannel(), "ending");
    }
    private long getFrameValue(int channelString type)
    {
        checkCondition(!.isNull(channel), "Window frame %s offset must not be null"type);
        long value = .getLong(channel);
        checkCondition(value >= 0, "Window frame %s offset must not be negative");
        return value;
    }
New to GrepCode? Check out our FAQ X