Examples of org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators.POCast

Package org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators

Examples of org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators.POCast

org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators.POCast
This is just a cast that converts DataByteArray into either String or Integer. Just added it for testing the POUnion. Need the full operator implementation.

//        System.err.println("Exiting Constant");
    }
    
    @Override
    public void visit( CastExpression op ) throws FrontendException {
        POCast pCast = new POCast(new OperatorKey(DEFAULT_SCOPE, nodeGen
                .getNextNodeId(DEFAULT_SCOPE)));
//        physOp.setAlias(op.getAlias());
        currentPlan.add(pCast);


        logToPhyMap.put(op, pCast);
        ExpressionOperator from = (ExpressionOperator) logToPhyMap.get(op
                .getExpression());
        pCast.setResultType(op.getType());
        pCast.setFieldSchema(new ResourceSchema.ResourceFieldSchema(Util.translateFieldSchema(op.getFieldSchema())));
        FuncSpec lfSpec = op.getFuncSpec();
        if(null != lfSpec) {
            try {
                pCast.setFuncSpec(lfSpec);
            } catch (IOException e) {
                int errCode = 1053;
                String msg = "Cannot resolve load function to use for casting" +
                        " from " + DataType.findTypeName(op.getExpression().
                                getType()) + " to " + DataType.findTypeName(op.getType());

View Full Code Here

  }


        @Test
  public void testCast() throws ExecException {


    POCast cast = new POCast(newOperatorKey(), -1);
    POProject proj = new POProject(newOperatorKey(), -1, 0);
    proj.setResultType(DataType.CHARARRAY);
    List<PhysicalOperator> inputs = new ArrayList<PhysicalOperator>();
    inputs.add(proj);
    cast.setInputs(inputs);


    // cast to double
    String[] items = { "12.0", "-13.2", "0.1f", "1.3e2", "zjf",
        MaxDouble.toString(), MinDouble.toString() };
    Double[] doubleExpected = { 12.0, -13.2, 0.1, 1.3e2, null, MaxDouble,
        MinDouble };
    for (int i = 0; i < items.length; ++i) {
      Tuple tuple = TupleFactory.getInstance().newTuple(1);
      tuple.set(0, items[i]);
      proj.attachInput(tuple);
      Double actual = (Double) cast.getNext(dummyDouble).result;
      if (doubleExpected[i] != null) {
        assertEquals(doubleExpected[i], actual, 1e-6);
      } else {
        assertNull(actual);
      }
    }


    // cast to float
    items = new String[] { "12.0", "-13.2", "0.1f", "1.3e2",
        MaxFloat.toString(), MinFloat.toString(), "zjf" };
    Float[] floatExpected = { 12.0f, -13.2f, 0.1f, 1.3e2f, MaxFloat,
        MinFloat, null };
    for (int i = 0; i < items.length; ++i) {
      Tuple tuple = TupleFactory.getInstance().newTuple(1);
      tuple.set(0, items[i]);
      proj.attachInput(tuple);
      Float actual = (Float) cast.getNext(dummyFloat).result;
      if (floatExpected[i] != null) {
        assertEquals(floatExpected[i], actual, 1e-6);
      } else {
        assertNull(actual);
      }
    }


    // cast to long
    items = new String[] { "1", "-1", "12.2", "12.8", MaxLong.toString(),
        MinLong.toString(), "df1.2" };
    Long[] longExpected = { 1L, -1L, 12L, 12L, MaxLong, MinLong, null };
    for (int i = 0; i < items.length; ++i) {
      Tuple tuple = TupleFactory.getInstance().newTuple(1);
      tuple.set(0, items[i]);
      proj.attachInput(tuple);
      Long actual = (Long) cast.getNext(dummyLong).result;
      if (longExpected[i] != null) {
        assertEquals(longExpected[i], actual);
      } else {
        assertNull(actual);
      }
    }


    // cast to int
    items = new String[] { "1", "-1", "12.2", "12.8",
        MaxInteger.toString(), MinInteger.toString(), "ff4332" };
    Integer[] intExpected = { 1, -1, 12, 12, MaxInteger, MinInteger, null };
    for (int i = 0; i < items.length; ++i) {
      Tuple tuple = TupleFactory.getInstance().newTuple(1);
      tuple.set(0, items[i]);
      proj.attachInput(tuple);
      Integer actual = (Integer) cast.getNext(dummyInteger).result;
      if (intExpected[i] != null) {
        assertEquals(intExpected[i], actual);
      } else {
        assertNull(actual);
      }

View Full Code Here

      Tuple t = TupleFactory.getInstance().newTuple();
      t.append(r.nextInt());
      bag.add(t);
    }
    
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    LoadFunc load = new TestLoader();
    op.setFuncSpec(new FuncSpec(load.getClass().getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.INTEGER);
    // Plan to test when result type is ByteArray and casting is requested
    // for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Integer i = (Integer) t.get(0);
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(i, res.result);
      }
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Float f = ((Integer)t.get(0)).floatValue();
      Result res = op.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(f, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(f, res.result);
      }
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Long l = ((Integer)t.get(0)).longValue();
      Result res = op.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(l, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(l, res.result);
      }
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Double d = ((Integer)t.get(0)).doubleValue();
      Result res = op.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(d, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(d, res.result);
      }
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      String str = ((Integer)t.get(0)).toString();
      Result res = op.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(str, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(str, res.result);
      }
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataByteArray dba = new DataByteArray(((Integer)t.get(0)).toString().getBytes());
      Result res = op.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(dba, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK) {
        assertEquals(dba, res.result);
      }
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Map map = null;
      Result res = op.getNext(map);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Result res = op.getNext(t);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataBag b = null;
      Result res = op.getNext(b);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyMap);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyTuple);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyBag);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
  }

