Java Code Examples for org.apache.pig.PigException#INPUT

@Override
public void visit(LOFilter filter) throws FrontendException {
    LogicalExpressionPlan expression = filter.getFilterPlan();
    if (expression != null) {
        // if it is a Sample, the expression must be scalar
        if (filter.isSample()) {
            ProjectFinder pf = new ProjectFinder(expression,
                    new ReverseDependencyOrderWalker(expression));
            pf.visit();
            if (pf.found()) {
                int errCode = 1131;
                throw new VisitorException(filter, ERR_MSG_SCALAR, errCode,
                        PigException.INPUT);
            }
        }
    }
}
 

@Override
public void visit(NegativeExpression negExp) throws FrontendException {
    byte type = negExp.getExpression().getType() ;
    if (DataType.isNumberType(type)) {
        //do nothing
    }
    else if (type == DataType.BYTEARRAY) {
        // cast bytearray to double
        insertCast(negExp, DataType.DOUBLE, negExp.getExpression());
    }
    else {
        int errCode = 1041;
        String msg = "NEG can be used with numbers or Bytearray only" ;
        msgCollector.collect(msg, MessageType.Error);
        throw new TypeCheckerException(negExp, msg, errCode, PigException.INPUT) ;
    }

}
 

protected BaseRank(Object[] args) throws IOException {

            if (args == null || args.length < 1) {
                throw new ExecException(
                    "Rank args must contain ordering column numbers, "
                    + "e.g. rank(1, 2)", 2107, PigException.INPUT);
            }

            lastKey = new Object[args.length];
            orderFields = new int[args.length];
            for (int i = 0; i < args.length; i++) {
                try {
                    orderFields[i] = (Integer)args[i];
                } catch (ClassCastException cce) {
                    throw new ExecException(
                        "Rank expected column number in arg " + i +
                        " but received " + DataType.findTypeName(args[i]),
                        2107, PigException.INPUT);
                }
            }

            reset();
        }
 

private void visitBooleanBinary(BinaryExpression boolExp)
throws FrontendException {
    // if lhs or rhs is null constant then cast it to boolean
    insertCastsForNullToBoolean(boolExp);
    LogicalExpression lhs = boolExp.getLhs();
    LogicalExpression rhs = boolExp.getRhs();

    byte lhsType = lhs.getType() ;
    byte rhsType = rhs.getType() ;

    if (  (lhsType != DataType.BOOLEAN)  ||
            (rhsType != DataType.BOOLEAN)  ) {
        int errCode = 1038;
        String msg = "Operands of AND/OR can be boolean only" ;
        msgCollector.collect(msg, MessageType.Error);
        throw new TypeCheckerException(boolExp, msg, errCode, PigException.INPUT) ;
    }
}
 

Lead(Object[] args) throws IOException {
    rowsAhead = 1;
    deflt = null;
    if (args != null) {
        if (args.length >= 1) {
            try {
                rowsAhead = (Integer)args[0];
            } catch (ClassCastException cce) {
                int errCode = 2107; // TODO not sure this is the right one
                String msg = "Lead expected an integer for arg 2 " +
                    " but received " + DataType.findTypeName(args[0]);
                throw new ExecException(msg, errCode, PigException.INPUT);
            }
        }
        if (args.length >= 2) {
            deflt = args[1];
        }
    }
    reset();
}
 

@Override
public void visit(DereferenceExpression deref) throws FrontendException{
    byte inputType = deref.getReferredExpression().getType();
    switch(inputType){
    case DataType.TUPLE:
    case DataType.BAG:
    case DataType.BYTEARRAY: // ideally determine type at runtime
        //allowed types
        break;
    default:
        int errCode = 1129;
        String msg = "Referring to column(s) within a column of type " +
        DataType.findTypeName(inputType)
        + " is not allowed";
        throw new TypeCheckerException(deref, msg, errCode, PigException.INPUT);
    }
}
 

