HBase查询（1）---Comparision Filters比较过滤器

1.1 RowFilter

构造函数

public RowFilter(CompareOp rowCompareOp, WritableByteArrayComparable rowComparator) {}

选择比较rowkey来确定选择合适的行信息。

示例代码：

package filter;

import java.io.IOException;

import org.apache.hadoop.hbase.client.HTable;
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.CompareFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.RegexStringComparator;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.util.Bytes;

public class RowFilterExample extends FilterExampleBase{

public static void main(String[] args) throws IOException {
new RowFilterExample().doMain();
}

@Override
public void testFilter() throws IOException {
System.out.println("-----------------testFilter() start-------------");
HTable table = new HTable(config, tableName);

Scan scan = new Scan();
// scan.addColumn(Bytes.toBytes("c1"), Bytes.toBytes("a"));

Filter filter1 = new RowFilter(CompareFilter.CompareOp.LESS_OR_EQUAL,
new BinaryComparator(Bytes.toBytes("r2")));
scan.setFilter(filter1);
ResultScanner scanner1 = table.getScanner(scan);
showScanner(scanner1);
scanner1.close();

showLine();
Filter filter2 = new RowFilter(CompareFilter.CompareOp.EQUAL,
new RegexStringComparator(".*3"));
scan.setFilter(filter2);
ResultScanner scanner2 = table.getScanner(scan);
showScanner(scanner2);
scanner2.close();

showLine();
Filter filter3 = new RowFilter(CompareFilter.CompareOp.EQUAL,
new SubstringComparator("4"));
scan.setFilter(filter3);
ResultScanner scanner3 = table.getScanner(scan);
showScanner(scanner3);
scanner3.close();
System.out.println("-----------------testFilter() end-------------");
}
}

结果：
start create table......
test is exist delete!!!
create table over......
start insert......
end insert......

-----------------findAll() start-------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------findAll() end-------------

-----------------testFilter() start-------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
-----------------
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
-----------------
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------testFilter() end-------------

1.2 FamilyFilter

构造函数

public FamilyFilter(CompareOp familyCompareOp, WritableByteArrayComparable familyComparator) {}

通过和列簇比较得到，返回结果为真的数据，示例：

package filter;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Get;
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.CompareFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.filter.ValueFilter;
import org.apache.hadoop.hbase.util.Bytes;

public class FamilyFilterExample extends FilterExampleBase{

public static void main(String[] args) throws IOException {
new FamilyFilterExample().doMain();
}

public void testFilter() throws IOException {

Filter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL,
new SubstringComparator("c1"));

Scan scan = new Scan();
scan.setFilter(filter);
ResultScanner scanner = table.getScanner(scan);
showScanner(scanner);
scanner.close();

showLine();
Get get = new Get(Bytes.toBytes("r1"));
get.setFilter(filter);
Result r = table.get(get);
showResult(r);
}
}

结果：
start create table......
test is exist delete!!!
create table over......
start insert......
end insert......

-----------------findAll() start-------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------findAll() end-------------

{rowkey:r1 c1:a=r1c1a c1:b=r1c1b}
{rowkey:r2 c1:a=r2c1a}
{rowkey:r3 c1:a=c1a c1:b=r3c1b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b}
-----------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b}

1.3 QualifierFilter

构造函数

public QualifierFilter(CompareOp qualifierCompareOp, WritableByteArrayComparable qualifierComparator) {  }

通过和列限定符比较，返回为真的数据，示例：

package filter;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Get;
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.CompareFilter;
import org.apache.hadoop.hbase.filter.FamilyFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.util.Bytes;