View Full Code Here

      Tuple t = TupleFactory.getInstance().newTuple();
      t.append(r.nextLong());
      bag.add(t);
    }
    
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    LoadFunc load = new TestLoader();
    op.setFuncSpec(new FuncSpec(load.getClass().getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.LONG);
    
    // Plan to test when result type is ByteArray and casting is requested
    // for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Integer i = ((Long) t.get(0)).intValue();
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
      
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Float f = ((Long)t.get(0)).floatValue();
      Result res = op.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK) {
//         System.out.println(res.result + " : " + f);
        assertEquals(f, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(f, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Long l = ((Long)t.get(0)).longValue();
      Result res = op.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + l);
        assertEquals(l, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(l, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Double d = ((Long)t.get(0)).doubleValue();
      Result res = op.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + d);
        assertEquals(d, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(d, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      String str = ((Long)t.get(0)).toString();
      Result res = op.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + str);
        assertEquals(str, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(str, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataByteArray dba = new DataByteArray(((Long)t.get(0)).toString().getBytes());
      Result res = op.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + dba);
        assertEquals(dba, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(dba, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Map map = null;
      Result res = op.getNext(map);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Result res = op.getNext(t);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataBag b = null;
      Result res = op.getNext(b);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyMap);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyTuple);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyBag);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
  }

View Full Code Here

      Tuple t = TupleFactory.getInstance().newTuple();
      t.append(r.nextFloat());
      bag.add(t);
    }
    
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    LoadFunc load = new TestLoader();
    op.setFuncSpec(new FuncSpec(load.getClass().getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.FLOAT);
    
    // Plan to test when result type is ByteArray and casting is requested
    // for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Integer i = ((Float) t.get(0)).intValue();
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Float f = ((Float)t.get(0)).floatValue();
      Result res = op.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK) {
//        System.out.println(res.result + " : " + f);
        assertEquals(f, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(f, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Long l = ((Float)t.get(0)).longValue();
      Result res = op.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + l);
        assertEquals(l, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(l, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Double d = ((Float)t.get(0)).doubleValue();
      Result res = op.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + d);
        assertEquals(d, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(d, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      String str = ((Float)t.get(0)).toString();
      Result res = op.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + str);
        assertEquals(str, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(str, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataByteArray dba = new DataByteArray(((Float)t.get(0)).toString().getBytes());
      Result res = op.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + dba);
        assertEquals(dba, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(dba, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      if(t.get(0) == null) {
      
            Float result = (Float) op.getNext((Float) null).result;
        assertEquals( null, result);


      }
    }


    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Map map = null;
      Result res = op.getNext(map);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Result res = op.getNext(t);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataBag b = null;
      Result res = op.getNext(b);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyMap);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyTuple);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyBag);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
  }

View Full Code Here

      Tuple t = TupleFactory.getInstance().newTuple();
      t.append(r.nextDouble());
      bag.add(t);
    }
    
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    LoadFunc load = new TestLoader();
    op.setFuncSpec(new FuncSpec(load.getClass().getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.DOUBLE);
    
    // Plan to test when result type is ByteArray and casting is requested
    // for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Integer i = ((Double) t.get(0)).intValue();
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Float f = ((Double)t.get(0)).floatValue();
      Result res = op.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK) {
//        System.out.println(res.result + " : " + f);
        assertEquals(f, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(f);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(f, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Long l = ((Double)t.get(0)).longValue();
      Result res = op.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + l);
        assertEquals(l, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(l);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(l, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Double d = ((Double)t.get(0)).doubleValue();
      Result res = op.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + d);
        assertEquals(d, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(d);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(d, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      String str = ((Double)t.get(0)).toString();
      Result res = op.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + str);
        assertEquals(str, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(str, res.result);
    }


    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataByteArray dba = new DataByteArray(((Double)t.get(0)).toString().getBytes());
      Result res = op.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + dba);
        assertEquals(dba, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(dba, res.result);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Map map = null;
      Result res = op.getNext(map);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      Result res = op.getNext(t);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    for(Iterator<Tuple> it = bag.iterator(); it.hasNext(); ) {
      Tuple t = it.next();
      plan.attachInput(t);
      DataBag b = null;
      Result res = op.getNext(b);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyMap);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyTuple);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyBag);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
  }

View Full Code Here

        }
  }
  
  @Test
  public void testStringToOther() throws IOException {
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    LoadFunc load = new TestLoader();
    op.setFuncSpec(new FuncSpec(load.getClass().getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.CHARARRAY);


    // Plan to test when result type is ByteArray and casting is requested
    // for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    
    TupleFactory tf = TupleFactory.getInstance();
    
    {
      Tuple t = tf.newTuple();
      t.append((new Integer(r.nextInt())).toString());
      plan.attachInput(t);
      Integer i = Integer.valueOf(((String) t.get(0)));
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append((new Float(r.nextFloat())).toString());
      plan.attachInput(t);
      Float i = Float.valueOf(((String) t.get(0)));
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append((new Long(r.nextLong())).toString());
      plan.attachInput(t);
      Long i = Long.valueOf(((String) t.get(0)));
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append((new Double(r.nextDouble())).toString());
      plan.attachInput(t);
      Double i = Double.valueOf(((String) t.get(0)));
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
      plan.attachInput(t);
      String str = (String) t.get(0);
      Result res = op.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + str);
        assertEquals(str, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(str, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
    
      plan.attachInput(t);
      DataByteArray dba = new DataByteArray(((String)t.get(0)).getBytes());
      Result res = op.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + dba);
        assertEquals(dba, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(dba, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
      plan.attachInput(t);
      Map map = null;
      Result res = op.getNext(map);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
      plan.attachInput(t);
      Result res = op.getNext(t);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
      plan.attachInput(t);
      DataBag b = null;
      Result res = op.getNext(b);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyMap);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyTuple);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
        {
            planToTestBACasts.attachInput(dummyTuple);
            try{
                opWithInputTypeAsBA.getNext(dummyBag);
            }catch (Exception e) {
                assertEquals(ExecException.class, e.getClass());
            }
        }
  }

View Full Code Here

        
  }
  
  @Test
  public void testByteArrayToOther() throws IOException {
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    LoadFunc load = new TestLoader();
    op.setFuncSpec(new FuncSpec(load.getClass().getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.BYTEARRAY);
    
    TupleFactory tf = TupleFactory.getInstance();
    
    // Plan to test when result type is ByteArray and casting is requested
    // for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray((new Integer(r.nextInt())).toString().getBytes()));
      plan.attachInput(t);
      Integer i = Integer.valueOf(((DataByteArray) t.get(0)).toString());
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);


    }


    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray((new Float(r.nextFloat())).toString().getBytes()));
      plan.attachInput(t);
      Float i = Float.valueOf(((DataByteArray) t.get(0)).toString());
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray((new Long(r.nextLong())).toString().getBytes()));
      plan.attachInput(t);
      Long i = Long.valueOf(((DataByteArray) t.get(0)).toString());
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray((new Double(r.nextDouble())).toString().getBytes()));
      plan.attachInput(t);
      Double i = Double.valueOf(((DataByteArray) t.get(0)).toString());
      Result res = op.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + i);
        assertEquals(i, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(i);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(i, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray(GenRandomData.genRandString(r).getBytes()));
      plan.attachInput(t);
      String str = ((DataByteArray) t.get(0)).toString();
      Result res = op.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK) {
        //System.out.println(res.result + " : " + str);
        assertEquals(str, res.result);
      }
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(str);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(str, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray(GenRandomData.genRandString(r).getBytes()));
      
      plan.attachInput(t);
      DataByteArray dba = (DataByteArray) t.get(0);
      Result res = op.getNext(dba);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(dba);
      if(res.returnStatus == POStatus.STATUS_OK)
        assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray(GenRandomData.genRandString(r).getBytes()));
      plan.attachInput(t);
      Map map = null;
      Result res = op.getNext(map);
      //assertEquals(POStatus.STATUS_ERR, res.returnStatus);
      assertEquals(POStatus.STATUS_OK, res.returnStatus);
      assertEquals(null, res.result);
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(map);
      assertEquals(POStatus.STATUS_OK, res.returnStatus);
      assertEquals(null, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray(GenRandomData.genRandString(r).getBytes()));
      plan.attachInput(t);
      Result res = op.getNext(t);
      //assertEquals(POStatus.STATUS_ERR, res.returnStatus);
      assertEquals(POStatus.STATUS_OK, res.returnStatus);
      assertEquals(null, res.result);
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(t);
      assertEquals(POStatus.STATUS_OK, res.returnStatus);
      assertEquals(null, res.result);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(new DataByteArray(GenRandomData.genRandString(r).getBytes()));
      plan.attachInput(t);
      DataBag b = null;
      Result res = op.getNext(b);
      //assertEquals(POStatus.STATUS_ERR, res.returnStatus);
      assertEquals(POStatus.STATUS_OK, res.returnStatus);
      assertEquals(null, res.result);
      
      planToTestBACasts.attachInput(t);
      res = opWithInputTypeAsBA.getNext(b);
      assertEquals(POStatus.STATUS_OK, res.returnStatus);
      assertEquals(null, res.result);
    }
  }

