public Filter getScanFilter() { SingleColumnValueFilter scf = new SingleColumnValueFilter(ESSENTIAL_CF, FILTER_COLUMN, CompareOperator.EQUAL, Bytes.toBytes(ACCEPTED_VALUE)); scf.setFilterIfMissing(true); return scf; } }
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; }
CompareOperator.valueOf(op), comparator.build()); if (ifMissing != null) { ((SingleColumnValueFilter)filter).setFilterIfMissing(ifMissing);
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); }
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"); }
private ResultScanner buildScanner(String keyPrefix, String value, Table ht) throws IOException { // OurFilterList allFilters = new OurFilterList(); FilterList allFilters = new FilterList(/* FilterList.Operator.MUST_PASS_ALL */); allFilters.addFilter(new PrefixFilter(Bytes.toBytes(keyPrefix))); SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes .toBytes("trans-tags"), Bytes.toBytes("qual2"), CompareOperator.EQUAL, Bytes .toBytes(value)); filter.setFilterIfMissing(true); allFilters.addFilter(filter); // allFilters.addFilter(new // RowExcludingSingleColumnValueFilter(Bytes.toBytes("trans-tags"), // Bytes.toBytes("qual2"), CompareOp.EQUAL, Bytes.toBytes(value))); 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 ht.getScanner(scan); }
((SingleColumnValueFilter) scanFilter).setFilterIfMissing(true);
@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(); } } } } }
scvf.setFilterIfMissing(true); s = new Scan(ROWS_THREE[0], Bytes.toBytes("rowThree-4")); s.addFamily(FAMILIES[0]); scvf.setFilterIfMissing(true); s = new Scan(ROWS_THREE[0], Bytes.toBytes("rowThree-4")); s.addFamily(FAMILIES[0]); scvf.setFilterIfMissing(true); s = new Scan(ROWS_THREE[0], Bytes.toBytes("rowThree-4")); s.addFamily(FAMILIES[0]);
private void nullFilterTests(Filter filter) throws Exception { ((SingleColumnValueFilter) filter).setFilterIfMissing(true); KeyValue cell = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, FULLSTRING_1); assertTrue("null1", filter.filterCell(cell) == Filter.ReturnCode.INCLUDE); byte[] buffer = cell.getBuffer(); Cell c = new ByteBufferKeyValue(ByteBuffer.wrap(buffer), 0, buffer.length); assertTrue("null1", filter.filterCell(c) == Filter.ReturnCode.INCLUDE); assertFalse("null1FilterRow", filter.filterRow()); filter.reset(); cell = new KeyValue(ROW, COLUMN_FAMILY, Bytes.toBytes("qual2"), FULLSTRING_2); assertTrue("null2", filter.filterCell(cell) == Filter.ReturnCode.INCLUDE); buffer = cell.getBuffer(); c = new ByteBufferKeyValue(ByteBuffer.wrap(buffer), 0, buffer.length); assertTrue("null2", filter.filterCell(c) == Filter.ReturnCode.INCLUDE); assertTrue("null2FilterRow", filter.filterRow()); }
((SingleColumnValueFilter)filter).setLatestVersionOnly(true); if (!isNullTest) { ((SingleColumnValueFilter)filter).setFilterIfMissing(true);
((SingleColumnValueFilter)filter).setLatestVersionOnly(true); if (!isNullTest) { ((SingleColumnValueFilter)filter).setFilterIfMissing(true);
f1.setFilterIfMissing( true ); Scan s1 = new Scan(); s1.addFamily(FAMILIES[0]); f2.setFilterIfMissing( true ); Scan s2 = new Scan(); s2.addFamily(FAMILIES[0]);
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; }
private static Filter getUserTableAndViewsFilter() { SingleColumnValueFilter tableFilter = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.TABLE_TYPE_BYTES, CompareOp.EQUAL, Bytes.toBytes(PTableType.TABLE.getSerializedValue())); tableFilter.setFilterIfMissing(true); SingleColumnValueFilter viewFilter = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.TABLE_TYPE_BYTES, CompareOp.EQUAL, Bytes.toBytes(PTableType.VIEW.getSerializedValue())); viewFilter.setFilterIfMissing(true); FilterList filter = new FilterList(FilterList.Operator.MUST_PASS_ONE, Arrays.asList(new Filter[] {tableFilter, viewFilter})); return filter; }
@Override public List<Object> findByRelation(String colName, Object colValue, Class entityClazz) { EntityMetadata m = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClazz); String tableName = HBaseUtils.getHTableName(m.getSchema(), m.getTableName()); String columnFamilyName = m.getTableName(); byte[] valueInBytes = HBaseUtils.getBytes(colValue); SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes(columnFamilyName), Bytes.toBytes(colName), CompareOp.EQUAL, valueInBytes); filter.setFilterIfMissing(true); try { return ((HBaseDataHandler) handler).readData(tableName, m, null, null, null, null, getFilterList(filter)); } catch (IOException ex) { log.error("Error during find By Relation, Caused by: .", ex); throw new KunderaException("Error during find By Relation, Caused by: .", ex); } }
CompareFilter.CompareOp.NOT_EQUAL, new SubstringComparator("val-5")); filter.setFilterIfMissing(true);
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);
filter1.setFilterIfMissing(schemaName.length > 0); SingleColumnValueFilter filter2 = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, BASE_TABLE_NAME_BYTES, EQUAL, tableName); filter2.setFilterIfMissing(true); BinaryComparator comparator = new BinaryComparator(ByteUtil.concat(tenantId, QueryConstants.SEPARATOR_BYTE_ARRAY, schemaName, QueryConstants.SEPARATOR_BYTE_ARRAY, tableName)); RowFilter filter3 = new RowFilter(CompareOp.NOT_EQUAL,comparator);
/** * @return true if the given table has at least one child view * @throws IOException */ public static boolean hasChildViews(Table systemCatalog, byte[] tenantId, byte[] schemaName, byte[] tableName, long timestamp) throws IOException { byte[] key = SchemaUtil.getTableKey(tenantId, schemaName, tableName); Scan scan = MetaDataUtil.newTableRowsScan(key, MetaDataProtocol.MIN_TABLE_TIMESTAMP, timestamp); SingleColumnValueFilter linkFilter = new SingleColumnValueFilter(TABLE_FAMILY_BYTES, LINK_TYPE_BYTES, CompareFilter.CompareOp.EQUAL, LinkType.CHILD_TABLE.getSerializedValueAsByteArray()) { // if we found a row with the CHILD_TABLE link type we are done and can // terminate the scan @Override public boolean filterAllRemaining() throws IOException { return matchedColumn; } }; linkFilter.setFilterIfMissing(true); scan.setFilter(linkFilter); scan.addColumn(TABLE_FAMILY_BYTES, LINK_TYPE_BYTES); try (ResultScanner scanner = systemCatalog.getScanner(scan)) { Result result = scanner.next(); return result!=null; } }