public void testSimplePlan() throws Exception {
    LogicalPlanTester lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load 'd.txt';");
    lpt.buildPlan("b = filter a by $0==NULL;");
    LogicalPlan plan = lpt.buildPlan("store b into 'empty';");

    // check basics
    org.apache.pig.experimental.logical.relational.LogicalPlan newPlan = migratePlan(plan);
    assertEquals(3, newPlan.size());
    assertEquals(newPlan.getSources().size(), 1);

    // check load
    LogicalRelationalOperator op = (LogicalRelationalOperator) newPlan.getSources().get(0);
    assertEquals(op.getClass(), org.apache.pig.experimental.logical.relational.LOLoad.class);

    // check filter
    op = (LogicalRelationalOperator) newPlan.getSuccessors(op).get(0);
    assertEquals(op.getClass(), org.apache.pig.experimental.logical.relational.LOFilter.class);

    LogicalExpressionPlan exp =
        ((org.apache.pig.experimental.logical.relational.LOFilter) op).getFilterPlan();

    EqualExpression eq = (EqualExpression) exp.getSources().get(0);
    assertEquals(eq.getLhs().getClass(), ProjectExpression.class);
    assertEquals(((ProjectExpression) eq.getLhs()).getColNum(), 0);
    assertEquals(((ProjectExpression) eq.getLhs()).getInputNum(), 0);

    assertEquals(eq.getRhs().getClass(), ConstantExpression.class);

    // check store
    op = (LogicalRelationalOperator) newPlan.getSuccessors(op).get(0);
    assertEquals(op.getClass(), org.apache.pig.experimental.logical.relational.LOStore.class);
  }
  public void testCoGroup() throws Exception {
    LogicalPlanTester lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (name:chararray, age:int, gpa:float);");
    lpt.buildPlan("b = group a by name;");
    LogicalPlan plan = lpt.buildPlan("store b into '/test/empty';");

    // check basics
    org.apache.pig.experimental.logical.relational.LogicalPlan newPlan = migratePlan(plan);

    LogicalSchema loadSchema =
        ((LogicalRelationalOperator) newPlan.getSources().get(0)).getSchema();

    Set<Long> uids = getAllUids(loadSchema);

    LogicalRelationalOperator op =
        (LogicalRelationalOperator) newPlan.getSuccessors(newPlan.getSources().get(0)).get(0);
    assertEquals(LOCogroup.class, op.getClass());
    LogicalSchema schema = op.getSchema();

    assertEquals(2, schema.size());
    assertEquals(DataType.CHARARRAY, schema.getField(0).type);
    assertEquals(false, uids.contains(schema.getField(0).uid));
    assertEquals(0, schema.getField(0).alias.compareTo("group"));

    assertEquals(DataType.BAG, schema.getField(1).type);

    assertEquals(DataType.CHARARRAY, schema.getField(1).schema.getField(0).type);
    assertEquals(0, schema.getField(1).schema.getField(0).alias.compareTo("name"));
    assertEquals(loadSchema.getField(0).uid, schema.getField(1).schema.getField(0).uid);
    assertEquals(DataType.INTEGER, schema.getField(1).schema.getField(1).type);
    assertEquals(0, schema.getField(1).schema.getField(1).alias.compareTo("age"));
    assertEquals(loadSchema.getField(1).uid, schema.getField(1).schema.getField(1).uid);
    assertEquals(DataType.FLOAT, schema.getField(1).schema.getField(2).type);
    assertEquals(0, schema.getField(1).schema.getField(2).alias.compareTo("gpa"));
    assertEquals(loadSchema.getField(2).uid, schema.getField(1).schema.getField(2).uid);

    uids.add(Long.valueOf(schema.getField(0).uid));
    assertEquals(false, uids.contains(schema.getField(1).uid));

    assertEquals(
        LOCogroup.class, newPlan.getSuccessors(newPlan.getSources().get(0)).get(0).getClass());
    LOCogroup cogroup = (LOCogroup) newPlan.getSuccessors(newPlan.getSources().get(0)).get(0);

    MultiMap<Integer, LogicalExpressionPlan> expressionPlans = cogroup.getExpressionPlans();
    assertEquals(1, expressionPlans.size());
    List<LogicalExpressionPlan> plans =
        (List<LogicalExpressionPlan>) expressionPlans.get(Integer.valueOf(0));
    assertEquals(1, plans.size());

    LogicalExpressionPlan exprPlan = plans.get(0);
    assertEquals(1, exprPlan.getSinks().size());
    assertEquals(ProjectExpression.class, exprPlan.getSinks().get(0).getClass());
    ProjectExpression prj = (ProjectExpression) exprPlan.getSinks().get(0);
    assertEquals(loadSchema.getField(0).uid, prj.getUid());
    assertEquals(0, prj.getColNum());
    assertEquals(0, prj.getInputNum());
  }