/**
 * Checks to see if any field of the input schema is a byte array
 * @param func
 * @param s - input schema
 * @return true if found else false
 * @throws VisitorException
 */
private boolean byteArrayFound(UserFuncExpression func, Schema s) throws VisitorException {
    for(int i=0;i<s.size();i++){
        try {
            FieldSchema fs=s.getField(i);
            if(fs == null)
                return false;
            if(fs.type==DataType.BYTEARRAY){
                return true;
            }
        } catch (FrontendException fee) {
            int errCode = 1043;
            String msg = "Unable to retrieve field schema.";
            throw new TypeCheckerException(func, msg, errCode, PigException.INPUT, fee);
        }
    }
    return false;
}
 

@SuppressWarnings("unchecked")
public static byte[] toBytes(Object o, byte type) throws ExecException {
    switch (type) {
    case BOOLEAN:
        //return ((Boolean) o).booleanValue() ? new byte[] {1} : new byte[] {0};
        return ((Boolean) o).toString().getBytes();
    case BYTE:
        return new byte[] {((Byte) o)};

    case BIGINTEGER:
    case BIGDECIMAL:
    case INTEGER:
    case DOUBLE:
    case FLOAT:
    case LONG:
        return ((Number) o).toString().getBytes();

    case DATETIME:
        return ((DateTime) o).toString().getBytes();

    case CHARARRAY:
        return ((String) o).getBytes();
    case MAP:
        return mapToString((Map<String, Object>) o).getBytes();
    case TUPLE:
        return ((Tuple) o).toString().getBytes();
    case BYTEARRAY:
        return ((DataByteArray) o).get();
    case BAG:
        return ((DataBag) o).toString().getBytes();
    case NULL:
        return null;
    default:
        int errCode = 1071;
        String msg = "Cannot convert a " + findTypeName(o) +
        " to a ByteArray";
        throw new ExecException(msg, errCode, PigException.INPUT);

    }
}
 

private void throwTypeCheckerException(Operator op, String msg,
        int errCode, byte input, FrontendException fe) throws TypeCheckerException {
    if( fe == null ) {
        throw new TypeCheckerException(op, msg, errCode, PigException.INPUT);
    }
    throw new TypeCheckerException(op, msg, errCode, PigException.INPUT, fe);
}
 

/**
 * Constructor for tuple fields.
 * 
 * @param a
 *            Alias, if known. If unknown leave null.
 * @param s
 *            Schema of this tuple.
 * @param t
 *            Type, using codes from
 *            {@link org.apache.pig.data.DataType}.
 * 
 */
public FieldSchema(String a, Schema s, byte t)  throws FrontendException {
    alias = a;
    schema = s;
    log.debug("t: " + t + " Bag: " + DataType.BAG + " tuple: " + DataType.TUPLE);
    
    if ((null != s) && !(DataType.isSchemaType(t))) {
        int errCode = 1020;
        throw new FrontendException("Only a BAG, TUPLE or MAP can have schemas. Got "
                + DataType.findTypeName(t), errCode, PigException.INPUT);
    }
    
    type = t;
    canonicalName = CanonicalNamer.getNewName();
}
 

/**
 * Finds if there is an exact match between the schema supported by
 * one of the funcSpecs and the input schema s
 * @param funcSpecs - mappings provided by udf
 * @param s - input schema
 * @param func user defined function
 * @param udfSchemaType - schema type of the user defined function
 * @param ignoreByteArrays - flag for whether the exact match is to computed
 * after ignoring bytearray (if true) or without ignoring bytearray (if false)
 * @return the matching spec if found else null
 * @throws FrontendException
 */
private FuncSpec exactMatchHelper(List<FuncSpec> funcSpecs, Schema s,
        UserFuncExpression func, SchemaType udfSchemaType, boolean ignoreByteArrays)
