| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.tinkerpop.gremlin.neo4j.structure.trait; |
| |
| import org.apache.tinkerpop.gremlin.neo4j.process.traversal.LabelP; |
| import org.apache.tinkerpop.gremlin.neo4j.structure.Neo4jGraph; |
| import org.apache.tinkerpop.gremlin.neo4j.structure.Neo4jHelper; |
| import org.apache.tinkerpop.gremlin.neo4j.structure.Neo4jVertex; |
| import org.apache.tinkerpop.gremlin.neo4j.structure.Neo4jVertexProperty; |
| import org.apache.tinkerpop.gremlin.process.traversal.Compare; |
| import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer; |
| import org.apache.tinkerpop.gremlin.structure.Property; |
| import org.apache.tinkerpop.gremlin.structure.T; |
| import org.apache.tinkerpop.gremlin.structure.Vertex; |
| import org.apache.tinkerpop.gremlin.structure.VertexProperty; |
| import org.apache.tinkerpop.gremlin.structure.util.ElementHelper; |
| import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils; |
| import org.neo4j.tinkerpop.api.Neo4jDirection; |
| import org.neo4j.tinkerpop.api.Neo4jNode; |
| import org.neo4j.tinkerpop.api.Neo4jRelationship; |
| |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Optional; |
| import java.util.function.Predicate; |
| |
| /** |
| * @author Marko A. Rodriguez (http://markorodriguez.com) |
| * @deprecated As of release 3.3.8, not replaced. |
| */ |
| @Deprecated |
| public final class NoMultiNoMetaNeo4jTrait implements Neo4jTrait { |
| |
| private static final NoMultiNoMetaNeo4jTrait INSTANCE = new NoMultiNoMetaNeo4jTrait(); |
| |
| private final static Predicate TRUE_PREDICATE = x -> true; |
| |
| public static NoMultiNoMetaNeo4jTrait instance() { |
| return INSTANCE; |
| } |
| |
| private NoMultiNoMetaNeo4jTrait() { |
| |
| } |
| |
| @Override |
| public Predicate<Neo4jNode> getNodePredicate() { |
| return TRUE_PREDICATE; |
| } |
| |
| @Override |
| public Predicate<Neo4jRelationship> getRelationshipPredicate() { |
| return TRUE_PREDICATE; |
| } |
| |
| @Override |
| public void removeVertex(final Neo4jVertex vertex) { |
| try { |
| final Neo4jNode node = vertex.getBaseVertex(); |
| for (final Neo4jRelationship relationship : node.relationships(Neo4jDirection.BOTH)) { |
| relationship.delete(); |
| } |
| node.delete(); |
| } catch (final IllegalStateException ignored) { |
| // this one happens if the vertex is still chilling in the tx |
| } catch (final RuntimeException ex) { |
| if (!Neo4jHelper.isNotFound(ex)) throw ex; |
| // this one happens if the vertex is committed |
| } |
| } |
| |
| @Override |
| public <V> VertexProperty<V> getVertexProperty(final Neo4jVertex vertex, final String key) { |
| return vertex.getBaseVertex().hasProperty(key) ? new Neo4jVertexProperty<>(vertex, key, (V) vertex.getBaseVertex().getProperty(key)) : VertexProperty.<V>empty(); |
| } |
| |
| @Override |
| public <V> Iterator<VertexProperty<V>> getVertexProperties(final Neo4jVertex vertex, final String... keys) { |
| return (Iterator) IteratorUtils.stream(vertex.getBaseVertex().getKeys()) |
| .filter(key -> ElementHelper.keyExists(key, keys)) |
| .map(key -> new Neo4jVertexProperty<>(vertex, key, (V) vertex.getBaseVertex().getProperty(key))).iterator(); |
| } |
| |
| @Override |
| public <V> VertexProperty<V> setVertexProperty(final Neo4jVertex vertex, final VertexProperty.Cardinality cardinality, final String key, final V value, final Object... keyValues) { |
| if (cardinality != VertexProperty.Cardinality.single) |
| throw VertexProperty.Exceptions.multiPropertiesNotSupported(); |
| if (keyValues.length > 0) |
| throw VertexProperty.Exceptions.metaPropertiesNotSupported(); |
| try { |
| vertex.getBaseVertex().setProperty(key, value); |
| return new Neo4jVertexProperty<>(vertex, key, value); |
| } catch (final IllegalArgumentException iae) { |
| throw Property.Exceptions.dataTypeOfPropertyValueNotSupported(value, iae); |
| } |
| } |
| |
| @Override |
| public VertexProperty.Cardinality getCardinality(final String key) { |
| return VertexProperty.Cardinality.single; |
| } |
| |
| @Override |
| public boolean supportsMultiProperties() { |
| return false; |
| } |
| |
| @Override |
| public boolean supportsMetaProperties() { |
| return false; |
| } |
| |
| @Override |
| public void removeVertexProperty(final Neo4jVertexProperty vertexProperty) { |
| final Neo4jNode node = ((Neo4jVertex) vertexProperty.element()).getBaseVertex(); |
| if (node.hasProperty(vertexProperty.key())) |
| node.removeProperty(vertexProperty.key()); |
| } |
| |
| @Override |
| public <V> Property<V> setProperty(final Neo4jVertexProperty vertexProperty, final String key, final V value) { |
| throw VertexProperty.Exceptions.metaPropertiesNotSupported(); |
| } |
| |
| @Override |
| public <V> Property<V> getProperty(final Neo4jVertexProperty vertexProperty, final String key) { |
| throw VertexProperty.Exceptions.metaPropertiesNotSupported(); |
| } |
| |
| @Override |
| public <V> Iterator<Property<V>> getProperties(final Neo4jVertexProperty vertexProperty, final String... keys) { |
| throw VertexProperty.Exceptions.metaPropertiesNotSupported(); |
| } |
| |
| @Override |
| public Iterator<Vertex> lookupVertices(final Neo4jGraph graph, final List<HasContainer> hasContainers, final Object... ids) { |
| // ids are present, filter on them first |
| if (ids.length > 0) |
| return IteratorUtils.filter(graph.vertices(ids), vertex -> HasContainer.testAll(vertex, hasContainers)); |
| ////// do index lookups ////// |
| graph.tx().readWrite(); |
| // get a label being search on |
| Optional<String> label = hasContainers.stream() |
| .filter(hasContainer -> hasContainer.getKey().equals(T.label.getAccessor())) |
| .filter(hasContainer -> Compare.eq == hasContainer.getBiPredicate()) |
| .map(hasContainer -> (String) hasContainer.getValue()) |
| .findAny(); |
| if (!label.isPresent()) |
| label = hasContainers.stream() |
| .filter(hasContainer -> hasContainer.getKey().equals(T.label.getAccessor())) |
| .filter(hasContainer -> hasContainer.getPredicate() instanceof LabelP) |
| .map(hasContainer -> (String) hasContainer.getValue()) |
| .findAny(); |
| |
| if (label.isPresent()) { |
| // find a vertex by label and key/value |
| for (final HasContainer hasContainer : hasContainers) { |
| if (Compare.eq == hasContainer.getBiPredicate() && !hasContainer.getKey().equals(T.label.getAccessor())) { |
| if (graph.getBaseGraph().hasSchemaIndex(label.get(), hasContainer.getKey())) { |
| return IteratorUtils.stream(graph.getBaseGraph().findNodes(label.get(), hasContainer.getKey(), hasContainer.getValue())) |
| .map(node -> (Vertex) new Neo4jVertex(node, graph)) |
| .filter(vertex -> HasContainer.testAll(vertex, hasContainers)).iterator(); |
| } |
| } |
| } |
| // find a vertex by label |
| return IteratorUtils.stream(graph.getBaseGraph().findNodes(label.get())) |
| .map(node -> (Vertex) new Neo4jVertex(node, graph)) |
| .filter(vertex -> HasContainer.testAll(vertex, hasContainers)).iterator(); |
| } else { |
| // linear scan |
| return IteratorUtils.filter(graph.vertices(), vertex -> HasContainer.testAll(vertex, hasContainers)); |
| } |
| } |
| } |