&& descriptor.getEndAttribute() == null) { GranuleSource gs = sr.getGranules(name, true); final Query query = new Query(gs.getSchema().getName().getLocalPart()); final PropertyName attribute = FF.property(descriptor.getStartAttribute()); final PropertyIsBetween rangeFilter = FF.between( attribute, FF.literal(range.getMinValue()), FF.literal(range.getMaxValue())); query.setFilter(rangeFilter); query.setMaxFeatures(maxEntries); query.setPropertyNames(new String[] {descriptor.getStartAttribute()}); query.setHints(new Hints(StructuredCoverageViewReader.QUERY_FIRST_BAND, true));
/** * Returns a predicate that evaluates to {@code true} if each of its components evaluates to * {@code true}. * * <p>The components are evaluated in order, and evaluation will be "short-circuited" as soon as * a false predicate is found. */ public static Filter and(Filter... operands) { List<Filter> anded = Lists.newArrayList(operands); return factory.and(anded); }
@Before public void setUp() throws Exception { data = File.createTempFile("retype", "data", new File("./target")); data.delete(); data.mkdir(); final String fileName = MockData.BUILDINGS.getLocalPart() + ".properties"; URL properties = MockData.class.getResource(fileName); IOUtils.copy(properties.openStream(), new File(data, fileName)); PropertyDataStore pds = new PropertyDataStore(data); rts = new RetypingDataStore(pds) { @Override protected String transformFeatureTypeName(String originalName) { if (originalName.equals(MockData.BUILDINGS.getLocalPart())) return RENAMED; else return super.transformFeatureTypeName(originalName); } }; // build a filter that will retrieve one feature only FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); fid = RENAMED + ".1107531701011"; fidFilter = ff.id(Collections.singleton(ff.featureId(fid))); }
public MedianVisitor(int attributeTypeIndex, SimpleFeatureType type) throws IllegalFilterException { FilterFactory factory = CommonFactoryFinder.getFilterFactory(null); expr = factory.property(type.getDescriptor(attributeTypeIndex).getLocalName()); }
@Test public void testFeautureSourceFidFilter() throws Exception { // grab the last feature in the collection (there are more than one) SimpleFeatureSource fs = rts.getFeatureSource(RENAMED); // build a filter that will retrieve that feature only FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); final String fid = RENAMED + ".1107531701011"; Filter fidFilter = ff.id(Collections.singleton(ff.featureId(fid))); SimpleFeatureCollection fc = fs.getFeatures(new Query(RENAMED, fidFilter)); assertEquals(RENAMED, fc.getSchema().getName().getLocalPart()); assertEquals(1, fc.size()); FeatureIterator<SimpleFeature> it = fc.features(); assertTrue(it.hasNext()); SimpleFeature sf = it.next(); assertFalse(it.hasNext()); it.close(); assertEquals(fid, sf.getID()); }
void doTestSimpleJoinWithLimitOffset(boolean exposePrimaryKeys) throws Exception { dataStore.setExposePrimaryKeyColumns(exposePrimaryKeys); FilterFactory ff = dataStore.getFilterFactory(); Filter j = ff.equal(ff.property(aname("stringProperty")), ff.property(aname("name")), true); Query q = new Query(tname("ft1")); q.getJoins().add(new Join(tname("ftjoin"), j)); q.setFilter(ff.greater(ff.property(aname("intProperty")), ff.literal(0))); q.setStartIndex(1); q.setSortBy(new SortBy[] {ff.sort(aname("intProperty"), SortOrder.ASCENDING)}); SimpleFeatureCollection features = dataStore.getFeatureSource(tname("ft1")).getFeatures(q); assertEquals(1, features.size()); try (SimpleFeatureIterator it = features.features()) { assertTrue(it.hasNext()); SimpleFeature f = it.next(); assertEquals("two", f.getAttribute(aname("stringProperty"))); SimpleFeature g = (SimpleFeature) f.getAttribute(aname("ftjoin")); assertEquals("two", g.getAttribute(aname("name"))); } }
public void testOutsideWorld() throws Exception { if (!isGeographySupportAvailable()) { return; } FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); BBOX bbox = ff.bbox("", -300, -40, -200, 40, "EPSG:4326"); // should select everything without bombing out Query q = new Query(tname("geopoint")); q.setFilter(bbox); try (FeatureReader r = dataStore.getFeatureReader(q, Transaction.AUTO_COMMIT)) { assertFalse(r.hasNext()); } }
public void testGetFeaturesWithQuery() throws Exception { FilterFactory ff = dataStore.getFilterFactory(); PropertyIsEqualTo filter = ff.equals(ff.property(aname("stringProperty")), ff.literal("one")); Query query = new Query(); query.setPropertyNames(new String[] {aname("doubleProperty"), aname("intProperty")}); query.setFilter(filter); SimpleFeatureCollection features = featureSource.getFeatures(query); assertEquals(1, features.size()); try (SimpleFeatureIterator iterator = features.features()) { assertTrue(iterator.hasNext()); SimpleFeature feature = (SimpleFeature) iterator.next(); assertEquals(2, feature.getAttributeCount()); assertEquals(new Double(1.1), feature.getAttribute(aname("doubleProperty"))); assertNotNull(feature.getAttribute(aname("intProperty"))); } }
public void testGetFeaturesWithLogicFilter() throws Exception { FilterFactory ff = dataStore.getFilterFactory(); PropertyIsEqualTo property = ff.equals(ff.property(aname("stringProperty")), ff.literal("one")); BBOX bbox = ff.bbox(aname("geometry"), -20, -20, 20, 20, "EPSG:4326"); And filter = ff.and(property, bbox); SimpleFeatureCollection features = featureSource.getFeatures(filter); assertEquals(1, features.size()); try (SimpleFeatureIterator iterator = features.features()) { assertTrue(iterator.hasNext()); SimpleFeature feature = (SimpleFeature) iterator.next(); assertEquals("one", feature.getAttribute(aname("stringProperty"))); assertEquals(new Double(1.1), feature.getAttribute(aname("doubleProperty"))); } }
void doTestSimpleJoinWithSort(boolean exposePrimaryKeys) throws Exception { dataStore.setExposePrimaryKeyColumns(exposePrimaryKeys); FilterFactory ff = dataStore.getFilterFactory(); Filter j = ff.equal(ff.property(aname("stringProperty")), ff.property(aname("name")), true); Query q = new Query(tname("ft1")); q.getJoins().add(new Join(tname("ftjoin"), j)); q.setSortBy(new SortBy[] {ff.sort(aname("intProperty"), SortOrder.DESCENDING)}); SimpleFeatureCollection features = dataStore.getFeatureSource(tname("ft1")).getFeatures(q); try (SimpleFeatureIterator it = features.features()) { assertTrue(it.hasNext()); assertEquals("two", it.next().getAttribute(aname("stringProperty"))); assertTrue(it.hasNext()); assertEquals("one", it.next().getAttribute(aname("stringProperty"))); assertTrue(it.hasNext()); assertEquals("zero", it.next().getAttribute(aname("stringProperty"))); } }
public void testBetweenNegation() throws Exception { Not filter = ff.not( ff.between( ff.property(aname(B)), ff.property(aname(A)), ff.property(aname(C)))); ContentFeatureSource fs = dataStore.getFeatureSource(tname(ABC)); Query q = new Query(tname(ABC), filter); int count = fs.getCount(q); assertEquals(1, count); SimpleFeature f = DataUtilities.first(fs.getFeatures(q)); assertEquals("n_n_n", f.getAttribute(aname(NAME))); }
public void testGetFeaturesWithFilter() throws Exception { FilterFactory ff = dataStore.getFilterFactory(); PropertyIsEqualTo filter = ff.equals(ff.property(aname("stringProperty")), ff.literal("one")); SimpleFeatureCollection features = featureSource.getFeatures(filter); assertEquals(1, features.size()); try (SimpleFeatureIterator iterator = features.features()) { assertTrue(iterator.hasNext()); SimpleFeature feature = (SimpleFeature) iterator.next(); assertEquals("one", feature.getAttribute(aname("stringProperty"))); assertEquals(new Double(1.1), feature.getAttribute(aname("doubleProperty"))); } }
public void testGeometryFactoryHint() throws Exception { FilterFactory ff = dataStore.getFilterFactory(); PropertyIsEqualTo filter = ff.equals(ff.property(aname("stringProperty")), ff.literal("one")); Query query = new Query(); query.setFilter(filter); // check we're respecting the geometry factory hint GeometryFactory gf1 = new GeometryFactory(); query.setHints(new Hints(Hints.JTS_GEOMETRY_FACTORY, gf1)); SimpleFeature f1 = DataUtilities.first(featureSource.getFeatures(query)); assertSame(gf1, ((Geometry) f1.getDefaultGeometry()).getFactory()); // check we're respecting the geometry factory when changing it GeometryFactory gf2 = new GeometryFactory(); query.setHints(new Hints(Hints.JTS_GEOMETRY_FACTORY, gf2)); SimpleFeature f2 = DataUtilities.first(featureSource.getFeatures(query)); assertSame(gf2, ((Geometry) f2.getDefaultGeometry()).getFactory()); }
assertEquals(BRIDGES.getLocalPart(), rs.getTypeNames()[0]); FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); String fid = BRIDGES.getLocalPart() + ".1107531701011"; Filter fidFilter = ff.id(Collections.singleton(ff.featureId(fid))); SimpleFeatureIterator it = retyped.getFeatures(fidFilter).features(); assertTrue(it.hasNext()); SimpleFeature f = it.next(); assertEquals("114", f.getAttribute("FID")); assertEquals("215 Main Street", f.getAttribute("ADDRESS"));
public void testGetFeatureInvalidFilter() throws Exception { FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); PropertyIsEqualTo f = ff.equals(ff.property("invalidAttribute"), ff.literal(5)); Query q = new Query(tname("river")); q.setPropertyNames(new String[] {aname("geom")}); q.setFilter(f); // make sure a complaint related to the invalid filter is thrown here try (FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(q, Transaction.AUTO_COMMIT)) { fail("This query should have failed, it contains an invalid filter"); } catch (Exception e) { // good, it's supposed to fail } }
LineSymbolizer ls = styleFactory.createLineSymbolizer(); ls.setStroke( styleFactory.createStroke( filterFactory.literal(color), filterFactory.literal(2))); PolygonSymbolizer ps = styleFactory.createPolygonSymbolizer(); ps.setFill(styleFactory.createFill(filterFactory.literal(color))); } else { Mark mark = styleFactory.createMark(); mark.setFill(styleFactory.createFill(filterFactory.literal(color))); PointSymbolizer ps = styleFactory.createPointSymbolizer();