Examples of org.lilyproject.repository.api.filter.FieldValueFilter

Package org.lilyproject.repository.api.filter

Examples of org.lilyproject.repository.api.filter.FieldValueFilter

org.lilyproject.repository.api.filter.FieldValueFilter
Filters based on the value of a record field.
Only equals and not-equals comparisons are possible. This is because the comparison happens inside the HBase region servers, on the bytes-encoded field values.

For versioned fields, the filtering always happens based on the last version of the field values.


    @Override
    public FieldValueFilter fromJson(JsonNode node, Namespaces namespaces, LRepository repository,
            RecordFilterJsonConverter<RecordFilter> converter)
            throws JsonFormatException, RepositoryException, InterruptedException {
        FieldValueFilter filter = new FieldValueFilter();


        String field = JsonUtil.getString(node, "field", null);
        JsonNode fieldValue = node.get("fieldValue");


        // field and fieldValue should be specified both, or not at all, for deserialization to work
        if ((field != null || fieldValue != null) && (field == null || fieldValue == null)) {
            throw new RuntimeException("FieldValueFilter deserialization: both field and fieldValue must be specified.");
        }


        if (field != null && fieldValue != null) {
            QName fieldQName = QNameConverter.fromJson(field, namespaces);
            filter.setField(fieldQName);
            ValueType valueType = repository.getTypeManager().getFieldTypeByName(fieldQName).getValueType();
            Object value = RecordReader.INSTANCE.readValue(
                    new RecordReader.ValueHandle(fieldValue, "fieldValue", valueType),
                    new RecordReader.ReadContext(repository, new NamespacesImpl(), defaultLinkTransformer));
            filter.setFieldValue(value);
        }


        String compareOp = JsonUtil.getString(node, "compareOp", null);
        if (compareOp != null) {
            filter.setCompareOp(CompareOp.valueOf(compareOp));
        }




        filter.setFilterIfMissing(JsonUtil.getBoolean(node, "filterIfMissing", filter.getFilterIfMissing()));


        return filter;
    }

View Full Code Here


        if (!(uncastFilter instanceof FieldValueFilter)) {
            return null;
        }


        FieldValueFilter filter = (FieldValueFilter)uncastFilter;


        if (filter.getField() == null) {
            throw new IllegalArgumentException("Field name should be specified in FieldValueFilter");
        }


        if (filter.getFieldValue() == null) {
            throw new IllegalArgumentException("Field value should be specified in FieldValueFilter");
        }


        CompareOp compareOp = filter.getCompareOp() != null ? filter.getCompareOp() : CompareOp.EQUAL;
        if (compareOp != CompareOp.EQUAL && compareOp != CompareOp.NOT_EQUAL) {
            throw new IllegalArgumentException("FieldValueFilter does not support this compare operator: " + compareOp);
        }


        FieldType fieldType = repository.getTypeManager().getFieldTypeByName(filter.getField());
        DataOutput dataOutput = new DataOutputImpl();
        fieldType.getValueType().write(filter.getFieldValue(), dataOutput, new IdentityRecordStack());
        byte[] fieldValue = dataOutput.toByteArray();


        LilyFieldSingleColumnValueFilter hbaseFilter = new LilyFieldSingleColumnValueFilter(RecordCf.DATA.bytes,
                ((FieldTypeImpl)fieldType).getQualifier(), HBaseRecordFilterUtil.translateCompareOp(compareOp), fieldValue);
        hbaseFilter.setFilterIfMissing(filter.getFilterIfMissing());


        return hbaseFilter;
    }

View Full Code Here

        repository.recordBuilder().recordType(rt.getName()).field(fieldType.getName(), "value2").create();
        repository.recordBuilder().recordType(rt.getName()).field(fieldType.getName(), "value2").create();
        repository.recordBuilder().recordType(rt.getName()).field(fieldType.getName(), "value2").create();


        RecordScan scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(fieldType.getName(), "value1"));
        assertEquals(2, countResults(repository.getScanner(scan)));


        scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(fieldType.getName(), "value2"));
        assertEquals(3, countResults(repository.getScanner(scan)));


        scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(fieldType.getName(), CompareOp.NOT_EQUAL, "value1"));
        assertEquals(3, countResults(repository.getScanner(scan)));


        // (At the time of this writing, ...) when non-versioned fields are deleted, a delete marker is
        // written rather than really deleting the field. This delete marker would then also be 'not equal'
        // to the value we search, and we'd get an extra result. This test verifies the implementation takes
        // care of that.
        record.getFieldsToDelete().add(fieldType.getName());
        record.setField(fieldType1.getName(), "whatever");
        record = repository.update(record);


        scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(fieldType.getName(), CompareOp.NOT_EQUAL, "value1"));
        assertEquals(3, countResults(repository.getScanner(scan)));
    }

