0
点赞
收藏
分享

微信扫一扫

hbase scan filter以及hbase逻辑存储图和hbase打印数据效果


 

 

0.0  看hbase shell命令行下结果:

 



ROW                   COLUMN+CELL
 1                    column=base:age, timestamp=1456557395891, value=31
 1                    column=base:name, timestamp=1456557377874, value=zm
 2                    column=base:age, timestamp=1456554268023, value=1
 2                    column=base:name, timestamp=1456554268023, value=baobao
 3                    column=base:age, timestamp=1456398168279, value=1
 3                    column=base:name, timestamp=1456542759628, value=houhou
3 row(s) in 0.5190 seconds



 

 

 上述数据 hbase逻辑存储结构为:

 

hbase scan filter以及hbase逻辑存储图和hbase打印数据效果_apache


 

 

如果 通过 scan循环上述表的话,那么真实中会有6行数据,并会循环六次。

 

0 前言:

 

hbase为筛选数据提供了一组过滤器,这样可以在hbase的多个维度(行,列,数据版本)上进行数据筛选,

通常使用 行健 ,  值来筛选数据的应用场景较多。

 

 

 

1 rowfilter:   筛选出行健匹配到的所有行

 

Filter rf = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("row1"))); // OK 筛选出匹配的所有的行

 

针对0.0的数据,下列代码和展示结果:


try {
			HBaseAdmin hBaseAdmin = new HBaseAdmin(conf);
			HTable htable = new HTable(conf, "stu");
			Scan scan = new Scan();
			// RowFilter是根据rowkey来过滤,下面是来过滤 rowkey只是非零的正整数的
			Filter filter = new RowFilter(CompareOp.EQUAL, new RegexStringComparator("^\\+?[1-9][0-9]*$")); 
			scan.setFilter(filter); // 增加过滤器
			ResultScanner resultScanner = htable.getScanner(scan);
			for(Result result : resultScanner){ //result: HBase cell defined by the row, family, qualifier, timestamp, and value
				/*String rowKey = new String(result.getRow());
				System.out.println(rowKey);*/
				if(result.raw().length==0){
					System.out.println("使用正则过滤stu 表数据为空");
				}else{ //在hbase中为6行,最后结果会循环着6行然后将这6行每一列打印出来
					for(KeyValue kv : result.raw()){ // 得到组成result的各个单元cell, 这些cell是由row, family, qualifier,value等组成
						System.out.println(Bytes.toString(kv.getRow()));
						System.out.println(Bytes.toString(kv.getFamily()));
						System.out.println(Bytes.toString(kv.getQualifier()));
						System.out.println(Bytes.toString(kv.getValue()));
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}


 

 

 

2  PrefixFilter:筛选出具有特定前缀的行键的数据。这个过滤器所实现的功能其实也可以由RowFilter结合RegexComparator来实现,不过这里提供了一种简便的使用方法,以下过滤器就是筛选出行键以row为前缀的所有的行:

 

 

Filter pf = new PrefixFilter(Bytes.toBytes("row")); // OK  筛选匹配行键的前缀成功的行



          
Filter kof = new KeyOnlyFilter(); // OK 返回所有的行,但值全是空


 

Filter rrf = new RandomRowFilter((float) 0.8); // OK 随机选出一部分的行


5 5. InclusiveStopFilter:扫描的时候,我们可以设置一个开始行键和一个终止行键,默认情况下,这个行键的返回是前闭后开区间,即包含起始行,单不包含中指行,如果我们想要同时包含起始行和终止行,那么我们可以使用此过滤器:


 

          
Filter isf = new InclusiveStopFilter(Bytes.toBytes("row1")); // OK 包含了扫描的上限在结果之内


6. FirstKeyOnlyFilter:如果你只想返回的结果集中只包含第一列的数据,那么这个过滤器能够满足你的要求。它在找到每行的第一列之后会停止扫描,从而使扫描的性能也得到了一定的提升:


 

 


          
Filter fkof = new FirstKeyOnlyFilter(); // OK 筛选出第一个每个第一个单元格


7. ColumnPrefixFilter:顾名思义,它是按照列名的前缀来筛选单元格的,如果我们想要对返回的列的前缀加以限制的话,可以使用这个过滤器:


 

          
Filter cpf = new ColumnPrefixFilter(Bytes.toBytes("qual1")); // OK 筛选出前缀匹配的列


8. ValueFilter:按照具体的值来筛选单元格的过滤器,这会把一行中值不能满足的单元格过滤掉,如下面的构造器,对于每一行的一个列,如果其对应的值不包含ROW2_QUAL1,那么这个列就不会返回给客户端:


 

 

Filter vf = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("ROW2_QUAL1")); // OK 筛选某个(值的条件满足的)特定的单元格



9. ColumnCountGetFilter:这个过滤器来返回每行最多返回多少列,并在遇到一行的列数超过我们所设置的限制值的时候,结束扫描操作:


 

          
Filter ccf = new ColumnCountGetFilter(2); // OK 如果突然发现一行中的列数超过设定的最大值时,整个扫描操作会停止


10. SingleColumnValueFilter:用一列的值决定这一行的数据是否被过滤。在它的具体对象上,可以调用setFilterIfMissing(true)或者setFilterIfMissing(false),默认的值是false,其作用是,对于咱们要使用作为条件的列,如果这一列本身就不存在,那么如果为true,这样的行将会被过滤掉,如果为false,这样的行会包含在结果集中。


 

 

          
SingleColumnValueFilter scvf = new SingleColumnValueFilter(  
"colfam1"),   
"qual2"),   
        CompareFilter.CompareOp.NOT_EQUAL,   
new SubstringComparator("BOGUS"));  
scvf.setFilterIfMissing(false);  
scvf.setLatestVersionOnly(true); // OK


