1. import java.io.IOException;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import org.apache.hadoop.conf.Configuration;
  6. import org.apache.hadoop.hbase.Cell;
  7. import org.apache.hadoop.hbase.CellUtil;
  8. import org.apache.hadoop.hbase.HBaseConfiguration;
  9. import org.apache.hadoop.hbase.TableName;
  10. import org.apache.hadoop.hbase.client.Admin;
  11. import org.apache.hadoop.hbase.client.Connection;
  12. import org.apache.hadoop.hbase.client.ConnectionFactory;
  13. import org.apache.hadoop.hbase.client.Get;
  14. import org.apache.hadoop.hbase.client.Result;
  15. import org.apache.hadoop.hbase.client.ResultScanner;
  16. import org.apache.hadoop.hbase.client.Scan;
  17. import org.apache.hadoop.hbase.client.Table;
  18. import org.apache.hadoop.hbase.filter.BinaryComparator;
  19. import org.apache.hadoop.hbase.filter.ColumnCountGetFilter;
  20. import org.apache.hadoop.hbase.filter.ColumnPaginationFilter;
  21. import org.apache.hadoop.hbase.filter.ColumnPrefixFilter;
  22. import org.apache.hadoop.hbase.filter.ColumnRangeFilter;
  23. import org.apache.hadoop.hbase.filter.DependentColumnFilter;
  24. import org.apache.hadoop.hbase.filter.FamilyFilter;
  25. import org.apache.hadoop.hbase.filter.Filter;
  26. import org.apache.hadoop.hbase.filter.FilterList;
  27. import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;
  28. import org.apache.hadoop.hbase.filter.FuzzyRowFilter;
  29. import org.apache.hadoop.hbase.filter.InclusiveStopFilter;
  30. import org.apache.hadoop.hbase.filter.KeyOnlyFilter;
  31. import org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter;
  32. import org.apache.hadoop.hbase.filter.PageFilter;
  33. import org.apache.hadoop.hbase.filter.PrefixFilter;
  34. import org.apache.hadoop.hbase.filter.QualifierFilter;
  35. import org.apache.hadoop.hbase.filter.RandomRowFilter;
  36. import org.apache.hadoop.hbase.filter.RegexStringComparator;
  37. import org.apache.hadoop.hbase.filter.RowFilter;
  38. import org.apache.hadoop.hbase.filter.SingleColumnValueExcludeFilter;
  39. import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
  40. import org.apache.hadoop.hbase.filter.SkipFilter;
  41. import org.apache.hadoop.hbase.filter.SubstringComparator;
  42. import org.apache.hadoop.hbase.filter.TimestampsFilter;
  43. import org.apache.hadoop.hbase.filter.ValueFilter;
  44. import org.apache.hadoop.hbase.filter.WhileMatchFilter;
  45. import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
  46. import org.apache.hadoop.hbase.util.Bytes;
  47. import org.apache.hadoop.hbase.util.Pair;
  48. public class HbaseUtils {
  49. public static Admin admin = null;
  50. public static Connection conn = null;
  51. public HbaseUtils() {
  52. Configuration conf = HBaseConfiguration.create();
  53. conf.set("hbase.zookeeper.quorum", "h71:2181");
  54. conf.set("hbase.rootdir", "hdfs://h71:9000/hbase");
  55. try {
  56. conn = ConnectionFactory.createConnection(conf);
  57. admin = conn.getAdmin();
  58. } catch (IOException e) {
  59. e.printStackTrace();
  60. }
  61. }
  62. public static void main(String[] args) throws Exception {
  63. HbaseUtils hbase = new HbaseUtils();
  64. //1，FamilyFilter：基于“列族”来过滤数据；
  65. //      hbase.FamilyFilter("scores");
  66. //2，QualifierFilter：基于“列名”来过滤数据；
  67. //      hbase.QualifierFilter("scores");
  68. //3.RowFilter：基于rowkey来过滤数据；
  69. //      hbase.RowFilter("scores","zhangsan01");
  70. //4.PrefixFilter：基于rowkey前缀来过滤数据；
  71. //      hbase.PrefixFilter("scores","zhang");
  72. //后缀过滤数据
  73. //      hbase.HouZui("scores");
  74. //5，ColumnPrefixFilter：基于列名前缀来过滤数据；
  75. //      hbase.ColumnPrefixFilter("scores");
  76. //6，MultipleColumnPrefixFilter：ColumnPrefixFilter的加强版；
  77. //      hbase.MultipleColumnPrefixFilter("scores");
  78. //7，ColumnCountGetFilter：限制每行返回多少列；
  79. //      hbase.columnCountGetFilter();
  80. //8，ColumnPaginationFilter：对一行的所有列分页，只返回[limit, offset]范围内的列；
  81. //      hbase.ColumnPaginationFilter("scores");
  82. //9，ColumnRangeFilter：可用于获得一个范围的列
  83. //      hbase.ColumnRangeFilter("scores");
  84. //10，DependentColumnFilter：返回（与（符合条件[列族，列名]或[列族，列名，值]的参考列）具有相同的时间戳）的所有列，即：基于比较器过滤参考列，基于参考列的时间戳过滤其他列；
  85. //      hbase.DependentColumnFilter("scores");
  86. //11，FirstKeyOnlyFilter：结果只返回每行的第一个值对；
  87. //      hbase.FirstKeyOnlyFilter("scores");
  88. //12，FuzzyRowFilter：模糊row查询；
  89. //      hbase.FuzzyRowFilter("scores");
  90. //13，InclusiveStopFilter：将stoprow也一起返回；
  91. //      hbase.InclusiveStopFilter("scores");
  92. //14，KeyOnlyFilter：只返回行键；
  93. //      hbase.KeyOnlyFilter("scores");
  94. //15，PageFilter： 取回XX条数据  ；
  95. //      hbase.PageFilter("scores");
  96. //16，RandomRowFilter：随机获取一定比例（比例为参数）的数据；
  97. //      hbase.RandomRowFilter("scores");
  98. //17，SingleColumnValueFilter：基于参考列的值来过滤数据；
  99. //      hbase.SingleColumnValueFilter("scores");
  100. //18，ValueFilter：基于值来过滤数据；
  101. //      hbase.ValueFilter("scores");
  102. //19，SkipFilter：当过滤器发现某一行中的一列要过滤时，就将整行数据都过滤掉；
  103. //      hbase.SkipFilter("scores");
  104. //20，TimestampsFilter：基于时间戳来过滤数据；
  105. //      hbase.TimestampsFilter("scores");
  106. //21，WhileMatchFilter：一旦遇到一条符合过滤条件的数据，就停止扫描；
  107. //      hbase.WhileMatchFilter("scores");
  108. //22，FilterList：多个过滤器组合过滤。
  109. //      hbase.FilterList("scores");
  110. }
  111. /**
  112. 1,FamilyFilter
  113. a,按family（列族）查找，取回所有符合条件的“family”
  114. b,构造方法第一个参数为compareOp
  115. c,第二个参数为WritableByteArrayComparable，有BinaryComparator, BinaryPrefixComparator,
  116. BitComparator, NullComparator, RegexStringComparator, SubstringComparator这些类，
  117. 最常用的为BinaryComparator
  118. */
  119. public void FamilyFilter(String tableName) throws Exception {
  120. Table table = conn.getTable(TableName.valueOf(tableName));
  121. Scan scan = new Scan();
  122. Filter filter = new FamilyFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("grc")));
  123. scan.setFilter(filter);
  124. ResultScanner scanner = table.getScanner(scan);
  125. for (Result r : scanner) {
  126. for (Cell cell : r.rawCells()) {
  127. System.out.println(
  128. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  129. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  130. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  131. }
  132. }
  133. }
  134. /*
  135. hbase(main):224:0> scan 'scores', {FILTER => "FamilyFilter(<=,'binary:grc')"}
  136. 或者
  137. hbase(main):011:0> scan 'scores', FILTER => "FamilyFilter(<=,'binary:grc')"
  138. ROW                                                          COLUMN+CELL
  139. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  140. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  141. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  142. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  143. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  144. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  145. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  146. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  147. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=102
  148. 3 row(s) in 0.0220 seconds
  149. */
  150. /**
  151. 2，QualifierFilter
  152. 类似于FamilyFilter，取回所有符合条件的“列”
  153. 构造方法第一个参数   compareOp
  154. 第二个参数为WritableByteArrayComparable
  155. */
  156. public void QualifierFilter(String tableName) throws Exception {
  157. Table table = conn.getTable(TableName.valueOf(tableName));
  158. Scan scan = new Scan();
  159. Filter filter = new QualifierFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("grc")));
  160. //这里输的参数是相应位置比大小，及当输入ms的时候，所有列名的第一位小于等于m，如果第一位相等则比较第二位的大小。一开始没理解，所以一开始参数输入math或course的时候把我整懵了。
  161. scan.setFilter(filter);
  162. ResultScanner scanner = table.getScanner(scan);
  163. for (Result r : scanner) {
  164. for (Cell cell : r.rawCells()) {
  165. System.out.println(
  166. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  167. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  168. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  169. }
  170. }
  171. }
  172. /*
  173. hbase(main):221:0> scan 'scores', {FILTER => "QualifierFilter(<=,'binary:b')"}
  174. ROW                                                          COLUMN+CELL
  175. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  176. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  177. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  178. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  179. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  180. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=102
  181. 3 row(s) in 0.0470 seconds
  182. */
  183. /**
  184. 3，RowFilter
  185. 构造方法参数设置类似于FamilyFilter，符合条件的row都返回
  186. 但是通过row查询时，如果知道开始结束的row，还是用scan的start和end方法更直接并且经测试速度快一半以上
  187. */
  188. public void RowFilter(String tableName, String reg) throws Exception {
  189. Table table = conn.getTable(TableName.valueOf(tableName));
  190. Scan scan = new Scan();
  191. //这个参数EQUAL很重要，如果参数不同，查询的结果也会不同
  192. //      RowFilter filter = new RowFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes(reg)));//这样写也行
  193. //      Filter filter = new RowFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes(reg)));
  194. Filter filter = new RowFilter(CompareOp.LESS_OR_EQUAL,  new BinaryComparator(Bytes.toBytes(reg)));
  195. scan.setFilter(filter);
  196. ResultScanner scanner = table.getScanner(scan);
  197. for (Result r : scanner) {
  198. for (Cell cell : r.rawCells()) {
  199. System.out.println(
  200. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  201. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  202. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  203. }
  204. }
  205. /**
  206. * 更推荐用下面的方法直接指定起止行，因为filter本质上还是会遍历全部数据，而设定起止行后会直接从指定行开始，指定行结束，效率高很多。
  207. */
  208. // scan.setStartRow(Bytes.toBytes("AAAAAAAAAAAA"));
  209. // scan.setStopRow(Bytes.toBytes( "AAAAAAAAABBB"));
  210. }
  211. /*
  212. hbase(main):004:0> scan 'scores', {FILTER => "RowFilter(<=,'binary:zhangsan01')"}
  213. ROW                                                          COLUMN+CELL
  214. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  215. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  216. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  217. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  218. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  219. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  220. 2 row(s) in 0.0210 seconds
  221. */
  222. /**
  223. 4，PrefixFilter
  224. 取回rowkey以指定prefix开头的所有行
  225. */
  226. public void PrefixFilter(String tableName, String reg) throws Exception {
  227. Table table = conn.getTable(TableName.valueOf(tableName));
  228. Scan scan = new Scan();
  229. Filter filter = new PrefixFilter(Bytes.toBytes("zhang"));
  230. scan.setFilter(filter);
  231. ResultScanner scanner = table.getScanner(scan);
  232. for (Result r : scanner) {
  233. for (Cell cell : r.rawCells()) {
  234. System.out.println(
  235. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  236. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  237. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  238. }
  239. }
  240. }
  241. /*
  242. hbase(main):022:0> scan 'scores', {FILTER => org.apache.hadoop.hbase.filter.PrefixFilter.new(org.apache.hadoop.hbase.util.Bytes.toBytes('li'))}
  243. 或者
  244. hbase(main):004:0> scan 'scores', {FILTER => "PrefixFilter('li')"}
  245. ROW                                                          COLUMN+CELL
  246. lisi01                                                      column=course:art, timestamp=1489747672249, value=89
  247. lisi01                                                      column=course:math, timestamp=1489747666861, value=89
  248. lisi01                                                      column=grade:, timestamp=1489747677402, value=201
  249. 1 row(s) in 0.0110 seconds
  250. */
  251. /**
  252. 由于其原生带有PrefixFilter这种对ROWKEY的前缀过滤查询，因此想着实现的后缀查询的过程中，发现这一方面相对来说还是空白。
  253. 因此，只能采用一些策略来实现，主要还是采用正则表达式的方式。
  254. */
  255. public void HouZui(String tableName) throws Exception {
  256. Table table = conn.getTable(TableName.valueOf(tableName));
  257. Scan scan = new Scan();
  258. Filter filter = new RowFilter(CompareOp.EQUAL,new RegexStringComparator(".*n01"));
  259. scan.setFilter(filter);
  260. ResultScanner scanner = table.getScanner(scan);
  261. for (Result r : scanner) {
  262. for (Cell cell : r.rawCells()) {
  263. System.out.println(
  264. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  265. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  266. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  267. }
  268. }
  269. }
  270. /*
  271. hbase(main):020:0> scan 'scores', {FILTER => "RowFilter(=,'regexstring:.*n01')"}
  272. ROW                                                          COLUMN+CELL
  273. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  274. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  275. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  276. 1 row(s) in 0.0080 seconds
  277. */
  278. /**
  279. 5，ColumnPrefixFilter
  280. */
  281. public void ColumnPrefixFilter(String tableName) throws Exception {
  282. Table table = conn.getTable(TableName.valueOf(tableName));
  283. Scan scan = new Scan();
  284. byte[] prefix = Bytes.toBytes("ar");
  285. Filter filter = new ColumnPrefixFilter(prefix);
  286. scan.setFilter(filter);
  287. ResultScanner scanner = table.getScanner(scan);
  288. for (Result r : scanner) {
  289. for (Cell cell : r.rawCells()) {
  290. System.out.println(
  291. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  292. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  293. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  294. }
  295. }
  296. }
  297. /*
  298. hbase(main):021:0> scan 'scores', {FILTER => "ColumnPrefixFilter('ar')"}
  299. 或者
  300. hbase(main):022:0> scan 'scores', {FILTER => org.apache.hadoop.hbase.filter.ColumnPrefixFilter.new(org.apache.hadoop.hbase.util.Bytes.toBytes('ar'))}
  301. ROW                                                          COLUMN+CELL
  302. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  303. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  304. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  305. 3 row(s) in 0.0140 seconds
  306. */
  307. /**
  308. 6，MultipleColumnPrefixFilter
  309. a,返回有此前缀的所有列，
  310. b,在byte[][]中定义所有需要的列前缀，只要满足其中一条约束就会被返回（ColumnPrefixFilter的加强版），
  311. */
  312. public void MultipleColumnPrefixFilter(String tableName) throws Exception {
  313. Table table = conn.getTable(TableName.valueOf(tableName));
  314. Scan scan = new Scan();
  315. byte[][] prefix = {Bytes.toBytes("ar"),Bytes.toBytes("ma")};
  316. Filter filter = new MultipleColumnPrefixFilter(prefix);
  317. scan.setFilter(filter);
  318. ResultScanner scanner = table.getScanner(scan);
  319. for (Result r : scanner) {
  320. for (Cell cell : r.rawCells()) {
  321. System.out.println(
  322. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  323. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  324. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  325. }
  326. }
  327. }
  328. /*
  329. hbase(main):023:0> scan 'scores', {FILTER => "MultipleColumnPrefixFilter('ar','ma')"}
  330. ROW                                                          COLUMN+CELL
  331. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  332. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  333. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  334. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  335. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  336. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  337. 3 row(s) in 0.0290 seconds
  338. */
  339. /**
  340. 7，ColumnCountGetFilter
  341. a,无法再scan中使用，只能在Get中
  342. b,若设为0，则无法返回数据，设为几就按服务器中存储位置取回几列
  343. c,可用size()取到列数，观察效果
  344. */
  345. public void columnCountGetFilter() throws Exception {
  346. Table table = conn.getTable(TableName.valueOf("scores"));
  347. Get get = new Get(Bytes.toBytes("zhangsan01"));
  348. get.setFilter(new ColumnCountGetFilter(2));
  349. Result result = table.get(get);
  350. //输出结果size，观察效果
  351. System.out.println(result.size());
  352. //        byte[] value1 = result.getValue("course".getBytes(), "art".getBytes());
  353. //        byte[] value2 = result.getValue("course".getBytes(), "math".getBytes());
  354. //        System.out.println("course:art"+"-->"+new String(value1)+"  "
  355. //                +"course:math"+"-->"+new String(value2));
  356. }
  357. /*
  358. hbase(main):026:0> scan 'scores', {FILTER => "ColumnCountGetFilter(2)"}
  359. ROW                                                          COLUMN+CELL
  360. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  361. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  362. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  363. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  364. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  365. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  366. 3 row(s) in 0.0120 seconds
  367. */
  368. /**
  369. 8，ColumnPaginationFilter
  370. a,limit 表示返回列数
  371. b,offset 表示返回列的偏移量，如果为0，则全部取出，如果为1，则返回第二列及以后
  372. */
  373. public void ColumnPaginationFilter(String tableName) throws Exception {
  374. Table table = conn.getTable(TableName.valueOf(tableName));
  375. Scan scan = new Scan();
  376. Filter filter = new ColumnPaginationFilter(2,1);
  377. scan.setFilter(filter);
  378. //      用addFamily增加列族后，会只返回指定列族的数据
  379. scan.addFamily(Bytes.toBytes("course"));
  380. ResultScanner scanner = table.getScanner(scan);
  381. for (Result r : scanner) {
  382. for (Cell cell : r.rawCells()) {
  383. System.out.println(
  384. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  385. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  386. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  387. }
  388. }
  389. }
  390. /*
  391. hbase(main):031:0> scan 'scores',{FILTER=>org.apache.hadoop.hbase.filter.ColumnPaginationFilter.new(2,1)}
  392. 或者
  393. hbase(main):030:0> scan 'scores',{FILTER=> "ColumnPaginationFilter(2,1)"}
  394. ROW                                                          COLUMN+CELL
  395. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  396. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  397. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  398. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  399. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  400. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=102
  401. 3 row(s) in 0.0100 seconds
  402. */
  403. /**
  404. 9，ColumnRangeFilter
  405. 构造函数：
  406. ColumnRangeFilter(byte[] minColumn, boolean minColumnInclusive, byte[] maxColumn, boolean maxColumnInclusive)
  407. *可用于获得一个范围的列，例如，如果你的一行中有百万个列，但是你只希望查看列名为bbbb到dddd的范围
  408. *该过滤器可以进行高效的列名内部扫描。（为何是高效呢？？？因为列名是已经按字典排序好的）HBase-0.9.2 版本引入该功能。
  409. *一个列名是可以出现在多个列族中的，该过滤器将返回所有列族中匹配的列
  410. */
  411. public void ColumnRangeFilter(String tableName) throws Exception {
  412. Table table = conn.getTable(TableName.valueOf(tableName));
  413. Scan scan = new Scan();
  414. Filter filter = new ColumnRangeFilter(Bytes.toBytes("a"),true, Bytes.toBytes("n"),true);
  415. scan.setFilter(filter);
  416. ResultScanner scanner = table.getScanner(scan);
  417. for (Result r : scanner) {
  418. for (Cell cell : r.rawCells()) {
  419. System.out.println(
  420. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  421. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  422. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  423. }
  424. }
  425. }
  426. /*
  427. hbase(main):032:0> scan 'scores',{FILTER=> "ColumnRangeFilter('a',true,'n',true)"}
  428. ROW                                                          COLUMN+CELL
  429. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  430. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  431. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  432. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  433. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  434. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  435. 3 row(s) in 0.0140 seconds
  436. */
  437. /**
  438. 10, DependentColumnFilter （该过滤器有两个参数：family和Qualifier,尝试找到该列所在的每一行，
  439. 并返回该行具有相同时间戳的全部键值对。如果某一行不包含指定的列，则该行的任何键值对都不返回，
  440. 该过滤器还可以有一个可选的布尔参数-如果为true,从属的列不返回；
  441. 该过滤器还可以有两个可选的参数--一个比较操作符和一个值比较器，用于family和Qualifier
  442. 的进一步检查，如果从属的列找到，其值还必须通过值检查，然后就是时间戳必须考虑）
  443. */
  444. public void DependentColumnFilter(String tableName) throws Exception {
  445. Table table = conn.getTable(TableName.valueOf(tableName));
  446. Scan scan = new Scan();
  447. //      Filter filter = new DependentColumnFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),false);
  448. //      Filter filter = new DependentColumnFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),true);
  449. Filter filter = new DependentColumnFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),false,CompareOp.EQUAL,new BinaryComparator(Bytes.toBytes("90")));
  450. //      Filter filter = new DependentColumnFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),true,CompareOp.EQUAL,new BinaryComparator(Bytes.toBytes("90")));
  451. //上面这四种情况输出的for循环中的内容也不一样，要做相应的修改，否则会报java.lang.NullPointerException
  452. scan.setFilter(filter);
  453. ResultScanner scanner = table.getScanner(scan);
  454. for (Result r : scanner) {
  455. for (Cell cell : r.rawCells()) {
  456. System.out.println(
  457. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  458. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  459. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  460. }
  461. }
  462. }
  463. /*
  464. hbase(main):036:0> scan 'scores',{FILTER=> "DependentColumnFilter('course','art',false,=,'binary:90')"}
  465. ROW                                                          COLUMN+CELL
  466. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  467. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  468. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  469. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=102
  470. 2 row(s) in 0.0160 seconds
  471. */
  472. /**
  473. 11，FirstKeyOnlyFilter
  474. 如名字所示，结果只返回每行的第一个值对
  475. */
  476. public void FirstKeyOnlyFilter(String tableName) throws Exception {
  477. Table table = conn.getTable(TableName.valueOf(tableName));
  478. Scan scan = new Scan();
  479. Filter filter = new FirstKeyOnlyFilter();
  480. scan.setFilter(filter);
  481. ResultScanner scanner = table.getScanner(scan);
  482. for (Result r : scanner) {
  483. for (Cell cell : r.rawCells()) {
  484. System.out.println(
  485. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  486. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  487. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  488. }
  489. }
  490. }
  491. /*
  492. hbase(main):037:0> scan 'scores',{FILTER=> "FirstKeyOnlyFilter()"}
  493. ROW                                                          COLUMN+CELL
  494. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  495. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  496. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  497. 3 row(s) in 0.0160 seconds
  498. */
  499. /**
  500. 12，FuzzyRowFilter
  501. 模糊row查询
  502. pair中第一个参数为模糊查询的string
  503. 第二个参数为byte[]其中装与string位数相同的数值0或1,0表示该位必须与string中值相同，1表示可以不同
  504. */
  505. public void FuzzyRowFilter(String tableName) throws Exception {
  506. Table table = conn.getTable(TableName.valueOf(tableName));
  507. Scan scan = new Scan();
  508. Filter filter = new FuzzyRowFilter( Arrays.asList(new Pair<byte[], byte[]>(Bytes.toBytes("zhangsan01"),
  509. new byte[] {0, 0, 0, 0 , 0, 0, 0, 0, 0, 1})));
  510. scan.setFilter(filter);
  511. ResultScanner scanner = table.getScanner(scan);
  512. for (Result r : scanner) {
  513. for (Cell cell : r.rawCells()) {
  514. System.out.println(
  515. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  516. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  517. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  518. }
  519. }
  520. }
  521. /*
  522. 。。。。。
  523. */
  524. /**
  525. 13，InclusiveStopFilter
  526. 指定stopRow，程序在scan时从头扫描全部返回，直到stopRow停止（stopRow这行也会返回，然后scan停止）
  527. */
  528. public void InclusiveStopFilter(String tableName) throws Exception {
  529. Table table = conn.getTable(TableName.valueOf(tableName));
  530. Scan scan = new Scan();
  531. Filter filter = new InclusiveStopFilter(Bytes.toBytes("zhangsan01"));
  532. scan.setFilter(filter);
  533. ResultScanner scanner = table.getScanner(scan);
  534. for (Result r : scanner) {
  535. for (Cell cell : r.rawCells()) {
  536. System.out.println(
  537. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  538. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  539. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  540. }
  541. }
  542. }
  543. /*
  544. hbase(main):012:0> scan 'scores', {FILTER => "InclusiveStopFilter('zhangsan01')"}
  545. ROW                                                          COLUMN+CELL
  546. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  547. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  548. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  549. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  550. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  551. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  552. 2 row(s) in 0.0170 seconds
  553. */
  554. /**
  555. 14，KeyOnlyFilter
  556. 只取key值，size正常，说明value不是没取而是在取的时候被重写为空（能打印，不是null）
  557. lenAsVal这个值没大搞明白，当设为false时打印为空，如果设为true时打印的将会是“口口口口”
  558. */
  559. public void KeyOnlyFilter(String tableName) throws Exception {
  560. Table table = conn.getTable(TableName.valueOf(tableName));
  561. Scan scan = new Scan();
  562. Filter filter = new KeyOnlyFilter(true);
  563. scan.setFilter(filter);
  564. ResultScanner scanner = table.getScanner(scan);
  565. for (Result r : scanner) {
  566. for (Cell cell : r.rawCells()) {
  567. System.out.println(
  568. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  569. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  570. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  571. }
  572. }
  573. }
  574. /*
  575. hbase(main):016:0> scan 'scores', {FILTER => "KeyOnlyFilter(true)"}
  576. ROW                                                          COLUMN+CELL
  577. lisi01                                                      column=course:art, timestamp=1498003655021, value=\x00\x00\x00\x02
  578. lisi01                                                      column=course:math, timestamp=1498003561726, value=\x00\x00\x00\x02
  579. lisi01                                                      column=grade:, timestamp=1498003561726, value=\x00\x00\x00\x03
  580. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=\x00\x00\x00\x02
  581. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=\x00\x00\x00\x02
  582. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=\x00\x00\x00\x03
  583. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=\x00\x00\x00\x02
  584. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=\x00\x00\x00\x02
  585. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=\x00\x00\x00\x03
  586. 3 row(s) in 0.0320 seconds
  587. hbase(main):015:0> scan 'scores', {FILTER => "KeyOnlyFilter(false)"}
  588. ROW                                                          COLUMN+CELL
  589. lisi01                                                      column=course:art, timestamp=1498003655021, value=
  590. lisi01                                                      column=course:math, timestamp=1498003561726, value=
  591. lisi01                                                      column=grade:, timestamp=1498003561726, value=
  592. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=
  593. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=
  594. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=
  595. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=
  596. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=
  597. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=
  598. 3 row(s) in 0.0190 seconds
  599. */
  600. /**
  601. 15，PageFilter
  602. 取回XX条数据
  603. */
  604. public void PageFilter(String tableName) throws Exception {
  605. Table table = conn.getTable(TableName.valueOf(tableName));
  606. Scan scan = new Scan();
  607. Filter filter = new PageFilter(2);
  608. scan.setFilter(filter);
  609. ResultScanner scanner = table.getScanner(scan);
  610. for (Result r : scanner) {
  611. for (Cell cell : r.rawCells()) {
  612. System.out.println(
  613. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  614. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  615. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  616. }
  617. }
  618. }
  619. /*
  620. hbase(main):017:0> scan 'scores', {FILTER => "PageFilter(2)"}
  621. ROW                                                          COLUMN+CELL
  622. lisi01                                                      column=course:art, timestamp=1498003655021, value=89
  623. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  624. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  625. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  626. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  627. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  628. 2 row(s) in 0.0130 seconds
  629. */
  630. /**
  631. 16，RandomRowFilter
  632. 参数小于0时一条查不出大于1值会返回所有，而想取随机行的话有效区间为0~1，值代表取到的几率
  633. */
  634. public void RandomRowFilter(String tableName) throws Exception {
  635. Table table = conn.getTable(TableName.valueOf(tableName));
  636. Scan scan = new Scan();
  637. Filter filter = new RandomRowFilter((float)0.5);
  638. //即使是0.5有时候也一条查不出来，有时候却全出来了，是几率并不是一定，那我就不知道这个具体有什么实际运用了。。。根据rowkey随机而不是根据列随机
  639. scan.setFilter(filter);
  640. ResultScanner scanner = table.getScanner(scan);
  641. for (Result r : scanner) {
  642. for (Cell cell : r.rawCells()) {
  643. System.out.println(
  644. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  645. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  646. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  647. }
  648. }
  649. }
  650. /*
  651. 。。。。。
  652. */
  653. /**
  654. 17，SingleColumnValueFilter和SingleColumnValueExcludeFilter
  655. 用来查找并返回指定条件的列的数据
  656. a，如果查找时没有该列，两种filter都会把该行所有数据返回
  657. b，如果查找时有该列，但是不符合条件，则该行所有列都不返回
  658. c，如果找到该列，并且符合条件，前者返回所有列，后者返回除该列以外的所有列
  659. */
  660. public void SingleColumnValueFilter(String tableName) throws Exception {
  661. Table table = conn.getTable(TableName.valueOf(tableName));
  662. Scan scan = new Scan();
  663. //完整匹配字节数组
  664. //      Filter filter = new SingleColumnValueFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),CompareOp.EQUAL,new BinaryComparator(Bytes.toBytes("90")));
  665. //匹配正则表达式
  666. //      Filter filter = new SingleColumnValueFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),CompareOp.EQUAL,new RegexStringComparator("8"));
  667. //匹配是否包含子串,大小写不敏感
  668. //      Filter filter = new SingleColumnValueFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),CompareOp.EQUAL,new SubstringComparator("9"));
  669. Filter filter = new SingleColumnValueExcludeFilter(Bytes.toBytes("course"), Bytes.toBytes("art"), CompareOp.EQUAL,new SubstringComparator("9"));
  670. scan.setFilter(filter);
  671. ResultScanner scanner = table.getScanner(scan);
  672. for (Result r : scanner) {
  673. for (Cell cell : r.rawCells()) {
  674. System.out.println(
  675. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  676. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  677. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  678. }
  679. }
  680. }
  681. /*
  682. hbase(main):032:0> scan 'scores', {FILTER => "SingleColumnValueExcludeFilter('course','art',=,'substring:9')"}
  683. ROW                                                          COLUMN+CELL
  684. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  685. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  686. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  687. zhangsan01                                                  column=grade:, timestamp=1498003593575, value=101
  688. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  689. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=102
  690. 3 row(s) in 0.0150 seconds
  691. */
  692. /**
  693. 18，ValueFilter
  694. 按value全数据库搜索（全部列的value均会被检索）
  695. */
  696. public void ValueFilter(String tableName) throws Exception {
  697. Table table = conn.getTable(TableName.valueOf(tableName));
  698. Scan scan = new Scan();
  699. Filter filter = new ValueFilter(CompareOp.NOT_EQUAL,new BinaryComparator(Bytes.toBytes("102")));
  700. scan.setFilter(filter);
  701. ResultScanner scanner = table.getScanner(scan);
  702. for (Result r : scanner) {
  703. for (Cell cell : r.rawCells()) {
  704. System.out.println(
  705. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  706. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  707. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  708. }
  709. }
  710. }
  711. /*
  712. NOT_EQUAL不知道该咋么表示。。。。。
  713. */
  714. /**
  715. 19，SkipFilter
  716. 根据整行中的每个列来做过滤，只要存在一列不满足条件，整行都被过滤掉。
  717. 例如，如果一行中的所有列代表的是不同物品的重量，则真实场景下这些数值都必须大于零，我们希望将那些包含任意列值为0的行都过滤掉。
  718. 在这个情况下，我们结合ValueFilter和SkipFilter共同实现该目的：
  719. scan.setFilter(new SkipFilter(new ValueFilter(CompareOp.NOT_EQUAL,new BinaryComparator(Bytes.toBytes(0))));
  720. */
  721. public void SkipFilter(String tableName) throws Exception {
  722. Table table = conn.getTable(TableName.valueOf(tableName));
  723. Scan scan = new Scan();
  724. Filter filter = new SkipFilter(new ValueFilter(CompareOp.NOT_EQUAL,new BinaryComparator(Bytes.toBytes("102"))));
  725. //      Filter filter = new SkipFilter(new DependentColumnFilter(Bytes.toBytes("course"), Bytes.toBytes("art"),false,CompareOp.NOT_EQUAL,new BinaryComparator(Bytes.toBytes("90"))));
  726. //该过滤器需要配合其他过滤器来使用
  727. scan.setFilter(filter);
  728. ResultScanner scanner = table.getScanner(scan);
  729. for (Result r : scanner) {
  730. for (Cell cell : r.rawCells()) {
  731. System.out.println(
  732. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  733. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  734. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  735. }
  736. }
  737. }
  738. /*
  739. 不知道咋么把两个过滤器嵌套使用。。。。。
  740. */
  741. /**
  742. 20，TimestampsFilter
  743. a，按时间戳搜索数据库
  744. b，需设定List<Long> 存放所有需要检索的时间戳，
  745. */
  746. public void TimestampsFilter(String tableName) throws Exception {
  747. Table table = conn.getTable(TableName.valueOf(tableName));
  748. Scan scan = new Scan();
  749. //ls中存放所有需要查找匹配的时间戳
  750. List<Long> ls = new ArrayList<Long>();
  751. ls.add((long)1498003561726L);
  752. ls.add((long)1498003601365L);
  753. //java语言的整型常量默认为int型，声明long型常量可以后加”l“或”L“
  754. Filter filter = new TimestampsFilter(ls);
  755. scan.setFilter(filter);
  756. ResultScanner scanner = table.getScanner(scan);
  757. //      for (Result result : scanner) {
  758. //          if(new String(result.getRow()).equals("zhangsan01")){
  759. //              System.out.println(new String(result.getRow())+"  "
  760. //                  +"course:art"+"-->"+new String(result.getValue(Bytes.toBytes("course"), Bytes.toBytes("art")))+"  "
  761. //                  +"course:math"+"-->"+new String(result.getValue(Bytes.toBytes("course"), Bytes.toBytes("math"))));
  762. //          }else if(new String(result.getRow()).equals("zhangsan02")){
  763. //              System.out.println(new String(result.getRow())+"  "
  764. //                  +"course:art"+"-->"+new String(result.getValue(Bytes.toBytes("course"), Bytes.toBytes("art")))+"  "
  765. //                  +"course:math"+"-->"+new String(result.getValue(Bytes.toBytes("course"), Bytes.toBytes("math")))+"  "
  766. //                  +"grade:"+"-->"+new String(result.getValue(Bytes.toBytes("grade"), Bytes.toBytes(""))));
  767. //          }else{
  768. //              System.out.println(new String(result.getRow())+"  "
  769. //                  +"course:math"+"-->"+new String(result.getValue(Bytes.toBytes("course"), Bytes.toBytes("math")))+"  "
  770. //                  +"grade:"+"-->"+new String(result.getValue(Bytes.toBytes("grade"), Bytes.toBytes(""))));
  771. //          }
  772. //      }
  773. for (Result r : scanner) {
  774. for (Cell cell : r.rawCells()) {
  775. System.out.println(
  776. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  777. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  778. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  779. }
  780. }
  781. }
  782. /*
  783. hbase(main):039:0> scan 'scores', {FILTER => "TimestampsFilter(1498003561726,1498003601365)"}
  784. ROW                                                          COLUMN+CELL
  785. lisi01                                                      column=course:math, timestamp=1498003561726, value=89
  786. lisi01                                                      column=grade:, timestamp=1498003561726, value=201
  787. zhangsan01                                                  column=course:art, timestamp=1498003561726, value=90
  788. zhangsan01                                                  column=course:math, timestamp=1498003561726, value=99
  789. zhangsan02                                                  column=course:art, timestamp=1498003601365, value=90
  790. zhangsan02                                                  column=course:math, timestamp=1498003561726, value=66
  791. zhangsan02                                                  column=grade:, timestamp=1498003601365, value=102
  792. 3 row(s) in 0.0160 seconds
  793. */
  794. /**
  795. 21，WhileMatchFilter
  796. 相当于while执行，直到不match就break了返回了。
  797. */
  798. public void WhileMatchFilter(String tableName) throws Exception {
  799. Table table = conn.getTable(TableName.valueOf(tableName));
  800. Scan scan = new Scan();
  801. Filter filter = new WhileMatchFilter(new ValueFilter(CompareOp.NOT_EQUAL,new BinaryComparator(Bytes.toBytes("101"))));
  802. scan.setFilter(filter);
  803. ResultScanner scanner = table.getScanner(scan);
  804. for (Result r : scanner) {
  805. for (Cell cell : r.rawCells()) {
  806. System.out.println(
  807. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  808. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  809. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  810. }
  811. }
  812. }
  813. /*
  814. 。。。。。
  815. */
  816. /**
  817. 22，FilterList
  818. 代表一个过滤器链，它可以包含一组即将应用于目标数据集的过滤器，过滤器间具有“与”FilterList.Operator.MUST_PASS_ALL和“或”FilterList.Operator.MUST_PASS_ONE关系。
  819. 官网实例代码，两个“或”关系的过滤器的写法：
  820. */
  821. public void FilterList(String tableName) throws Exception {
  822. Table table = conn.getTable(TableName.valueOf(tableName));
  823. FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE);   //数据只要满足一组过滤器中的一个就可以
  824. SingleColumnValueFilter filter1 = new SingleColumnValueFilter(Bytes.toBytes("course"), Bytes.toBytes("math"),CompareOp.EQUAL,new BinaryComparator(Bytes.toBytes("89")));
  825. list.addFilter(filter1);
  826. SingleColumnValueFilter filter2 = new SingleColumnValueFilter(Bytes.toBytes("course"), Bytes.toBytes("math"),CompareOp.EQUAL,new BinaryComparator(Bytes.toBytes("66")));
  827. list.addFilter(filter2);
  828. Scan scan = new Scan();
  829. scan.setFilter(list);
  830. ResultScanner scanner = table.getScanner(scan);
  831. for (Result r : scanner) {
  832. for (Cell cell : r.rawCells()) {
  833. System.out.println(
  834. "Rowkey-->"+Bytes.toString(r.getRow())+"  "+
  835. "Familiy:Quilifier-->"+Bytes.toString(CellUtil.cloneQualifier(cell))+"  "+
  836. "Value-->"+Bytes.toString(CellUtil.cloneValue(cell)));
  837. }
  838. }
  839. }
  840. /*
  841. hbase(main):009:0> scan 'scores', {FILTER => "PrefixFilter('zhang') OR QualifierFilter(>=,'binary:b')"}
  842. ROW                                                          COLUMN+CELL
  843. lisi01                                                      column=course:math, timestamp=1489747666861, value=89
  844. lisi01                                                      column=grade:, timestamp=1489747677402, value=201
  845. zhangsan01                                                  column=course:art, timestamp=1489747593360, value=90
  846. zhangsan01                                                  column=course:math, timestamp=1489747589255, value=99
  847. zhangsan01                                                  column=grade:, timestamp=1489747598001, value=101
  848. zhangsan02                                                  column=course:art, timestamp=1489747607561, value=60
  849. zhangsan02                                                  column=course:math, timestamp=1489747602883, value=66
  850. zhangsan02                                                  column=grade:, timestamp=1489747614601, value=102
  851. 3 row(s) in 0.0180 seconds
  852. */
  853. }

上面有几个过滤器在hbase shell中没有找出，如果大家有找到的告诉我一声，一起进步。

参考：
http://blog.csdn.net/blue__yeah/article/details/41040399
http://blog.csdn.net/liangtingac/article/details/40078637
http://blog.csdn.net/u010967382/article/details/37653177
http://blog.csdn.net/sparkexpert/article/details/51942354

from：https://blog.csdn.net/m0_37739193/article/details/73615016

hbase各种遍历查询shell语句 包含过滤组合条件的更多相关文章

  1. mysq查询语句包含中文以及中文乱码，字符集 GBK、GB2312、UTF8的区别

    一.查看mysql 字符集设置情况 使用Navicat for Mysql查看工具,打开命令列界面,输入show variables like '%char%';如下图,查看当前mysql字符集设置情 ...

  2. Kali学习笔记31：目录遍历漏洞、文件包含漏洞

    文章的格式也许不是很好看,也没有什么合理的顺序 完全是想到什么写一些什么,但各个方面都涵盖到了 能耐下心看的朋友欢迎一起学习,大牛和杠精们请绕道 目录遍历漏洞: 应用程序如果有操作文件的功能,限制不严 ...

  3. CASE函数 sql server——分组查询(方法和思想) ref和out 一般处理程序结合反射技术统一执行客户端请求 遍历查询结果集，update数据 HBuilder设置APP状态栏

    CASE函数   作用: 可以将查询结果集的某一列的字段值进行替换 它可以生成一个新列 相当于switch...case和 if..else 使用语法: case 表达式/字段 when 值 then ...

  4. Oracle 查询(SELECT)语句（一）

    Ø  简介 本文介绍 Oracle 中查询(SELECT)语句的使用,在 SQL 中 SELECT 语句是相对内容较多的,也是相对比较复杂一点的,所以这里拿出来单独学习. 首先,我们先来理一下思路,我 ...

  5. 《Entity Framework 6 Recipes》中文翻译系列 (17) -----第三章 查询之分页、过滤和使用DateTime中的日期部分分组

    翻译的初衷以及为什么选择<Entity Framework 6 Recipes>来学习,请看本系列开篇 3-12 分页和过滤 问题 你想使用分页和过滤来创建查询. 解决方案 假设你有如图3 ...

  6. {MySQL的逻辑查询语句的执行顺序}一 SELECT语句关键字的定义顺序 二 SELECT语句关键字的执行顺序 三 准备表和数据 四 准备SQL逻辑查询测试语句 五 执行顺序分析

    MySQL的逻辑查询语句的执行顺序 阅读目录 一 SELECT语句关键字的定义顺序 二 SELECT语句关键字的执行顺序 三 准备表和数据 四 准备SQL逻辑查询测试语句 五 执行顺序分析 一 SEL ...

  7. 数组方法map（映射），reduce（规约），foreach（遍历），filter（过滤）

    数组方法map(映射),reduce(规约),foreach(遍历),filter(过滤) map()方法返回一个由原数组中每一个元素调用一个指定方法后返回的新数组 reduce()方法接受一个函数作 ...

  8. 多表查询sql语句

    多表查询sql语句 1 --解锁SCOTT用户 2 alter user scott account unlock 3 --检索指定的列 4 select job,ename,empno from e ...

  9. Entity Framework Code First 在Object Join Linq查询时出现全表查询的语句。

    最近一个项目,使用微软的Entity Framework的ORM框架的项目,部署到现场后,出现了系统缓慢,多个客户端的内存溢出崩溃的问题. 打开了SQL Server Profiler(SQL Ser ...

随机推荐

  1. HTTPS协议原理透析

    1.HTTPS本身并非协议,而是标准的HTTP协议架在SSL/TLS协议之上的一种结构.(一种不太合适的说法可以认为是两种协议的叠加).HTTP是工作在OSI7层模型的最上层,就是第7层:Applic ...

  2. 正确认识 DIV+CSS 概念

    今天看到神采飞扬发表于前端观察的<DIV+CSS 请不要再忽悠人了>,讲的挺有深意的,尤其对于新手如何正确认识div,学习web标准,使用web标准建站应该有很大帮助.转载过来,共同分享. ...

  3. Linux电源管理(5)_Hibernate和Sleep功能介绍【转】

    本文转载自:http://www.wowotech.net/pm_subsystem/std_str_func.html 1. 前言 Hibernate和Sleep两个功能是Linux Generic ...

  4. python_unittest详解

    一 整体结构概览 unittest原名为PyUnit,是由java的JUnit衍生而来.对于单元测试,需要设置预先条件,对比预期结果和实际结果. 整体结构:unittest库提供了test cases ...

  5. JS高阶函数的理解（函数作为参数传递）

    JS高阶函数的理解 高阶函数是指至少满足下列条件之一的函数. · 函数可以作为参数被传递 · 函数可以作为返回值输出 一个例子,我们想在页面中创建100个div节点,这是一种写法.我们发现并不是所有用 ...

  6. Codeforces 294B Shaass and Bookshelf：dp

    题目链接:http://codeforces.com/problemset/problem/294/B 题意: 有n本书,每本书的厚度为t[i],宽度为w[i] (1<=t[i]<=2, ...

  7. tomcat警告：Setting property 'source' to 'org.eclipse.jst.j2ee.server:ServletPro' did not find a matching property

    警告: [SetPropertiesRule]{Server/Service/Engine/Host/Context} Setting property 'source' to 'org.eclips ...

  8. Twitter的流处理器系统Heron——升级的storm，可以利用mesos来进行资源调度

    2011年,Twitter发布了开源的分布式流计算系统Storm.四年后,随着用户数量的急剧增加,Twitter每天要处理的事件已经增加到十亿以上.Storm系统应对如此庞大而复杂多样的流数据变得十分 ...

  9. 关于c++中的全局变量（不赋值的全局变量算定义）

    定义有三种: 1.不赋值的定义:int a; 2.赋值的定义:int a=5; 或者 int a;a=5; 3.加extern的定义:extern int a=5;//其实和不加是一样的. 声明只有一 ...

  10. 第十七章-异步IO

    异步IO的出现源自于CPU速度与IO速度完全不匹配 一般的可以采用多线程或者多进程的方式来解决IO等待的问题 同样异步IO也可以解决同步IO所带来的问题 常见的异步IO的实现方式是使用一个消息循环, ...