View Full Code Here

     * a Cast to convert the bytearray to string. Though in reality
     * the input to the cast is already a string
     */
  @Test
  public void testByteArrayToOtherNoCast() throws IOException {
        POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
        PhysicalPlan plan = constructPlan(op);
        TupleFactory tf = TupleFactory.getInstance();
        
        {
            Tuple t = tf.newTuple();
            Integer input = new Integer(r.nextInt()); 
            t.append(input);
            plan.attachInput(t);
            Result res = op.getNext(new Integer(0));
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + i);
                assertEquals(input, res.result);
            }
        }
        
        {
            // create a new POCast each time since we 
            // maintain a state variable per POCast object
            // indicating if cast is really required
            POCast newOp = new POCast(new OperatorKey("", r.nextLong()), -1);
            plan = constructPlan(newOp);
            Tuple t = tf.newTuple();
            Float input = new Float(r.nextFloat());
            t.append(input);
            plan.attachInput(t);
            Result res = newOp.getNext(new Float(0));
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + i);
                assertEquals(input, res.result);
            }
        }
        
        {
            // create a new POCast each time since we 
            // maintain a state variable per POCast object
            // indicating if cast is really required
            POCast newOp = new POCast(new OperatorKey("", r.nextLong()), -1);
            plan = constructPlan(newOp);
            Tuple t = tf.newTuple();
            Long input = new Long(r.nextLong());
            t.append(input);
            plan.attachInput(t);
            Result res = newOp.getNext(new Long(0));
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + i);
                assertEquals(input, res.result);
            }
        }
        
        {
            // create a new POCast each time since we 
            // maintain a state variable per POCast object
            // indicating if cast is really required
            POCast newOp = new POCast(new OperatorKey("", r.nextLong()), -1);
            plan = constructPlan(newOp);
            Tuple t = tf.newTuple();
            Double input = new Double(r.nextDouble());
            t.append(input);
            plan.attachInput(t);
            Result res = newOp.getNext(new Double(0));
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + i);
                assertEquals(input, res.result);
            }
        }
        
        {
            // create a new POCast each time since we 
            // maintain a state variable per POCast object
            // indicating if cast is really required
            POCast newOp = new POCast(new OperatorKey("", r.nextLong()), -1);
            plan = constructPlan(newOp);
            Tuple t = tf.newTuple();
            Tuple input = GenRandomData.genRandSmallTuple("test", 1);
            t.append(input);
            plan.attachInput(t);
            Result res = newOp.getNext(tf.newTuple());
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + str);
                assertEquals(input, res.result);
            }
        }
        
        {
            // create a new POCast each time since we 
            // maintain a state variable per POCast object
            // indicating if cast is really required
            POCast newOp = new POCast(new OperatorKey("", r.nextLong()), -1);
            plan = constructPlan(newOp);
            Tuple t = tf.newTuple();
            DataBag input = GenRandomData.genRandSmallTupDataBag(r, 10, 100);
            t.append(input);
            plan.attachInput(t);
            Result res = newOp.getNext(DefaultBagFactory.getInstance().newDefaultBag());
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + str);
                assertEquals(input, res.result);
            }
        }
        
        {
            // create a new POCast each time since we 
            // maintain a state variable per POCast object
            // indicating if cast is really required
            POCast newOp = new POCast(new OperatorKey("", r.nextLong()), -1);
            plan = constructPlan(newOp);
            Tuple t = tf.newTuple();
            Map<String, Object> input = new HashMap<String, Object>();
            input.put("key1", "value1");
            input.put("key2", "value2");
            t.append(input);
            plan.attachInput(t);
            Result res = newOp.getNext(new HashMap<String, Object>());
            if(res.returnStatus == POStatus.STATUS_OK) {
                //System.out.println(res.result + " : " + str);
                assertEquals(input, res.result);
            }
        }