throws FrontendException {
    List<FuncSpec> matchingSpecs = new ArrayList<FuncSpec>();
    for (Iterator<FuncSpec> iterator = funcSpecs.iterator(); iterator.hasNext();) {
        FuncSpec fs = iterator.next();
        if (schemaEqualsForMatching(s, fs.getInputArgsSchema(), udfSchemaType, ignoreByteArrays)) {
            matchingSpecs.add(fs);

        }
    }
    if(matchingSpecs.size() == 0)
        return null;

    if(matchingSpecs.size() > 1) {
        int errCode = 1046;
        String msg = "Multiple matching functions for "
                                    + func.getFuncSpec() + " with input schema: "
                                    + "(" + matchingSpecs.get(0).getInputArgsSchema()
                                    + ", " + matchingSpecs.get(1).getInputArgsSchema()
                                    + "). Please use an explicit cast.";
        msgCollector.collect(msg, MessageType.Error);
        throw new TypeCheckerException(func, msg, errCode, PigException.INPUT);
    }

    // exactly one matching spec - return it
    return matchingSpecs.get(0);
}
 

public void doInsertBetween(
        E after,
        E newNode,
        E before,
        boolean rewire) throws PlanException {
    checkInPlan(newNode);
    List<E> newNodePreds = getPredecessors(newNode);
    //assuming that the newNode has zero or one predecessor
    E newNodePred = (newNodePreds == null? null: newNodePreds.get(0));
    if (!replaceNode(after, newNode, before, mFromEdges) || !replaceNode(before, newNode, after, mToEdges)) {
        int errCode = 1094;
        String msg = "Attempt to insert between two nodes " +
        "that were not connected.";
        PlanException pe = new PlanException(msg, errCode, PigException.INPUT);
        throw pe;
    }
    mFromEdges.put(newNode, before);
    mToEdges.put(newNode, after);

    if(rewire) {
        if((newNodePred != null) && !(newNodePred.equals(after))) {
            newNodePred.regenerateProjectionMap();
            newNode.rewire(newNodePred, 0, after, true);
        }
        newNode.regenerateProjectionMap();
        IndexHelper<E> indexHelper = new IndexHelper<E>(getPredecessors(newNode));
        before.rewire(after, indexHelper.getIndex(after), newNode, false);
    }
}
 

@Override
public DataBag exec(Tuple input) throws IOException {

    if (input == null || input.size() == 0) return null;

    List<DataBag> bags = new ArrayList<DataBag>(input.size());

    for (int i = 0; i < input.size(); i++) {
        Object o = input.get(i);
        try {
            bags.add((DataBag)o);
        } catch (ClassCastException cce) {
            int errCode = 2107; // TODO not sure this is the right one
            String msg = "Stitch expected bags as input but argument " +
                i + " is a " + DataType.findTypeName(o);
            throw new ExecException(msg, errCode, PigException.INPUT);
        }
    }

    if (bags.size() == 1) return bags.get(0);

    DataBag output = BagFactory.getInstance().newDefaultBag();
    List<Iterator<Tuple>> iters = new ArrayList<Iterator<Tuple>>(bags.size());
    for (DataBag bag : bags) {
        iters.add(bag.iterator());
    }

    while (iters.get(0).hasNext()) {
        Tuple outTuple = TupleFactory.getInstance().newTuple();
        for (Iterator<Tuple> iter : iters) {
            if (iter.hasNext()) {
                Tuple t = iter.next();
                List<Object> fields = t.getAll();
                for (Object field : fields) {
                    outTuple.append(field);
                }
            }
        }
        output.add(outTuple);
    }
    return output;
}
 

