HBase过滤器

 

 比较运算符

* LESS <

* LESS_OR_EQUAL <=

* EQUAL =

* NOT_EQUAL <>

* GREATER_OR_EQUAL >=

* GREATER >

* NO_OP 排除所有

六大比较过滤器

###### BinaryComparator

> 按字节索引顺序比较指定字节数组，采用Bytes.compareTo(byte[])

###### BinaryPrefixComparator

> 通BinaryComparator，只是比较左端前缀的数据是否相同

###### NullComparator

> 判断给定的是否为空

###### BitComparator

> 按位比较

###### RegexStringComparator

> 提供一个正则的比较器，仅支持 EQUAL 和非EQUAL

###### SubstringComparator

> 判断提供的子串是否出现在中

专业过滤器

单列值过滤器：SingleColumnValueFilter

> SingleColumnValueFilter会返回满足条件的cell所在行的所有cell的值（即会返回一行数据）

列值排除过滤器：SingleColumnValueExcludeFilter

> 与SingleColumnValueFilter相反，会排除掉指定的列，其他的列全部返回

rowkey前缀过滤器：PrefixFilter

> 通过PrefixFilter查询以150010008开头的所有前缀的rowkey

分页过滤器PageFilter

实例代码

1.RegexStringComparator+ValueFilter 

@Test
    //RegexStringComparator+ValueFilter
    //ValueFilter会将比较器作用到所有的列值上，相当于作用到每一个cell上
    //把符合比较器规则的cell过滤出来，不符合的直接丢弃
    public void Filter1() throws IOException {

        Scan scan = new Scan();

        //^以什么为开头，.*表示全部，$表示已什么为结尾
        RegexStringComparator rsc = new RegexStringComparator("^文科.*班$");
        ValueFilter valueFilter = new ValueFilter(EQUAL, rsc);
        scan.setFilter(valueFilter);
        ResultScanner rs = sT.getScanner(scan);
        for (Result r : rs) {

            for (Cell cell : r.listCells()) {
                String values = Bytes.toString(CellUtil.cloneValue(cell));
                System.out.println(values);
            }
//            String id = Bytes.toString(r.getRow());
//            String name = Bytes.toString(r.getValue("info".getBytes(), "name".getBytes()));
//            String age = Bytes.toString(r.getValue("info".getBytes(), "age".getBytes()));
//            String sex = Bytes.toString(r.getValue("info".getBytes(), "sex".getBytes()));
//            String clazz = Bytes.toString(r.getValue("info".getBytes(), "clazz".getBytes()));
//            System.out.println(id+","+name+","+age+","+sex+","+clazz);
        }


    }

 

 

 

 2.RegexStringComparator+SingleColumnValueFilter

@Test
    // RegexStringComparator比较器
    // SingleColumnValueFilter过滤器，对单列进行过滤，
    // 注意和SingleColumnValueExcludeFilter区分，这也是过滤列，但不输出此列
    public void Filter2() throws IOException {
        Scan scan = new Scan();


        SingleColumnValueFilter scv =
                new SingleColumnValueFilter("info".getBytes(),"clazz".getBytes(),
                        CompareFilter.CompareOp.EQUAL,
                        new RegexStringComparator("^文科.*班$"));

        scan.setFilter(scv);
        ResultScanner rs = sT.getScanner(scan);
        for (Result r : rs) {
            String s = Bytes.toString(r.getRow());
            for (Cell cell : r.listCells()) {

                String values = Bytes.toString(CellUtil.cloneValue(cell));
                s=s+" "+values;

            }
            System.out.println(s);

        }
    }

 

3.SubstringComparator+QualifierFilter

可以写一个方法吧重复的代码进行处理

//这里可以写一个方法把重复的代码进行处理
    public void printScannerWithFilter(Filter filter) throws IOException {
        Scan scan = new Scan();
        scan.setFilter(filter);
        ResultScanner rs = sT.getScanner(scan);
        for (Result r : rs) {
            String s = Bytes.toString(r.getRow());
            for (Cell cell : r.listCells()) {
                String values = Bytes.toString(CellUtil.cloneValue(cell));
                s+=" "+values+" ";
            }
            System.out.println(s);
        }
    }

 

    @Test
    // SubstringComparator 判断提供的子串是否出现在中
    // QualifierFilter,列过滤器，根据列名过滤出符合条件的列
    public void Filter3() throws IOException {

        //筛选出age，name，clazz列
        SubstringComparator a = new SubstringComparator("a");
        QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, a);

        //直接调用我下面写的方法
        printScannerWithFilter(qualifierFilter);
    }

 

4.BinaryPrefixComparator+RowFilter

    @Test
    //BinaryPrefixComparator比较器，按字节索引顺序比较指定字节数组，只是比较左端前缀的数据是否相同
    //RowFilter 行键过滤器
    public void Filter4() throws IOException {
        BinaryPrefixComparator bpc = new BinaryPrefixComparator("150010098".getBytes());
        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL, bpc);
        printScannerWithFilter(rowFilter);
    }

 

 

 5.rowkey前置过滤器，等于BinaryPrefixComparator+RowFilter

 //专用过滤器：rowkey前置过滤器PrefixFliter
    //相当于BinaryPrefixComparator+RowFilter
    @Test
    public  void Filter5() throws IOException {
        PrefixFilter prefixFilter = new PrefixFilter("150010098".getBytes());
        printScannerWithFilter(prefixFilter);
    }

 

 5.过滤器综合用FilterList存储

@Test
    //过滤age>=23,sex=男，ROWKEY以150010010开头所有学生数据
    public void Filter6() throws IOException {
        SingleColumnValueFilter age =
                new SingleColumnValueFilter(
                        "info".getBytes(),
                        "age".getBytes(),
                        CompareFilter.CompareOp.GREATER_OR_EQUAL,
                        "23".getBytes()
                );
        SingleColumnValueFilter sex =
                new SingleColumnValueFilter(
                        "info".getBytes(),
                        "sex".getBytes(),
                        CompareFilter.CompareOp.EQUAL, "男".getBytes()
                );
        PrefixFilter prefixFilter = new PrefixFilter("150010010".getBytes());
        //创建一个filter数组存储多个过滤器
        FilterList filterList = new FilterList();
        filterList.addFilter(age);
        filterList.addFilter(sex);
        filterList.addFilter(prefixFilter);

        printScannerWithFilter(filterList);
    }