Refine search
private InternalScanner buildScanner(String keyPrefix, String value, HRegion r) throws IOException { // Defaults FilterList.Operator.MUST_PASS_ALL. FilterList allFilters = new FilterList(); allFilters.addFilter(new PrefixFilter(Bytes.toBytes(keyPrefix))); // Only return rows where this column value exists in the row. SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("trans-tags"), Bytes.toBytes("qual2"), CompareOp.EQUAL, Bytes.toBytes(value)); filter.setFilterIfMissing(true); allFilters.addFilter(filter); Scan scan = new Scan(); scan.addFamily(Bytes.toBytes("trans-blob")); scan.addFamily(Bytes.toBytes("trans-type")); scan.addFamily(Bytes.toBytes("trans-date")); scan.addFamily(Bytes.toBytes("trans-tags")); scan.addFamily(Bytes.toBytes("trans-group")); scan.setFilter(allFilters); return r.getScanner(scan); }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6, "Expected 4 or 6 but got: %s", filterArguments.size()); byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(2)); org.apache.hadoop.hbase.filter.ByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(3))); if (comparator instanceof RegexStringComparator || comparator instanceof SubstringComparator) { if (op != CompareOperator.EQUAL && op != CompareOperator.NOT_EQUAL) { throw new IllegalArgumentException ("A regexstring comparator and substring comparator " + "can only be used with EQUAL and NOT_EQUAL"); } } SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier, op, comparator); if (filterArguments.size() == 6) { boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4)); boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5)); filter.setFilterIfMissing(filterIfMissing); filter.setLatestVersionOnly(latestVersionOnly); } return filter; }
} break; case FilterList: this.op = ((FilterList)filter).getOperator().toString(); this.filters = new ArrayList<>(); for (Filter child: ((FilterList)filter).getFilters()) { this.filters.add(new FilterModel(child)); case SingleColumnValueFilter: { SingleColumnValueFilter scvf = (SingleColumnValueFilter) filter; this.family = Bytes.toString(Base64.getEncoder().encode(scvf.getFamily())); byte[] qualifier = scvf.getQualifier(); if (qualifier != null) { this.qualifier = Bytes.toString(Base64.getEncoder().encode(qualifier)); this.op = scvf.getOperator().toString(); this.comparator = new ByteArrayComparableModel(scvf.getComparator()); if (scvf.getFilterIfMissing()) { this.ifMissing = true; if (scvf.getLatestVersionOnly()) { this.latestVersion = true;
@Override public int hashCode() { return Objects.hash(Bytes.hashCode(getFamily()), Bytes.hashCode(getQualifier()), this.op, getComparator(), getFilterIfMissing(), getLatestVersionOnly()); } }
/** * @return true if and only if the fields of the filter that are serialized * are equal to the corresponding fields in other. Used for testing. */ @Override boolean areSerializedFieldsEqual(Filter o) { if (o == this) return true; if (!(o instanceof SingleColumnValueFilter)) return false; SingleColumnValueFilter other = (SingleColumnValueFilter)o; return Bytes.equals(this.getFamily(), other.getFamily()) && Bytes.equals(this.getQualifier(), other.getQualifier()) && this.op.equals(other.op) && this.getComparator().areSerializedFieldsEqual(other.getComparator()) && this.getFilterIfMissing() == other.getFilterIfMissing() && this.getLatestVersionOnly() == other.getLatestVersionOnly(); }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { SingleColumnValueFilter tempFilter = (SingleColumnValueFilter) SingleColumnValueFilter.createFilterFromArguments(filterArguments); SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter ( tempFilter.getFamily(), tempFilter.getQualifier(), tempFilter.getOperator(), tempFilter.getComparator()); if (filterArguments.size() == 6) { filter.setFilterIfMissing(tempFilter.getFilterIfMissing()); filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly()); } return filter; }
+ 1; byte[] startRow = ByteUtil.join(Constants.SEP_BYTES, Bytes.toBytes(cluster), Bytes.toBytes(topDayEndTime)); byte[] endRow = ByteUtil.join(Constants.SEP_BYTES, Bytes.toBytes(cluster), Bytes.toBytes(topDayStartTime)); Scan scan = new Scan(); ByteUtil.join(Constants.SEP_BYTES, startRow, Bytes.toBytes(user)); endRow = ByteUtil.join(Constants.SEP_BYTES, endRow, Bytes.toBytes(user)); FilterList filters = new FilterList(FilterList.Operator.MUST_PASS_ALL); filters.addFilter(new SingleColumnValueFilter(Constants.INFO_FAM_BYTES, AggregationConstants.USER_BYTES, CompareFilter.CompareOp.EQUAL, Bytes.toBytes(user))); scan.setFilter(filters); scan.setStartRow(startRow); scan.setStopRow(endRow); LOG.info(" scan is " + scan.toJSON()); byte[] rowKey = result.getRow(); AppAggregationKey appAggKey = aggConv.fromBytes(rowKey); AppKey ak = new AppKey(cluster, appAggKey.getUserName(), } finally { if (scanner != null) { scanner.close();
byte [][] values = new byte[10][]; for (int i = 0; i < 10; i ++) { values[i] = Bytes.toBytes(100L * i); ht.put(put); Scan scan = new Scan(); scan.addFamily(FAMILY); Filter filter = new SingleColumnValueFilter(FAMILY, QUALIFIER, CompareOperator.GREATER, new LongComparator(500)); scan.setFilter(filter); ResultScanner scanner = ht.getScanner(scan); int expectedIndex = 0; for(Result result : ht.getScanner(scan)) { assertEquals(1, result.size()); assertTrue(Bytes.toLong(result.getValue(FAMILY, QUALIFIER)) > 500); expectedIndex++; scanner.close();
Table table = connection.getTable(TableName.valueOf("testtable")); Put put = new Put(Bytes.toBytes("row-5")) .addColumn(Bytes.toBytes("colfam1"), Bytes.toBytes("col-6"), Bytes.toBytes("val-6")); table.put(put); SingleColumnValueFilter filter = new SingleColumnValueFilter( Bytes.toBytes("colfam1"), Bytes.toBytes("col-6"), CompareFilter.CompareOp.NOT_EQUAL, new NullComparator()); filter.setFilterIfMissing(true); SingleColumnValueFilter filter2 = new SingleColumnValueFilter( Bytes.toBytes("colfam1"), Bytes.toBytes("col-3"), CompareFilter.CompareOp.NOT_EQUAL, new NullComparator()); filter2.setFilterIfMissing(true); FilterList list = new FilterList(); list.addFilter(filter); list.addFilter(filter2); Scan scan = new Scan(); scan.setFilter(list); for (Cell cell : result.rawCells()) { System.out.println("Cell: " + cell + ", Value: " + Bytes.toString(cell.getValueArray(), cell.getValueOffset(), scanner.close();
private TableViewFinder findChildViews_4_11(Region region, byte[] tenantId, byte[] schemaName, byte[] tableName, boolean stopAfterFirst) throws IOException { Scan scan = new Scan(); byte[] startRow = SchemaUtil.getTableKey(tenantId, schemaName, tableName); byte[] stopRow = ByteUtil.nextKey(startRow); scan.setStartRow(startRow); scan.setStopRow(stopRow); SingleColumnValueFilter linkFilter = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, LINK_TYPE_BYTES, CompareOp.EQUAL, CHILD_TABLE_BYTES); Filter filter = linkFilter; linkFilter.setFilterIfMissing(true); if (stopAfterFirst) { filter = new FilterList(linkFilter, new PageFilter(1)); scan.setFilter(filter); List<ViewInfo> viewInfoList = Lists.newArrayList(); try (ResultScanner scanner = hTable.getScanner(scan)) { for (Result result = scanner.next(); (result != null); result = scanner.next()) { numOfChildViews++; ImmutableBytesWritable ptr = new ImmutableBytesWritable(); getVarChars(result.getRow(), 5, rowViewKeyMetaData); byte[] viewTenantId = rowViewKeyMetaData[PhoenixDatabaseMetaData.COLUMN_NAME_INDEX]; byte[] viewSchemaName = SchemaUtil.getSchemaNameFromFullName(rowViewKeyMetaData[PhoenixDatabaseMetaData.FAMILY_NAME_INDEX]).getBytes();
protected Scan constructScan(byte[] valuePrefix) throws IOException { FilterList list = new FilterList(); Filter filter = new SingleColumnValueFilter(FAMILY_ZERO, COLUMN_ZERO, CompareOperator.EQUAL, new BinaryComparator(valuePrefix)); list.addFilter(filter); if (opts.filterAll) { list.addFilter(new FilterAllFilter()); } Scan scan = new Scan().setCaching(opts.caching).setCacheBlocks(opts.cacheBlocks) .setAsyncPrefetch(opts.asyncPrefetch).setReadType(opts.scanReadType) .setScanMetricsEnabled(true); if (opts.addColumns) { for (int column = 0; column < opts.columns; column++) { byte [] qualifier = column == 0? COLUMN_ZERO: Bytes.toBytes("" + column); scan.addColumn(FAMILY_ZERO, qualifier); } } else { scan.addFamily(FAMILY_ZERO); } scan.setFilter(list); return scan; } }
public static int doScan(HTable table, int val) throws IOException, InterruptedException { Scan s = new Scan(); byte[] start = {}; byte[] stop = {}; byte[] value = Bytes.toBytes(String.format("%010d", val)); s.setStartRow(start); s.setStopRow(stop); SingleColumnValueFilter filter = new SingleColumnValueFilter( Bytes.toBytes("f1"), Bytes.toBytes("qual"), CompareOp.EQUAL, value); s.setFilter(filter); ResultScanner rs = table.getScanner(s); for (Result r : rs) { if (r.getRow() == null) { continue; byte[]>>> columnFamilyMap = r.getMap(); String k = Bytes.toStringBinary(r.getRow()); if (mm.get(k).size() >= 1) { System.out.println("Duplicate rowkey " + k);
public String[] getObjectIDs(String objectType, String... tags) throws IOException { List<String> ret = new ArrayList<String>(); FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ALL); SingleColumnValueFilter filter1 = new SingleColumnValueFilter("tags".getBytes(), "OBJECTTYPE".getBytes(), CompareOp.EQUAL, Bytes.toBytes(objectType)); list.addFilter(filter1); SingleColumnValueFilter filter2 = new SingleColumnValueFilter("tags".getBytes(), tag.toUpperCase() .getBytes(), CompareOp.EQUAL, Bytes.toBytes(1)); filter2.setFilterIfMissing(true); list.addFilter(filter2); Scan s = new Scan(); s.setFilter(list); s.setMaxVersions(1); ResultScanner scanner = htable.getScanner(s); try { for (Result rr = scanner.next(); rr != null; rr = scanner.next()) { String localObjectType = new String(rr.getValue("tags".getBytes(), "OBJECTTYPE".getBytes())); String localObjectId = new String(rr.getValue("tags".getBytes(), "OBJECTID".getBytes())); ret.add(localObjectId); scanner.close();
int kv_number = 0; try { Scan scan = new Scan(); scan.setBatch(2); SingleColumnValueFilter filter = new SingleColumnValueFilter( Bytes.toBytes(columnFamily), Bytes.toBytes("c5"), CompareOperator .EQUAL, new SubstringComparator("2_c5")); scan.setFilter(filter); Table table = openTable(tableName); ResultScanner scanner = table.getScanner(scan); for (Cell kv : result.listCells()) { kv_number++; LOG.debug(kv_number + ". kv: " + kv); scanner.close(); table.close(); } catch (Exception e) {
@Test(expected = DoNotRetryIOException.class) public void testWithReverseScan() throws Exception { try (Connection con = TEST_UTIL.getConnection(); Admin admin = con.getAdmin()) { TableName tableName = TableName.valueOf(name.getMethodName()); TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(tableName) .setColumnFamily(ColumnFamilyDescriptorBuilder.of("cf1")) .setColumnFamily(ColumnFamilyDescriptorBuilder.of("cf2")) .build(); admin.createTable(tableDescriptor); try (Table table = con.getTable(tableName)) { SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("cf1"), Bytes.toBytes("col"), CompareOperator.EQUAL, Bytes.toBytes("val")); filter.setFilterIfMissing(true); // Reverse scan with loading CFs on demand Scan scan = new Scan(); scan.setFilter(filter); scan.setReversed(true); scan.setLoadColumnFamiliesOnDemand(true); try (ResultScanner scanner = table.getScanner(scan)) { // DoNotRetryIOException should occur scanner.next(); } } } } }
private void runScanner(Table table, boolean slow) throws Exception { long time = System.nanoTime(); Scan scan = new Scan(); scan.addColumn(cf_essential, col_name); scan.addColumn(cf_joined, col_name); SingleColumnValueFilter filter = new SingleColumnValueFilter( cf_essential, col_name, CompareFilter.CompareOp.EQUAL, flag_yes); filter.setFilterIfMissing(true); scan.setFilter(filter); scan.setLoadColumnFamiliesOnDemand(!slow); ResultScanner result_scanner = table.getScanner(scan); Result res; long rows_count = 0; while ((res = result_scanner.next()) != null) { rows_count++; } double timeSec = (System.nanoTime() - time) / 1000000000.0; result_scanner.close(); LOG.info((slow ? "Slow" : "Joined") + " scanner finished in " + Double.toString(timeSec) + " seconds, got " + Long.toString(rows_count/2) + " rows"); }
Scan scan = new Scan(); InternalScanner scanner = region.getScanner(scan); verifyCountAndOrder(scanner, ROWSIZE * QUALSIZE * 2, ROWSIZE, true); scan.setReversed(true); scanner = region.getScanner(scan); verifyCountAndOrder(scanner, ROWSIZE * QUALSIZE * 2, ROWSIZE, false); scan = new Scan(); scan.setReversed(true); scan.addFamily(FAMILYNAME); Filter filter = new SingleColumnValueFilter(FAMILYNAME, specifiedQualifiers[0], CompareOp.EQUAL, VALUES[valueNum]); scan.setFilter(filter); SingleColumnValueFilter scvFilter1 = new SingleColumnValueFilter( FAMILYNAME, specifiedQualifiers[0], CompareOp.EQUAL, VALUES[0]); SingleColumnValueFilter scvFilter2 = new SingleColumnValueFilter( FAMILYNAME, specifiedQualifiers[0], CompareOp.EQUAL, VALUES[1]); expectedRowNum = 0; filter = new FilterList(Operator.MUST_PASS_ONE, scvFilter1, scvFilter2); scan.setFilter(filter); scanner = region.getScanner(scan);
Scan scan = new Scan(); scan.addColumn(COLUMN_FAMILY, qualifier1); scan.setRowPrefixFilter(Bytes.toBytes("scvfnees")); ByteArrayComparable emptyStringValueComparable = new BinaryComparator(emptyStringValue); SingleColumnValueFilter filter = new SingleColumnValueFilter(COLUMN_FAMILY, qualifier2, CompareOp.NOT_EQUAL, emptyStringValueComparable); scan.setFilter(filter); results = table.getScanner(scan).next(10); Assert.assertEquals(1, results.length); Assert.assertArrayEquals(rowKey1, results[0].getRow());
PhoenixConnection conn = null; try { Scan scan = new Scan(); SingleColumnValueFilter filter = new SingleColumnValueFilter(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.INDEX_DISABLE_TIMESTAMP_BYTES, CompareFilter.CompareOp.NOT_EQUAL, PLong.INSTANCE.toBytes(0L)); filter.setFilterIfMissing(true); scan.setFilter(filter); scan.addColumn(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.TABLE_NAME_BYTES); scan.addColumn(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, Result r = Result.create(results); byte[] disabledTimeStamp = r.getValue(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.INDEX_DISABLE_TIMESTAMP_BYTES); Cell indexStateCell = r.getColumnLatestCell(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.INDEX_STATE_BYTES);
Scan scan = MetaDataUtil.newTableRowsScan(key, MetaDataProtocol.MIN_TABLE_TIMESTAMP, timestamp); SingleColumnValueFilter linkFilter = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, LINK_TYPE_BYTES, CompareFilter.CompareOp.EQUAL, linkType.getSerializedValueAsByteArray()); linkFilter.setFilterIfMissing(true); scan.setFilter(linkFilter); scan.addColumn(TABLE_FAMILY_BYTES, LINK_TYPE_BYTES); if (linkType==PTable.LinkType.PARENT_TABLE) scan.addColumn(TABLE_FAMILY_BYTES, PARENT_TENANT_ID_BYTES); if (linkType==PTable.LinkType.PHYSICAL_TABLE) scan.addColumn(TABLE_FAMILY_BYTES, TABLE_TYPE_BYTES); List<TableInfo> tableInfoList = Lists.newArrayList(); try (ResultScanner scanner = systemCatalog.getScanner(scan)) { for (Result result = scanner.next(); (result != null); result = scanner.next()) { byte[][] rowKeyMetaData = new byte[5][]; byte[] viewTenantId = null; getVarChars(result.getRow(), 5, rowKeyMetaData); if (linkType==PTable.LinkType.PARENT_TABLE) { viewTenantId = result.getValue(TABLE_FAMILY_BYTES, PARENT_TENANT_ID_BYTES); } else if (linkType==PTable.LinkType.CHILD_TABLE) { viewTenantId = rowKeyMetaData[PhoenixDatabaseMetaData.COLUMN_NAME_INDEX]; viewTenantId = rowKeyMetaData[PhoenixDatabaseMetaData.TENANT_ID_INDEX]; else if (linkType==PTable.LinkType.PHYSICAL_TABLE && result.getValue(TABLE_FAMILY_BYTES, TABLE_TYPE_BYTES)!=null) {