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等查询方式
以上纯属个人见解,如有问题请联系本人!