11.  SingleColumnValueExcludeFilter:这个与10种的过滤器唯一的区别就是,作为筛选条件的列的不会包含在返回的结果中。


 

12. SkipFilter:这是一种附加过滤器,其与ValueFilter结合使用,如果发现一行中的某一列不符合条件,那么整行就会被过滤掉:

 

Filter skf = new SkipFilter(vf); // OK 发现某一行中的一列需要过滤时,整个行就会被过滤掉



13. WhileMatchFilter:这个过滤器的应用场景也很简单,如果你想要在遇到某种条件数据之前的数据时,就可以使用这个过滤器;当遇到不符合设定条件的数据的时候,整个扫描也就结束了:


 

 

Filter wmf = new WhileMatchFilter(rf); // OK 类似于Python itertools中的takewhile



14. FilterList:用于综合使用多个过滤器。其有两种关系:FilterList.Operator.MUST_PASS_ONE和FilterList.Operator.MUST_PASS_ALL,默认的是FilterList.Operator.MUST_PASS_ALL,顾名思义,它们分别是AND和OR的关系,并且 FilterList可以嵌套使用FilterList,使我们能够表达更多的需求:


 

 

List<Filter> filters = new ArrayList<Filter>();  
filters.add(rf);  
filters.add(vf);  
FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL, filters); // OK 综合使用多个过滤器, AND 和 OR 两种关系


以下代码是数据写入代码:


package com.reyun.hbase;  
  
import java.io.IOException;  
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.Put;  
import org.apache.hadoop.hbase.util.Bytes;  
  
public class HBaseDataFeeding {  
private final static byte[] ROW1 = Bytes.toBytes("row1");  
private final static byte[] ROW2 = Bytes.toBytes("row2");  
private final static byte[] COLFAM1 = Bytes.toBytes("colfam1");  
private final static byte[] COLFAM2 = Bytes.toBytes("colfam2");  
private final static byte[] QUAL1 = Bytes.toBytes("qual1");  
private final static byte[] QUAL2 = Bytes.toBytes("qual2");  
      
      
public static void main(String[] args) throws IOException {  
        Configuration conf = HBaseConfiguration.create();  
new HTable(conf, "testtable");  
false);  
new Put(ROW1);  
"ROW1_QUAL1_VAL"));  
"ROW1_QUAL2_VAL"));  
          