@Override
public void visit(LOSort sort) throws FrontendException{
    List<LogicalExpressionPlan> expPlans = sort.getSortColPlans();
    List<Boolean> ascOrder = sort.getAscendingCols();

    // new expressionplans and sort order list after star expansion
    List<LogicalExpressionPlan> newExpPlans =
        new ArrayList<LogicalExpressionPlan>();
    List<Boolean> newAscOrder =  new ArrayList<Boolean>();

    if(expPlans.size() != ascOrder.size()){
        throw new AssertionError("Size of expPlans and ascorder should be same");
    }            
    
    for(int i=0; i < expPlans.size(); i++){
        //expand the plan
        LogicalExpressionPlan ithExpPlan = expPlans.get(i);
        List<LogicalExpressionPlan> expandedPlans = expandPlan(ithExpPlan, 0);
        newExpPlans.addAll(expandedPlans);

        //add corresponding isAsc flags
        Boolean isAsc = ascOrder.get(i);
        for(int j=0; j < expandedPlans.size(); j++){
            newAscOrder.add(isAsc);
        }
    }

    //check if there is a project-star-to-end followed by another sort plan
    // in the expanded plans (can happen if there is no input schema)
    for(int i=0; i < newExpPlans.size(); i++){
        ProjectExpression proj = getProjectStar(newExpPlans.get(i));
        if(proj != null && 
                proj.isRangeProject() && proj.getEndCol() == -1 &&
                i != newExpPlans.size() -1
        ){
            //because of order by sampler logic limitation, this is not
            //supported right now
            String msg = "Project-range to end (eg. x..)" +
            " is supported in order-by only as last sort column";
            throw new FrontendException(
                    msg,
                    1128,
                    PigException.INPUT
            );
        }
    }

    sort.setSortColPlans(newExpPlans);
    sort.setAscendingCols(newAscOrder);
}
 

@Override
public void visit(LORank rank) throws FrontendException {

    List<LogicalExpressionPlan> expPlans = rank.getRankColPlans();
    List<Boolean> ascOrder = rank.getAscendingCol();

    List<LogicalExpressionPlan> newExpPlans = new ArrayList<LogicalExpressionPlan>();
    List<Boolean> newAscOrder = new ArrayList<Boolean>();

    if (expPlans.size() != ascOrder.size()) {
        throw new AssertionError(
                "Size of expPlans and ascorder should be same");
    }

    for (int i = 0; i < expPlans.size(); i++) {
        // expand the plan
        LogicalExpressionPlan ithExpPlan = expPlans.get(i);
        List<LogicalExpressionPlan> expandedPlans = expandPlan(ithExpPlan,
                0);
        newExpPlans.addAll(expandedPlans);

        // add corresponding isAsc flags
        Boolean isAsc = ascOrder.get(i);
        for (int j = 0; j < expandedPlans.size(); j++) {
            newAscOrder.add(isAsc);
        }
    }

    // check if there is a project-star-to-end followed by another sort plan
    // in the expanded plans (can happen if there is no input schema)
    for (int i = 0; i < newExpPlans.size(); i++) {
        ProjectExpression proj = getProjectStar(newExpPlans.get(i));
        if (proj != null && proj.isRangeProject() && proj.getEndCol() == -1
                && i != newExpPlans.size() - 1) {
            String msg = "Project-range to end (eg. x..)"
                    + " is supported in rank-by only as last rank column";
            throw new FrontendException(msg, 1128, PigException.INPUT);
        }
    }

    rank.setRankColPlan(newExpPlans);
    rank.setAscendingCol(newAscOrder);
}
 

