test/org/apache/pig/test/TestPhyPatternMatch.java

/*
 * 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.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.List;

import org.apache.pig.backend.executionengine.ExecException;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans.PatternNode;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans.PatternPlan;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans.PhysicalPlan;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POFRJoin;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POFilter;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POForEach;
import org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators.POStore;
import org.apache.pig.impl.plan.OperatorKey;
import org.apache.pig.impl.plan.PlanException;
import org.junit.Before;
import org.junit.Test;


public class TestPhyPatternMatch {
  
    int opKeyNum = 0;
    
    @Before
    public void setUp() throws Exception {
        opKeyNum = 0;
    }
    
    
    @Test
    public void testSingleNodePattern() throws PlanException{
        
        //create pattern 
        PatternPlan ptPlan = new PatternPlan();
        PatternNode ptFilNode = new PatternNode(ptPlan);
        ptFilNode.setClassName(POFilter.class);
        ptPlan.add(ptFilNode);
                
        //create plan with single ForEach node
        PhysicalPlan pplan = new PhysicalPlan();
        POForEach fe = new POForEach(getNewOpKey()); 
        pplan.add(fe);

        // verify that match is false
        boolean matched = ptPlan.match(pplan);
        assertFalse("plan not matched", matched);

        
        //add a filter to the plan (fe -> fil)
        POFilter fil = new POFilter(getNewOpKey()); 
        pplan.add(fil);
        pplan.connect(fe, fil);
        
        //verify that pattern matches
        matched = ptPlan.match(pplan);
        assertTrue("plan matched", matched);
        assertEquals(" class matched ", ptFilNode.getMatch(), fil);
        
        //test leaf/source settings in pattern node
        ptFilNode.setSourceNode(true);
        assertFalse("plan matched", ptPlan.match(pplan));
        
        ptFilNode.setSourceNode(false);
        ptFilNode.setLeafNode(true);
        assertTrue("plan matched", ptPlan.match(pplan));
        
        
        
    }

    @Test
    public void testTwoNodePattern() throws PlanException{
        //create pattern (foreach -> filter)
        Class<?>[] nodes = {POForEach.class, POFilter.class};
        PatternPlan ptPlan = PatternPlan.create(nodes);
        PatternNode ptFilNode = (PatternNode) ptPlan.getSinks().get(0);
        PatternNode ptFENode = (PatternNode) ptPlan.getSources().get(0);

        
        //create plan with single Filter node
        PhysicalPlan pplan = new PhysicalPlan();
        POFilter fil = new POFilter(getNewOpKey()); 
        pplan.add(fil);

        // verify that match is false
        assertFalse("plan not matched", ptPlan.match(pplan));
        
        //verify that there is no match in the pattern nodes
        assertEquals("null match", ptFilNode.getMatch(), null);
        assertEquals("null match", ptFENode.getMatch(), null);

        //add a foreach to the plan (fe -> fil)
        POForEach fe = new POForEach(getNewOpKey()); 
        pplan.add(fe);
        pplan.connect(fe, fil);

        // verify that match is true
        assertTrue("plan matched", ptPlan.match(pplan));

        // set leaf and source properties and try again
        ptFilNode.setLeafNode(true);
        ptFENode.setSourceNode(true);
        assertTrue("plan matched", ptPlan.match(pplan));        
        
        //add a store to the plan to make it (fe -> fil -> store)
        POStore store = new POStore(getNewOpKey());
        pplan.add(store);
        pplan.connect(fil, store);
        
        // match should fail because filter pt node leaf property is set
        assertFalse("plan matched", ptPlan.match(pplan));
        //reset patter filter node leaf property
        ptFilNode.setLeafNode(false);
        
        
        // verify that match is true
        assertTrue("plan matched", ptPlan.match(pplan));
        assertEquals("filter pt node match", ptFilNode.getMatch(), fil);
        assertEquals("foreach pt node match", ptFENode.getMatch(), fe);
               
        
        //add a store to the plan to make it (fe -> fe -> fil -> store)
        POForEach fe2 = new POForEach(getNewOpKey());
        pplan.add(fe2);
        pplan.connect(fe2, fe);
        
        // match fails because fe pattern node is set to be source
        assertFalse("plan matched", ptPlan.match(pplan));
        ptFENode.setSourceNode(false);
        
        // verify that match is true
        assertTrue("plan matched", ptPlan.match(pplan));
        assertEquals("filter pt node match", ptFilNode.getMatch(), fil);
        assertEquals("foreach pt node match", ptFENode.getMatch(), fe);
        
        //create new plan (fil -> fe)
        PhysicalPlan pplan2 = new PhysicalPlan();
        POFilter fil2 = new POFilter(getNewOpKey()); 
        pplan.add(fil2);
        POForEach fe21 = new POForEach(getNewOpKey()); 
        pplan.add(fe21);
        pplan.connect(fil2, fe21);

        //verify that plan does not match
        assertFalse("plan not matched", ptPlan.match(pplan2));
        assertEquals("null match", ptFilNode.getMatch(), null);
        assertEquals("null match", ptFENode.getMatch(), null);     
        
    }
    
    
    @Test
    public void testThreeNodePatternLinear() throws PlanException{
        
        //create pattern (fil -> FE -> store) 
        PatternPlan ptPlan = new PatternPlan();
        PatternNode ptFilNode = createPtNode(ptPlan, POFilter.class);
        PatternNode ptFENode = createPtNode(ptPlan, POForEach.class);
        PatternNode ptStNode = createPtNode(ptPlan, POStore.class);

        ptPlan.connect(ptFilNode, ptFENode);
        ptPlan.connect(ptFENode, ptStNode);
        
        //create plan fil -> fil -> fe -> store
        PhysicalPlan pplan = new PhysicalPlan();
        POFilter fil = new POFilter(getNewOpKey()); 
        pplan.add(fil);
        assertFalse("plan not matched", ptPlan.match(pplan));
        assertEquals("null match", ptFilNode.getMatch(), null);
        assertEquals("null match", ptFENode.getMatch(), null);
        assertEquals("null match", ptStNode.getMatch(), null);
        
        POForEach fe = new POForEach(getNewOpKey()); 
        pplan.add(fe);
        pplan.connect(fil, fe);
        assertFalse("plan not matched", ptPlan.match(pplan));
        
        POFilter fil2 = new POFilter(getNewOpKey()); 
        pplan.add(fil2);
        pplan.connect(fil2, fil);
        assertFalse("plan not matched", ptPlan.match(pplan));
        
        POStore store = new POStore(getNewOpKey()); 
        pplan.add(store);
        pplan.connect(fe, store);
        assertTrue("plan matched", ptPlan.match(pplan));
        
        assertEquals("test match node", ptFilNode.getMatch(), fil);
        assertEquals("test match node", ptFENode.getMatch(), fe);
        assertEquals("test match node", ptStNode.getMatch(), store);
        
        
        
    }
    
    
    @Test
    public void testThreeNodePatternTwoParents() throws PlanException, ExecException{
        //create pattern fe   fil
        //                \   /
        //                frJoin
        PatternPlan ptPlan = new PatternPlan();
        PatternNode ptFilNode = createPtNode(ptPlan, POFilter.class);
        PatternNode ptFENode = createPtNode(ptPlan, POForEach.class);
        PatternNode ptJoinNode = createPtNode(ptPlan, POFRJoin.class);

        ptPlan.connect(ptFilNode, ptJoinNode);
        ptPlan.connect(ptFENode, ptJoinNode);
        
        //create plan 
        PhysicalPlan pplan = new PhysicalPlan();
        POFilter fil = new POFilter(getNewOpKey()); 
        pplan.add(fil);
        assertFalse("plan not matched", ptPlan.match(pplan));
        
        POForEach fe = new POForEach(getNewOpKey()); 
        pplan.add(fe);
        assertFalse("plan not matched", ptPlan.match(pplan));
        
        POFRJoin join = new POFRJoin(getNewOpKey(), 0, null,
                new ArrayList<List<PhysicalPlan>>(), null, null, 0, false,null); 
        pplan.add(join);
        pplan.connect(fil, join);
        pplan.connect(fe, join);
        assertTrue("plan matched", ptPlan.match(pplan));
        assertEquals("test match node", ptFilNode.getMatch(), fil);
        assertEquals("test match node", ptFENode.getMatch(), fe);
        assertEquals("test match node", ptJoinNode.getMatch(), join);
        
    }
    
    
    private PatternNode createPtNode(PatternPlan ptPlan, Class<?> ptClass) {
        PatternNode ptNode = new PatternNode(ptPlan);
        ptNode.setClassName(ptClass);
        ptPlan.add(ptNode);
        return ptNode;
        
    }


    private OperatorKey getNewOpKey() {
        return new OperatorKey("", ++opKeyNum);
    }
    
    
}