Refine search
String typeName = query.getTypeName(); SimpleFeatureStore fs = null; try { Transaction t = new DefaultTransaction(); try { final int retVal = fs.getFeatures(query).size(); // ensures we get a value if (retVal > 0) { fs.setTransaction(t); fs.removeFeatures(query.getFilter()); t.commit(); } finally { if (rollback) { t.rollback(); t.close();
(DiffTransactionState) getTransaction().getState(getEntry()); Diff diff = state.getDiff(); synchronized (diff) { Filter filter = query.getFilter(); while (it.hasNext()) { SimpleFeature feature = it.next(); count--; } else { modifiedFids.add(ff.featureId(feature.getID())); if (filter.evaluate(feature)) { modifiedPostCount++; Query q = new Query(query); q.setFilter(ff.and(idFilter, query.getFilter())); int modifiedPreCount = getCountInternal(q); if (modifiedPreCount == -1) {
private ArcTransactionState getState(final Transaction transaction) { if (Transaction.AUTO_COMMIT.equals(transaction)) { return null; } ArcTransactionState state = (ArcTransactionState) transaction.getState(this); if (state == null) { state = new ArcTransactionState(this, listenerManager); transaction.putState(this, state); } return state; }
ShapefileDataStore outStore = new ShapefileDataStore(shapeFile.toURI().toURL()); outStore.createSchema(contourSchema); Transaction transaction = new DefaultTransaction("create"); SimpleFeatureStore featureStore = (SimpleFeatureStore) outStore.getFeatureSource(); featureStore.setTransaction(transaction); try { featureStore.addFeatures(contourFeatures); transaction.commit(); } catch (Exception e) { transaction.rollback(); throw e; } finally { transaction.close();
Connection cx = createConnection(); try { cx.setAutoCommit(true); JDBCTransactionState tstate = (JDBCTransactionState) t.getState(this); if (tstate != null) { return tstate.cx; } else { Connection cx = createConnection(); try { cx.setAutoCommit(false); t.putState(this, tstate); return cx;
@Test public void testFeatureWriterAppend() throws Exception { dataStore.createSchema(linesType); Transaction tx = new DefaultTransaction(); FeatureWriter<SimpleFeatureType, SimpleFeature> fw = dataStore .getFeatureWriterAppend(linesTypeName.getLocalPart(), tx); LineString line = new GeometryBuilder().lineString(0, 0, 1, 1); SimpleFeature f = (SimpleFeature) fw.next(); f.setAttribute("sp", "foo"); f.setAttribute("ip", 10); f.setAttribute("pp", line); fw.write(); fw.close(); tx.commit(); tx.close(); FeatureSource<SimpleFeatureType, SimpleFeature> source = dataStore .getFeatureSource(linesName); assertEquals(1, source.getCount(null)); FeatureReader<SimpleFeatureType, SimpleFeature> r = dataStore .getFeatureReader(new Query(linesName), Transaction.AUTO_COMMIT); assertTrue(r.hasNext()); f = r.next(); assertEquals("foo", f.getAttribute("sp")); assertEquals(10, f.getAttribute("ip")); assertTrue(line.equals((Geometry) f.getAttribute("pp"))); }
if (query.getStartIndex() != null && (query.getSortBy() == null || query.getSortBy().length == 0)) { Query dq = new Query(query); dq.setSortBy(new SortBy[] {SortBy.NATURAL_ORDER}); (DiffTransactionState) getTransaction().getState(getEntry()); reader = new DiffFeatureReader<SimpleFeatureType, SimpleFeature>(
public void testCommit() throws IOException { // JDBCFeatureStore fs = (JDBCFeatureStore) dataStore.getFeatureSource(tname("ft1")); try (Transaction tx = new DefaultTransaction(); FeatureWriter<SimpleFeatureType, SimpleFeature> writer = dataStore.getFeatureWriterAppend(tname("ft1"), tx)) { SimpleFeature feature = writer.next(); feature.setAttribute(aname("intProperty"), Integer.valueOf(100)); writer.write(); writer.close(); tx.commit(); } SimpleFeatureCollection fc = dataStore.getFeatureSource(tname("ft1")).getFeatures(); assertEquals(4, fc.size()); }
Transaction tx = new DefaultTransaction(); try { SimpleFeatureWriter w = writer(e, true, null, tx); if (pd.getType().getBinding() == Boolean.class) { int bool = 0; if (f.getAttribute(name) != null) { bool = (Boolean) (f.getAttribute(name)) ? 1 : 0; g.setAttribute(name, bool); } else { g.setAttribute(name, f.getAttribute(name)); it.close(); tx.commit(); } catch (Exception ex) { tx.rollback(); throw new IOException(ex); } finally { tx.close();
lock.lock(); checkStore(); final String typeName = q.getTypeName(); tx = new DefaultTransaction("getGranulesTransaction" + System.nanoTime()); ((FeatureStore) featureSource).setTransaction(tx); String[] requestedProperties = q.getPropertyNames(); boolean postRetypeRequired = requestedProperties != Query.ALL_NAMES; SimpleFeatureType target = null; requestedProperties, 0, properties, 0, requestedProperties.length); properties[requestedProperties.length] = IMAGE_INDEX_ATTR; q.setPropertyNames(properties); Integer granuleIndex = (Integer) sf.getAttribute(IMAGE_INDEX_ATTR); if (coverageSliceDescriptorsCache.containsKey(granuleIndex)) { slice = coverageSliceDescriptorsCache.get(granuleIndex); tx.close();
Transaction t1 = new DefaultTransaction(); Transaction t2 = new DefaultTransaction(); feature = ORIGIONAL[i]; if (!feature.getID().equals("road.rd1")) { REMOVE[index++] = feature; reader = data.getFeatureReader(new Query("road"), Transaction.AUTO_COMMIT); assertTrue(covers(reader, ORIGIONAL)); assertEquals("road.rd1", feature.getID()); writer1.remove(); feature.setAttributes(newRoad.getAttributes()); writer2.write(); t1.commit(); t2.commit(); assertTrue(coversLax(reader, FINAL)); } finally { t1.close(); t2.close();
try (Transaction t1 = new DefaultTransaction(); Transaction t2 = new DefaultTransaction()) { feature = ORIGINAL[i]; if (!feature.getID().equals(td.roadFeatures[0].getID())) { REMOVE[index++] = feature; dataStore.getFeatureReader( new Query(tname("road"), Filter.INCLUDE), Transaction.AUTO_COMMIT)) { assertTrue( assertEquals(td.roadFeatures[0].getID(), feature.getID()); writer1.remove(); dataStore.getFeatureReader( new Query(tname("road"), Filter.INCLUDE), Transaction.AUTO_COMMIT)) { assertTrue( dataStore.getFeatureReader(new Query(tname("road"), Filter.INCLUDE), t1)) { assertTrue(covers(reader, REMOVE)); t1.commit(); t2.commit();
(DiffTransactionState) getTransaction().getState(getEntry()); Diff diff = state.getDiff(); Query q = new Query(query); q.setFilter(ff.and(skipFilter, query.getFilter())); bounds = getBoundsInternal(q); while (it.hasNext()) { SimpleFeature feature = it.next(); BoundingBox fb = feature.getBounds(); if (fb != null) { bounds.expandToInclude(ReferencedEnvelope.reference(fb)); SimpleFeature feature = it.next(); if (feature != Diff.NULL) { BoundingBox fb = feature.getBounds(); if (fb != null) { bounds.expandToInclude(ReferencedEnvelope.reference(fb));
public void testFeatureEvents() throws Exception { SimpleFeatureStore store1 = (SimpleFeatureStore) data.getFeatureSource(roadFeatures[0].getFeatureType().getTypeName()); SimpleFeatureStore store2 = (SimpleFeatureStore) data.getFeatureSource(roadFeatures[0].getFeatureType().getTypeName()); store1.setTransaction(defaultTransaction); class Listener implements FeatureListener { factory.id(Collections.singleton(factory.featureId(feature.getID())))); assertEquals(1, listener1.events.size()); assertEquals(0, listener2.events.size()); listener2.events.clear(); store1.getTransaction().commit(); listener2.events.clear(); store1.getTransaction().rollback();
SimpleFeature feature = (SimpleFeature) reader.next(); FeatureId fid = fid(feature.getID()); Id fidFilter = fidFilter(fid); new Query( meta.getName(), (Filter) fidFilter, Transaction t = new DefaultTransaction(); t.addAuthorization(fLock.getAuthorization()); DataStore dataStore = (DataStore) source.getDataStore(); dataStore.getLockingManager().refresh(fLock.getAuthorization(), t); } finally { t.commit(); } finally { try { t.close(); } catch (IOException e) { throw new WFSException(request, e);
public void testDeleteLockedFeatures() throws Exception { FeatureLock lock = FeatureLockFactory.generate(tname("ft1"), 60 * 60 * 1000); try (Transaction tx = new DefaultTransaction()) { store.setTransaction(tx); store.setFeatureLock(lock); tx.addAuthorization(lock.getAuthorization()); FilterFactory ff = dataStore.getFilterFactory(); Filter f1 = ff.id(Collections.singleton(ff.featureId(tname("ft1") + ".1"))); assertEquals(1, store.lockFeatures(f1)); try (Transaction tx1 = new DefaultTransaction()) { store.setTransaction(tx1); try { store.removeFeatures(f1); fail("Locked feature should not be deleted."); } catch (FeatureLockException e) { } } store.setTransaction(tx); store.removeFeatures(f1); tx.commit(); } }
config.getDatastoreSpi().createDataStore(config.getParams()); final Set<String> typeNames = new HashSet<>(Arrays.asList(sourceDataStore.getTypeNames())); Transaction t = new DefaultTransaction(); try { t.commit(); netcdfWriter.addLines(path); h2Writer.addLines(collectH2Files(config)); } finally { t.close(); if (sourceDataStore != null) { sourceDataStore.dispose();
public void testGetFeatureReaderFilterTransaction() throws NoSuchElementException, IOException, IllegalAttributeException { SimpleFeatureType type = dataStore.getSchema(tname("road")); try (Transaction t = new DefaultTransaction()) { try (FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(new Query(tname("road"), Filter.EXCLUDE), t)) { assertFalse(reader.hasNext()); assertEquals(type, reader.getFeatureType()); dataStore.getFeatureReader(new Query(tname("road"), Filter.INCLUDE), t)) { assertEquals(type, reader.getFeatureType()); assertEquals(td.roadFeatures.length, count(reader)); dataStore.getFeatureReader(new Query(tname("road"), td.rd1Filter), t)) { assertEquals(type, reader.getFeatureType()); assertEquals(1, count(reader)); feature = (SimpleFeature) writer.next(); if (feature.getID().equals(td.roadFeatures[0].getID())) { writer.remove(); t.rollback(); try (FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(new Query(tname("road"), Filter.EXCLUDE), t)) {
FeatureReader<SimpleFeatureType, SimpleFeature> reader; reader = data.getFeatureReader(new Query("road", Filter.EXCLUDE), defaultTransaction); assertEquals(type, reader.getFeatureType()); assertEquals(0, count(reader)); reader = data.getFeatureReader(new Query("road"), defaultTransaction); assertEquals(roadFeatures.length, count(reader)); reader = data.getFeatureReader(new Query("road", rd1Filter), defaultTransaction); feature = writer.next(); if (feature.getID().equals("road.rd1")) { writer.remove(); assertEquals(0, count(reader)); defaultTransaction.rollback(); reader = data.getFeatureReader(new Query("road", Filter.EXCLUDE), defaultTransaction); assertEquals(0, count(reader));
try (Transaction tx = new DefaultTransaction()) { store.setTransaction(tx); store.setFeatureLock(lock); Query query = new Query(tname("ft1")); try (FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(query, tx)) { dataStore.getFeatureWriter(tname("ft1"), tx)) { assertTrue(writer.hasNext()); SimpleFeature feature = writer.next(); feature.setAttribute(aname("intProperty"), Integer.valueOf(100)); try { writer.write(); tx.addAuthorization(lock.getAuthorization()); try (FeatureWriter<SimpleFeatureType, SimpleFeature> writer = dataStore.getFeatureWriter(tname("ft1"), tx)) { assertTrue(writer.hasNext()); SimpleFeature feature = writer.next(); feature.setAttribute(aname("intProperty"), Integer.valueOf(100)); writer.write();