Java Expression类代码示例

import org.apache.pig.Expression; //导入依赖的package包/类
/**
 * Return cql where clauses for the corresponding partition filter. Make sure the data format matches
 * Only support the following Pig data types: int, long, float, double, boolean and chararray
 * */
private String partitionFilterToWhereClauseString(Expression expression) throws IOException
{
    Expression.BinaryExpression be = (Expression.BinaryExpression) expression;
    OpType op = expression.getOpType();
    String opString = op.toString();
    switch (op)
    {
        case OP_EQ:
            opString = " = ";
        case OP_GE:
        case OP_GT:
        case OP_LE:
        case OP_LT:
            String name = be.getLhs().toString();
            String value = be.getRhs().toString();
            return String.format("%s %s %s", name, opString, value);
        case OP_AND:
            return String.format("%s AND %s", partitionFilterToWhereClauseString(be.getLhs()), partitionFilterToWhereClauseString(be.getRhs()));
        default:
            throw new IOException("Unsupported expression type: " + opString);
    }
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** 
 * Return cql where clauses for the corresponding partition filter. Make sure the data format matches 
 * Only support the following Pig data types: int, long, float, double, boolean and chararray
 * */
private String partitionFilterToWhereClauseString(Expression expression) throws IOException
{
    Expression.BinaryExpression be = (Expression.BinaryExpression) expression;
    OpType op = expression.getOpType();
    String opString = op.toString();
    switch (op)
    {
        case OP_EQ:
            opString = " = ";
        case OP_GE:
        case OP_GT:
        case OP_LE:
        case OP_LT:
            String name = be.getLhs().toString();
            String value = be.getRhs().toString();
            return String.format("%s %s %s", name, opString, value);
        case OP_AND:
            return String.format("%s AND %s", partitionFilterToWhereClauseString(be.getLhs()), partitionFilterToWhereClauseString(be.getRhs()));
        default:
            throw new IOException("Unsupported expression type: " + opString);
    }
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
private String getHCatComparisonString(Expression expr) {
  if (expr instanceof BinaryExpression) {
    // call getHCatComparisonString on lhs and rhs, and and join the
    // results with OpType string

    // we can just use OpType.toString() on all Expression types except
    // Equal, NotEqualt since Equal has '==' in toString() and
    // we need '='
    String opStr = null;
    switch (expr.getOpType()) {
    case OP_EQ:
      opStr = " = ";
      break;
    default:
      opStr = expr.getOpType().toString();
    }
    BinaryExpression be = (BinaryExpression) expr;
    return "(" + getHCatComparisonString(be.getLhs()) +
      opStr +
      getHCatComparisonString(be.getRhs()) + ")";
  } else {
    // should be a constant or column
    return expr.toString();
  }
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** 
 * Return cql where clauses for the corresponding partition filter. Make sure the data format matches 
 * Only support the following Pig data types: int, long, float, double, boolean and chararray
 * */
private String partitionFilterToWhereClauseString(Expression expression)
{
    Expression.BinaryExpression be = (Expression.BinaryExpression) expression;
    String name = be.getLhs().toString();
    String value = be.getRhs().toString();
    OpType op = expression.getOpType();
    String opString = op.name();
    switch (op)
    {
        case OP_EQ:
            opString = " = ";
        case OP_GE:
        case OP_GT:
        case OP_LE:
        case OP_LT:
            return String.format("%s %s %s", name, opString, value);
        case OP_AND:
            return String.format("%s AND %s", partitionFilterToWhereClauseString(be.getLhs()), partitionFilterToWhereClauseString(be.getRhs()));
        default:
            throw new RuntimeException("Unsupported expression type: " + opString);
    }
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** 
 * Return cql where clauses for the corresponding partition filter. Make sure the data format matches 
 * Only support the following Pig data types: int, long, float, double, boolean and chararray
 * */
private String partitionFilterToWhereClauseString(Expression expression) throws IOException
{
    Expression.BinaryExpression be = (Expression.BinaryExpression) expression;
    String name = be.getLhs().toString();
    String value = be.getRhs().toString();
    OpType op = expression.getOpType();
    String opString = op.toString();
    switch (op)
    {
        case OP_EQ:
            opString = " = ";
        case OP_GE:
        case OP_GT:
        case OP_LE:
        case OP_LT:
            return String.format("%s %s %s", name, opString, value);
        case OP_AND:
            return String.format("%s AND %s", partitionFilterToWhereClauseString(be.getLhs()), partitionFilterToWhereClauseString(be.getRhs()));
        default:
            throw new IOException("Unsupported expression type: " + opString);
    }
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
@Override
public List<Expression.OpType> getSupportedExpressionTypes() {
  OpType supportedTypes [] = {
      OpType.OP_EQ,
      OpType.OP_NE,
      OpType.OP_GT,
      OpType.OP_GE,
      OpType.OP_LT,
      OpType.OP_LE,
      OpType.OP_AND,
      OpType.OP_OR,
      //OpType.OP_BETWEEN, // not implemented in Pig yet
      //OpType.OP_IN,      // not implemented in Pig yet
      OpType.OP_NOT
  };

  return Arrays.asList(supportedTypes);
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
@VisibleForTesting
SearchArgument getSearchArgument(Expression expr) {
    if (expr == null) {
        return null;
    }
    Builder builder = SearchArgumentFactory.newBuilder();
    boolean beginWithAnd = !(expr.getOpType().equals(OpType.OP_AND) || expr.getOpType().equals(OpType.OP_OR) || expr.getOpType().equals(OpType.OP_NOT));
    if (beginWithAnd) {
        builder.startAnd();
    }
    buildSearchArgument(expr, builder);
    if (beginWithAnd) {
        builder.end();
    }
    SearchArgument sArg = builder.build();
    return sArg;
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** set partition filter */
public void setPartitionFilter(Expression partitionFilter) throws IOException
{
    UDFContext context = UDFContext.getUDFContext();
    Properties property = context.getUDFProperties(AbstractCassandraStorage.class);
    property.setProperty(PARTITION_FILTER_SIGNATURE, indexExpressionsToString(filterToIndexExpressions(partitionFilter)));
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** get a list of Cassandra IndexExpression from Pig expression */
private List<IndexExpression> filterToIndexExpressions(Expression expression) throws IOException
{
    List<IndexExpression> indexExpressions = new ArrayList<IndexExpression>();
    Expression.BinaryExpression be = (Expression.BinaryExpression)expression;
    ByteBuffer name = ByteBuffer.wrap(be.getLhs().toString().getBytes());
    ByteBuffer value = ByteBuffer.wrap(be.getRhs().toString().getBytes());
    switch (expression.getOpType())
    {
        case OP_EQ:
            indexExpressions.add(new IndexExpression(name, IndexOperator.EQ, value));
            break;
        case OP_GE:
            indexExpressions.add(new IndexExpression(name, IndexOperator.GTE, value));
            break;
        case OP_GT:
            indexExpressions.add(new IndexExpression(name, IndexOperator.GT, value));
            break;
        case OP_LE:
            indexExpressions.add(new IndexExpression(name, IndexOperator.LTE, value));
            break;
        case OP_LT:
            indexExpressions.add(new IndexExpression(name, IndexOperator.LT, value));
            break;
        case OP_AND:
            indexExpressions.addAll(filterToIndexExpressions(be.getLhs()));
            indexExpressions.addAll(filterToIndexExpressions(be.getRhs()));
            break;
        default:
            throw new IOException("Unsupported expression type: " + expression.getOpType().name());
    }
    return indexExpressions;
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
@Override
public void setPartitionFilter(Expression partitionFilter) throws IOException {
  // convert the partition filter expression into a string expected by
  // hcat and pass it in setLocation()

  partitionFilterString = getHCatComparisonString(partitionFilter);

  // store this in the udf context so we can get it later
  storeInUDFContext(signature,
    PARTITION_FILTER, partitionFilterString);
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** set partition filter */
public void setPartitionFilter(Expression partitionFilter)
{
    UDFContext context = UDFContext.getUDFContext();
    Properties property = context.getUDFProperties(AbstractCassandraStorage.class);
    property.setProperty(PARTITION_FILTER_SIGNATURE, indexExpressionsToString(filterToIndexExpressions(partitionFilter)));
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/** get a list of Cassandra IndexExpression from Pig expression */
private List<IndexExpression> filterToIndexExpressions(Expression expression)
{
    List<IndexExpression> indexExpressions = new ArrayList<IndexExpression>();
    Expression.BinaryExpression be = (Expression.BinaryExpression)expression;
    ByteBuffer name = ByteBuffer.wrap(be.getLhs().toString().getBytes());
    ByteBuffer value = ByteBuffer.wrap(be.getRhs().toString().getBytes());
    switch (expression.getOpType())
    {
        case OP_EQ:
            indexExpressions.add(new IndexExpression(name, IndexOperator.EQ, value));
            break;
        case OP_GE:
            indexExpressions.add(new IndexExpression(name, IndexOperator.GTE, value));
            break;
        case OP_GT:
            indexExpressions.add(new IndexExpression(name, IndexOperator.GT, value));
            break;
        case OP_LE:
            indexExpressions.add(new IndexExpression(name, IndexOperator.LTE, value));
            break;
        case OP_LT:
            indexExpressions.add(new IndexExpression(name, IndexOperator.LT, value));
            break;
        case OP_AND:
            indexExpressions.addAll(filterToIndexExpressions(be.getLhs()));
            indexExpressions.addAll(filterToIndexExpressions(be.getRhs()));
            break;
        default:
            throw new RuntimeException("Unsupported expression type: " + expression.getOpType().name());
    }
    return indexExpressions;
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
/**
 * @return the condition on partition columns extracted from filter
 */
public  Expression getPColCondition(){
   if(!canPushDown || pColConditions.size() == 0)
       return null;
	Expression cond =  pColConditions.get(0);
	for(int i=1; i<pColConditions.size(); i++){
		//if there is more than one condition expression
		// connect them using "AND"s
		cond = new Expression.BinaryExpression(cond, pColConditions.get(i),
                   OpType.OP_AND);
	}
	return cond;
}
 

import org.apache.pig.Expression; //导入依赖的package包/类
@Override
    public void transform(OperatorPlan matched) throws FrontendException {
    	subPlan = new OperatorSubPlan( currentPlan );

    	setupColNameMaps();
    	
    	// PIG-1871: Don't throw exception if partition filters cannot be pushed up. 
    	// Perform transformation on a copy of the filter plan, and replace the 
    	// original filter plan only if the transformation is successful 
    	// (i.e. partition filter can be pushed down) 
    	LogicalExpressionPlan filterExpr = loFilter.getFilterPlan();
    	LogicalExpressionPlan filterExprCopy = filterExpr.deepCopy();
    	
    	PColFilterExtractor pColFilterFinder = new PColFilterExtractor(
    	        filterExprCopy, getMappedKeys( partitionKeys ) );
    	pColFilterFinder.visit();
    	Expression partitionFilter = pColFilterFinder.getPColCondition();
    	
    	if(partitionFilter != null) {
    		// the column names in the filter may be the ones provided by
    		// the user in the schema in the load statement - we may need
    		// to replace them with partition column names as given by
    		// LoadFunc.getSchema()
    		updateMappedColNames(partitionFilter);
    		try {
	loadMetadata.setPartitionFilter(partitionFilter);
} catch (IOException e) {
	throw new FrontendException( e );
}
    		if(pColFilterFinder.isFilterRemovable()) {  
    			currentPlan.removeAndReconnect( loFilter );
    		} else {
    		    loFilter.setFilterPlan(filterExprCopy);
    		}
    	}
    }
 

import org.apache.pig.Expression; //导入依赖的package包/类
private void updateMappedColNames(Expression expr) {
    if(expr instanceof BinaryExpression) {
        updateMappedColNames(((BinaryExpression) expr).getLhs());
        updateMappedColNames(((BinaryExpression) expr).getRhs());
    } else if (expr instanceof Column) {
        Column col = (Column) expr;
        col.setName(reverseColNameMap.get(col.getName()));
    }
}