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.newplan.logical.rules;
 
 import java.util.Map;
 import java.util.Set;
 
This Rule prunes columns and map keys and set to loader. This rule depends on MapKeysPruneHelper to calculate what keys are required for a loader, and ColumnPruneHelper to calculate the required columns for a loader. Then it combines the map keys and columns info to set into the loader.
 
 public class ColumnMapKeyPrune extends WholePlanRule {
     private boolean hasRun;
     
     public ColumnMapKeyPrune(String n) {
         super(nfalse);
          = false;
     }
 
     @Override
     public Transformer getNewTransformer() {
         return new ColumnMapKeyPruneTransformer();
     }
     
     public class ColumnMapKeyPruneTransformer extends Transformer {
         private MapKeysPruneHelper mapKeyHelper;
         private ColumnPruneHelper columnHelper;
         private boolean columnPrune;
         private boolean mapKeyPrune;
 
         /*
          * This is a map of of required columns and map keys for each LOLoad        
          * RequiredMapKeys --> Map<Integer, Set<String> >
          * RequiredColumns --> Set<Integer>
          * 
          * The integer are column indexes.
          */
         private Map<LOLoad,Pair<Map<Integer,Set<String>>,Set<Integer>>> requiredItems = 
             new HashMap<LOLoad,Pair<Map<Integer,Set<String>>,Set<Integer>>>();
         
         @Override
         public boolean check(OperatorPlan matchedthrows FrontendException {
             // only run this rule once
             if () {
                 return false;
             }
             
              = true;
              = new MapKeysPruneHelper(matched);
              = new ColumnPruneHelper(matched);
             
             // check if map keys can be pruned
              = .check();
             // check if columns can be pruned
              = .check();
             
             return  || ;
         }
 
         @Override
         public OperatorPlan reportChanges() {
             return ;
         }
         
         @SuppressWarnings("unchecked")
         private void merge() throws FrontendException {            
             // combine annotations
             forOperator source : .getSources() ) {
                 Map<Integer,Set<String>> mapKeys = 
                     (Map<IntegerSet<String>>) source.getAnnotation(.);
                 Set<IntegerrequiredColumns = null;
                if (source.getAnnotation(.) != null) {
                    requiredColumns = new HashSet<Integer>((Set<Integer>) source.getAnnotation(.));
                }
                
                // We dont have any information so skip
                ifrequiredColumns == null && mapKeys == null ) {
                    continue;
                }
                                
                ifrequiredColumns != null && mapKeys != null ) { 
                    Set<IntegerduplicatedCols = new HashSet<Integer>();
                    // Remove the columns already marked by MapKeys
                    forInteger col : requiredColumns ) {
                        ifmapKeys.containsKey(col) ) {
                            duplicatedCols.add(col);
                        }
                    }
                    requiredColumns.removeAll(duplicatedCols);
                } else if ( mapKeys != null && requiredColumns == null ) {
                    // This is the case where only mapKeys can be pruned. And none
                    // of the columns can be pruned. So we add all columns to the
                    // requiredcolumns part
                    requiredColumns = new HashSet<Integer>();
                    for(int i = 0; i < ((LogicalRelationalOperator)source).getSchema().size(); i++ ) {
                        if( !mapKeys.containsKey(i) ) {
                            requiredColumns.add(i);
                        }
                    }
                }
                .put((LOLoadsourcenew Pair<Map<Integer,Set<String>>,Set<Integer>>(mapKeysrequiredColumns));
            }         
        }
        @Override
        public void transform(OperatorPlan matchedthrows FrontendException {        	            
            merge();
            
            ColumnPruneVisitor columnPruneVisitor = new ColumnPruneVisitor();
            columnPruneVisitor.visit();
        }
    }
New to GrepCode? Check out our FAQ X