Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you 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 org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators;
 
 import java.util.List;
 
 
 public class POLimit extends PhysicalOperator {
   
 
     private static final long serialVersionUID = 1L;
 
     // Counts for outputs processed
     private long soFar = 0;
     
     // Number of limited outputs
     long mLimit;
 
     // The expression plan
 
     public POLimit(OperatorKey k) {
         this(k, -1, null);
     }
 
     public POLimit(OperatorKey kint rp) {
         this(krpnull);
     }
 
     public POLimit(OperatorKey kList<PhysicalOperatorinputs) {
         this(k, -1, inputs);
     }
 
     public POLimit(OperatorKey kint rpList<PhysicalOperatorinputs) {
         super(krpinputs);
     }
     
     public void setLimit(long limit) {
     	 = limit;
     }
     
     public long getLimit() {
     	return ;
     }
 
     public PhysicalPlan getLimitPlan() {
         return ;
     }
 
     public void setLimitPlan(PhysicalPlan expressionPlan) {
         this. = expressionPlan;
     }

    
Counts the number of tuples processed into static variable soFar, if the number of tuples processed reach the limit, return EOP; Otherwise, return the tuple
 
     @Override
     public Result getNextTuple() throws ExecException {
         // if it is the first time, evaluate the expression. Otherwise reuse the computed value.
         if (this.getLimit() < 0 &&  != null) {
             PhysicalOperator expression = .getLeaves().get(0);
             long variableLimit;
             Result returnValue;
             switch (expression.getResultType()) {
             case .:
                 returnValue = expression.getNextLong();
                 if (returnValue.returnStatus != . || returnValue.result == null)
                     throw new RuntimeException("Unable to evaluate Limit expression: "
                             + returnValue);
                 variableLimit = (LongreturnValue.result;
                break;
            case .:
                returnValue = expression.getNextInteger();
                if (returnValue.returnStatus != . || returnValue.result == null)
                    throw new RuntimeException("Unable to evaluate Limit expression: "
                            + returnValue);
                variableLimit = (IntegerreturnValue.result;
                break;
            default:
                throw new RuntimeException("Limit requires an integer parameter");
            }
            if (variableLimit <= 0)
                throw new RuntimeException("Limit requires a positive integer parameter");
            this.setLimit(variableLimit);
        }
        Result inp = null;
        while (true) {
            inp = processInput();
            if (inp.returnStatus == . || inp.returnStatus == .)
                break;
            
            illustratorMarkup(inp.resultnull, 0);
            // illustrator ignore LIMIT before the post processing
            if (( == null || .getOriginalLimit() != -1) && >=)
            	inp.returnStatus = .;
            
            ++;
            break;
        }
        return inp;
    }
    @Override
    public String name() {
        return getAliasString() + "Limit - " + .toString();
    }
    @Override
    public boolean supportsMultipleInputs() {
        return false;
    }
    @Override
    public boolean supportsMultipleOutputs() {
        return false;
    }
    @Override
    public void visit(PhyPlanVisitor vthrows VisitorException {
        v.visitLimit(this);
    }
    @Override
    public void reset() {
         = 0;
    }
    @Override
    public POLimit clone() throws CloneNotSupportedException {
        POLimit newLimit = new POLimit(new OperatorKey(this..,
            NodeIdGenerator.getGenerator().getNextNodeId(this..)),
            this.this.);
        newLimit.mLimit = this.;
        newLimit.expressionPlan = this..clone();
        newLimit.addOriginalLocation(getOriginalLocations());
        return newLimit;
    }
    
    @Override
    public Tuple illustratorMarkup(Object inObject outint eqClassIndex) {
        if( != null) {
            ExampleTuple tIn = (ExampleTuplein;
            .getEquivalenceClasses().get(eqClassIndex).add(tIn);
            .addData((Tuplein);
        }
        return (Tuplein;
    }
New to GrepCode? Check out our FAQ X