Java Code Examples for org.apache.hadoop.hbase.filter.CompareFilter.CompareOp#NOT_EQUAL

The following examples show how to use org.apache.hadoop.hbase.filter.CompareFilter.CompareOp#NOT_EQUAL . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: HBaseFilterBuilder.java    From eagle with Apache License 2.0 6 votes vote down vote up 
/**
 * Convert ComparisonOperator to native HBase CompareOp Support: =, =~,CONTAINS,<,<=,>,>=,!=,!=~
 *
 * @param comp
 * @return
 */
protected static CompareOp convertToHBaseCompareOp(ComparisonOperator comp) {
    if (comp == ComparisonOperator.EQUAL || comp == ComparisonOperator.LIKE
        || comp == ComparisonOperator.CONTAINS || comp == ComparisonOperator.IN
        || comp == ComparisonOperator.IS) {
        return CompareOp.EQUAL;
    } else if (comp == ComparisonOperator.LESS) {
        return CompareOp.LESS;
    } else if (comp == ComparisonOperator.LESS_OR_EQUAL) {
        return CompareOp.LESS_OR_EQUAL;
    } else if (comp == ComparisonOperator.GREATER) {
        return CompareOp.GREATER;
    } else if (comp == ComparisonOperator.GREATER_OR_EQUAL) {
        return CompareOp.GREATER_OR_EQUAL;
    } else if (comp == ComparisonOperator.NOT_EQUAL || comp == ComparisonOperator.NOT_LIKE
               || comp == ComparisonOperator.NOT_CONTAINS || comp == ComparisonOperator.IS_NOT
               || comp == ComparisonOperator.NOT_IN) {
        return CompareOp.NOT_EQUAL;
    } else {
        LOG.error("{} operation is not supported now\n", comp);
        throw new IllegalArgumentException("Illegal operation: " + comp + ", avaliable options: "
                                           + Arrays.toString(ComparisonOperator.values()));
    }
}
Example 2
Source File: ParseNodeRewriter.java    From phoenix with BSD 3-Clause "New" or "Revised" License 6 votes vote down vote up 
@Override
public ParseNode visitLeave(final ComparisonParseNode node, List<ParseNode> nodes) throws SQLException {
    ParseNode normNode = leaveCompoundNode(node, nodes, new CompoundNodeFactory() {
        @Override
        public ParseNode createNode(List<ParseNode> children) {
            return NODE_FACTORY.comparison(node.getFilterOp(), children.get(0), children.get(1));
        }
    });
    
    CompareOp op = node.getFilterOp();
    if (op == CompareOp.EQUAL || op == CompareOp.NOT_EQUAL) {
        // Rewrite row value constructor in = or != expression, as this is the same as if it was
        // used in an equality expression for each individual part.
        ParseNode lhs = normNode.getChildren().get(0);
        ParseNode rhs = normNode.getChildren().get(1);
        if (lhs instanceof RowValueConstructorParseNode || rhs instanceof RowValueConstructorParseNode) {
            List<ParseNode> andNodes = Lists.newArrayListWithExpectedSize(Math.max(lhs.getChildren().size(), rhs.getChildren().size()));
            rewriteRowValueConstuctorEqualityComparison(lhs,rhs,andNodes);
            normNode = NODE_FACTORY.and(andNodes);
            if (op == CompareOp.NOT_EQUAL) {
                normNode = NODE_FACTORY.not(normNode);
            }
        }
    }
    return normNode;
}
Example 3
Source File: WhereOptimizer.java    From phoenix with Apache License 2.0 6 votes vote down vote up 
@Override
public SortOrder getSortOrder() {
    //See PHOENIX-4969: Clean up and unify code paths for RVCs with
    //  respect to Optimizations for SortOrder
    //Handle the different paths for InList vs Normal Comparison
    //The code paths in InList assume the sortOrder is ASC for
    // their optimizations
    //The code paths for Comparisons on RVC rewrite equality,
    // for the non-equality cases return actual sort order
    //This work around should work
    // but a more general approach can be taken.
    if(rvcElementOp == CompareOp.EQUAL ||
            rvcElementOp == CompareOp.NOT_EQUAL){
        return SortOrder.ASC;
    }
    return childPart.getColumn().getSortOrder();
}
Example 4
Source File: HbaseServiceImpl.java    From searchanalytics-bigdata with MIT License 6 votes vote down vote up 
@Override
public List<String> getSearchClicksRowKeysWithValidQueryString() {
	LOG.debug("Checking getSearchClicksRowKeys searchclicks table content!");
	Scan scan = new Scan();
	scan.addFamily(HbaseJsonEventSerializer.COLUMFAMILY_SEARCH_BYTES);
	SingleColumnValueFilter filter = new SingleColumnValueFilter(HbaseJsonEventSerializer.COLUMFAMILY_SEARCH_BYTES, 
			Bytes.toBytes("querystring"), CompareOp.NOT_EQUAL, Bytes.toBytes("jaiblahblah"));
	filter.setFilterIfMissing(true);
	scan.setFilter(filter);
	List<String> rows = hbaseTemplate.find("searchclicks", scan,
			new RowMapper<String>() {
				@Override
				public String mapRow(Result result, int rowNum)
						throws Exception {
					return new String(result.getRow());
				}
			});
	for (String row : rows) {
		LOG.debug("searchclicks table content, Table returned row key: {}", row);
	}
	LOG.debug("Checking getSearchClicksRowKeys searchclicks table content done!");
	return rows;
}
Example 5
Source File: MetaDataEndpointImpl.java    From phoenix with BSD 3-Clause "New" or "Revised" License 5 votes vote down vote up 
/**
 * @param tableName parent table's name
 * @return true if there exist a table that use this table as their base table.
 * TODO: should we pass a timestamp here?
 */
