All Classes and Interfaces
Class
Description
Base class for imperative SDN configuration using JavaConfig.
Base class for reactive SDN configuration using JavaConfig.
A callback that can be used to modify an instance of a
Neo4jPersistentEntity after it has been converted:
That is, when a Neo4j record has been fully processed and the entity and all its associations have been processed.Warning Internal API, might change without further notice, even in patch releases.
EntityCallback to populate auditing related fields on an entity about to be bound to a record.Entity callback triggered before an Entity is bound to a record (represented by a
java.util.Map<String, Object>).Don't use outside SDN code.
This is a utility class that computes the bounding box of a polygon as a rectangle defined by the lower left and
upper right point.
An internally used CDI
Qualifier to mark all beans produced by our
configuration support as built in.This annotation indicates a
persistent property
that is composed of multiple properties on a node or relationship.The default implementation, passing map properties through as they are on the way to the graph and possibly
applying a post processor on the way out of the graph.
The default operation for transforming the keys.
Phase of the mapping currently taking place.
A pool of constants used in our Cypher generation.
This annotation can be used to define either custom conversions for single attributes by specifying a custom
Neo4jPersistentPropertyConverter and if needed, a custom factory to create that converter or the annotation
can be used to build custom meta-annotated annotations like @org.springframework.data.neo4j.core.support.DateLong.Indicates an unset converter.
The
CreateRelationshipStatementHolder holds the Cypher Statement to create a relationship as well as the optional
properties that describe the relationship in case of more than a simple relationship.Bridging between Spring Data domain Objects and Cypher constructs.
An interface that can be added to any repository so that queries can be enriched by
conditions of the
Cypher-DSL.An interface that can be added to any imperative repository so that the repository exposes several methods taking in
a
Statement from the Cypher-DSL, that allows for full customization of the queries executed in a programmatic
way in contrast to provide custom queries declaratively via @Query
annotations.A generator based on the schema defined by node and relationship descriptions.
A value holder indicating a database selection based on an optional name.
A provider interface that knows in which database repositories or either the reactive or imperative template should
work.
Indicates SDN to store dates as long in the database.
Indicates SDN 6 to store dates as
String in the database.Converter to instantiate DTOs from fully equipped domain objects.This annotation can be used on a field of type
Collection<String>.A Neo4j element id.
Annotation to enable auditing for SDN entities via annotation configuration.
Annotation to activate Neo4j repositories.
Annotation to enable auditing for SDN entities using reactive infrastructure via annotation configuration.
Annotation to activate reactive Neo4j repositories.
Converter to instantiate entity objects from DTOsUsed to keep the raw result around in case of a DTO based projection so that missing properties can be filled later on.
Utility class that orchestrates
EntityCallbacks.Specialized version of
Query whose values is always used as exists projection.FluentFindOperation allows creation and execution of Neo4j find operations in a fluent API style.Entry point for creating executable find operations.
Result type override (Optional).
Terminating operations invoking the actual query execution.
Triggers find execution by calling one of the terminating methods.
Trigger find execution by calling one of the terminating methods from a state where no query is yet defined.
An additional interface accompanying the
Neo4jOperations and adding a couple of fluent operations, especially
around finding and projecting things.FluentSaveOperation allows creation and execution of Neo4j save operations in a fluent API style.After the domain type has been specified, related projections or instances of the domain type can be saved.
Indicates a generated id.
This
IdGenerator does nothing.This generator is automatically applied when a field of type
UUID is annotated with
@Id and @GeneratedValue.Provides minimal information how to map class attributes to the properties of a node or a relationship.
This annotation is included here for completeness.
Description how to generate Ids for entities.
This class is not part of any public API and will be changed without further notice as needed.
Interface for generating ids for entities.
Class that defines a tuple of relationship with properties and the connected target entity.
A wrapper or marker for a Neo4j
MapValue that needs to be unwrapped when used
for properties.Responsible for storing, updating and retrieving the bookmarks of Neo4j's transaction.
This event will be published after a Neo4j transaction manager physically committed a transaction without errors
and received a new set of bookmarks from the cluster.
This CDI extension enables Spring Data Neo4j on a CDI 2.0 compatible CDI container.
Definition of a modern Neo4j client.
Contract for binding parameters to a query.
A builder for
Neo4j clients.Indicates an illegal database name and is not translated into a
DataAccessException.Ongoing bind specification.
A contract for an ongoing delegation in the selected database.
A runnable delegation.
Contract for a runnable query that can be either run returning its result, run without results or be
parameterized.
Contract for a runnable query inside a dedicated database.
Combination of
Neo4jClient.RunnableSpecBoundToDatabase and Neo4jClient.RunnableSpecBoundToUser, can't be
bound any further.Contract for a runnable query bound to a user to be impersonated.
Contract for a runnable query specification which still can be bound to a specific database and an impersonated user.
This service orchestrates a standard Spring conversion service with
Neo4jConversions registered.This orchestrates the built-in store conversions and any additional Spring converters.
Neo4j specific contract for
entity informations.A utility class providing a way to discover an initial entity set for a
Neo4jMappingContext.This class registers the Neo4j SpEL Support it is registered by the appropriate repository factories as a root bean.
An implementation of both a
Schema as well as a Neo4j version of Spring Data's
MappingContext.A builder for creating custom instances of a
Neo4jMappingContext.Specifies operations one can perform on a database, based on an Domain Type.
An interface for controlling query execution.
A PersistenceExceptionTranslator to get picked up by the Spring exception translation infrastructure.
A
PersistentEntity interface with additional methods for metadata related to
Neo4j.A
PersistentProperty interface with additional methods for metadata related
to Neo4j.This interface represents a pair of methods capable of converting values of type
T to and from values.This interface needs to be implemented to provide custom configuration for a
Neo4jPersistentPropertyConverter.You need to provide an implementation of this interface in case you want to store a property of an entity as separate
properties on a node.
A dedicated Neo4j point, that is aware of its nature, either being geographic or cartesian.
Contains some useful transformers for adding additional, supported transformations to
example matchers via
ExampleMatcher.withTransformer(String, ExampleMatcher.PropertyValueTransformer).A wrapper indicating a negated value (will be used as
n.property != $parameter (in case of string properties
all operators and not only the equality operator are supported, such as not (n.property contains 'x').Lookup strategy for queries.
Neo4j specific
Repository interface.This dedicated Neo4j repository extension will be registered via
Neo4jRepositoriesRegistrar and then provide
all necessary beans to be registered in the application's context before the user's "business" beans gets registered.Special adapter for Springs
FactoryBean interface to allow easy setup of
repository factories via Spring configuration.The CDI pendant to the
Neo4jRepositoryFactoryBean.A list of Neo4j simple types: All attributes that can be mapped to a property.
This class provides a couple of extensions to the Spring Data Neo4j SpEL support.
Dedicated
PlatformTransactionManager for native Neo4j transactions.A builder for
Neo4jTransactionManager.Internal use only.
Working on nested relationships happens in a certain algorithmic context.
This stores all processed nested relations and objects during save of objects so that the recursive descent can be
stopped accordingly.
Valid processing states.
The annotation to configure the mapping from a node with a given set of labels to a class and vice versa.
Describes how a class is mapped to a node inside the database.
Throw when a query doesn't return a required result.
A
NoRootNodeMappingException is thrown when the entity converter cannot find a node or map like structure
that can be mapped.The characteristics of a
Neo4jPersistentProperty can diverge from what is by default derived from the annotated
classes.An instance of such a provider can be registered as a Spring bean and will be consulted by the
Neo4jMappingContext
prior to creating and populating persistent properties.Informs SDN that the method annotated with this should be run once the object is loaded from the database and
fully hydrated.
Typed preparation of a query that is used to create either an executable query.
The annotation to configure the mapping from a property to an attribute and vice versa.
Something that makes sense of propertyPaths by having an understanding of projection classes.
Wrapper class for property paths and information if they point to an entity.
A very loose coupling between a dot path and its (possible) owning type.
This class is responsible for creating a List of
PropertyPath entries that contains all reachable
properties (w/o circles).Warning Internal API, might change without further notice, even in patch releases.
A strategy for traversing all properties (including association) once, without going in circles with cyclic mappings.
Annotation to provide Cypher statements that will be used for executing the method.
Querydsl specific fragment for extending
SimpleNeo4jRepository
with an implementation of QuerydslPredicateExecutor.Collects the parts of a Cypher query to be handed over to the Cypher generator.
Combines the QueryFragments with parameters.
Reactive
EntityCallback to populate auditing related fields on an entity about to be bound to a record.Entity callback triggered before an Entity is bound to a record (represented by a
java.util.Map<String, Object>).An interface that can be added to any repository so that queries can be enriched by
conditions of the
Cypher-DSL.An interface that can be added to any reactive repository so that the repository exposes several methods taking in
a
Statement from the Cypher-DSL, that allows for full customization of the queries executed in a programmatic
way in contrast to provide custom queries declaratively via @Query
annotations.This is the reactive version of a the
DatabaseSelectionProvider and it works in the same way but uses
reactive return types containing the target database name.Utility class that orchestrates
EntityCallbacks.ReactiveFluentFindOperation allows creation and execution of Neo4j find operations in a fluent API style.Entry point for creating executable find operations.
Result type override (Optional).
Terminating operations invoking the actual query execution.
Trigger find execution by calling one of the terminating methods.
Trigger find execution by calling one of the terminating methods from a state where no query is yet defined.
An additional interface accompanying the
ReactiveNeo4jOperations and adding a couple of fluent operations, especially
around finding and projecting things.ReactiveFluentSaveOperation allows creation and execution of Neo4j save operations in a fluent API style.After the domain type has been specified, related projections or instances of the domain type can be saved.
Reactive Neo4j client.
A builder for
reactive Neo4j clients.A contract for an ongoing delegation in the selected database.
A runnable delegation.
Contract for a runnable query that can be either run returning its result, run without results or be
parameterized.
Contract for a runnable query inside a dedicated database.
Combination of
Neo4jClient.RunnableSpecBoundToDatabase and Neo4jClient.RunnableSpecBoundToUser, can't be
bound any further.Contract for a runnable query bound to a user to be impersonated.
Contract for a runnable query specification which still can be bound to a specific database and an impersonated user.
Specifies reactive operations one can perform on a database, based on an Domain Type.
An interface for controlling query execution in a reactive fashion.
Lookup strategy for queries.
Neo4j specific
Repository interface with reactive support.This dedicated Neo4j repository extension will be registered via
Neo4jRepositoriesRegistrar and then provide
all necessary beans to be registered in the application's context before the user's "business" beans gets registered.Special adapter for Springs
FactoryBean interface to allow easy setup of
repository factories via Spring configuration.A builder for
ReactiveNeo4jTransactionManager.Bean post-processor that automatically applies persistence exception translation to all methods returning either
Mono or Flux of any bean marked with
Spring's @Repository annotation, adding a corresponding
AbstractPointcutAdvisor to the exposed proxy (either an existing AOP proxy or a newly
generated proxy that implements all of the target's interfaces).Querydsl specific fragment for extending
SimpleReactiveNeo4jRepository
with an implementation of ReactiveQuerydslPredicateExecutor.Annotation to configure mappings of relationship.
Enumeration of the direction a relationship can take.
Description of a relationship.
A combined annotation for id fields in
RelationshipProperties classes.This marker interface is used on classes to mark that they represent additional relationship properties.
A predicate indicating true for
throwables that can be safely retried and false
in any other case.Contains the descriptions of all nodes, their properties and relationships known to SDN.
Repository base implementation for Neo4j.
A fragment for repositories providing "Query by example" functionality.
Repository base implementation for Neo4j.
A fragment for repositories providing "Query by example" functionality in a reactive way.
Marks an entity in a
RelationshipProperties as the target node.Utilities for templates.
Indicator for an empty collection
Thrown when required information about a class or primary label is requested from the
Schema and that
information is not available.Representation of a user agent containing sensible information to identify queries generated by or executed via Spring Data Neo4j.
This is a value object for a Neo4j user, potentially different from the user owning the physical Neo4j connection.
A generator providing UUIDs.