Exemplo n.º 3
0
  @Test
  public void testMRCompilerErr() throws Exception {
    planTester.buildPlan("a = load 'input';");
    LogicalPlan lp = planTester.buildPlan("b = filter a by $0 > 5;");

    PhysicalPlan pp = Util.buildPhysicalPlan(lp, pc);
    pp.remove(pp.getRoots().get(0));
    try {
      Util.buildMRPlan(new PhysicalPlan(), pc);
      fail("Expected failure.");
    } catch (MRCompilerException mrce) {
      assertTrue(mrce.getErrorCode() == 2053);
    }
  }
Exemplo n.º 4
0
  /**
   * Test to ensure that the order by with parallel followed by a limit, i.e., top k always produces
   * the correct number of map reduce jobs
   */
  @Test
  public void testNumReducersInLimitWithParallel() throws Exception {
    planTester.buildPlan("a = load 'input';");
    planTester.buildPlan("b = order a by $0 parallel 2;");
    planTester.buildPlan("c = limit b 10;");
    LogicalPlan lp = planTester.buildPlan("store c into '/tmp';");

    PhysicalPlan pp = Util.buildPhysicalPlan(lp, pc);
    MROperPlan mrPlan = Util.buildMRPlan(pp, pc);
    MapReduceOper mrOper = mrPlan.getRoots().get(0);
    int count = 1;

    while (mrPlan.getSuccessors(mrOper) != null) {
      mrOper = mrPlan.getSuccessors(mrOper).get(0);
      ++count;
    }
    assertTrue(count == 4);
  }