@Override
public void visit(ModExpression binOp) throws FrontendException {
    LogicalExpression lhs = binOp.getLhs() ;
    LogicalExpression rhs = binOp.getRhs() ;

    byte lhsType = lhs.getType() ;
    byte rhsType = rhs.getType() ;
    boolean error = false;

    if (lhsType == DataType.INTEGER) {
        if (rhsType == DataType.INTEGER) {
            //do nothing
        } else if (rhsType == DataType.LONG || rhsType == DataType.BIGINTEGER) {
            insertCast(binOp, rhsType, binOp.getLhs());
        } else {
            error = true;
        }
    } else if (lhsType == DataType.LONG) {
        if (rhsType == DataType.INTEGER) {
            insertCast(binOp, lhsType, binOp.getRhs());
        } else if (rhsType == DataType.BIGINTEGER) {
            insertCast(binOp, rhsType, binOp.getLhs());
        } else if (rhsType == DataType.LONG) {
            //do nothing
        } else {
            error = true;
        }
    } else if (lhsType == DataType.BIGINTEGER) {
        if (rhsType == DataType.INTEGER || rhsType == DataType.LONG) {
            insertCast(binOp, lhsType, binOp.getRhs());
        } else if (rhsType == DataType.BIGINTEGER) {
            //do nothing
        } else {
            error = true;
        }
    } else if (lhsType == DataType.BYTEARRAY) {
        if (rhsType == DataType.INTEGER || rhsType == DataType.LONG || rhsType == DataType.BIGINTEGER) {
            insertCast(binOp, rhsType, binOp.getLhs());
        } else {
            error = true;
        }
    } else {
        error = true;
    }
    if (error) {
        int errCode = 1039;
        String msg = generateIncompatibleTypesMessage(binOp);
        msgCollector.collect(msg, MessageType.Error);
        throw new TypeCheckerException(binOp, msg, errCode, PigException.INPUT) ;
    }
}
 

@Override
public Tuple exec(Tuple inputTuple) throws IOException {

	if (inputTuple.size() != 1) {
		throw new ExecException("Expecting 1 input, found " + inputTuple.size(), PigException.INPUT);
	}
	
	if (inputTuple.get(0) == null) {
		return null;
	}
	
	if (!(inputTuple.get(0) instanceof DataBag)) {
	  throw new ExecException("Usage BagToTuple(DataBag)", PigException.INPUT);			
	}
	
	
	DataBag inputBag = (DataBag) (inputTuple.get(0));
	try {
		Tuple outputTuple = null;
		
		long outputTupleSize = getOuputTupleSize(inputBag);

		// TupleFactory.newTuple(int size) can only support up to Integer.MAX_VALUE
		if (outputTupleSize > Integer.MAX_VALUE) {
			throw new ExecException("Input bag is too large", 105, PigException.INPUT);
		}

		TupleFactory tupleFactory = TupleFactory.getInstance();
		outputTuple = tupleFactory.newTuple((int) outputTupleSize);

		int fieldNum = 0;
		for (Tuple t : inputBag) {
			if (t != null) {
				for (int i = 0; i < t.size(); i++) {
					outputTuple.set(fieldNum++, t.get(i));
				}
			}
		}
		return outputTuple;
	} catch (Exception e) {
		String msg = "Encourntered error while flattening a bag to tuple"
				+ this.getClass().getSimpleName();
		throw new ExecException(msg, PigException.BUG, e);
	}
}
 

private static Class<? extends WritableComparator> comparatorForKeyType(byte keyType, boolean hasOrderBy)
        throws JobCreationException {

    switch (keyType) {
    case DataType.BOOLEAN:
        return PigBooleanRawComparator.class;

    case DataType.INTEGER:
        return PigIntRawComparator.class;

    case DataType.BIGINTEGER:
        return PigBigIntegerRawComparator.class;

    case DataType.BIGDECIMAL:
        return PigBigDecimalRawComparator.class;

    case DataType.LONG:
        return PigLongRawComparator.class;

    case DataType.FLOAT:
        return PigFloatRawComparator.class;

    case DataType.DOUBLE:
        return PigDoubleRawComparator.class;

    case DataType.DATETIME:
        return PigDateTimeRawComparator.class;

    case DataType.CHARARRAY:
        return PigTextRawComparator.class;

    case DataType.BYTEARRAY:
        //if (hasOrderBy) {
            return PigBytesRawComparator.class;
        //} else {
        //    return PigDBAWritableComparator.class;
        //}

    case DataType.MAP:
        int errCode = 1068;
        String msg = "Using Map as key not supported.";
        throw new JobCreationException(msg, errCode, PigException.INPUT);

    case DataType.TUPLE:
        //TODO: PigTupleWritableComparator gives wrong results with cogroup in
        //Checkin_2 and few other e2e tests. But MR has PigTupleWritableComparator
        //Investigate the difference later
        //if (hasOrderBy) {
            return PigTupleSortComparator.class;
        //} else {
        //    return PigTupleWritableComparator.class;
        //}

    case DataType.BAG:
        errCode = 1068;
        msg = "Using Bag as key not supported.";
        throw new JobCreationException(msg, errCode, PigException.INPUT);

    default:
        errCode = 2036;
        msg = "Unhandled key type " + DataType.findTypeName(keyType);
        throw new JobCreationException(msg, errCode, PigException.BUG);
    }
}
 

