// select data
// http://blog.csdn.net/cnweike/article/details/42920547 for more detail.
public static String select(
String tableName, String begin, String end, String colFamily, String column, String value) {
String result = "";
TableName tn = TableName.valueOf(tableName);
try {
Table table = conn.getTable(tn);
Scan scan = new Scan(Bytes.toBytes(begin), Bytes.toBytes(end));
SingleColumnValueFilter scvf =
new SingleColumnValueFilter(
Bytes.toBytes(colFamily),
Bytes.toBytes(column),
CompareFilter.CompareOp.EQUAL,
new SubstringComparator(value));
scvf.setFilterIfMissing(false);
scvf.setLatestVersionOnly(true); // OK
scan.setFilter(scvf);
ResultScanner scanner = table.getScanner(scan);
List<Map<String, String>> total = new ArrayList<Map<String, String>>();
for (Result res : scanner) {
Map<String, String> map = new HashMap<String, String>();
for (Cell cell : res.rawCells())
map.put(
Bytes.toString(CellUtil.cloneQualifier(cell)),
Bytes.toString(CellUtil.cloneValue(cell)));
total.add(map);
}
ObjectMapper mapper = new ObjectMapper();
result = mapper.writeValueAsString(total);
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
/*
* Must be sure that column is in format like 'family: column'
*/
public void prepare(String[] columns) throws IOException {
this.scan = new Scan();
if (this.startKey != null) {
logger.info(String.format("HBaseReader set startkey to %s .", Bytes.toString(this.startKey)));
scan.setStartRow(startKey);
}
if (this.endKey != null) {
logger.info(String.format("HBaseReader set endkey to %s .", Bytes.toString(this.endKey)));
scan.setStopRow(endKey);
}
if (this.minStamp > 0 && this.maxStamp > 0) {
scan.setTimeRange(minStamp, maxStamp);
if (StringUtils.isNotEmpty(primaryKey)) {
String[] cs = StringUtils.split(primaryKey, ":");
scan.addColumn(cs[0].getBytes(), cs[1].getBytes());
}
} else if (ETLStringUtils.isNotEmpty(startDate)
&& ETLStringUtils.isNotEmpty(familyName)
&& ETLStringUtils.isNotEmpty(fieldName)) {
SingleColumnValueFilter scvf =
new SingleColumnValueFilter(
Bytes.toBytes(familyName),
Bytes.toBytes(fieldName),
CompareOp.GREATER_OR_EQUAL,
new BinaryPrefixComparator(startDate.getBytes()));
scvf.setFilterIfMissing(true);
scvf.setLatestVersionOnly(true);
if (ETLStringUtils.isNotEmpty(endDate)) {
SingleColumnValueFilter scvf1 =
new SingleColumnValueFilter(
Bytes.toBytes(familyName),
Bytes.toBytes(fieldName),
CompareOp.LESS_OR_EQUAL,
new BinaryPrefixComparator(endDate.getBytes()));
scvf1.setFilterIfMissing(true);
scvf1.setLatestVersionOnly(true);
List<Filter> filters = new ArrayList<Filter>();
filters.add(scvf);
filters.add(scvf1);
FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL, filters);
scan.setFilter(fl);
} else {
scan.setFilter(scvf);
}
}
this.families = new String[columns.length];
this.columns = new String[columns.length];
int idx = 0;
for (String column : columns) {
this.families[idx] = column.split(":")[0].trim();
this.columns[idx] = column.split(":")[1].trim();
if (!(this.minStamp > 0 && this.maxStamp > 0)) {
scan.addColumn(this.families[idx].getBytes(), this.columns[idx].getBytes());
}
idx++;
}
if ("true".equalsIgnoreCase(this.isSaveOneObj)) {
scan.addColumn(this.oneObjFamilyName.getBytes(), this.oneObjColName.getBytes());
}
if (this.maxversion > 0) {
scan.setMaxVersions(this.maxversion);
} else {
scan.setMaxVersions();
}
htable.setScannerCaching(SCAN_CACHE);
this.rs = htable.getScanner(this.scan);
}
public Filter build() {
Filter filter;
switch (FilterType.valueOf(type)) {
case ColumnCountGetFilter:
filter = new ColumnCountGetFilter(limit);
break;
case ColumnPaginationFilter:
filter = new ColumnPaginationFilter(limit, offset);
break;
case ColumnPrefixFilter:
filter = new ColumnPrefixFilter(Base64.decode(value));
break;
case ColumnRangeFilter:
filter =
new ColumnRangeFilter(
Base64.decode(minColumn),
minColumnInclusive,
Base64.decode(maxColumn),
maxColumnInclusive);
break;
case DependentColumnFilter:
filter =
new DependentColumnFilter(
Base64.decode(family),
qualifier != null ? Base64.decode(qualifier) : null,
dropDependentColumn,
CompareOp.valueOf(op),
comparator.build());
break;
case FamilyFilter:
filter = new FamilyFilter(CompareOp.valueOf(op), comparator.build());
break;
case FilterList:
{
List<Filter> list = new ArrayList<Filter>();
for (FilterModel model : filters) {
list.add(model.build());
}
filter = new FilterList(FilterList.Operator.valueOf(op), list);
}
break;
case FirstKeyOnlyFilter:
filter = new FirstKeyOnlyFilter();
break;
case InclusiveStopFilter:
filter = new InclusiveStopFilter(Base64.decode(value));
break;
case KeyOnlyFilter:
filter = new KeyOnlyFilter();
break;
case MultipleColumnPrefixFilter:
{
byte[][] values = new byte[prefixes.size()][];
for (int i = 0; i < prefixes.size(); i++) {
values[i] = Base64.decode(prefixes.get(i));
}
filter = new MultipleColumnPrefixFilter(values);
}
break;
case PageFilter:
filter = new PageFilter(Long.valueOf(value));
break;
case PrefixFilter:
filter = new PrefixFilter(Base64.decode(value));
break;
case QualifierFilter:
filter = new QualifierFilter(CompareOp.valueOf(op), comparator.build());
break;
case RandomRowFilter:
filter = new RandomRowFilter(chance);
break;
case RowFilter:
filter = new RowFilter(CompareOp.valueOf(op), comparator.build());
break;
case SingleColumnValueFilter:
filter =
new SingleColumnValueFilter(
Base64.decode(family),
qualifier != null ? Base64.decode(qualifier) : null,
CompareOp.valueOf(op),
comparator.build());
if (ifMissing != null) {
((SingleColumnValueFilter) filter).setFilterIfMissing(ifMissing);
}
if (latestVersion != null) {
((SingleColumnValueFilter) filter).setLatestVersionOnly(latestVersion);
}
break;
case SingleColumnValueExcludeFilter:
filter =
new SingleColumnValueExcludeFilter(
Base64.decode(family),
qualifier != null ? Base64.decode(qualifier) : null,
CompareOp.valueOf(op),
comparator.build());
if (ifMissing != null) {
((SingleColumnValueExcludeFilter) filter).setFilterIfMissing(ifMissing);
}
if (latestVersion != null) {
((SingleColumnValueExcludeFilter) filter).setLatestVersionOnly(latestVersion);
}
break;
case SkipFilter:
filter = new SkipFilter(filters.get(0).build());
break;
case TimestampsFilter:
filter = new TimestampsFilter(timestamps);
break;
case ValueFilter:
filter = new ValueFilter(CompareOp.valueOf(op), comparator.build());
break;
case WhileMatchFilter:
filter = new WhileMatchFilter(filters.get(0).build());
break;
default:
throw new RuntimeException("unhandled filter type: " + type);
}
return filter;
}
