hbase filter查询

最新推荐文章于 2021-11-16 00:40:41 发布
最新推荐文章于 2021-11-16 00:40:41 发布
阅读量581 收藏
点赞数
文章标签： filter hbase

引自 ：   http://www.cnblogs.com/liuwei6/p/6840300.html


引言：过滤器的类型很多，但是可以分为两大类——比较过滤器，专用过滤器
过滤器的作用是在服务端判断数据是否满足条件，然后只将满足条件的数据返回给客户端；

一、hbase过滤器的分类

   1、比较过滤器

      行键过滤器 RowFilter

Filter filter1 = new RowFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("row-22")));

scan.setFilter(filter1);

      列族过滤器 FamilyFilter

Filter filter1 = new FamilyFilter(CompareFilter.CompareOp.LESS, new BinaryComparator(Bytes.toBytes("colfam3")));
scan.setFilter(filter1);

     列过滤器 QualifierFilter

Filter filter = new QualifierFilter(CompareFilter.CompareOp.LESS_OR_EQUAL, new  BinaryComparator(Bytes.toBytes("col-2")));
scan.setFilter(filter1);

    值过滤器 ValueFilter

Filter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(".4") );
scan.setFilter(filter1);

   2、专用过滤器

单列值过滤器 SingleColumnValueFilter ----会返回满足条件的整行

SingleColumnValueFilter filter = new SingleColumnValueFilter(
Bytes.toBytes("colfam1"),
Bytes.toBytes("col-5"),
CompareFilter.CompareOp.NOT_EQUAL,
new SubstringComparator("val-5"));
filter.setFilterIfMissing(true); //如果不设置为 true，则那些不包含指定 column 的行也会返回
scan.setFilter(filter1);

单列值排除器 SingleColumnValueExcludeFilter -----返回排除了该列的结果 与上面的结果相反

前缀过滤器 PrefixFilter----针对行键
Filter filter = new PrefixFilter(Bytes.toBytes("row1"));
scan.setFilter(filter1);

列前缀过滤器 ColumnPrefixFilter
Filter filter = new ColumnPrefixFilter(Bytes.toBytes("qual2"));
scan.setFilter(filter1);