Exemplo n.º 5
0
  @Test
  public void testImplicitSplitInCoGroup2() throws Exception {
    // this query is similar to the one reported in JIRA - PIG-537
    LogicalPlanTester planTester = new LogicalPlanTester();
    planTester.buildPlan("a = load 'file1' using PigStorage(':') as (name:chararray, marks:int);");
    planTester.buildPlan(
        "b = load 'file2' using PigStorage(':') as (name:chararray, rank:chararray);");
    planTester.buildPlan("c = cogroup a by name, b by name;");
    planTester.buildPlan("d = foreach c generate group, FLATTEN(a.marks) as newmarks;");
    planTester.buildPlan("e = cogroup a by marks, d by newmarks;");
    LogicalPlan plan =
        planTester.buildPlan("f = foreach e generate group, flatten(a), flatten(d);");

    // Set the logical plan values correctly in all the operators
    PlanSetter ps = new PlanSetter(plan);
    ps.visit();

    // run through validator
    CompilationMessageCollector collector = new CompilationMessageCollector();
    TypeCheckingValidator typeValidator = new TypeCheckingValidator();
    typeValidator.validate(plan, collector);
    printMessageCollector(collector);
    printTypeGraph(plan);

    if (collector.hasError()) {
      throw new Exception("Error during type checking");
    }

    // this will run ImplicitSplitInserter
    TestLogicalOptimizer.optimizePlan(plan);

    // get Schema of leaf and compare:
    Schema expectedSchema =
        Util.getSchemaFromString(
            "grp: int,A::username: chararray,A::marks: int,AB::group: chararray,AB::newmarks: int");
    assertTrue(Schema.equals(expectedSchema, plan.getLeaves().get(0).getSchema(), false, true));
  }
  public void testCoGroup4() throws Exception {
    LogicalPlanTester lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (name:chararray, age:int, gpa:float);");
    lpt.buildPlan("b = load '/test/e.txt' as (name:chararray, age:int, blah:chararray );");
    lpt.buildPlan("c = group a by ( name, age ), b by ( name, age );");
    LogicalPlan plan = lpt.buildPlan("store c into '/test/empty';");

    // check basics
    org.apache.pig.experimental.logical.relational.LogicalPlan newPlan = migratePlan(plan);

    assertEquals(
        LOCogroup.class, newPlan.getSuccessors(newPlan.getSources().get(0)).get(0).getClass());
    LOCogroup cogroup = (LOCogroup) newPlan.getSuccessors(newPlan.getSources().get(0)).get(0);

    // Reason for this strange way of getting the load schema is to maintain the sequence correctly
    LogicalSchema loadSchema =
        ((LogicalRelationalOperator) newPlan.getPredecessors(cogroup).get(0)).getSchema();

    LogicalSchema load2Schema =
        ((LogicalRelationalOperator) newPlan.getPredecessors(cogroup).get(1)).getSchema();

    Set<Long> uids = getAllUids(loadSchema);
    uids.addAll(getAllUids(load2Schema));

    LogicalRelationalOperator op =
        (LogicalRelationalOperator) newPlan.getSuccessors(newPlan.getSources().get(0)).get(0);
    assertEquals(LOCogroup.class, op.getClass());
    LogicalSchema schema = op.getSchema();

    assertEquals(3, schema.size());
    assertEquals(DataType.TUPLE, schema.getField(0).type);
    assertEquals(false, uids.contains(schema.getField(0).uid));
    assertEquals(0, schema.getField(0).alias.compareTo("group"));
    assertEquals(DataType.CHARARRAY, schema.getField(0).schema.getField(0).type);
    assertEquals(0, schema.getField(0).schema.getField(0).alias.compareTo("name"));
    assertEquals(DataType.INTEGER, schema.getField(0).schema.getField(1).type);
    assertEquals(0, schema.getField(0).schema.getField(1).alias.compareTo("age"));

    assertEquals(DataType.BAG, schema.getField(1).type);

    assertEquals(DataType.CHARARRAY, schema.getField(1).schema.getField(0).type);
    assertEquals(0, schema.getField(1).schema.getField(0).alias.compareTo("name"));
    assertEquals(loadSchema.getField(0).uid, schema.getField(1).schema.getField(0).uid);
    assertEquals(DataType.INTEGER, schema.getField(1).schema.getField(1).type);
    assertEquals(0, schema.getField(1).schema.getField(1).alias.compareTo("age"));
    assertEquals(loadSchema.getField(1).uid, schema.getField(1).schema.getField(1).uid);
    assertEquals(DataType.FLOAT, schema.getField(1).schema.getField(2).type);
    assertEquals(0, schema.getField(1).schema.getField(2).alias.compareTo("gpa"));
    assertEquals(loadSchema.getField(2).uid, schema.getField(1).schema.getField(2).uid);

    assertEquals(DataType.BAG, schema.getField(2).type);

    assertEquals(DataType.CHARARRAY, schema.getField(2).schema.getField(0).type);
    assertEquals(0, schema.getField(2).schema.getField(0).alias.compareTo("name"));
    assertEquals(load2Schema.getField(0).uid, schema.getField(2).schema.getField(0).uid);
    assertEquals(DataType.INTEGER, schema.getField(2).schema.getField(1).type);
    assertEquals(0, schema.getField(2).schema.getField(1).alias.compareTo("age"));
    assertEquals(load2Schema.getField(1).uid, schema.getField(2).schema.getField(1).uid);
    assertEquals(DataType.CHARARRAY, schema.getField(2).schema.getField(2).type);
    assertEquals(0, schema.getField(2).schema.getField(2).alias.compareTo("blah"));
    assertEquals(load2Schema.getField(2).uid, schema.getField(2).schema.getField(2).uid);

    // We are doing Uid tests at the end as the uids should not repeat
    assertEquals(false, uids.contains(schema.getField(0).schema.getField(0).uid));
    assertEquals(false, uids.contains(schema.getField(0).schema.getField(1).uid));
    assertEquals(false, uids.contains(schema.getField(1).uid));
    uids.add(schema.getField(1).uid);
    assertEquals(false, uids.contains(schema.getField(2).uid));

    MultiMap<Integer, LogicalExpressionPlan> expressionPlans = cogroup.getExpressionPlans();
    assertEquals(2, expressionPlans.size());
    List<LogicalExpressionPlan> plans =
        (List<LogicalExpressionPlan>) expressionPlans.get(Integer.valueOf(0));
    assertEquals(2, plans.size());

    List<LogicalExpressionPlan> plans2 =
        (List<LogicalExpressionPlan>) expressionPlans.get(Integer.valueOf(1));
    assertEquals(2, plans2.size());

    LogicalExpressionPlan exprPlan = plans.get(0);
    assertEquals(1, exprPlan.getSinks().size());
    assertEquals(ProjectExpression.class, exprPlan.getSinks().get(0).getClass());
    ProjectExpression prj = (ProjectExpression) exprPlan.getSinks().get(0);
    assertEquals(loadSchema.getField(0).uid, prj.getUid());
    assertEquals(0, prj.getColNum());
    assertEquals(0, prj.getInputNum());

    LogicalExpressionPlan exprPlan2 = plans.get(1);
    assertEquals(1, exprPlan2.getSinks().size());
    assertEquals(ProjectExpression.class, exprPlan2.getSinks().get(0).getClass());
    ProjectExpression prj2 = (ProjectExpression) exprPlan2.getSinks().get(0);
    assertEquals(loadSchema.getField(1).uid, prj2.getUid());
    assertEquals(1, prj2.getColNum());
    assertEquals(0, prj2.getInputNum());

    LogicalExpressionPlan exprPlan3 = plans2.get(0);
    assertEquals(1, exprPlan3.getSinks().size());
    assertEquals(ProjectExpression.class, exprPlan3.getSinks().get(0).getClass());
    ProjectExpression prj3 = (ProjectExpression) exprPlan3.getSinks().get(0);
    assertEquals(load2Schema.getField(0).uid, prj3.getUid());
    assertEquals(0, prj3.getColNum());
    assertEquals(1, prj3.getInputNum());

    LogicalExpressionPlan exprPlan4 = plans2.get(1);
    assertEquals(1, exprPlan4.getSinks().size());
    assertEquals(ProjectExpression.class, exprPlan4.getSinks().get(0).getClass());
    ProjectExpression prj4 = (ProjectExpression) exprPlan4.getSinks().get(0);
    assertEquals(load2Schema.getField(1).uid, prj4.getUid());
    assertEquals(1, prj4.getColNum());
    assertEquals(1, prj4.getInputNum());
  }
  public void testForeachPlan2() throws Exception {
    LogicalPlanTester lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (id, d:bag{t:(id:int, s)});");
    lpt.buildPlan("b = foreach a generate id, FLATTEN(d);");
    LogicalPlan plan = lpt.buildPlan("store b into '/test/empty';");

    // check basics
    org.apache.pig.experimental.logical.relational.LogicalPlan newPlan = migratePlan(plan);

    org.apache.pig.experimental.logical.relational.LogicalPlan expected =
        new org.apache.pig.experimental.logical.relational.LogicalPlan();

    LogicalSchema aschema = new LogicalSchema();
    aschema.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.BYTEARRAY));
    LogicalSchema aschema2 = new LogicalSchema();
    LogicalSchema aschema3 = new LogicalSchema();
    aschema3.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.INTEGER));
    aschema3.addField(new LogicalSchema.LogicalFieldSchema("s", null, DataType.BYTEARRAY));
    aschema2.addField(new LogicalSchema.LogicalFieldSchema("t", aschema3, DataType.TUPLE));
    aschema.addField(new LogicalSchema.LogicalFieldSchema("d", aschema2, DataType.BAG));

    LOLoad load =
        new LOLoad(
            new FileSpec("file:///test/d.txt", new FuncSpec("org.apache.pig.builtin.PigStorage")),
            aschema,
            expected);
    expected.add(load);

    LOForEach foreach2 = new LOForEach(expected);
    org.apache.pig.experimental.logical.relational.LogicalPlan innerPlan =
        new org.apache.pig.experimental.logical.relational.LogicalPlan();
    LOInnerLoad l1 = new LOInnerLoad(innerPlan, foreach2, 0);
    innerPlan.add(l1);
    LOInnerLoad l2 = new LOInnerLoad(innerPlan, foreach2, 1);

    List<LogicalExpressionPlan> eps = new ArrayList<LogicalExpressionPlan>();
    LogicalExpressionPlan p1 = new LogicalExpressionPlan();
    new ProjectExpression(p1, DataType.BYTEARRAY, 0, 0);
    LogicalExpressionPlan p2 = new LogicalExpressionPlan();
    new ProjectExpression(p2, DataType.BAG, 1, 0);
    eps.add(p1);
    eps.add(p2);

    LOGenerate gen = new LOGenerate(innerPlan, eps, new boolean[] {false, true});
    innerPlan.add(gen);
    innerPlan.connect(l1, gen);
    innerPlan.connect(l2, gen);

    foreach2.setInnerPlan(innerPlan);
    expected.add(foreach2);

    LOStore s =
        new LOStore(
            expected,
            new FileSpec("file:///test/empty", new FuncSpec("org.apache.pig.builtin.PigStorage")));

    expected.add(s);

    expected.connect(load, foreach2);

    expected.connect(foreach2, s);
    try {
      UidStamper stamper = new UidStamper(expected);
      stamper.visit();
    } catch (Exception e) {
      throw new VisitorException(e);
    }

    assertTrue(expected.isEqual(newPlan));

    LogicalSchema schema = foreach2.getSchema();
    aschema = new LogicalSchema();
    aschema.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.BYTEARRAY));
    aschema.addField(new LogicalSchema.LogicalFieldSchema("d::id", null, DataType.INTEGER));
    aschema.addField(new LogicalSchema.LogicalFieldSchema("s", null, DataType.BYTEARRAY));
    assertTrue(schema.isEqual(aschema));
    assertTrue(schema.getField("id") == schema.getField(0));
    assertTrue(schema.getField("d::id") == schema.getField(1));
  }
  public void testForeachSchema() throws Exception {
    // test flatten
    LogicalPlanTester lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (id, d:tuple(v, s));");
    LogicalPlan plan = lpt.buildPlan("b = foreach a generate id, FLATTEN(d);");

    org.apache.pig.experimental.logical.relational.LogicalPlan newPlan = migratePlan(plan);
    LogicalRelationalOperator op = (LogicalRelationalOperator) newPlan.getSinks().get(0);

    LogicalSchema s2 = new LogicalSchema();
    s2.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.BYTEARRAY));
    s2.addField(new LogicalSchema.LogicalFieldSchema("v", null, DataType.BYTEARRAY));
    s2.addField(new LogicalSchema.LogicalFieldSchema("s", null, DataType.BYTEARRAY));
    assertTrue(s2.isEqual(op.getSchema()));

    // test no flatten
    lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (id, d:bag{t:(v, s)});");
    plan = lpt.buildPlan("b = foreach a generate id, d;");

    newPlan = migratePlan(plan);
    op = (LogicalRelationalOperator) newPlan.getSinks().get(0);

    LogicalSchema aschema = new LogicalSchema();
    aschema.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.BYTEARRAY));
    LogicalSchema aschema2 = new LogicalSchema();
    LogicalSchema aschema3 = new LogicalSchema();
    aschema3.addField(new LogicalSchema.LogicalFieldSchema("v", null, DataType.BYTEARRAY));
    aschema3.addField(new LogicalSchema.LogicalFieldSchema("s", null, DataType.BYTEARRAY));
    aschema2.addField(new LogicalSchema.LogicalFieldSchema("t", aschema3, DataType.TUPLE));
    aschema.addField(new LogicalSchema.LogicalFieldSchema("d", aschema2, DataType.BAG));

    assertTrue(aschema.isEqual(op.getSchema()));

    // check with defined data type
    lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (id, d:bag{t:(v:int, s)});");
    lpt.buildPlan("b = foreach a generate id, FLATTEN(d);");
    plan = lpt.buildPlan("store b into '/test/empty';");

    newPlan = migratePlan(plan);
    op = (LogicalRelationalOperator) newPlan.getSinks().get(0);
    op = (LogicalRelationalOperator) newPlan.getPredecessors(op).get(0);
    LogicalSchema schema = op.getSchema();

    aschema = new LogicalSchema();
    aschema.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.BYTEARRAY));
    aschema.addField(new LogicalSchema.LogicalFieldSchema("v", null, DataType.INTEGER));
    aschema.addField(new LogicalSchema.LogicalFieldSchema("s", null, DataType.BYTEARRAY));
    assertTrue(schema.isEqual(aschema));

    // test with add
    lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load '/test/d.txt' as (id, v:int, s:int);");
    lpt.buildPlan("b = foreach a generate id, v+s;");
    plan = lpt.buildPlan("store b into '/test/empty';");

    newPlan = migratePlan(plan);
    op = (LogicalRelationalOperator) newPlan.getSinks().get(0);
    op = (LogicalRelationalOperator) newPlan.getPredecessors(op).get(0);
    schema = op.getSchema();

    aschema = new LogicalSchema();
    aschema.addField(new LogicalSchema.LogicalFieldSchema("id", null, DataType.BYTEARRAY));
    aschema.addField(new LogicalSchema.LogicalFieldSchema(null, null, DataType.INTEGER));
    assertTrue(schema.isEqual(aschema));
  }
  public void testJoinPlan() throws Exception {
    LogicalPlanTester lpt = new LogicalPlanTester();
    lpt.buildPlan("a = load 'd1.txt' as (id, c);");
    lpt.buildPlan("b = load 'd2.txt'as (id, c);");
    lpt.buildPlan("c = join a by id, b by c;");
    lpt.buildPlan("d = filter c by a::id==NULL AND b::c==NULL;");
    LogicalPlan plan = lpt.buildPlan("store d into 'empty';");

    // check basics
    org.apache.pig.experimental.logical.relational.LogicalPlan newPlan = migratePlan(plan);
    assertEquals(5, newPlan.size());
    assertEquals(newPlan.getSources().size(), 2);

    // check load and join
    LogicalRelationalOperator op =
        (LogicalRelationalOperator) newPlan.getSuccessors(newPlan.getSources().get(0)).get(0);
    assertEquals(op.getClass(), org.apache.pig.experimental.logical.relational.LOJoin.class);
    assertEquals(((LOJoin) op).getJoinType(), LOJoin.JOINTYPE.HASH);

    LogicalRelationalOperator l1 = (LogicalRelationalOperator) newPlan.getPredecessors(op).get(0);
    assertEquals(l1.getClass(), org.apache.pig.experimental.logical.relational.LOLoad.class);
    assertEquals(l1.getAlias(), "a");

    LogicalRelationalOperator l2 = (LogicalRelationalOperator) newPlan.getPredecessors(op).get(1);
    assertEquals(l2.getClass(), org.apache.pig.experimental.logical.relational.LOLoad.class);
    assertEquals(l2.getAlias(), "b");

    // check join input plans
    LogicalExpressionPlan p1 = ((LOJoin) op).getJoinPlan(0).iterator().next();
    assertEquals(p1.size(), 1);

    ProjectExpression prj = (ProjectExpression) p1.getSources().get(0);

    assertEquals(prj.getInputNum(), 0);
    assertEquals(prj.getColNum(), 0);

    LogicalExpressionPlan p2 = ((LOJoin) op).getJoinPlan(1).iterator().next();
    assertEquals(p2.size(), 1);

    prj = (ProjectExpression) p2.getSources().get(0);

    assertEquals(prj.getInputNum(), 1);
    assertEquals(prj.getColNum(), 1);

    // check filter
    op = (LogicalRelationalOperator) newPlan.getSuccessors(op).get(0);
    assertEquals(op.getClass(), org.apache.pig.experimental.logical.relational.LOFilter.class);
    LogicalExpressionPlan exp =
        ((org.apache.pig.experimental.logical.relational.LOFilter) op).getFilterPlan();

    AndExpression ae = (AndExpression) exp.getSources().get(0);

    EqualExpression eq = (EqualExpression) exp.getSuccessors(ae).get(0);
    assertEquals(eq.getLhs().getClass(), ProjectExpression.class);
    assertEquals(((ProjectExpression) eq.getLhs()).getColNum(), 0);
    assertEquals(((ProjectExpression) eq.getLhs()).getInputNum(), 0);

    assertEquals(eq.getRhs().getClass(), ConstantExpression.class);

    eq = (EqualExpression) exp.getSuccessors(ae).get(1);
    assertEquals(eq.getLhs().getClass(), ProjectExpression.class);
    assertEquals(((ProjectExpression) eq.getLhs()).getColNum(), 3);
    assertEquals(((ProjectExpression) eq.getLhs()).getInputNum(), 0);

    assertEquals(eq.getRhs().getClass(), ConstantExpression.class);

    // check store
    op = (LogicalRelationalOperator) newPlan.getSuccessors(op).get(0);
    assertEquals(op.getClass(), org.apache.pig.experimental.logical.relational.LOStore.class);
  }