private boolean hasViews(HRegion region, byte[] tenantId, PTable table) throws IOException {
    byte[] schemaName = table.getSchemaName().getBytes();
    byte[] tableName = table.getTableName().getBytes();
    Scan scan = new Scan();
    // If the table is multi-tenant, we need to check across all tenant_ids,
    // so we can't constrain the row key. Otherwise, any views would have
    // the same tenantId.
    if (!table.isMultiTenant()) {
        byte[] startRow = ByteUtil.concat(tenantId, QueryConstants.SEPARATOR_BYTE_ARRAY);
        byte[] stopRow = ByteUtil.nextKey(startRow);
        scan.setStartRow(startRow);
        scan.setStopRow(stopRow);
    }
    SingleColumnValueFilter filter1 = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, BASE_SCHEMA_NAME_BYTES, EQUAL, schemaName);
    filter1.setFilterIfMissing(schemaName.length > 0);
    SingleColumnValueFilter filter2 = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, BASE_TABLE_NAME_BYTES, EQUAL, tableName);
    filter2.setFilterIfMissing(true);
    BinaryComparator comparator = new BinaryComparator(ByteUtil.concat(tenantId, QueryConstants.SEPARATOR_BYTE_ARRAY, schemaName, QueryConstants.SEPARATOR_BYTE_ARRAY, tableName));
    RowFilter filter3 = new RowFilter(CompareOp.NOT_EQUAL,comparator);
    Filter filter = new FilterList(filter1,filter2,filter3);
    scan.setFilter(filter);
    RegionScanner scanner = region.getScanner(scan);
    try {
        List<KeyValue> results = newArrayList();
        scanner.next(results);
        return results.size() > 0;
    }
    finally {
        scanner.close();
    }
}
Example 6
Source File: HBaseFilterBuilder.java    From Eagle with Apache License 2.0 5 votes vote down vote up 
/**
 * Convert ComparisonOperator to native HBase CompareOp
 *
 * Support:
 *      =, =~,CONTAINS,<,<=,>,>=,!=,!=~
 *
 * @param comp
 * @return
 */