View Full Code Here

        
  }
  
  @Test
  public void testTupleToOther() throws IOException {
    POCast op = new POCast(new OperatorKey("", r.nextLong()), -1);
    op.setFuncSpec(new FuncSpec(PigStorage.class.getName()));
    POProject prj = new POProject(new OperatorKey("", r.nextLong()), -1, 0);
    PhysicalPlan plan = new PhysicalPlan();
    plan.add(prj);
    plan.add(op);
    plan.connect(prj, op);
    
    prj.setResultType(DataType.TUPLE);
    
    TupleFactory tf = TupleFactory.getInstance();
    
    //Plan to test when result type is ByteArray and casting is requested
    //for example casting of values coming out of map lookup.
    POCast opWithInputTypeAsBA = new POCast(new OperatorKey("", r.nextLong()), -1);
    PhysicalPlan planToTestBACasts = constructPlan(opWithInputTypeAsBA);
    
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
      Tuple tNew = tf.newTuple();
      tNew.append(t);
      plan.attachInput(tNew);
      Map map = null;
      Result res = op.getNext(map);
      assertEquals(POStatus.STATUS_ERR, res.returnStatus);
    }
    
    {
      Tuple t = tf.newTuple();
      t.append(GenRandomData.genRandString(r));
      Tuple tNew = tf.newTuple();
      tNew.append(t);
      plan.attachInput(tNew);
      Result res = op.getNext(t);
      //System.out.println(res.result + " : " + t);
      assertEquals(t, res.result);
      
      planToTestBACasts.attachInput(tNew);
      res = opWithInputTypeAsBA.getNext(t);
      assertEquals(t, res.result);
    }
    
    {
      Tuple t = tf.newTuple();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators.POCast

org.apache.pig.backend.hadoop.executionengine.physicalLayer.PhysicalOperator

org.apache.pig.backend.hadoop.executionengine.physicalLayer.Result

org.apache.pig.data.DataBag

org.apache.pig.data.DataByteArray

org.apache.pig.data.Tuple

org.apache.pig.experimental.logical.expression.ExpToPhyTranslationVisitor

org.apache.pig.impl.plan.OperatorKey

org.apache.pig.newplan.logical.expression.ExpToPhyTranslationVisitor

org.apache.pig.ResourceSchema

org.apache.pig.ResourceSchema.ResourceFieldSchema

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.