public class QualifierFilterExample extends FilterExampleBase{

public static void main(String[] args) throws IOException {
new QualifierFilterExample().doMain();
}

@Override
public void testFilter() throws IOException {

HTable table = new HTable(config, tableName);

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

Scan scan = new Scan();
scan.setFilter(filter1);
ResultScanner scanner = table.getScanner(scan);
showScanner(scanner);
scanner.close();

showLine();
Get get1 = new Get(Bytes.toBytes("r4"));
get1.setFilter(filter1);
Result r1 = table.get(get1);
showResult(r1);

showLine();
Filter filter2 = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("c2")));
Get get2 = new Get(Bytes.toBytes("r4"));
// get2.addFamily(Bytes.toBytes("c2"));
get2.setFilter(filter2);
Result r2 = table.get(get2);
showResult(r2);
}
}

结果：
start create table......
test is exist delete!!!
create table over......
start insert......
end insert......

-----------------findAll() start-------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------findAll() end-------------

{rowkey:r1 c1:a=r1c1a c1:b=r1c1b}
{rowkey:r2 c1:a=r2c1a}
{rowkey:r3 c1:a=c1a c1:b=r3c1b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b}
-----------------
{rowkey:r4 c1:a=c1a c1:b=r4c1b}
-----------------
{rowkey:r4 c2:a=r4c2b c2:b=r4c2b}

1.4 ValueFilter

构造函数

public ValueFilter(CompareOp valueCompareOp, WritableByteArrayComparable valueComparator) {}

通过和列值比较，返回为真的数据，示例：

package filter;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Get;
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.CompareFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.QualifierFilter;
import org.apache.hadoop.hbase.util.Bytes;

public class ValueFilterExample extends FilterExampleBase{

public static void main(String[] args) throws IOException {
new ValueFilterExample().doMain();
}

public void testFilter() throws IOException {
HTable table = new HTable(config, tableName);

Filter filter = new QualifierFilter(CompareFilter.CompareOp.LESS, new BinaryComparator(Bytes.toBytes("b")));

Scan scan = new Scan();
scan.setFilter(filter);
ResultScanner scanner = table.getScanner(scan);
showScanner(scanner);
scanner.close();

showLine();
Get get = new Get(Bytes.toBytes("r4"));
get.setFilter(filter);
Result r = table.get(get);
showResult(r);
}
}

结果：
start create table......
test is exist delete!!!
create table over......
start insert......
end insert......

-----------------findAll() start-------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------findAll() end-------------

{rowkey:r1 c1:a=r1c1a c2:a=r1c2a}
{rowkey:r2 c1:a=r2c1a}
{rowkey:r3 c1:a=c1a c2:a=r3c2b}
{rowkey:r4 c1:a=c1a c2:a=r4c2b}
-----------------
{rowkey:r4 c1:a=c1a c2:a=r4c2b}

1.5 DependentColumnFilter

该过滤器有两个参数 —— 列族和列修饰。尝试找到该列所在的每一行，并返回该行具有相同时间戳的全部键值对。如果某一行不包含指定的列，则该行的任何键值对都不返回。

该过滤器还可以有一个可选布尔参数 —— dropDependentColumn. 如果为true,从属的列不返回。

该过滤器还可以有两个可选参数 ——
一个比较操作符和一个值比较器，用于列族和修饰的进一步检查。如果从属的列找到，其值还必须通过值检查，然后就是时间戳必须考虑。

package filter;

import java.io.IOException;

import org.apache.hadoop.hbase.client.Get;
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.BinaryPrefixComparator;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.DependentColumnFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.WritableByteArrayComparable;
import org.apache.hadoop.hbase.util.Bytes;

public class DependentColumnFilterExample extends FilterExampleBase{

public static void main(String[] args) throws IOException {
new DependentColumnFilterExample().doMain();
}

public void testFilter() throws IOException {
filter(true, CompareFilter.CompareOp.NO_OP, null);
filter(false, CompareFilter.CompareOp.NO_OP, null);
filter(true, CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("c")));
filter(false, CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("c")));
//		filter(true, CompareFilter.CompareOp.EQUAL, new RegexStringComparator(".*\\.5"));
//		filter(false, CompareFilter.CompareOp.EQUAL, new RegexStringComparator(".*\\.5"));
}

