HBase：Filter Query

1.声明

当前内容主要用于本人学习和复习，当前的内容主要为官方文档中的Filter Query

当前内容中的工具类基于前面的博文

准备数据表test-filter,并开始写入数据

2.FilterList查询

/**
 * @description 当前内容主要用于测试FilterList的查询操作
 * @author hy
 * @date 2020-06-18
 */
public class FilterListTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		// 这里使用的是or关系，可以修改为and FilterList.Operator.MUST_PASS_ALL;
		FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE);
		SingleColumnValueFilter filter1 = new SingleColumnValueFilter("cf".getBytes(), "name".getBytes(),
				CompareOperator.EQUAL, Bytes.toBytes("admin"));
		list.addFilter(filter1);
		SingleColumnValueFilter filter2 = new SingleColumnValueFilter("cf".getBytes(), "name".getBytes(),
				CompareOperator.EQUAL, Bytes.toBytes("guest"));
		list.addFilter(filter2);
		
		scan.setFilter(list);
		// 结果为两个数据，说明这个表示FilterList表示的关系应该是or
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}
		hBaseUtils.close();
	}
}

上面的查询时，查询列cf:name中是admin和guest的row,使用关系为or

结果为：

修改上面的查询条件：FilterList.Operator.MUST_PASS_ALL,使用and查询，结果为空

3.SingleColumnValueFilter查询

/**
 * @description 当前内容主要用于测试SingleColumnValueFilter的查询操作
 * @author hy
 * @date 2020-06-18
 */
public class SingleColumnValueFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		SingleColumnValueFilter filter1 = new SingleColumnValueFilter("cf".getBytes(), "name".getBytes(),
				CompareOperator.EQUAL, Bytes.toBytes("admin"));
		
		scan.setFilter(filter1);
		
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}
		hBaseUtils.close();
	}
}

这里的查询是，查询cf:name为admin的row的数据，返回row数据

结果为：

4.ColumnValueFilter查询

/**
 * @description 使用ColumnValueFilter的查询
 * @author hy
 * @date 2020-06-18
 */
public class ColumnValueFilterTest {
	private static String tableName="test-filter";
	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		ColumnValueFilter filter1 = new ColumnValueFilter("cf".getBytes(), "name".getBytes(),
				CompareOperator.EQUAL, Bytes.toBytes("admin"));
		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
	
		for (Result result : results) {
			System.out.println(result);
		}
		hBaseUtils.close();
	}
}

结果为：

发现返回结果就一个列，说明这个ColumnValueFilter查询只返回查询的列和对应的值(用于检测是否存在这样的列的值),返回结果是单元格级别

5.RegexStringComparator查询

从名字来看应该就是正则查询

/**
 * @description 当前内容主要用于测试RegexStringComparator的查询操作
 * @author hy
 * @date 2020-06-18
 */
public class RegexStringComparatorTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		RegexStringComparator comp=new RegexStringComparator("a.");
		SingleColumnValueFilter filter1 = new SingleColumnValueFilter("cf".getBytes(), "name".getBytes(),
				CompareOperator.EQUAL, comp);
		// 使用正则查询当前的表中的数据，查询column为cf:a并且值以a开头的数据行
		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			 System.out.println(result);
		}
		hBaseUtils.close();
	}
}

上面的查询：查询cf:name中的数据是以aXXX的数据

从结果上来看，返回的结果是row级别的

6.SubstringComparator查询

从名称上看应该就是substring方法的查询吧？

/**
 * @description 当前内容主要用于测试RegexStringComparator的查询操作
 * @author hy
 * @date 2020-06-18
 */
public class SubstringComparatorTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		SubstringComparator comp = new SubstringComparator("has all"); 
		SingleColumnValueFilter filter1 = new SingleColumnValueFilter("cf".getBytes(), "desc".getBytes(),
				CompareOperator.EQUAL, comp);
		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}
		hBaseUtils.close();
	}
}

上面的查询中就是查询cf:desc中包含has all字符的数据

发现这种查询也是row级别的

7.FamilyFilter查询

应该是查询列族？

/**
 * @description 当前内容主要用于测试FamilyFilter的查询操作(列族的查询操作)
 * @author hy
 * @date 2020-06-18
 */
public class FamilyFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		FamilyFilter filter1=new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("cf")));		
		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}
		hBaseUtils.close();
	}
}

当前的查询就是查询列族是cf的数据

发现查询的数据是，只有匹配的列族的才会查询的出来，级别为单元格级别