private static Class<? extends WritableComparator> getGroupingComparatorForKeyType(byte keyType)
        throws JobCreationException {

    switch (keyType) {
    case DataType.BOOLEAN:
        return PigGroupingBooleanWritableComparator.class;

    case DataType.INTEGER:
        return PigGroupingIntWritableComparator.class;

    case DataType.BIGINTEGER:
        return PigGroupingBigIntegerWritableComparator.class;

    case DataType.BIGDECIMAL:
        return PigGroupingBigDecimalWritableComparator.class;

    case DataType.LONG:
        return PigGroupingLongWritableComparator.class;

    case DataType.FLOAT:
        return PigGroupingFloatWritableComparator.class;

    case DataType.DOUBLE:
        return PigGroupingDoubleWritableComparator.class;

    case DataType.DATETIME:
        return PigGroupingDateTimeWritableComparator.class;

    case DataType.CHARARRAY:
        return PigGroupingCharArrayWritableComparator.class;

    case DataType.BYTEARRAY:
        return PigGroupingDBAWritableComparator.class;

    case DataType.MAP:
        int errCode = 1068;
        String msg = "Using Map as key not supported.";
        throw new JobCreationException(msg, errCode, PigException.INPUT);

    case DataType.TUPLE:
        return PigGroupingTupleWritableComparator.class;

    case DataType.BAG:
        errCode = 1068;
        msg = "Using Bag as key not supported.";
        throw new JobCreationException(msg, errCode, PigException.INPUT);

    default:
        errCode = 2036;
        msg = "Unhandled key type " + DataType.findTypeName(keyType);
        throw new JobCreationException(msg, errCode, PigException.BUG);
    }
}
 

/**
 * This method will store the scriptSchema:Schema using ObjectSerializer to
 * the current configuration.<br/>
 * The schema can be retrieved by load functions or UDFs to know the schema
 * the user entered in the as clause.<br/>
 * The name format is:<br/>
 * 
 * <pre>
 * ${UDFSignature}.scriptSchema = ObjectSerializer.serialize(scriptSchema)
 * </pre>
 * <p/>
    * Note that this is not the schema the load function returns but will
 * always be the as clause schema.<br/>
 * That is a = LOAD 'input' as (a:chararray, b:chararray)<br/>
 * The schema wil lbe (a:chararray, b:chararray)<br/>
 * <p/>
 * 
 * TODO Find better solution to make script schema available to LoadFunc see
 * https://issues.apache.org/jira/browse/PIG-1717
 */
   private void storeScriptSchema(Configuration conf, LogicalSchema scriptSchema, String signature) {
     if (conf != null && scriptSchema != null && signature != null) {
		try {
         conf.set(
             Utils.getScriptSchemaKey(signature),
             ObjectSerializer.serialize(Util.translateSchema(scriptSchema)));
		} catch (IOException ioe) {
			int errCode = 1018;
			String msg = "Problem serializing script schema";
			FrontendException fee = new FrontendException(this, msg, errCode,
					PigException.INPUT, false, null, ioe);
			throw new RuntimeException(fee);
		}
	}
}