`

Hbase使用filter快速高效查询

 
阅读更多

 

  1. 本博客是hbase使用filter快速高效查询的方法，我会慢慢补齐  

几大Filters
1、Comparision Filters
     1.1  RowFilter
1.2 FamilyFilter
     1.3 QualifierFilter
     1.4 ValueFilter
     1.5 DependentColumnFilter
2、Dedicated Filters
     2.1 SingleColumnValueFilter
     2.2 SingleColumnValueExcludeFilter
     2.3 PrefixFilter
     2.4 PageFilter
     2.5 KeyOnlyFilter
     2.6 FirstKeyOnlyFilter
     2.7 TimestampsFilter
     2.8 RandomRowFilter
3、Decorating Filters
     3.1  SkipFilter
     3.2 WhileMatchFilters

 

一个简单的示例 SingleColumnValueFilter

 

[java] view plain copy
  1.   public   static   void  selectByFilter(String tablename,List<String> arr)  throws  IOException{    
  2.         HTable table=new  HTable(hbaseConfig,tablename);    
  3.         FilterList filterList = new  FilterList();    
  4.         Scan s1 = new  Scan();    
  5.         for (String v:arr){  // 各个条件之间是“与”的关系     
  6.             String [] s=v.split("," );    
  7.             filterList.addFilter(new  SingleColumnValueFilter(Bytes.toBytes(s[ 0 ]),    
  8.                                                              Bytes.toBytes(s[1 ]),    
  9.                                                              CompareOp.EQUAL,Bytes.toBytes(s[2 ])    
  10.                                                              )    
  11.             );    
  12.             // 添加下面这一行后，则只返回指定的cell，同一行中的其他cell不返回     
  13. //          s1.addColumn(Bytes.toBytes(s[0]), Bytes.toBytes(s[1]));     
  14.         }    
  15.         s1.setFilter(filterList);    
  16.         ResultScanner ResultScannerFilterList = table.getScanner(s1);    
  17.         for (Result rr=ResultScannerFilterList.next();rr!= null ;rr=ResultScannerFilterList.next()){    
  18.             for (KeyValue kv:rr.list()){    
  19.                 System.out.println("row : " + new  String(kv.getRow()));    
  20.                 System.out.println("column : " + new  String(kv.getColumn()));    
  21.                 System.out.println("value : " + new  String(kv.getValue()));    
  22.             }    
  23.         }    
  24.     }    


MultipleColumnPrefixFilter

api上介绍如下

[html] view plain copy
  1. This filter is used for selecting only those keys with columns that matches a particular prefix. For example, if prefix is 'an', it will pass keys will columns like 'and', 'anti' but not keys with columns like 'ball', 'act'.   

构造方法如下

[html] view plain copy
  1. public MultipleColumnPrefixFilter(byte[][] prefixes)  

传入多个prefix
源码里说明如下

[html] view plain copy
  1. public MultipleColumnPrefixFilter(final byte [][] prefixes) {  
  2.      if (prefixes != null) {  
  3.        for (int i  =  0 ; i  <   prefixes.length ; i++) {  
  4.          if (!sortedPrefixes.add(prefixes[i]))  
  5.            throw new IllegalArgumentException ("prefixes must be distinct");  
  6.        }  
  7.      }  
  8.    }  

示例代码如下：是我从网上找的，看了，没啥难理解的，

[html] view plain copy
  1. +public class TestMultipleColumnPrefixFilter {  
  2. +  
  3. +  private final static HBaseTestingUtility TEST_UTIL  =  new   
  4. +      HBaseTestingUtility();  
  5. +  
  6. +  @Test  
  7. +  public void testMultipleColumnPrefixFilter() throws IOException {  
  8. +    String family  =  "Family" ;  
  9. +    HTableDescriptor htd  =  new  HTableDescriptor("TestMultipleColumnPrefixFilter");  
  10. +    htd.addFamily(new HColumnDescriptor(family));  
  11. +    // HRegionInfo info  =  new  HRegionInfo(htd, null, null, false);  
  12. +    HRegionInfo info  =  new  HRegionInfo(htd.getName(), null, null, false);  
  13. +    HRegion region  =  HRegion .createHRegion(info, HBaseTestingUtility.  
  14. +        getTestDir(), TEST_UTIL.getConfiguration(), htd);  
  15. +  
  16. +    List< String >   rows  =  generateRandomWords (100, "row");  
  17. +    List< String >   columns  =  generateRandomWords (10000, "column");  
  18. +    long maxTimestamp  =  2 ;  
  19. +  
  20. +    List< KeyValue >   kvList  =  new  ArrayList < KeyValue > ();  
  21. +  
  22. +    Map< String , List < KeyValue > >   prefixMap  =  new  HashMap < String ,  
  23. +        List< KeyValue > > ();  
  24. +  
  25. +    prefixMap.put("p", new ArrayList< KeyValue > ());  
  26. +    prefixMap.put("q", new ArrayList< KeyValue > ());  
  27. +    prefixMap.put("s", new ArrayList< KeyValue > ());  
  28. +  
  29. +    String valueString  =  "ValueString" ;  
  30. +  
  31. +    for (String row: rows) {  
  32. +      Put p  =  new  Put(Bytes.toBytes(row));  
  33. +      for (String column: columns) {  
  34. +        for (long timestamp  =  1 ; timestamp  < = maxTimestamp; timestamp++) {  
  35. +          KeyValue kv  =  KeyValueTestUtil .create(row, family, column, timestamp,  
  36. +              valueString);  
  37. +          p.add(kv);  
  38. +          kvList.add(kv);  
  39. +          for (String s: prefixMap.keySet()) {  
  40. +            if (column.startsWith(s)) {  
  41. +              prefixMap.get(s).add(kv);  
  42. +            }  
  43. +          }  
  44. +        }  
  45. +      }  
  46. +      region.put(p);  
  47. +    }  
  48. +  
  49. +    MultipleColumnPrefixFilter filter;  
  50. +    Scan scan  =  new  Scan();  
  51. +    scan.setMaxVersions();  
  52. +    byte [][] filter_prefix  =  new  byte [2][];  
  53. +    filter_prefix[0] = new byte [] {'p'};  
  54. +    filter_prefix[1] = new byte [] {'q'};  
  55. +      
  56. +    filter  =  new  MultipleColumnPrefixFilter(filter_prefix);  
  57. +    scan.setFilter(filter);  
  58. +    List< KeyValue >   results  =  new  ArrayList < KeyValue > ();    
  59. +    InternalScanner scanner  =  region .getScanner(scan);  
  60. +    while(scanner.next(results));  
  61. +    assertEquals(prefixMap.get("p").size() + prefixMap.get("q").size(), results.size());  
  62. +  }  
  63. +  
  64. +  @Test  
  65. +  public void testMultipleColumnPrefixFilterWithManyFamilies() throws IOException {  
  66. +    String family1  =  "Family1" ;  
  67. +    String family2  =  "Family2" ;  
  68. +    HTableDescriptor htd  =  new  HTableDescriptor("TestMultipleColumnPrefixFilter");  
  69. +    htd.addFamily(new HColumnDescriptor(family1));  
  70. +    htd.addFamily(new HColumnDescriptor(family2));  
  71. +    HRegionInfo info  =  new  HRegionInfo(htd.getName(), null, null, false);  
  72. +    HRegion region  =  HRegion .createHRegion(info, HBaseTestingUtility.  
  73. +        getTestDir(), TEST_UTIL.getConfiguration(), htd);  
  74. +  
  75. +    List< String >   rows  =  generateRandomWords (100, "row");  
  76. +    List< String >   columns  =  generateRandomWords (10000, "column");  
  77. +    long maxTimestamp  =  3 ;  
  78. +  
  79. +    List< KeyValue >   kvList  =  new  ArrayList < KeyValue > ();  
  80. +  
  81. +    Map< String , List < KeyValue > >   prefixMap  =  new  HashMap < String ,  
  82. +        List< KeyValue > > ();  
  83. +  
  84. +    prefixMap.put("p", new ArrayList< KeyValue > ());  
  85. +    prefixMap.put("q", new ArrayList< KeyValue > ());  
  86. +    prefixMap.put("s", new ArrayList< KeyValue > ());  
  87. +  
  88. +    String valueString  =  "ValueString" ;  
  89. +  
  90. +    for (String row: rows) {  
  91. +      Put p  =  new  Put(Bytes.toBytes(row));  
  92. +      for (String column: columns) {  
  93. +        for (long timestamp  =  1 ; timestamp  < = maxTimestamp; timestamp++) {  
  94. +          double rand  =  Math .random();  
  95. +          KeyValue kv;  
  96. +          if (rand <   0.5 )   
  97. +            kv  =  KeyValueTestUtil .create(row, family1, column, timestamp,  
  98. +                valueString);  
  99. +          else   
  100. +            kv  =  KeyValueTestUtil .create(row, family2, column, timestamp,  
  101. +                valueString);  
  102. +          p.add(kv);  
  103. +          kvList.add(kv);  
  104. +          for (String s: prefixMap.keySet()) {  
  105. +            if (column.startsWith(s)) {  
  106. +              prefixMap.get(s).add(kv);  
  107. +            }  
  108. +          }  
  109. +        }  
  110. +      }  
  111. +      region.put(p);  
  112. +    }  
  113. +  
  114. +    MultipleColumnPrefixFilter filter;  
  115. +    Scan scan  =  new  Scan();  
  116. +    scan.setMaxVersions();  
  117. +    byte [][] filter_prefix  =  new  byte [2][];  
  118. +    filter_prefix[0] = new byte [] {'p'};  
  119. +    filter_prefix[1] = new byte [] {'q'};  
  120. +      
  121. +    filter  =  new  MultipleColumnPrefixFilter(filter_prefix);  
  122. +    scan.setFilter(filter);  
  123. +    List< KeyValue >   results  =  new  ArrayList < KeyValue > ();    
  124. +    InternalScanner scanner  =  region .getScanner(scan);  
  125. +    while(scanner.next(results));  
  126. +    assertEquals(prefixMap.get("p").size() + prefixMap.get("q").size(), results.size());  
  127. +  }  
  128. +    
  129. +  @Test  
  130. +  public void testMultipleColumnPrefixFilterWithColumnPrefixFilter() throws IOException {  
  131. +    String family  =  "Family" ;  
  132. +    HTableDescriptor htd  =  new  HTableDescriptor("TestMultipleColumnPrefixFilter");  
  133. +    htd.addFamily(new HColumnDescriptor(family));  
  134. +    HRegionInfo info  =  new  HRegionInfo(htd.getName(), null, null, false);  
  135. +    HRegion region  =  HRegion .createHRegion(info, HBaseTestingUtility.  
  136. +        getTestDir(), TEST_UTIL.getConfiguration(),htd);  
  137. +  
  138. +    List< String >   rows  =  generateRandomWords (100, "row");  
  139. +    List< String >   columns  =  generateRandomWords (10000, "column");  
  140. +    long maxTimestamp  =  2 ;  
  141. +  
  142. +    String valueString  =  "ValueString" ;  
  143. +  
  144. +    for (String row: rows) {  
  145. +      Put p  =  new  Put(Bytes.toBytes(row));  
  146. +      for (String column: columns) {  
  147. +        for (long timestamp  =  1 ; timestamp  < = maxTimestamp; timestamp++) {  
  148. +          KeyValue kv  =  KeyValueTestUtil .create(row, family, column, timestamp,  
  149. +              valueString);  
  150. +          p.add(kv);  
  151. +        }  
  152. +      }  
  153. +      region.put(p);  
  154. +    }  
  155. +  
  156. +    MultipleColumnPrefixFilter multiplePrefixFilter;  
  157. +    Scan scan1  =  new  Scan();  
  158. +    scan1.setMaxVersions();  
  159. +    byte [][] filter_prefix  =  new  byte [1][];  
  160. +    filter_prefix[0] = new byte [] {'p'};  
  161. +   
  162. +    multiplePrefixFilter  =  new  MultipleColumnPrefixFilter(filter_prefix);  
  163. +    scan1.setFilter(multiplePrefixFilter);  
  164. +    List< KeyValue >   results1  =  new  ArrayList < KeyValue > ();    
  165. +    InternalScanner scanner1  =  region .getScanner(scan1);  
  166. +    while(scanner1.next(results1));  
  167. +      
  168. +    ColumnPrefixFilter singlePrefixFilter;  
  169. +    Scan scan2  =  new  Scan();  
  170. +    scan2.setMaxVersions();  
  171. +    singlePrefixFilter  =  new  ColumnPrefixFilter(Bytes.toBytes("p"));  
  172. +   
  173. +    scan2.setFilter(singlePrefixFilter);  
  174. +    List< KeyValue >   results2  =  new  ArrayList < KeyValue > ();    
  175. +    InternalScanner scanner2  =  region .getScanner(scan1);  
  176. +    while(scanner2.next(results2));  
  177. +      
  178. +    assertEquals(results1.size(), results2.size());  
  179. +  }  
  180. +    
  181. +  List< String >  generateRandomWords(int numberOfWords, String suffix) {  
  182. +    Set< String >   wordSet  =  new  HashSet < String > ();  
  183. +    for (int i  =  0 ; i  <   numberOfWords ; i++) {  
  184. +      int lengthOfWords  = (int) (Math.random()*2) + 1;  
  185. +      char[] wordChar  =  new  char[lengthOfWords];  
  186. +      for (int j  =  0 ; j  <   wordChar.length ; j++) {  
  187. +        wordChar[j] = (char) (Math.random() * 26 + 97);  
  188. +      }  
  189. +      String word;  
  190. +      if (suffix  == null) {  
  191. +        word  =  new  String(wordChar);  
  192. +      } else {  
  193. +        word  =  new  String(wordChar) + suffix;  
  194. +      }  
  195. +      wordSet.add(word);  
  196. +    }  
  197. +    List< String >   wordList  =  new  ArrayList < String > (wordSet);  
  198. +    return wordList;  
  199. +  }  
  200. +}  
  201. +  
  202. .  


ColumnPrefixFilter

[html] view plain copy
  1. public class ColumnPrefixFilterextends FilterBaseThis filter is used for selecting only those keys with columns that matches a particular prefix. For example, if prefix is 'an', it will pass keys will columns like 'and', 'anti' but not keys with columns like 'ball', 'act'.   

上面是类的说明
只有一个有参构造 ColumnPrefixFilter (byte[] prefix)
这个类用法很简单，就是匹配前缀是prefix的rowkey，但是，不知道大家用了之后有什么感觉，我是用了，但是不起作用，有起作用的大牛告诉我下。

无奈之下，只好选择PrefixFilter

PrefixFilter

类说明 ：

Pass results that have same row prefix.

同样的构造方法，跟ColumnPrefixFilter一模一样，用法也相同，

基本上几个Filter就是这些了，慢慢的我再更新这个文章

上段代码，我自己写的，使用中的代码

[java] view plain copy
  1. public   static  String getKeywordTableRowkeyUseFilter(String filterString1,String filterString2) {  
  2.     FilterList filterList = new  FilterList();  
  3.     String rowkeyValue = ""  ;  
  4.     Scan s1 = new  Scan();  
  5.         String [] sf1=filterString1.split("," );  
  6.         filterList.addFilter(new  SingleColumnValueFilter(Bytes.toBytes(sf1[ 0 ]),  
  7.                                                          Bytes.toBytes(sf1[1 ]),  
  8.                                                          CompareOp.EQUAL,Bytes.toBytes(sf1[2 ])  
  9.                                                          ));  
  10.         String [] sf2=filterString2.split("," );  
  11.         filterList.addFilter(new  SingleColumnValueFilter(Bytes.toBytes(sf2[ 0 ]),  
  12.                    Bytes.toBytes(sf2[1 ]),  
  13.                    CompareOp.EQUAL,Bytes.toBytes(sf2[2 ])  
  14.                    ));  
  15.         filterList.addFilter(new  ColumnPrefixFilter(Bytes.toBytes( "3274980668:" ))) ;  
  16.         filterList.addFilter(new  PrefixFilter(Bytes.toBytes( "3274980668:" ))) ;  
  17.   
  18.     s1.setFilter(filterList);  
  19.     ResultScanner ResultScannerFilterList;  
  20.     try  {  
  21.         ResultScannerFilterList = tableKeyword.getScanner(s1);  
  22.         for (Result rr=ResultScannerFilterList.next();rr!= null ;rr=ResultScannerFilterList.next()){  
  23.             String rowkeyValueTmp  = new  String(rr.getRow()) ;  
  24.               
  25.             rowkeyValue = rowkeyValue + "##"  + rowkeyValueTmp ;  
  26.               
  27.         }  
  28.     } catch  (IOException e) {  
  29.         // TODO Auto-generated catch block   
  30.         e.printStackTrace();  
  31.     }  
  32.     log.warn("rowkeyValue"  + rowkeyValue) ;  
  33.     return  rowkeyValue ;  
  34. }  


PrefixFilter和ColumnPrefixFilter的用法几乎一样，但是在开发中，建议使用PrefixFilter

分享到：
| Hbase使用filter快速高效查询
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    HBase基本操作.pdf

    HBase通过Filter来支持复杂的查询操作。例如，使用`scan '表名', {FILTER =&gt; '过滤器'} `可以对表数据进行过滤。过滤器可以是多个，用以组合不同条件。 #### 10. 时间戳和数据版本操作 HBase存储数据时会自动为每条...

    HBase实战实例

    1. 快速查询：通过高效的Row Key设计，实现基于地理位置的范围查询和点查询。 2. 空间JOIN操作：通过预计算或者MapReduce任务，模拟实现传统数据库中的JOIN操作。 3. 并行处理：利用HBase的分布式特性，进行大规模...

    hbase一些查询

    在探讨HBase查询技巧及其应用时，我们聚焦于利用各种Filter进行精确且高效的查询操作。HBase，作为一款分布式、版本化的列存储数据库，专为海量数据设计，其查询性能和灵活性很大程度上依赖于合理使用Filter。以下是...

    hbase 学习 hbase原理 hbase资料

    - 大数据存储：对于PB级别的数据，HBase能够提供高效的存储和检索。 - 图像和视频元数据存储：存储大量的元数据信息，便于快速查找和过滤。 6. **学习资源** - HBase官方文档：提供详细的技术参考和最佳实践。 ...

    HBase上搭建广告实时数据处理平台-广点通.pdf

    - 方案四：选择HBase作为数据存储，广告请求信息写入HBase，曝光和点击时查询HBase，实现日志关联，此方案可充分利用缓存，减少I/O操作。 3. **技术方案** - 整体框架：每个广告请求分配唯一ID，创建关联表存储...

    hbase-1.2.6

    5. **索引和过滤**：虽然HBase不支持像关系数据库那样的复杂查询，但通过行键、列族和时间戳的组合，可以实现高效的数据检索。此外，还可以使用Filter机制对数据进行筛选。 6. **MapReduce集成**：HBase与Hadoop的...

    hbase-0.92.1.tar.gz

    8. **Secondary Index**：虽然HBase不直接支持二级索引，但可以通过实现自定义的Filter或者使用 Coprocessors 来实现类似的功能。 9. **Coprocessors**：这是一种可以在Region Server上运行的用户定义代码，用于...

    hbase 表设计

    HBase表设计通常围绕核心的查询模式，例如快速定位到特定的行，或在列族内快速扫描数据。HBase还提供了过滤器来优化查询，例如单列值过滤器、列前缀过滤器、分页过滤器等，这些过滤器可以在服务器端执行，从而减少了...

    hbase 分页功能

    在大数据存储领域，HBase作为一个分布式列式数据库，经常用于处理海量数据的快速查询。由于数据量巨大，分页查询成为必不可少的功能，以避免一次性加载过多数据导致性能问题。本篇将详细介绍HBase如何利用PageFilter...

    hadoop、hbase、hive等相关面试问题

    - 两者可以通过Hive-on-HBase的方式结合使用，即利用Hive的SQL接口来查询HBase中的数据，增强了HBase的查询灵活性。 #### 2. HBase数据结构 **知识点解析：** HBase的数据模型主要由行键（Row Key）、列族（Column...

    Hbase行键设计（rowkey）实现多条件查询

    实现多条件查询时，可以使用HBase的自定义比较器（Comparator）和过滤器（Filter）。例如，创建一个相等比较器用于实现精确匹配查询，另一个范围比较器用于执行范围查询。这两个比较器结合过滤器，可以在一次Scan...

    hbase学习笔记

    理解并熟练掌握上述概念和命令，将有助于在实践中高效地使用HBase来处理大规模数据。在设计HBase表结构时，需要综合考虑数据模型、访问模式、存储和计算资源等因素，以达到最佳的性能和可扩展性。

    最新版linux hbase-2.3.2-bin.tar.gz

    7. **强大的索引和查询机制**：通过RowKey进行快速定位，可以结合Secondary Index和Filter实现复杂查询。 ### HBase 2.3.2的改进与新特性 - **性能优化**：包括读写性能提升、查询效率增强以及更有效的内存管理和...

    HBase权威指南中文版+官方文档

    - **Bloom Filter**：介绍如何使用Bloom Filter来提高查询效率。 #### 三、HBase升级指南 - **从0.20.x或0.89.x升级到0.90.x**：列出具体的步骤与注意事项。 - **从0.90.x到0.92.x**：提供升级路径与建议。 ####...

    Interactive SQL query on HBase (孙元浩)

    通过介绍HBase SQL所支持的数据类型，如布尔型、各种整数类型、浮点型等，文章提供了HBase SQL的强大能力，以及其在处理交互式查询时的高效性和性能优势。通过这篇文章，我们可以得知HBase SQL不仅能够支持快速的...

    HBase在淘宝的应用和优化

    - **0.90.x版本**：2011年1月发布的0.90.0版本成为HBase应用的一个重要里程碑，该版本加入了众多新特性，如Bloom Filter等，显著提升了性能。 - **ZooKeeper集成**：0.20.0版本引入了ZooKeeper来管理BackupMaster...

    javaApi_sparkhiveAPI_hbaseAPI.zip

    - **Spark** 是一个快速、通用且可扩展的大数据处理框架，它提供了与Hive的集成，允许开发者使用Spark SQL来执行Hive查询。 - **Spark SQL**：Spark SQL结合了SQL和DataFrame API，使得开发人员可以用SQL或者...

    hbase-1.2.0-cdh5.14.2.tar.gz

    同时，HBase提供了强大的实时查询能力，通过索引和过滤机制，用户可以快速定位到所需数据，满足实时业务需求。 CDH5.14.2中的HBase 1.2.0还支持 Coprocessors 和 Filter，这是两个强大的扩展机制。Coprocessors允许...

    hadoop_hbase_pig

    HBase的表由行、列族、列和时间戳组成，这种结构使得数据可以根据不同的维度进行快速查询。 3. **Pig**： Apache Pig是一个用于大数据分析的平台，其主要特点是Pig Latin，一种高级脚本语言，简化了大规模数据集的...

Magicbox
Global site tag (gtag.js) - Google Analytics