8.QualifierFilter查询

应该是查询Qualifier,列=列族:Qualifier

/**
 * @description 当前内容主要用于测试QualifierFilter的查询操作(列族:Qualifiter的Qualifiter查询操作)
 * @author hy
 * @date 2020-06-18
 */
public class QualifierFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();

		QualifierFilter filter1=new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("name")));
		
		scan.setFilter(filter1);
		// 查询所有的列族为XXX:name的数据，只显示XXX:name的列，不显示其他的
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}

		hBaseUtils.close();
	}
}

上面查询列族:name的数据

发现查询的数据是单元格级别的

9.ColumnPrefixFilter查询

从名字上看应该是列前缀的查询

/**
 * @description 当前内容主要用于测试FamilyFilter的查询操作(列族的查询操作)
 * @author hy
 * @date 2020-06-18
 */
public class ColumnPrefixFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		// 查询所有的列，并且Qualifier是以c开头的列族(即查询cXXX),并且Qualifier中也包含c的数据
		ColumnPrefixFilter filter1=new ColumnPrefixFilter("c".getBytes());
		
		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}

		hBaseUtils.close();
	}
}

发现没有匹配的数据，将当前的查询的c替换成n继续查询

说明当前的ColumnPrefixFilter查询实际上是查询Qualifier的前缀的查询，查询结果是单元格级别的

10.MultipleColumnPrefixFilter查询

由于ColumnPrefixFilter是单元格级别的查询并且查询的是Qualifier的前缀，那么这个应该是多前缀查询

/**
 * @description 当前内容主要用于测试FamilyFilter的查询操作(列族的查询操作)
 * @author hy
 * @date 2020-06-18
 */
public class MultipleColumnPrefixFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
			//只查询列族Qualifier中具有a，d的行的数据(返回结果中只有a和d开头的数据)
		byte[][] prefiexs = { Bytes.toBytes("n"), Bytes.toBytes("d") };
		MultipleColumnPrefixFilter filter1 = new MultipleColumnPrefixFilter(prefiexs);

		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}

		hBaseUtils.close();
	}
}

结果为：

说明这就是多列的Qualifiler的查询,返回的数据是单元格级别的

11.ColumnRangeFilter

列区间查询，应该是Qualifier的区间查询

/**
 * @description 测试ColumnRangeFilter(列区间过滤器)
 * @author hy
 * @date 2020-06-18
 */
public class ColumnRangeFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		// 只查询列族中的Qualifier从aaaa到zzzz的行的数据
		ColumnRangeFilter filter1 = new ColumnRangeFilter(Bytes.toBytes("aaaa"), true, Bytes.toBytes("zzzz"), true);

		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}

		hBaseUtils.close();
	}
}

结果为：

发现查询的只是Qualifier，使用aaaa到zzzz区间的数据，是单元格级别的

12.RowFilter查询

应该是按照row kwy进行查询

/**
 * @description 测试RowFilter
 * @author hy
 * @date 2020-06-18
 */
public class RowFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		// 按照行的名称进行搜索，可以指定其实行和结束行的名称
		RowFilter filter1 = new RowFilter(CompareOperator.EQUAL,new BinaryComparator("row2".getBytes()));
		scan.withStartRow("row1".getBytes());// 设置搜索的起始行
		scan.withStopRow("row3".getBytes()); // 设置搜索的结束行
		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}

		hBaseUtils.close();
	}
}

可以通过scan设置查询的起始行和结束行

返回的结果是row级别的

13.FirstKeyOnlyFilter查询

public class FirstKeyOnlyFilterTest {
	private static String tableName = "test-filter";

	public static void main(String[] args) throws IOException {
		HBaseUtils hBaseUtils = new HBaseUtils("192.168.1.104:2181");
		Scan scan = new Scan();
		// 返回每一行的第一个单元格中的数据
		FirstKeyOnlyFilter filter1 = new FirstKeyOnlyFilter();

		scan.setFilter(filter1);
		List<Result> results = hBaseUtils.scanTable(tableName, scan);
		for (Result result : results) {
			System.out.println(result);
		}

		hBaseUtils.close();
	}
}

结果：

发现查询的是desc，结合scan发现，当前查询的是排在最前面的row的第一个单元格数据，返回的数据结果是单元格级别的

14.总结

1.可以使用FilterList实现多个一起查询，可以指定是and还是or查询

2.查询可以通过值查询、列族查询、Qualifier查询、还有row等查询方式

以上纯属个人见解，如有问题请联系本人！