new Put(ROW2);  
"ROW2_QUAL1_VAL"));  
"ROW2_QUAL2_VAL"));  
          
try{  
            table.put(put_row1);  
            table.put(put_row2);  
finally{  
            table.close();  
        }  
    }  
  
}


以下是过滤器测试代码,可以通过修改代码,更换过滤器来看到具体的效果:

 

          
package com.reyun.hbase;  
  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
  
import org.apache.hadoop.conf.Configuration;  
import org.apache.hadoop.hbase.Cell;  
import org.apache.hadoop.hbase.CellUtil;  
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.ColumnCountGetFilter;  
import org.apache.hadoop.hbase.filter.ColumnPrefixFilter;  
import org.apache.hadoop.hbase.filter.CompareFilter;  
import org.apache.hadoop.hbase.filter.Filter;  
import org.apache.hadoop.hbase.filter.FilterList;  
import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;  
import org.apache.hadoop.hbase.filter.InclusiveStopFilter;  
import org.apache.hadoop.hbase.filter.KeyOnlyFilter;  
import org.apache.hadoop.hbase.filter.PageFilter;  
import org.apache.hadoop.hbase.filter.PrefixFilter;  
import org.apache.hadoop.hbase.filter.RandomRowFilter;  
import org.apache.hadoop.hbase.filter.RowFilter;  
import org.apache.hadoop.hbase.filter.SkipFilter;  
import org.apache.hadoop.hbase.filter.ValueFilter;  
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;  
import org.apache.hadoop.hbase.filter.SubstringComparator;  
import org.apache.hadoop.hbase.filter.WhileMatchFilter;  
import org.apache.hadoop.hbase.util.Bytes;  
  
public class HBaseScannerTest {  
  
public static void main(String[] args) throws IOException, IllegalAccessException {  
        Configuration conf = HBaseConfiguration.create();  
new HTable(conf, "testtable");  
false);  
          
new Scan();  
new SingleColumnValueFilter(  
"colfam1"),   
"qual2"),   
                CompareFilter.CompareOp.NOT_EQUAL,   
new SubstringComparator("BOGUS"));  
false);  
true); // OK  
new ColumnCountGetFilter(2); // OK 如果突然发现一行中的列数超过设定的最大值时,整个扫描操作会停止  
new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("ROW2_QUAL1")); // OK 筛选某个(值的条件满足的)特定的单元格  
new ColumnPrefixFilter(Bytes.toBytes("qual2")); // OK 筛选出前缀匹配的列  
new FirstKeyOnlyFilter(); // OK 筛选出第一个每个第一个单元格  
new InclusiveStopFilter(Bytes.toBytes("row1")); // OK 包含了扫描的上限在结果之内  
new RandomRowFilter((float) 0.8); // OK 随机选出一部分的行  
new KeyOnlyFilter(); // OK 返回所有的行,但值全是空  
new PrefixFilter(Bytes.toBytes("row")); // OK  筛选匹配行键的前缀成功的行  
new RowFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes("row1"))); // OK 筛选出匹配的所有的行  
new WhileMatchFilter(rf); // OK 类似于Python itertools中的takewhile  
new SkipFilter(vf); // OK 发现某一行中的一列需要过滤时,整个行就会被过滤掉  
          
new ArrayList<Filter>();  
        filters.add(rf);  
        filters.add(vf);  
new FilterList(FilterList.Operator.MUST_PASS_ALL, filters); // OK 综合使用多个过滤器, AND 和 OR 两种关系  
          
        scan1.  
"row1")).  
"row3")).  
        setFilter(scvf);   
        ResultScanner scanner1 = table.getScanner(scan1);  
          
for(Result res : scanner1){  
for(Cell cell : res.rawCells()){  
"KV: " + cell + ", Value: " + Bytes.toString(CellUtil.cloneValue(cell)));  
            }  
"------------------------------------------------------------");  
        }  
          
        scanner1.close();  
        table.close();  
    }  
   
}


 

举报

相关推荐

0 条评论