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.A concrete, 2-dimensional cartesian point.
A concrete, 3-dimensional cartesian point.
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.
A generic coordinate type with x, y and z values having an arbitrary meaning.
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.Imperative variant of the
CypherdslConditionExecutor.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>.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 DTOs.Used 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.A concrete, 2-dimensional geographic point with a specific coordinate system.
A concrete, 3-dimensional geographic point with a specific coordinate system.
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.
Utility methods for the actual object mapping.
Class that defines a tuple of relationship with properties and the connected target
entity.
A wrapper or marker for a Neo4j
org.neo4j.driver.internal.value.MapValue that
needs to be unwrapped when used for properties.Predicates used in the AoT (native image) support.
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.
Support class that can be used as is for all necessary CDI beans or as a blueprint for
custom producers.
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.Step for defining the mapping.
Ongoing bind specification.
A contract for an ongoing delegation in the selected database.
Final step that triggers fetching.
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.
Manages all build-in Neo4j conversions: Cypher types, some additional types and the
shared set of Spring Data and Neo4j spatial types.
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.
The set of types managed by Neo4j.
Registered managed types and repositories to be included in AoT (native image)
processing.
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.AoT runtime hints registering various types for reflection.
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.
A marker interface that indicates a literal replacement in a query instead of a
parameter replacement.
The target of this replacement.
The Neo4j template combines various operations.
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.
Reactive Supplier for arbitrary relationship ids.
Supplier for arbitrary relationship ids.
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.A builder for points, so that coordinates and optionally a coordinate system can be
configured.
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.
Step configuring parameters or mapping functions.
Step configuring the query to be used.
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.Implementation of the
ReactiveCypherdslConditionExecutor.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.Step for defining the mapping.
A contract for an ongoing delegation in the selected database.
Final step that triggers fetching.
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.The Neo4j template combines various operations.
Neo4j specific implementation of an
AbstractReactiveTransactionManager.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.Functional interface for dynamic provision of usernames to the system.
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.
Supporting class for CypherDSL related customizations.
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.
Functional interface for dynamic provision of usernames to the system.
A generator providing UUIDs.
Indicates a vector search on a repository.
Collected params for vector search.