private static void filter(boolean drop, CompareFilter.CompareOp operator, WritableByteArrayComparable comparator) throws IOException {
System.out.println("\n\n------------filter() start--------------------");
Filter filter;
if (comparator != null) {
filter = new DependentColumnFilter(Bytes.toBytes("c1"), Bytes.toBytes("a"), drop, operator, comparator);
} else {
filter = new DependentColumnFilter(Bytes.toBytes("c1"), Bytes.toBytes("a"), drop);

}

Scan scan = new Scan();
scan.setFilter(filter);
ResultScanner scanner = table.getScanner(scan);
showScanner(scanner);
scanner.close();

showLine();
Get get = new Get(Bytes.toBytes("r4"));
get.setFilter(filter);
Result r = table.get(get);
showResult(r);
System.out.println("------------filter() end--------------------");
}

}
结果：
start create table......
test is exist delete!!!
create table over......
start insert......
end insert......

-----------------findAll() start-------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------findAll() end-------------

------------filter() start--------------------
{rowkey:r1 c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c2:b=r2c2b}
{rowkey:r3 c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------
{rowkey:r4 c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
------------filter() end--------------------

------------filter() start--------------------
{rowkey:r1 c1:a=r1c1a c1:b=r1c1b c2:a=r1c2a c2:b=r1c2b}
{rowkey:r2 c1:a=r2c1a c2:b=r2c2b}
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
------------filter() end--------------------

------------filter() start--------------------
{rowkey:r3 c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------
{rowkey:r4 c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
------------filter() end--------------------

------------filter() start--------------------
{rowkey:r3 c1:a=c1a c1:b=r3c1b c2:a=r3c2b c2:b=r3c2b}
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
-----------------
{rowkey:r4 c1:a=c1a c1:b=r4c1b c2:a=r4c2b c2:b=r4c2b}
------------filter() end--------------------

最后附上基类：

package filter;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.HTablePool;
import org.apache.hadoop.hbase.client.Put;
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.CompareFilter;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.QualifierFilter;
import org.apache.hadoop.hbase.util.Bytes;

public class FilterExampleBase {

public static Configuration config;
public static String tableName = "test";
public static HBaseAdmin hBaseAdmin;
public static HTablePool pool;
public static HTable table;

public static void setup() throws MasterNotRunningException,
ZooKeeperConnectionException {
config = HBaseConfiguration.create();
config.set("hbase.zookeeper.quorum", "10.10.4.55");
config.set("hbase.zookeeper.property.clientPort", "2181");

hBaseAdmin = new HBaseAdmin(config);
pool = new HTablePool(config, 1000);
//table = (HTable) pool.getTable(tableName);
}

public static void createTable() throws IOException {
System.out.println("start create table......");
if (hBaseAdmin.tableExists(tableName)) {
hBaseAdmin.disableTable(tableName);
hBaseAdmin.deleteTable(tableName);
System.out.println(tableName + " is exist delete!!!");
}
HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
hTableDescriptor.addFamily(new HColumnDescriptor("c1"));
hTableDescriptor.addFamily(new HColumnDescriptor("c2"));

hBaseAdmin.createTable(hTableDescriptor);
table = (HTable) pool.getTable(tableName);
System.out.println("create table over......");
}

public static void dropTable() throws IOException {
System.out.println("start drop table......");
if (hBaseAdmin.tableExists(tableName)) {
hBaseAdmin.disableTable(tableName);
hBaseAdmin.deleteTable(tableName);
System.out.println(tableName + " is exist delete!!!");
}
System.out.println("end drop table......");
}

public static void insert() throws IOException {
System.out.println("start insert......");

Put put = new Put("r1".getBytes());
put.add("c1".getBytes(), "a".getBytes(), "r1c1a".getBytes());
put.add("c1".getBytes(), "b".getBytes(), "r1c1b".getBytes());
put.add("c2".getBytes(), "a".getBytes(), "r1c2a".getBytes());
put.add("c2".getBytes(), "b".getBytes(), "r1c2b".getBytes());
table.put(put);
Put put2 = new Put("r2".getBytes());
put2.add("c1".getBytes(), "a".getBytes(), "r2aaa".getBytes());
put2.add("c1".getBytes(), "a".getBytes(), "r2c1a".getBytes());
put2.add("c2".getBytes(), "b".getBytes(), "r2bbb".getBytes());
put2.add("c2".getBytes(), "b".getBytes(), "r2c2b".getBytes());
table.put(put2);

Put put3 = new Put("r3".getBytes());
put3.add("c1".getBytes(), "a".getBytes(), "c1a".getBytes());
put3.add("c1".getBytes(), "b".getBytes(), "r3c1b".getBytes());
put3.add("c2".getBytes(), "a".getBytes(), "r3c2b".getBytes());
put3.add("c2".getBytes(), "b".getBytes(), "r3c2b".getBytes());

table.put(put3);
Put put4 = new Put("r4".getBytes());
put4.add("c1".getBytes(), "a".getBytes(), "c1a".getBytes());
put4.add("c1".getBytes(), "b".getBytes(), "r4c1b".getBytes());
put4.add("c2".getBytes(), "a".getBytes(), "r4c2b".getBytes());
put4.add("c2".getBytes(), "b".getBytes(), "r4c2b".getBytes());
table.put(put4);
System.out.println("end insert......");
}

public static void findAll() throws IOException {
System.out.println("\n\n-----------------findAll() start-------------");
HTablePool pool = new HTablePool(config, 1000);
HTable table = (HTable) pool.getTable(tableName);

ResultScanner rs = table.getScanner(new Scan());
for (Result r : rs) {
System.out.print("{rowkey:" + new String(r.getRow()));
for (KeyValue keyValue : r.raw()) {
System.out.print(" " + new String(keyValue.getFamily()) + ":"
+ new String(keyValue.getQualifier()) + "="
+ new String(keyValue.getValue()));
}
System.out.println("}");
}
System.out.println("-----------------findAll() end-------------\n\n");
}

public static void cleanup() throws IOException {
table.close();
pool.close();
hBaseAdmin.close();
}

public static void main(String[] args) throws IOException {
new FilterExampleBase().doMain();
}

public void doMain() throws IOException {
setup();

createTable();

insert();

findAll();

testFilter();

cleanup();
}

public void testFilter() throws IOException {
HTable table = new HTable(config, tableName);

Filter filter = new QualifierFilter(CompareFilter.CompareOp.LESS,
new BinaryComparator(Bytes.toBytes("b")));

Scan scan = new Scan();
scan.setFilter(filter);
ResultScanner scanner = table.getScanner(scan);
showScanner(scanner);
scanner.close();

System.out.println("-----------------------");
Get get = new Get(Bytes.toBytes("r4"));
get.setFilter(filter);
Result r = table.get(get);
showResult(r);
}

public static void showScanner(ResultScanner scanner) {
for (Result r : scanner) {
System.out.print("{rowkey:" + new String(r.getRow()));
for (KeyValue keyValue : r.raw()) {
System.out.print(" " + new String(keyValue.getFamily()) + ":"
+ new String(keyValue.getQualifier()) + "="
+ new String(keyValue.getValue()));
}
System.out.println("}");
}
}

public static void showResult(Result r) {
if(r == null || r.getRow() == null) {
return;
}
System.out.print("{rowkey:" + new String(r.getRow()));
for (KeyValue keyValue : r.raw()) {
System.out.print(" " + new String(keyValue.getFamily()) + ":"
+ new String(keyValue.getQualifier()) + "="
+ new String(keyValue.getValue()));
}
System.out.println("}");
}

public static void showLine() {
System.out.println("-----------------");
}
}