All Classes and Interfaces
Class
Description
Base class for schema based LoadClauseBuilder implementations
based on JPA AttributeConverter, but with methods
appropriate for property graphs, rather than
column stores/RDBMS.
This class serves as a holder for converters from a given type to another.
Boolean operators used in queries.
By default the OGM will map byte[] objects to Base64
String values when being stored as a node / relationship property
By default the OGM will map Byte[] wrapped byte[] objects to Base64
String values when being stored as a node / relationship property
The conversion between the primitive byte[] class and its wrapper
Byte[] means that this converter is slightly slower than
using the ByteArray64Converter, which works with primitive
byte arrays directly.
Implementation of
PropertyValueTransformer that transforms a traditional "LIKE" expression with asterisk wildcards
into a case-insensitive regular expression compatible with Cypher.Maintains object to graph mapping details at the class (type) level
The ClassInfo object is used to maintain mappings from Java Types->Neo4j Labels
thereby allowing the correct labels to be applied to new nodes when they
are persisted.
Comparison operators used in queries.
Maintains contextual information throughout the process of compiling Cypher statements to persist a graph of objects.
Defines a simple API for building up Cypher queries programmatically.
This annotation is kept as a marker interface and for API reasons.
This annotation is kept as a marker interface and for API reasons.
Exception thrown when there is a problem with configuration of OGM
Filter to allow searching in collection properties.
Defines a method to be called by the underlying OGM when it needs to perform a type conversion at runtime but no explicit
AttributeConverter has been found.Let's do the simplest thing we possibly can to link this together.
Annotation to be applied to fields of entity properties to specify the AttributeConverter to use for
writing or reading its value in the graph database.
Placeholder to allow the annotation to be applied without specifying an explicit converter implementation.
Encapsulates Cypher statements used to execute aggregation queries.
Maintains contextual information throughout the process of compiling Cypher statements to persist a graph of objects.
Simple encapsulation of a Cypher query and its parameters
Note, this object will be transformed directly to JSON so don't add anything here that is
not part of the HTTP Transactional endpoint syntax
By default the OGM will map date arrays to UTC-based ISO8601 compliant
String arrays when being stored as a node / relationship property
Users can override this behaviour for Date objects using
the appropriate annotations:
DateString.FORMAT will convert between dates and strings
using a user defined date format, e.g.By default the OGM will map date collections to UTC-based ISO8601 compliant
String collections when being stored as a node / relationship property
Users can override this behaviour for Date objects using
the appropriate annotations:
DateString.FORMAT will convert between dates and strings
using a user defined date format, e.g.Indicates OGM to store dates as long in the database.
Indicates OGM to store dates as String in ISO_8601 format in the database.
By default the OGM will map date objects to UTC-based ISO8601 compliant
String values when being stored as a node / relationship property
Users can override this behaviour for Date objects using
the appropriate annotations:
DateString.FORMAT will convert between dates and strings
using a user defined date format, e.g.A
CypherQuery which returns data in both row and graph formats.Utility class helping with descriptor to type mappings, especially providing maps of primitives and their
corresponding object wrapper classes ("autoboxers").
Represents a relationship type along with a direction.
A DirectedRelationship mapping to objects of a particular type.
Builder of
Schema which takes DomainInfo as inputIdentifies the domain entity representing the end node of
a relationship in the graph, and, along with @
StartNode
is a mandatory annotation on any domain entity that is annotated
with @RelationshipEntityDetermines how entities should be accessed in both reading and writing scenarios by looking up information from
ClassInfo in the following order.A metadata-driven factory class for creating node and relationship entities.
Implementation of
EntityMapper that is driven by an instance of MetaData.Interface to be implemented to override entity instances creation.
Specification for an object-graph mapper, which can map arbitrary Java objects onto Cypher data manipulation queries.
The utility methods here will all throw a
NullPointerException if invoked with null.By default the OGM will map enum arrays to and from
the string arrays with values returned by enum.name()
enum.name() is preferred to enum.ordinal() because it
is (slightly) safer: a persisted enum have to be renamed
to break its database mapping, whereas if its ordinal
was persisted instead, the mapping would be broken
simply by changing the declaration order of the enum constants.
By default the OGM will map enum collections to and from
the string collections containing values returned by enum.name()
enum.name() is preferred to enum.ordinal() because it
is (slightly) safer: a persisted enum have to be renamed
to break its database mapping, whereas if its ordinal
was persisted instead, the mapping would be broken
simply by changing the declaration order of the enum constants.
By default the OGM will map enum objects to and from
the string value returned by enum.name()
enum.name() is preferred to enum.ordinal() because it
is (slightly) safer: a persisted enum have to be renamed
to break its database mapping, whereas if its ordinal
was persisted instead, the mapping would be broken
simply by changing the declaration order of the enum constants.
A parameter along with filter information to be added to a query.
A FilteredQuery is constructed by a
FilteredQueryBuilder
A FilteredQuery represents the MATCH clause of a cypher statement containing various WHERE predicates
The various implementing classes of DeleteStatements,
AggregateStatements and
QueryStatements can set the return clause that
fits their purpose.All statements that take a
Filters parameter delegate the generation of the appropriate
Cypher to this class
The FilteredQueryBuilder, as its name suggests, returns instances of FilteredQueryUsed to generate an ID.
Represents the primary unique constraint used to reference an EntityNode.
Id generation strategy that allows custom implementations of id generation.
This annotation is kept as a marker interface and for API reasons.
Direct and ancestral interfaces of a given interface.
This strategy will use internally generated Long ids as entity ids
RuntimeException that indicates a field that possibly should be persisted as a property
but cannot be persisted as such, maybe due to a missing converter.This exception is thrown when a one to many relationship collection contains the null value.
A common delegate for detecting Kotlin's presence and for identifying Kotlin types.
Annotation to declare that the mapped entity will control which labels are added to a node.
Load clause builder builds final part of load queries
Converter to convert between
LocalDateTime and String.MapCompositeConverter converts Map field into prefixed properties of node or relationship entity.
Light-weight record of a relationship mapped from the database
startNodeId - relationshipId - relationshipType - endNodeId
The relationshipId is recorded for relationship entities, and not for simple relationships.The MappingContext maintains a map of all the objects created during the hydration
of an object map (domain hierarchy).
Specialised
RuntimeException thrown when an unrecoverable issue occurs when mapping between objects and graphs.Unrecoverable exception thrown when there is a user error in entity metadata (conflicting annotations,
missing id fields etc.)
Cypher compiler that produces multiple statements that can be executed together or split over a transaction.
Node in a
SchemaBuilds a node to be persisted in the database.
Identifies a domain entity as being backed by a node in the graph.
This converter is provided for convenience so that the default conversion of byte arrays (byte[]
to Base64 encoded Strings can be turned off.
PropertyValueTransformer that does nothing but pass through the property value.This converter is provided for convenience so that the default conversion of byte arrays (Byte[]
to Base64 encoded Strings can be turned off.
The NumberStringConverter can be used to convert any java object array containing values that extend
Number to and from its String array representation.The NumberStringConverter can be used to convert any java object collection containing values that extend
Number to and from its String array representation.The NumberStringConverter can be used to convert any java object that extends
Number to and from its String representation.Converter to convert between
OffsetDateTime and String.Extends
CypherQuery with additional functionality for Paging and Sorting.There is one PathMatchClause per set (one or more) RelatedNodePropertyMatchClause
Path based load clause for nodes - starts from given node variable
Path based load clause builder for nodes - starts from given relationship variable
Represents a PersistenceEvent in the OGM.
Informs the OGM that the method annotated with this should be run once the object is loaded from the database and
fully hydrated.
Specialized
Event which is fired before an entity is saved.Specialized
Event which is fired before an entity is saved.Tells OGM to map values of a Map field in a node or relationship entity to properties of a node or a relationship
in the graph.
Phase of the mapping currently taking place.
Establishes the mapping between a domain entity attribute
and a node or relationship property in the graph.
Internal class for modifying an EQUALS or CONTAINS comparison to ignore the case of both attribute and parameter.
Interface to abstract setting properties on nodes/relationship entities
Allows a property value to be transformed into a certain format for use with particular
ComparisonOperators
when building a Cypher query.Proxy implementation of
AttributeConverter backed by an index to which custom generic converters
can be added after the object-graph mapping framework has been initialised.Simple instantiator that uses either the no-arg constructor, without using property values,
or creates an instance with property population.
Identifies field that is to be represented as a relationship
Relationship in a
SchemaEnumeration of the direction a relationship can take.
Builds a relationship to be persisted in the database
Identifies a domain entity as being backed by a relationship in the graph.
Contains helper methods to facilitate inference of relationship types from field and methods and vice versa.
Plans request execution and processes the response.
Annotation which notifies OGM that this property is required.
Specification for an object-model mapper, which can map a model M onto arbitrary Java objects.
Map NodeModels and RelationshipModels obtained from cypher queries to domain entities
Schema based load clause builder for nodes - starts from given node variable
A
Session serves as the main point of integration for the Neo4j OGM.This is the main initialization point of OGM.
Simple graph-to-entity mapper suitable for ad-hoc, one-off mappings.
Identifies a domain entity as being the start node of
a relationship in the graph, and, along with @
EndNode
is a mandatory annotation on any domain entity that is annotated
with @RelationshipEntityCallback to be executed inside an OGM managed transaction.
Callback to be executed inside an OGM managed transaction.
By default, all domain entity types will be persisted unless they are
annotated with @Transient, or are non-annotated abstract classes.
A TransientRelationship represents a relationship that is not yet
established in the graph, where at least one of either the
start node or end node is also a new object.
Generates random UUID as entity id using
UUID.randomUUID().Annotation mainly focused to be used on the value attribute of another annotation.
Tells OGM to use a property as a version field to implement optimistic locking on entities
A strategy that provides write protection for nodes in certain modes.
Indicates a write protection on safe.