return storeDelegate.addFeatures(collection); } else { return storeDelegate.addFeatures(collection); } else { if (collection.getSchema() instanceof SimpleFeatureType + "the attributes one cannot write off complex features. " + "However at this time there is no writable complex feature!"); return storeDelegate.addFeatures(collection);
public void setTransaction(Transaction transaction) { storeDelegate.setTransaction(transaction); }
public void removeFeatures(Filter filter) throws IOException { // are we limiting anything? Query writeQuery = getWriteQuery(policy); if (writeQuery == Query.ALL) { storeDelegate.removeFeatures(filter); } else if (writeQuery.getFilter() == Filter.EXCLUDE || writeQuery.getPropertyNames() == Query.NO_NAMES) { throw unsupportedOperation(); } // get the mixed filter final Query local = new Query(null, filter); Query mixed = mixQueries(local, writeQuery); storeDelegate.removeFeatures(mixed.getFilter()); }
static void write(List<SimpleFeature> features, File file) throws IOException { String basename = file.getName(); if (basename.endsWith(FILE_EXTENSION_SHAPEFILE)) { basename = basename.substring(0, basename.length() - 4); } File shapefile = new File(file.getParentFile(), basename + FILE_EXTENSION_SHAPEFILE); ShapefileDataStoreFactory factory = new ShapefileDataStoreFactory(); Map map = Collections.singletonMap("url", shapefile.toURI().toURL()); DataStore dataStore = factory.createNewDataStore(map); SimpleFeature simpleFeature = features.get(0); SimpleFeatureType simpleFeatureType = simpleFeature.getType(); final String typeName = simpleFeatureType.getName().getLocalPart(); dataStore.createSchema(simpleFeatureType); FeatureStore<SimpleFeatureType, SimpleFeature> featureStore = (FeatureStore<SimpleFeatureType, SimpleFeature>) dataStore.getFeatureSource(typeName); DefaultTransaction transaction = new DefaultTransaction("X"); featureStore.setTransaction(transaction); final FeatureCollection<SimpleFeatureType, SimpleFeature> featureCollection = DataUtilities.collection(features); featureStore.addFeatures(featureCollection); try { transaction.commit(); } catch (Exception e) { transaction.rollback(); throw new IOException("Cannot write shapefile. Error:\n" + e.getMessage(), e); } finally { dataStore.dispose(); transaction.close(); } } }
FeatureStore store2 = (FeatureStore) data.getFeatureSource(roadFeatures[0].getFeatureType() .getTypeName()); store1.setTransaction(new DefaultTransaction()); class Listener implements FeatureListener { String name; Listener listener2 = new Listener("two"); store1.addFeatureListener(listener1); store2.addFeatureListener(listener2); Id fidFilter = ff.id(Collections.singleton(ff.featureId(feature.getID()))); store1.removeFeatures(fidFilter); listener2.events.clear(); store1.getTransaction().commit(); listener2.events.clear(); store1.addFeatures( DataUtilities.collection( feature )); listener2.events.clear(); store1.getTransaction().rollback();
FeatureStore road2 = (FeatureStore) data.getFeatureSource("ROAD"); road1.setTransaction(t1); road2.setTransaction(t2); assertTrue(covers(road.getFeatures().features(), ORIGIONAL)); road1.removeFeatures(rd1Filter); assertTrue(covers(road.getFeatures().features(), ORIGIONAL)); assertTrue(covers(road1.getFeatures().features(), REMOVE)); road2.addFeatures(collection); assertTrue(covers(road.getFeatures().features(), ORIGIONAL)); assertTrue(covers(road1.getFeatures().features(), REMOVE)); assertTrue(coversLax(road2.getFeatures().features(), ADD)); assertTrue(covers(road.getFeatures().features(), REMOVE)); assertTrue(covers(road1.getFeatures().features(), REMOVE)); assertTrue(coversLax(road2.getFeatures().features(), FINAL)); assertTrue(coversLax(road.getFeatures().features(), FINAL)); assertTrue(coversLax(road1.getFeatures().features(), FINAL)); assertTrue(coversLax(road2.getFeatures().features(), FINAL));
fs.setTransaction(transaction); fs.removeFeatures(Filter.INCLUDE);
featureStore.setTransaction(transaction); fc, featureDataConverter, featureStore.getSchema(), tx, task, dataStoreDestination); featureStore.addFeatures(fc);
fs.addFeatures(singleton(productFeature)); final String nsURI = fs.getSchema().getName().getNamespaceURI(); Filter filter = getProductFilter(collection, productId); fs.modifyFeatures( new NameImpl(nsURI, OpenSearchAccess.DESCRIPTION), descriptionString, fs.modifyFeatures( OpenSearchAccess.METADATA_PROPERTY_NAME, descriptionString, filter); fs.modifyFeatures( OpenSearchAccess.OGC_LINKS_PROPERTY_NAME, linksCollection, filter); fs.modifyFeatures( OpenSearchAccess.QUICKLOOK_PROPERTY_NAME, thumbnail, filter); fs.modifyFeatures( new NameImpl(nsURI, OpenSearchAccess.GRANULES), granulesCollection,
store.setTransaction(transaction); store.addFeatures(collection); transaction.commit(); } catch (Exception eek) { eek.printStackTrace(); try { store.getTransaction().rollback(); } catch (IOException e) { e.printStackTrace();
void addFeature(FeatureStore store, String wkt, Object... atts) throws Exception { SimpleFeatureBuilder b = new SimpleFeatureBuilder((SimpleFeatureType) store.getSchema()); b.add(new WKTReader().read(wkt)); for (Object att : atts) { b.add(att); } DefaultFeatureCollection features = new DefaultFeatureCollection(null, null); features.add(b.buildFeature(null)); store.addFeatures(features); }
protected void addFeature(int id, Date time, Double elevation) throws IOException { FeatureTypeInfo timeWithStartEnd = getCatalog().getFeatureTypeByName(TIME_WITH_START_END.getLocalPart()); FeatureStore fs = (FeatureStore) timeWithStartEnd.getFeatureSource(null, null); SimpleFeatureType type = (SimpleFeatureType) timeWithStartEnd.getFeatureType(); MemoryFeatureCollection coll = new MemoryFeatureCollection(type); StringBuffer content = new StringBuffer(); content.append(id); content.append('|'); content.append(time.toString()); content.append("||"); content.append(elevation); content.append('|'); SimpleFeature f = DataUtilities.createFeature(type, content.toString()); coll.add(f); org.geotools.data.Transaction tx = fs.getTransaction(); fs.addFeatures(coll); tx.commit(); }
@PutMapping( path = "{product:.+}/granules", produces = {MediaType.APPLICATION_JSON_VALUE} ) public void putProductGranules( @PathVariable(name = "collection", required = true) String collection, @PathVariable(name = "product", required = true) String product, @RequestBody SimpleFeatureCollection granules) throws IOException { SimpleFeatureStore store = (SimpleFeatureStore) getOpenSearchAccess().getGranules(collection, product); runTransactionOnStore( store, s -> { s.removeFeatures(Filter.INCLUDE); s.addFeatures(granules); }); }
public void setValueAt(Object aValue, int rowIndex, int columnIndex) { FeatureStore<SimpleFeatureType, SimpleFeature> store; if (layer.getFeatureSource() instanceof FeatureStore) { store = (FeatureStore<SimpleFeatureType, SimpleFeature>) layer.getFeatureSource(); DefaultTransaction transaction = new DefaultTransaction("trans_maj"); store.setTransaction(transaction); FilterFactory ff = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints()); Filter filter = ff.id(Collections.singleton(features.get(rowIndex).getIdentifier())); FeatureType schema = store.getSchema(); AttributeDescriptor NAME = (AttributeDescriptor) schema.getDescriptor(getColumnName(columnIndex)); try { store.modifyFeatures(NAME, aValue, filter); transaction.commit(); } catch (IOException ex) { ex.printStackTrace(); try { transaction.rollback(); } catch (IOException e) { e.printStackTrace(); } } setQuery(query); } }
public void testWrite() throws Exception { FeatureStore<SimpleFeatureType, SimpleFeature> fs = (FeatureStore<SimpleFeatureType, SimpleFeature>) dataStore.getFeatureSource(tname(TESTLOB)); SimpleFeature sf = SimpleFeatureBuilder.build( lobSchema, new Object[] {new byte[] {6, 7, 8}, "newclob", new byte[] {11, 12, 13}}, null); List<FeatureId> fids = fs.addFeatures(DataUtilities.collection(sf)); Filter filter = ff.id(new HashSet<Identifier>(fids)); try (FeatureIterator<SimpleFeature> fi = fs.getFeatures(filter).features()) { assertTrue(fi.hasNext()); SimpleFeature f = fi.next(); assertTrue( Arrays.equals( new byte[] {6, 7, 8}, (byte[]) f.getAttribute(aname(BLOB_FIELD)))); assertTrue( Arrays.equals( new byte[] {11, 12, 13}, (byte[]) f.getAttribute(aname(RAW_FIELD)))); assertEquals("newclob", f.getAttribute(aname(CLOB_FIELD))); } }
storeDelegate.modifyFeatures(names, values, filter); return; } else if (writeQuery.getFilter() == Filter.EXCLUDE storeDelegate.modifyFeatures(names, values, mixed.getFilter()); } else { storeDelegate.modifyFeatures(names, values, mixed.getFilter());
public void testGetFeatureStoreModifyFeatures2() throws IOException { FeatureStore road = (FeatureStore) data.getFeatureSource("ROAD"); AttributeType name = roadType.getAttributeType("NAME"); road.modifyFeatures(new AttributeType[] { name, }, new Object[] { "changed", }, rd1Filter); FeatureCollection results = road.getFeatures(rd1Filter); assertEquals("changed", results.features().next().getAttribute("NAME")); }
public Transaction getTransaction() { return storeDelegate.getTransaction(); }
store.setTransaction(transaction); FilterFactory ff = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints()); Filter filter = ff.id(Collections.singleton(ff.featureId(ID))); store.modifyFeatures(geomAttribut, geom, filter); transaction.commit(); } catch (IOException ex) {
public void testGetFeatureStoreRemoveFeatures() throws IOException { FeatureStore road = (FeatureStore) data.getFeatureSource("ROAD"); road.removeFeatures(rd1Filter); assertEquals(0, road.getFeatures(rd1Filter).size()); assertEquals(roadFeatures.length - 1, road.getFeatures().size()); }