protected static CompareOp convertToHBaseCompareOp(ComparisonOperator comp) {
	if(comp == ComparisonOperator.EQUAL || comp == ComparisonOperator.LIKE
			|| comp == ComparisonOperator.CONTAINS
			|| comp == ComparisonOperator.IN
			|| comp == ComparisonOperator.IS
			) {
		return CompareOp.EQUAL;
	}else if(comp == ComparisonOperator.LESS) {
		return CompareOp.LESS;
	} else if(comp == ComparisonOperator.LESS_OR_EQUAL){
		return CompareOp.LESS_OR_EQUAL;
	}else if(comp == ComparisonOperator.GREATER) {
		return CompareOp.GREATER;
	} else if(comp == ComparisonOperator.GREATER_OR_EQUAL){
		return CompareOp.GREATER_OR_EQUAL;
	} else if(comp == ComparisonOperator.NOT_EQUAL
			|| comp == ComparisonOperator.NOT_LIKE
			|| comp == ComparisonOperator.NOT_CONTAINS
			|| comp == ComparisonOperator.IS_NOT
			|| comp == ComparisonOperator.NOT_IN)
	{
		return CompareOp.NOT_EQUAL;
	} else {
		LOG.error("{} operation is not supported now\n", comp);
		throw new IllegalArgumentException("Illegal operation: "+comp+ ", avaliable options: "+ Arrays.toString(ComparisonOperator.values()));
	}
}
Example 7
Source File: WhereOptimizer.java    From phoenix with BSD 3-Clause "New" or "Revised" License 5 votes vote down vote up 
@Override
public Iterator<Expression> visitEnter(ComparisonExpression node) {
    Expression rhs = node.getChildren().get(1);
    if (!rhs.isStateless() || node.getFilterOp() == CompareOp.NOT_EQUAL) {
        return Iterators.emptyIterator();
    }
    return Iterators.singletonIterator(node.getChildren().get(0));
}
Example 8
Source File: WhereOptimizer.java    From phoenix with Apache License 2.0 5 votes vote down vote up 
@Override
public Iterator<Expression> visitEnter(ComparisonExpression node) {
    Expression rhs = node.getChildren().get(1);
    if (!rhs.isStateless() || node.getFilterOp() == CompareOp.NOT_EQUAL) {
        return Collections.emptyIterator();
    }
    return Iterators.singletonIterator(node.getChildren().get(0));
}
Example 9
Source File: PrepareClusterJob.java    From recsys-offline with Apache License 2.0 5 votes vote down vote up 
public void run() {
	
	try {
		Job job = Job.getInstance(HBaseContext.config, "ClusterPrepareJob");
		job.setJarByClass(PrepareClusterJob.class);

		Scan scan = new Scan();
		scan.setCaching(500);
		scan.setCacheBlocks(false);
		scan.addColumn(Constants.hbase_column_family.getBytes(),
				Constants.hbase_column_yearrate.getBytes());
		scan.addColumn(Constants.hbase_column_family.getBytes(),
				Constants.hbase_column_repaylimittime.getBytes());
		scan.addColumn(Constants.hbase_column_family.getBytes(),
				Constants.hbase_column_progress.getBytes());

		Filter filter = new SingleColumnValueFilter(Bytes.toBytes(Constants.hbase_column_family), 
				Bytes.toBytes(Constants.hbase_column_progress), CompareOp.NOT_EQUAL, Bytes.toBytes("100"));

		scan.setFilter(filter);

		TableMapReduceUtil.initTableMapperJob(Constants.hbase_p2p_table,
				scan, HBaseReadMapper.class, Text.class, Text.class, job);
		TableMapReduceUtil.initTableReducerJob(
				Constants.hbase_cluster_model_table,
				HBaseWriteReducer.class, job);
		job.setNumReduceTasks(1);

		boolean b = job.waitForCompletion(true);
		if (!b) {
			throw new IOException("error with job!");
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
}
Example 10
Source File: WhereOptimizer.java    From phoenix with Apache License 2.0 5 votes vote down vote up 
@Override
public Iterator<Expression> visitEnter(ComparisonExpression node) {
    Expression rhs = node.getChildren().get(1);
    if (!rhs.isStateless() || node.getFilterOp() == CompareOp.NOT_EQUAL) {
        return Iterators.emptyIterator();
    }
    return Iterators.singletonIterator(node.getChildren().get(0));
}
Example 11
Source File: ExpressionCompiler.java    From phoenix with Apache License 2.0 4 votes vote down vote up 
@Override
public Expression visitLeave(LikeParseNode node, List<Expression> children) throws SQLException {
    ParseNode lhsNode = node.getChildren().get(0);
    ParseNode rhsNode = node.getChildren().get(1);
    Expression lhs = children.get(0);
    Expression rhs = children.get(1);
    if ( rhs.getDataType() != null && lhs.getDataType() != null && 
            !lhs.getDataType().isCoercibleTo(rhs.getDataType())  && 
            !rhs.getDataType().isCoercibleTo(lhs.getDataType())) {
        throw TypeMismatchException.newException(lhs.getDataType(), rhs.getDataType(), node.toString());
    }
    if (lhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode)lhsNode, rhs);
    }
    if (rhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode)rhsNode, lhs);
    }
    if (rhs instanceof LiteralExpression) {
        String pattern = (String)((LiteralExpression)rhs).getValue();
        if (pattern == null || pattern.length() == 0) {
            return LiteralExpression.newConstant(null, PBoolean.INSTANCE, rhs.getDeterminism());
        }
        // TODO: for pattern of '%' optimize to strlength(lhs) > 0
        // We can't use lhs IS NOT NULL b/c if lhs is NULL we need
        // to return NULL.
        int index = LikeExpression.indexOfWildcard(pattern);
        // Can't possibly be as long as the constant, then FALSE
        Integer lhsMaxLength = lhs.getMaxLength();
        if (lhsMaxLength != null && lhsMaxLength < index) {
            return LiteralExpression.newConstant(false, rhs.getDeterminism());
        }
        if (index == -1) {
            String rhsLiteral = LikeExpression.unescapeLike(pattern);
            if (node.getLikeType() == LikeType.CASE_SENSITIVE) {
              CompareOp op = node.isNegate() ? CompareOp.NOT_EQUAL : CompareOp.EQUAL;
              if (pattern.equals(rhsLiteral)) {
                  return new ComparisonExpression(children, op);
              } else {
                  rhs = LiteralExpression.newConstant(rhsLiteral, PChar.INSTANCE, rhs.getDeterminism());
                  return new ComparisonExpression(Arrays.asList(lhs,rhs), op);
              }
            }
        } else {
            byte[] wildcardString = new byte[pattern.length()];
            byte[] wildcard = {StringUtil.MULTI_CHAR_LIKE};
            StringUtil.fill(wildcardString, 0, pattern.length(), wildcard, 0, 1, false);
            if (pattern.equals(new String (wildcardString))) {
                List<Expression> compareChildren = Arrays.asList(lhs, NOT_NULL_STRING);
                return new ComparisonExpression(compareChildren, node.isNegate() ? CompareOp.LESS : CompareOp.GREATER_OR_EQUAL);
            }
        }
    }
    QueryServices services = context.getConnection().getQueryServices();
    boolean useByteBasedRegex =
            services.getProps().getBoolean(QueryServices.USE_BYTE_BASED_REGEX_ATTRIB,
                QueryServicesOptions.DEFAULT_USE_BYTE_BASED_REGEX);
    Expression expression;
    if (useByteBasedRegex) {
        expression = ByteBasedLikeExpression.create(children, node.getLikeType());
    } else {
        expression = StringBasedLikeExpression.create(children, node.getLikeType());
    }
    if (ExpressionUtil.isConstant(expression)) {
        ImmutableBytesWritable ptr = context.getTempPtr();
        if (!expression.evaluate(null, ptr)) {
            return LiteralExpression.newConstant(null, expression.getDeterminism());
        } else {
            return LiteralExpression.newConstant(Boolean.TRUE.equals(PBoolean.INSTANCE.toObject(ptr)) ^ node.isNegate(), expression.getDeterminism());
        }
    }
    if (node.isNegate()) {
        expression = new NotExpression(expression);
    }
    return wrapGroupByExpression(expression);
}
Example 12
Source File: NotEqualParseNode.java    From phoenix with Apache License 2.0 4 votes vote down vote up 
@Override
public CompareOp getInvertFilterOp() {
    return CompareOp.NOT_EQUAL;
}
Example 13
Source File: NotEqualParseNode.java    From phoenix with Apache License 2.0 4 votes vote down vote up 
@Override
public CompareOp getFilterOp() {
    return CompareOp.NOT_EQUAL;
}
Example 14
Source File: NotEqualParseNode.java    From phoenix with Apache License 2.0 4 votes vote down vote up 
@Override
public CompareOp getInvertFilterOp() {
    return CompareOp.NOT_EQUAL;
}
Example 15
Source File: ExpressionCompiler.java    From phoenix with BSD 3-Clause "New" or "Revised" License 4 votes vote down vote up 
@Override
public Expression visitLeave(LikeParseNode node, List<Expression> children) throws SQLException {
    ParseNode lhsNode = node.getChildren().get(0);
    ParseNode rhsNode = node.getChildren().get(1);
    Expression lhs = children.get(0);
    Expression rhs = children.get(1);
    if ( rhs.getDataType() != null && lhs.getDataType() != null && 
            !lhs.getDataType().isCoercibleTo(rhs.getDataType())  && 
            !rhs.getDataType().isCoercibleTo(lhs.getDataType())) {
        throw TypeMismatchException.newException(lhs.getDataType(), rhs.getDataType(), node.toString());
    }
    if (lhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode)lhsNode, rhs);
    }
    if (rhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode)rhsNode, lhs);
    }
    if (rhs instanceof LiteralExpression) {
        String pattern = (String)((LiteralExpression)rhs).getValue();
        if (pattern == null || pattern.length() == 0) {
            return LiteralExpression.newConstant(null, rhs.isDeterministic());
        }
        // TODO: for pattern of '%' optimize to strlength(lhs) > 0
        // We can't use lhs IS NOT NULL b/c if lhs is NULL we need
        // to return NULL.
        int index = LikeExpression.indexOfWildcard(pattern);
        // Can't possibly be as long as the constant, then FALSE
        Integer lhsByteSize = lhs.getByteSize();
        if (lhsByteSize != null && lhsByteSize < index) {
            return LiteralExpression.newConstant(false, rhs.isDeterministic());
        }
        if (index == -1) {
            String rhsLiteral = LikeExpression.unescapeLike(pattern);
            if (lhsByteSize != null && lhsByteSize != rhsLiteral.length()) {
                return LiteralExpression.newConstant(false, rhs.isDeterministic());
            }
            CompareOp op = node.isNegate() ? CompareOp.NOT_EQUAL : CompareOp.EQUAL;
            if (pattern.equals(rhsLiteral)) {
                return new ComparisonExpression(op, children);
            } else {
                rhs = LiteralExpression.newConstant(rhsLiteral, PDataType.CHAR, rhs.isDeterministic());
                return new ComparisonExpression(op, Arrays.asList(lhs,rhs));
            }
        }
    }
    Expression expression = new LikeExpression(children);
    if (node.isStateless()) {
        ImmutableBytesWritable ptr = context.getTempPtr();
        if (!expression.evaluate(null, ptr)) {
            return LiteralExpression.newConstant(null, expression.isDeterministic());
        } else {
            return LiteralExpression.newConstant(Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(ptr)) ^ node.isNegate(), expression.isDeterministic());
        }
    }
    if (node.isNegate()) {
        expression = new NotExpression(expression);
    }
    return expression;
}
Example 16
Source File: NotEqualParseNode.java    From phoenix with Apache License 2.0 4 votes vote down vote up 
@Override
public CompareOp getFilterOp() {
    return CompareOp.NOT_EQUAL;
}
Example 17
Source File: NotEqualParseNode.java    From phoenix with BSD 3-Clause "New" or "Revised" License 4 votes vote down vote up 
@Override
public CompareOp getFilterOp() {
    return CompareOp.NOT_EQUAL;
}
Example 18
Source File: NotEqualParseNode.java    From phoenix with BSD 3-Clause "New" or "Revised" License 4 votes vote down vote up 
@Override
public CompareOp getInvertFilterOp() {
    return CompareOp.NOT_EQUAL;
}
Example 19
Source File: ExpressionCompiler.java    From phoenix with Apache License 2.0 4 votes vote down vote up 
@Override
public Expression visitLeave(LikeParseNode node, List<Expression> children) throws SQLException {
    ParseNode lhsNode = node.getChildren().get(0);
    ParseNode rhsNode = node.getChildren().get(1);
    Expression lhs = children.get(0);
    Expression rhs = children.get(1);
    if ( rhs.getDataType() != null && lhs.getDataType() != null && 
            !lhs.getDataType().isCoercibleTo(rhs.getDataType())  && 
            !rhs.getDataType().isCoercibleTo(lhs.getDataType())) {
        throw TypeMismatchException.newException(lhs.getDataType(), rhs.getDataType(), node.toString());
    }
    if (lhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode)lhsNode, rhs);
    }
    if (rhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode)rhsNode, lhs);
    }
    if (rhs instanceof LiteralExpression) {
        String pattern = (String)((LiteralExpression)rhs).getValue();
        if (pattern == null || pattern.length() == 0) {
            return LiteralExpression.newConstant(null, rhs.getDeterminism());
        }
        // TODO: for pattern of '%' optimize to strlength(lhs) > 0
        // We can't use lhs IS NOT NULL b/c if lhs is NULL we need
        // to return NULL.
        int index = LikeExpression.indexOfWildcard(pattern);
        // Can't possibly be as long as the constant, then FALSE
        Integer lhsMaxLength = lhs.getMaxLength();
        if (lhsMaxLength != null && lhsMaxLength < index) {
            return LiteralExpression.newConstant(false, rhs.getDeterminism());
        }
        if (index == -1) {
            String rhsLiteral = LikeExpression.unescapeLike(pattern);
            if (lhsMaxLength != null && lhsMaxLength != rhsLiteral.length()) {
                return LiteralExpression.newConstant(false, rhs.getDeterminism());
            }
            if (node.getLikeType() == LikeType.CASE_SENSITIVE) {
              CompareOp op = node.isNegate() ? CompareOp.NOT_EQUAL : CompareOp.EQUAL;
              if (pattern.equals(rhsLiteral)) {
                  return new ComparisonExpression(children, op);
              } else {
                  rhs = LiteralExpression.newConstant(rhsLiteral, PChar.INSTANCE, rhs.getDeterminism());
                  return new ComparisonExpression(Arrays.asList(lhs,rhs), op);
              }
            }
        }
    }
    Expression expression = LikeExpression.create(children, node.getLikeType());
    if (ExpressionUtil.isConstant(expression)) {
        ImmutableBytesWritable ptr = context.getTempPtr();
        if (!expression.evaluate(null, ptr)) {
            return LiteralExpression.newConstant(null, expression.getDeterminism());
        } else {
            return LiteralExpression.newConstant(Boolean.TRUE.equals(PBoolean.INSTANCE.toObject(ptr)) ^ node.isNegate(), expression.getDeterminism());
        }
    }
    if (node.isNegate()) {
        expression = new NotExpression(expression);
    }
    return wrapGroupByExpression(expression);
}