分页过滤器 PageFilter

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package  com.ghgj.hbase;
import  org.apache.hadoop.conf.Configuration;
import  org.apache.hadoop.hbase.HBaseConfiguration;
import  org.apache.hadoop.hbase.client.HTable;
import  org.apache.hadoop.hbase.client.Result;
import  org.apache.hadoop.hbase.client.ResultScanner;
import  org.apache.hadoop.hbase.client.Scan;
import  org.apache.hadoop.hbase.filter.BinaryComparator;
import  org.apache.hadoop.hbase.filter.BinaryPrefixComparator;
import  org.apache.hadoop.hbase.filter.ByteArrayComparable;
import  org.apache.hadoop.hbase.filter.ColumnPrefixFilter;
import  org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import  org.apache.hadoop.hbase.filter.FamilyFilter;
import  org.apache.hadoop.hbase.filter.Filter;
import  org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter;
import  org.apache.hadoop.hbase.filter.PageFilter;
import  org.apache.hadoop.hbase.filter.PrefixFilter;
import  org.apache.hadoop.hbase.filter.QualifierFilter;
import  org.apache.hadoop.hbase.filter.RegexStringComparator;
import  org.apache.hadoop.hbase.filter.RowFilter;
import  org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import  org.apache.hadoop.hbase.filter.SubstringComparator;
import  org.apache.hadoop.hbase.util.Bytes;
import  org.junit.Test;
public  class  HbasePageDemo {
// 声明静态配置
static  Configuration conf =  null ;
private  static  final  String ZK_CONNECT_STR =
"hadoop01:2181,hadoop02:2181,hadoop03:2181,hadoop04:2181,hadoop05:2181" ;
static  {
conf = HBaseConfiguration.create();
conf.set( "hbase.zookeeper.quorum" , ZK_CONNECT_STR);
}
public  static  void  main(String[] args)  throws  Exception {
String tableName =  "testfilter" ;
String cfName =  "f1" ;
final  byte [] POSTFIX =  new  byte [] {  0x00  };
HTable table =  new  HTable(conf, tableName);
Filter filter =  new  PageFilter( 3 );
byte [] lastRow =  null ;
int  totalRows =  0 ;
while  ( true ) {
Scan scan =  new  Scan();
scan.setFilter(filter);
if (lastRow !=  null ){
//注意这里添加了 POSTFIX 操作，用来重置扫描边界
byte [] startRow = Bytes.add(lastRow,POSTFIX);
scan.setStartRow(startRow);
}
ResultScanner scanner = table.getScanner(scan);
int  localRows =  0 ;
Result result;
while ((result = scanner.next()) !=  null ){
System.out.println(localRows++ +  ":"  + result);
totalRows ++;
lastRow = result.getRow();
}
scanner.close();
if (localRows ==  0 )  break ;
}
System.out.println( "total rows:"  + totalRows);
} /
**
* 多种过滤条件的使用方法
*  @throws  Exception
*/
@Test
public  void  testScan()  throws  Exception{
HTable table =  new  HTable(conf,  "person" .getBytes());
Scan scan =  new  Scan(Bytes.toBytes( "person_zhang_000001" ),
Bytes.toBytes( "person_zhang_000002" ));
//前缀过滤器----针对行键
Filter filter =  new  PrefixFilter(Bytes.toBytes( "person" ));
//行过滤器 ---针对行键
ByteArrayComparable rowComparator =  new
BinaryComparator(Bytes.toBytes( "person_zhang_000001" ));
RowFilter rf =  new  RowFilter(CompareOp.LESS_OR_EQUAL, rowComparator);
rf =  new  RowFilter(CompareOp.EQUAL ,  new
SubstringComparator( "_2016-12-31_" ));
//单值过滤器 1 完整匹配字节数组
new  SingleColumnValueFilter( "base_info" .getBytes(),  "name" .getBytes(),
CompareOp.EQUAL,  "zhangsan" .getBytes());
//单值过滤器 2 匹配正则表达式
ByteArrayComparable comparator =  new  RegexStringComparator( "zhang." );
new  SingleColumnValueFilter( "info" .getBytes(),  "NAME" .getBytes(),
CompareOp.EQUAL, comparator);
//单值过滤器 3 匹配是否包含子串,大小写不敏感
comparator =  new  SubstringComparator( "wu" );
new  SingleColumnValueFilter( "info" .getBytes(),  "NAME" .getBytes(),
CompareOp.EQUAL, comparator);
//键值对元数据过滤-----family 过滤----字节数组完整匹配
FamilyFilter ff =  new  FamilyFilter(CompareOp.EQUAL ,
new  BinaryComparator(Bytes.toBytes( "base_info" ))  //表中不存
在 inf 列族，过滤结果为空
);
//键值对元数据过滤-----family 过滤----字节数组前缀匹配
ff =  new  FamilyFilter(
CompareOp.EQUAL ,
new  BinaryPrefixComparator(Bytes.toBytes( "inf" ))  //表中存在以
inf 打头的列族 info，过滤结果为该列族所有行
);
//键值对元数据过滤-----qualifier 过滤----字节数组完整匹配
filter =  new  QualifierFilter(
CompareOp.EQUAL ,
new  BinaryComparator(Bytes.toBytes( "na" ))  //表中不存在 na
列，过滤结果为空
);
filter =  new  QualifierFilter(
CompareOp.EQUAL ,
new  BinaryPrefixComparator(Bytes.toBytes( "na" ))  //表中存在以
na 打头的列 name，过滤结果为所有行的该列数据
);
//基于列名(即 Qualifier)前缀过滤数据的 ColumnPrefixFilter
filter =  new  ColumnPrefixFilter( "na" .getBytes());
//基于列名(即 Qualifier)多个前缀过滤数据的 MultipleColumnPrefixFilter
byte [][] prefixes =  new  byte [][] {Bytes.toBytes( "na" ), Bytes.toBytes( "me" )};
filter =  new  MultipleColumnPrefixFilter(prefixes);
//为查询设置过滤条件
scan.setFilter(filter);
scan.addFamily(Bytes.toBytes( "base_info" ));
//一行
// Result result = table.get(get);
//多行的数据
ResultScanner scanner = table.getScanner(scan);
for (Result r : scanner){
/**
for(KeyValue kv : r.list()){
String family = new String(kv.getFamily());
System.out.println(family);
String qualifier = new String(kv.getQualifier());
System.out.println(qualifier);
System.out.println(new String(kv.getValue()));
}
*/
//直接从 result 中取到某个特定的 value
byte [] value = r.getValue(Bytes.toBytes( "base_info" ),
Bytes.toBytes( "name" ));
System.out.println( new  String(value));
}
table.close();
}
}

　　

分页过滤器  代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package  com.ghgj.hbase.test1610;
 