View Full Code Here

                .create();


        // Test f1=A and f2=B
        RecordScan scan = new RecordScan();
        RecordFilterList filterList = new RecordFilterList();
        filterList.addFilter(new FieldValueFilter(f1.getName(), "A"));
        filterList.addFilter(new FieldValueFilter(f2.getName(), "B"));
        scan.setRecordFilter(filterList);
        assertEquals(1, countResults(repository.getScanner(scan)));


        // Test f1=A or f2=B
        scan = new RecordScan();
        filterList = new RecordFilterList(RecordFilterList.Operator.MUST_PASS_ONE);
        filterList.addFilter(new FieldValueFilter(f1.getName(), "A"));
        filterList.addFilter(new FieldValueFilter(f2.getName(), "B"));
        scan.setRecordFilter(filterList);
        assertEquals(3, countResults(repository.getScanner(scan)));


        // Test f1=A and (f2=B or f2=C)
        scan = new RecordScan();
        RecordFilterList filterList2 = new RecordFilterList(RecordFilterList.Operator.MUST_PASS_ONE);
        filterList2.addFilter(new FieldValueFilter(f2.getName(), "B"));
        filterList2.addFilter(new FieldValueFilter(f2.getName(), "C"));
        filterList = new RecordFilterList();
        filterList.addFilter(new FieldValueFilter(f1.getName(), "A"));
        filterList.addFilter(filterList2);
        scan.setRecordFilter(filterList);
        assertEquals(2, countResults(repository.getScanner(scan)));


        // Test f1=F and f2=Z
        scan = new RecordScan();
        filterList = new RecordFilterList();
        filterList.addFilter(new FieldValueFilter(f1.getName(), "F"));
        filterList.addFilter(new FieldValueFilter(f2.getName(), "Z"));
        scan.setRecordFilter(filterList);
        assertEquals(0, countResults(repository.getScanner(scan)));


        // Test f1=F and (f2=Z with filterIfMissing=false)
        scan = new RecordScan();
        filterList = new RecordFilterList();
        filterList.addFilter(new FieldValueFilter(f1.getName(), "F"));
        FieldValueFilter fvf = new FieldValueFilter(f2.getName(), "Z");
        fvf.setFilterIfMissing(false);
        filterList.addFilter(fvf);
        scan.setRecordFilter(filterList);
        assertEquals(1, countResults(repository.getScanner(scan)));
    }

View Full Code Here


        // Test scanning on filtered field, should not work
        scan = new RecordScan();
        RecordFilterList filterList = new RecordFilterList();
        filterList.addFilter(new RecordTypeFilter(rt.getName()));
        filterList.addFilter(new FieldValueFilter(f1.getName(), "A"));
        scan.setRecordFilter(filterList);
        // without ReturnFields, we get a result
        assertNotNull(repository.getScanner(scan).next());
        // with ReturnFields that doesn't include f1, we don't get a result
        scan.setReturnFields(new ReturnFields(f2.getName()));

View Full Code Here

        record.setField(fieldType1.getName(), "stop drinking coke");
        record.setMetadata(fieldType1.getName(), new MetadataBuilder().value("field1", "foobar").build());
        repository.create(record);


        RecordScan scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(fieldType1.getName(), "stop drinking coke"));
        assertEquals(1, countResults(repository.getScanner(scan)));
    }

View Full Code Here

    public void testScanFieldValueFilter() throws Exception {
        QName name = new QName("ns", "stringField");
        Object value = "foo";


        RecordScan scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(name, value));


        byte[] data = scanToBytes(scan);
        RecordScan parsedScan = scanFromBytes(data);


        assertNotNull(parsedScan.getRecordFilter());
        assertTrue(parsedScan.getRecordFilter() instanceof FieldValueFilter);
        FieldValueFilter filter = (FieldValueFilter) parsedScan.getRecordFilter();
        assertEquals(name, filter.getField());
        assertEquals(value, filter.getFieldValue());
        assertTrue(filter.getFilterIfMissing());


        // Check json structure
        JsonNode node = new ObjectMapper().readTree(data);
        assertEquals("org.lilyproject.repository.api.filter.FieldValueFilter",
                node.get("recordFilter").get("@class").getTextValue());
        assertEquals("foo", node.get("recordFilter").get("fieldValue").getTextValue());


        // Try different data types as field value
        value = 3L;
        scan.setRecordFilter(new FieldValueFilter(new QName("ns", "longField"), value));
        assertEquals(value, ((FieldValueFilter) scanFromBytes(scanToBytes(scan))
                .getRecordFilter()).getFieldValue());


        value = Lists.newArrayList("foo", "bar");
        scan.setRecordFilter(new FieldValueFilter(new QName("ns", "stringListField"), value));
        assertEquals(value, ((FieldValueFilter) scanFromBytes(scanToBytes(scan))
                .getRecordFilter()).getFieldValue());


        // The following test made more sense when we were using a generic type-detection
        // in the json serialization rather than using TypeManager.
        // Use a list as field value, but with a mixture of datatypes. This should fail,
        // as lists in Lily should contain values of the same type.
        value = Lists.newArrayList("foo", 123L);
        scan.setRecordFilter(new FieldValueFilter(new QName("ns", "stringListField"), value));
        try {
            data = scanToBytes(scan);
            fail("Expected exception with list containing different data types");
        } catch (Exception e) {
            // expected

View Full Code Here

    public void testScanNamespaces() throws Exception {
        QName name = new QName("ns", "stringField");
        Object value = "foo";


        RecordScan scan = new RecordScan();
        scan.setRecordFilter(new FieldValueFilter(name, value));


        // Test serialization without namespace prefixes
        byte[] data = scanToBytes(scan);


        JsonNode node = new ObjectMapper().readTree(data);

View Full Code Here

TOP

Related Classes of org.lilyproject.repository.api.filter.FieldValueFilter

org.lilyproject.repository.impl.filter.HBaseFieldValueFilter

org.lilyproject.repository.impl.test.AbstractRepositoryTest

org.lilyproject.tools.import_.json.filters.FieldValueFilterJson

org.lilyproject.tools.import_.json.test.JsonConversionTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.