for ( Node node : data.createdNodes() ) assertFalse( data.isDeleted( node ) ); for ( Relationship rel : data.createdRelationships() ) assertFalse( data.isDeleted( rel ) ); for ( Node node : data.deletedNodes() ) assertTrue( data.isDeleted( node ) ); for ( Relationship rel : data.deletedRelationships() ) assertTrue( data.isDeleted( rel ) ); for ( PropertyEntry<Node> entry : data.assignedNodeProperties() ) assertFalse( data.isDeleted( entry.entity() ) ); for ( PropertyEntry<Relationship> entry : data.assignedRelationshipProperties() ) assertFalse( data.isDeleted( entry.entity() ) ); for ( PropertyEntry<Node> entry : data.removedNodeProperties() ) for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() ) for ( LabelEntry entry : data.assignedLabels() )
@Override public Void beforeCommit( TransactionData data ) { if ( active ) { check( added, "added to", data.assignedLabels() ); check( removed, "removed from", data.removedLabels() ); } active = false; return null; }
@Override public void afterCommit( TransactionData data, Object state ) { for ( PropertyEntry<Node> entry : data.removedNodeProperties() ) { String key = entry.key(); Object value = entry.previouslyCommitedValue(); nodeProps.put( key, value ); } for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() ) { relProps.put( entry.key(), entry.previouslyCommitedValue() ); } }
private static Map<String, Object> txDataParams(TransactionData txData, String phase) { return map("transactionId", phase.equals("after") ? txData.getTransactionId() : -1, "commitTime", phase.equals("after") ? txData.getCommitTime() : -1, "createdNodes", txData.createdNodes(), "createdRelationships", txData.createdRelationships(), "deletedNodes", txData.deletedNodes(), "deletedRelationships", txData.deletedRelationships(), "removedLabels", aggregateLabels(txData.removedLabels()), "removedNodeProperties", aggregatePropertyKeys(txData.removedNodeProperties(),true,true), "removedRelationshipProperties", aggregatePropertyKeys(txData.removedRelationshipProperties(),false,true), "assignedLabels", aggregateLabels(txData.assignedLabels()), "assignedNodeProperties",aggregatePropertyKeys(txData.assignedNodeProperties(),true,false), "assignedRelationshipProperties",aggregatePropertyKeys(txData.assignedRelationshipProperties(),false,false)); }
Collection<Consumer<Void>> state = async ? new LinkedList<>() : null; iterateNodePropertyChange(stream(data.assignedNodeProperties()),false, (index, node, key, value, oldValue) -> indexUpdate(state, aVoid -> { if (oldValue != null) { index.remove(node, key); iterateNodePropertyChange(stream(data.removedNodeProperties()).filter(nodePropertyEntry -> !data.isDeleted(nodePropertyEntry.entity())), true, (index, node, key, value, oldValue) -> indexUpdate(state, aVoid -> { index.remove(node, key); index.remove(node, FreeTextSearch.KEY); final Set<Node> createdNodes = Iterables.asSet(data.createdNodes()); iterateLabelChanges( stream(data.assignedLabels()).filter( labelEntry -> !createdNodes.contains( labelEntry.node() ) ), (index, node, key, value, ignore) -> indexUpdate(state, aVoid -> { index.add(node, key, value); stream(data.removedLabels()).filter( labelEntry -> !data.isDeleted(labelEntry.node()) ), (index, node, key, value, ignore) -> indexUpdate(state, aVoid -> { index.remove(node, key); })); iterateNodeDeletions(stream(data.removedLabels()).filter( labelEntry -> data.isDeleted(labelEntry.node())), (nodeIndex, node, void1, void2, void3) -> indexUpdate(state, aVoid -> nodeIndex.remove(node))); return state;
@Override public Object beforeCommit( TransactionData data ) { Iterator<Node> nodes = data.createdNodes().iterator(); if ( nodes.hasNext() ) { Node node = nodes.next(); index.add( node, "key", "value" ); } return null; }
@SuppressWarnings( "boxing" ) @Override public Void beforeCommit( TransactionData data ) { if ( Iterables.count( data.createdRelationships() ) == 0 ) { return null; } node.setProperty( "counter", ((Long) node.removeProperty( "counter" )) + 1 ); return null; }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Node>> removedProperties() { return transactionData.removedNodeProperties(); }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Relationship>> removedProperties() { return transactionData.removedRelationshipProperties(); }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Node>> assignedProperties() { return transactionData.assignedNodeProperties(); }
/** * {@inheritDoc} */ @Override protected Iterable<Node> deleted() { return transactionData.deletedNodes(); }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Relationship>> assignedProperties() { return transactionData.assignedRelationshipProperties(); }
/** * {@inheritDoc} */ @Override protected Iterable<Relationship> deleted() { return transactionData.deletedRelationships(); }
@Override public Collection<BulkableAction> beforeCommit(TransactionData transactionData) throws Exception { Map<IndexId, BulkableAction> actions = new HashMap<>(1000); for (Node node : transactionData.createdNodes()) { if (hasLabel(node)) actions.putAll(indexRequests(node)); } for (LabelEntry labelEntry : transactionData.assignedLabels()) { if (hasLabel(labelEntry)) { if (transactionData.isDeleted(labelEntry.node())) { actions.putAll(deleteRequests(labelEntry.node())); } else { actions.putAll(indexRequests(labelEntry.node())); } } } for (LabelEntry labelEntry : transactionData.removedLabels()) { if (hasLabel(labelEntry)) actions.putAll(deleteRequests(labelEntry.node(), labelEntry.label())); } for (PropertyEntry<Node> propEntry : transactionData.assignedNodeProperties()) { if (hasLabel(propEntry)) actions.putAll(indexRequests(propEntry.entity())); } for (PropertyEntry<Node> propEntry : transactionData.removedNodeProperties()) { if (!transactionData.isDeleted(propEntry.entity()) && hasLabel(propEntry)) actions.putAll(updateRequests(propEntry.entity())); } return actions.isEmpty() ? Collections.<BulkableAction>emptyList() : actions.values(); }
private Object verify( TransactionData data ) { // TODO Hmm, makes me think... should we really call transaction event handlers // for these relationship type / property index transactions? if ( Iterables.count( data.createdNodes() ) == 0 ) { return null; } try { this.expectedData.compareTo( data ); this.hasBeenCalled = true; return null; } catch ( Exception e ) { failure = e; throw e; } }
for (LabelEntry labelEntry : transactionData.assignedLabels()) { Node node = labelEntry.node(); for (LabelEntry labelEntry : transactionData.removedLabels()) { Node node = labelEntry.node();
/** * {@inheritDoc} */ @Override protected Iterable<Relationship> created() { return transactionData.createdRelationships(); }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Node>> removedProperties() { return transactionData.removedNodeProperties(); } }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Relationship>> removedProperties() { return transactionData.removedRelationshipProperties(); }
/** * {@inheritDoc} */ @Override protected Iterable<PropertyEntry<Node>> assignedProperties() { return transactionData.assignedNodeProperties(); }