import  org.apache.commons.lang.StringUtils;
import  org.apache.hadoop.conf.Configuration;
import  org.apache.hadoop.hbase.HBaseConfiguration;
import  org.apache.hadoop.hbase.client.HTable;
import  org.apache.hadoop.hbase.client.Result;
import  org.apache.hadoop.hbase.client.ResultScanner;
import  org.apache.hadoop.hbase.client.Scan;
import  org.apache.hadoop.hbase.filter.Filter;
import  org.apache.hadoop.hbase.filter.PageFilter;
import  org.apache.hadoop.hbase.util.Bytes;
 
/**
  * 501条
  *
  * 每页100条，求第四页 ： 301 - 400
  *
  * pageIndex:第几页 
  * pageNumber:每页几条
  *
  *
  * 在hbase当中取一部分数据的取法：
  * scan 'user_info',{COLUMNS => 'base_info:name',
  * LIMIT => 4, STARTROW => 'zhangsan_20150701_0001'}
  *
  * mysqL:从第几条开始，取多少条
  *
  * 从mysql的分页规则引申到hbase的分页：把startRow转换成mysql的第几条
  */
public  class  HBasePageFilterDemo {
 
     private  static  final  String ZK_CONNECT_STR =  "hadoop03:2181,hadoop04:2181,hadoop05:2181" ;
 
     private  static  final  String TABLE_NAME =  "user_info" ;
     private  static  final  String FAMILY_BASIC =  "base_info" ;
     private  static  final  String FAMILY_EXTRA =  "extra_info" ;
     private  static  final  String COLUMN_NAME =  "name" ;
     private  static  final  String COLUMN_AGE =  "age" ;
     private  static  final  String ROW_KEY =  "rk0001" ;
 
     private  static  Configuration config =  null ;
     private  static  HTable table =  null ;
     static  {
         config = HBaseConfiguration.create();
         config.set( "hbase.zookeeper.quorum" , ZK_CONNECT_STR);
         try  {
             table =  new  HTable(config, TABLE_NAME);
         }  catch  (Exception e) {
             e.printStackTrace();
         }
     }
     
     public  static  void  main(String[] args)  throws  Exception {
         
//      ResultScanner pageData = getPageData("zhangsan_20150701_0001", 4);
         ResultScanner pageData = getPageData( 2 ,  4 );
         HBasePrintUtil.printResultScanner(pageData);
         
//      String lastRowkey = getLastRowkey(pageData);
//      System.out.println(lastRowkey);
         
     }
     
     public  static  ResultScanner getPageData( int  pageIndex,  int  pageNumber)  throws  Exception{
         // 怎么把pageIndex 转换成 startRow
         String startRow =  null ;
         
         if (pageIndex ==  1 ){  // 当客户方法只取第一页的分页数据时，
             ResultScanner pageData = getPageData(startRow, pageNumber);
             return  pageData;
             
         } else {
             ResultScanner newPageData =  null ;
             for ( int  i= 0 ; i<pageIndex -  1 ; i++){   // 总共循环次数是比你取的页数少1
                 newPageData = getPageData(startRow, pageNumber);
                 startRow = getLastRowkey(newPageData);
                 byte [] add = Bytes.add(Bytes.toBytes(startRow),  new  byte []{  0X00  });
                 startRow = Bytes.toString(add);
             }
             newPageData = getPageData(startRow, pageNumber);
             return  newPageData;
         }
     }
     
     /**
      * @param startRow
      * @param pageNumber
      * @return
      *  * scan 'user_info',{COLUMNS => 'base_info:name',
      * LIMIT => 4, STARTROW => 'zhangsan_20150701_0001'}
      * @throws Exception
      */
     public  static  ResultScanner getPageData(String startRow,  int  pageNumber)  throws  Exception{
         Scan scan  =  new  Scan();
         scan.addColumn(Bytes.toBytes( "base_info" ), Bytes.toBytes( "name" ));
         // 設置當前查询的其实位置
         if (!StringUtils.isBlank(startRow)){
             scan.setStartRow(Bytes.toBytes(startRow));
         }
         // 第二个参数
         Filter pageFilter =  new  PageFilter(pageNumber);
         scan.setFilter(pageFilter);
         
         ResultScanner rs = table.getScanner(scan);
         return  rs;
     }
     
     public  static  String getLastRowkey(ResultScanner rs){
         String lastRowkey =  null ;
         for (Result result : rs){
//          System.out.println(result.getRow());
             lastRowkey = Bytes.toString(result.getRow());
         }
         return  lastRowkey;
//      return null;
     }
}

　　

 

多条件过滤时，可以使用FilterList

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
List<Filter> filters =  new  ArrayList<Filter>();
         SingleColumnValueFilter filter = new   SingleColumnValueFilter(
                 Bytes.toBytes( "info" ),
                 Bytes.toBytes( "age" ),
                 CompareOp.LESS_OR_EQUAL,
                 new  BinaryComparator(Bytes.toBytes( "20" )));
         filters.add(filter);
         
         SingleColumnValueFilter filter1 = new   SingleColumnValueFilter(
                 Bytes.toBytes( "info" ),
                 Bytes.toBytes( "age" ),
                 CompareOp.GREATER,
                 new  BinaryComparator(Bytes.toBytes( "18" )));
         
         filters.add(filter1);
         
         Filter filter2 =  new  ValueFilter(CompareOp.EQUAL,  new  SubstringComparator( "lisi" ) );
         filters.add(filter2);
         
         
         FilterList f= new  FilterList(filters);
                 scan.setFilter(f);

**飞星**
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hbase分页查询实现
09-09
实现HBase分页查询的思路是使用Scan对象来扫描表中的数据，然后使用Filter来过滤数据，最后使用ResultScanner来获取结果集。在实现过程中，我们需要注意的一点是，每次Scan操作都需要指定开始行和结束行，以便实现...
hbase一些查询
05-17
在探讨HBase查询技巧及其应用时，我们聚焦于利用各种Filter进行精确且高效的查询操作。HBase，作为一款分布式、版本化的列存储数据库，专为海量数据设计，其查询性能和灵活性很大程度上依赖于合理使用Filter。以下是...
HBase过滤器Filter总结
MY BLOG
06-13 3874
一、HBase的scan可通过setStartRow、setStopRow对rowkey范围进行过滤 二、HBase中的get、scan都支持过滤器，过滤器在服务端生效，这样可以保证被过滤掉的数据不会被传送到客户端，从而提高了代码运行的效率。 三、过滤器可以根据列族、列、版本等更多的条件来对数据进行过滤，hbase中过滤器分类： 1、RowFilter 说明：筛选出匹配的所有的行，支持基于行键过滤数据，可以执行精确匹配，子字符串匹配或正则表达式匹配，过滤掉不匹配的数据。 用法：使用Binary
Hbase之过滤器的使用
weixin_30865427的博客
04-02 167
一、过滤器概念 基础API中的查询操作在面对大量数据的时候是非常物无力的，这里Hbase提供了高级的查询方法:Filter（过滤器）。过滤器可以根据簇、列、版本等更多的条件来对数据进行过滤，基于Hbase本身提供的三维有序（主键有序、列有序、版本有序），这些Filter可以高效的完成查询过滤的任务。带有Filter条件的RPC查询请求会把Filter分发到各个RegionServer,是一个服务...
HBase client总览
yang_net
12-27 1054
HBase Client总览 1. affects concurrent readers and writers of that same row ==> atomic on a per-row basis 2. RWCC : ReadWriteConsistencyControl read without wait for writes write wait for other
Hbase-之Client-scan请求过滤器(request filter)
shufangreal的博客
11-19 832
Hbase之Client-scan请求过滤器Filter 0 前言 在Hbase的Client对Hbase的数据进行请求的时候，实际上是可以通过过滤器进行数据的筛选的，Hbase的客户端请求过滤器大致分为5种类，具体详情请参考官方。 FilterList 【传入过滤器列表，按照MUST_PASS_ONE \MUST_PASS_ALL的规则进行使用】 Column Value Filter【为列值维度的过滤，通过特定的value与具体column的值进行匹配】 MetaData Filter【为元
hbase java操作api - 过滤器Filter使用
小哇
09-13 2778
过滤器（Filter） 　　基础API中的查询操作在面对大量数据的时候是非常苍白的，这里Hbase提供了高级的查询方法：Filter。Filter可以根据簇、列、版本等更多的条件来对数据进行过滤，基于Hbase本身提供的三维有序（主键有序、列有序、版本有序），这些Filter可以高效的完成查询过滤的任务。带有Filter条件的RPC查询请求会把Filter分发到各个RegionServer，是一个服务器端（Server-side）的过滤器，这样也可以降低网络传输的压力。 　　要完成一个过滤的操作，至少需
hbase行键过滤器RowFilter
谭成
06-04 2485
RowFilter是用来对rowkey进行过滤的,比较符如下: Operator Description LESS 小于 LESS_OR_EQUAL 小于等于 EQUAL 等于 NOT_EQUAL 不等于 GREATER_OR_EQUAL
hbase分页查询实现.pdf
07-14
HBase分页查询实现 HBase作为一个NoSQL数据库，具有高性能、...本文讲解了如何使用Java语言实现HBase的分页查询，并介绍了HBase的配置、HTablePool、获取HBase表、字节数组的转换、Filter和ResultScanner等知识点。
happybase查询hbase
03-10
HappyBase是Python的一个库，为HBase提供了简单易用的API，使得开发者可以方便地通过Python进行HBase的操作，包括查询、插入和更新数据。这篇博客的配套文件主要展示了如何使用HappyBase来查询HBase。 首先，我们...
hbase分页查询实现[归类].pdf
10-11
此外，我们还使用了Filter对象来过滤查询结果。 四、HBase分页查询的优点 HBase分页查询可以带来以下几个优点： * 高效的查询性能：HBase分页查询可以根据实际情况进行查询，避免了全表扫描，提高了查询效率。 * ...
Hbase之滤器Filter
angeliacmm的博客
06-14 3112
3.基本命令 hbase shell ​ 在终端输入hbase shell命令进入hbase命令行。 hbase shell 1.输入help命令，查看帮助文档 hbase(main):000:0> help hbase(main):000:0> help '分组名称' 练习: help 'ddl' help 'dml' help 'namespace' 2.输入list命令，查看表列表 hbase(main):000:0> list #案例: #查看有哪些命名空间 list_n
关于hbase过滤查询的一些
yyqq188的博客
04-12 633
hbase有两种查询的方式一个get  一个scan 其中get是根据精确的rowkey查出单条的记录    ，那么如果一条记录是有成千上万个字段的话，网络IO大，所以要 get.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("f3")); get.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("f2")
Hbase shell中使用Filter过滤器总结
浅谈
07-02 5924
Hbase shell中使用Filter过滤器总结RowFilterValueFilterSingleColumnValueFilterPrefixFilterColumnPrefixFilterMultipleColumnPrefixFilterPageFilterInclusiveStopFilterFamilyFilterQualifierFilterSingleColumnValueExcludeFilter 在hbase shel1中使用过滤器的格式为 #可以通过show_filters查询当前版
HBase入门：查询中常用的Filter总结
u011236069的博客
11-16 4056
简介： 根据技术调研的过程可以明显的体会到hbase的存储方式和数据库的存储有着明显的区别，查询的方式也有着很大不同，HBase主要是通过这种filter来对数据进行筛选。同时对于数据的体量较大（10亿级别以上的数据数据量），检索和修改的场景较多时是比较适合使用hbase。 HBase过滤器可以根据分为：列簇与列类型过滤器，行键过滤器，其他过滤器 HBase Filter 概览 查询hbase支持的filter 列表 hbase(main):015:0> show...
Hbase Filter过滤器查询详解
Transkai
04-18 195
过滤器查询 引言：过滤器的类型很多，但是可以分为两大类——比较过滤器，专用过滤器 过滤器的作用是在服务端判断数据是否满足条件，然后只将满足条件的数据返回给客户端； hbase过滤器的比较运算符： LESS < LESS_OR_EQUAL <= EQUAL = NOT_EQUAL <> GREATER_OR_EQUAL >= GREATER > NO_...
hbase的过滤 Filter 之PrefixFilter
luyee2010的专栏
12-28 1万+
首先来can下表： hbase(main):004:0> scan 'scores' ROW                              COLUMN+CELL                                                                                    zkb
Hbase Filter+Scan 查询效率优化
u013465194的博客
10-14 1万+
Hbase Fileter+Scan 查询效率问题 众所周知，Hbase利用filter过滤器查询时候会进行全表扫描，查询效率低下，如果没有二级索引，在项目中很多情况需要利用filter,下面针对这种情况尝试了几种优化的方案，仅供参考，欢迎交流。 根据业务要求，作者需要根据时间范围搜索所需要的数据，所以作者设计的rowKey是以时间戳为起始字符串的。 正确尝试： 1.scan 设置 开始行和结束行...
Hbase使用filter快速高效查询
热门推荐
liuxiaochen123的专栏
07-11 2万+
本博客是hbase使用filter快速高效查询的方法，我会慢慢补齐 几大Filters 1、Comparision Filters      1.1  RowFilter 1.2 FamilyFilter      1.3 QualifierFilter      1.4 ValueFilter      1.5 DependentColumnFilter 2、Dedicated
hbase 模糊查询
最新发布
08-08
针对 HBase 的模糊查询，可以使用 HBase 提供的过滤器（Filter）来实现。HBase 中常用的过滤器有前缀过滤器（PrefixFilter）、单列值过滤器（SingleColumnValueFilter）和正则表达式过滤器（RegexStringComparator）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值