All Classes and Interfaces

Class
Description
Base class for delete events.
Base class for Spring Data MongoDB configuration using JavaConfig with MongoClient.
Base class for MongoConverter implementations.
Base class to implement domain class specific ApplicationListeners.
Base class for RepositoryQuery implementations for Mongo.
Base class to encapsulate common configuration settings when connecting to a database
Base class for reactive Spring Data MongoDB configuration using JavaConfig.
Base class for reactive RepositoryQuery implementations for MongoDB.
Gateway to accumulator aggregation operations.
 
AggregationExpression for $covariancePop.
AggregationExpression for $covarianceSamp.
AccumulatorOperators.ExpMovingAvg calculates the exponential moving average of numeric values.
AggregationExpression for $stdDevPop.
AggregationExpression for $stdDevSamp.
Adds new fields to documents.
 
 
Callback being invoked after a domain object is materialized from a Document when reading results.
MongoMappingEvent thrown after convert of a document.
Event being thrown after a single or a set of documents has/have been deleted.
Event to be triggered after loading Documents to be mapped onto a given type.
Entity callback triggered after save of a Document.
MongoMappingEvent triggered after save of a document.
An Aggregation is a representation of a list of aggregation steps to be performed by the MongoDB Aggregation Framework.
The Aggregation annotation can be used to annotate a Repository query method so that it runs the Aggregation.pipeline() on invocation.
An AggregationExpression can be used with field expressions in aggregation pipeline stages like project and group.
Represents one single operation in an aggregation pipeline.
The context for an AggregationOperation.
Holds a set of configurable aggregation options that can be used within an aggregation pipeline.
A Builder for AggregationOptions.
Aggregation pipeline Domain type mappings supported by the mapping layer.
The AggregationPipeline holds the collection of aggregation stages.
Collects the results of executing an aggregation operation.
An AggregationExpression that renders a MongoDB Aggregation Framework expression from the AST of a SpEL expression.
Abstraction for db.collection.update() using an aggregation pipeline.
Fluent API AggregationUpdate builder.
 
Gateway to Arithmetic aggregation operations that perform math operations on numbers.
An expression that calculates the inverse cosine of a value.
An expression that calculates the inverse hyperbolic cosine of a value.
The unit of measure for computations that operate upon angles.
 
An expression that calculates the inverse sine of a value.
An expression that calculates the inverse hyperbolic sine of a value
An expression that calculates the inverse tangent of a value.
An expression that calculates the inverse tangent of y / x, where y and x are the first and second values passed to the expression respectively.
An expression that calculates the inverse hyperbolic tangent of a value
An expression that calculates the cosine of a value that is measured in radians.
An expression that calculates the hyperbolic cosine of a value that is measured in ArithmeticOperators.AngularUnit.RADIANS.
Value object to represent an expression that calculates the average rate of change within the specified window.
Value object to represent an expression that calculates the approximation for the mathematical integral value.
AggregationExpression for $multiply.
ArithmeticOperators.Rand returns a floating value between 0 and 1.
ArithmeticOperators.Round rounds a number to a whole integer or to a specified decimal place.
An expression that calculates the sine of a value that is measured in radians.
An expression that calculates the hyperbolic sine of a value that is measured in ArithmeticOperators.AngularUnit.RADIANS.
AggregationExpression for $subtract.
An expression that calculates the tangent of a value that is measured in radians.
An expression that calculates the hyperbolic tangent of a value that is measured in ArithmeticOperators.AngularUnit.RADIANS.
Gateway to array aggregation operations.
AggregationExpression for $arrayElementAt.
 
 
AggregationExpression for $arrayToObject that transforms an array into a single document.
AggregationExpression for $concatArrays.
$filter AggregationExpression allows to select a subset of the array to return based on the specified condition.
 
 
 
AggregationExpression for $first that returns the first element in an array.
 
AggregationExpression for $indexOfArray.
 
AggregationExpression for $isArray.
AggregationExpression for $last that returns the last element in an array.
 
 
 
 
 
 
AggregationExpression for $reverseArray.
 
AggregationExpression for $sortArray that sorts elements in an array.
 
JMX Metrics for assertions
EntityCallback to populate auditing related fields on an entity about to be saved.
JMX Metrics for Background Flushing
MongoDB specific MongoPersistentEntity implementation that adds Mongo specific meta-data such as the collection name and the like.
MongoDB specific PersistentProperty implementation.
Custom Query implementation to setup a basic query from some arbitrary JSON query string.
 
Constants to declare bean names used by the namespace configuration.
Callback being invoked before a domain object is converted to be persisted.
Event being thrown before a domain object is converted to be persisted.
Event being thrown before a document is deleted.
Entity callback triggered before save of a document.
MongoMappingEvent triggered before save of a document.
A MongoExpression using the ParameterBindingDocumentCodec for parsing a raw (json) expression.
Gateway to boolean expressions that evaluate their argument expressions as booleans and return a boolean as the result.
 
Internal API for operations on Bson elements that can be either Document or DBObject.
JMX Metrics for B-tree index counters
Encapsulates the aggregation framework $bucketAuto-operation.
Supported MongoDB granularities.
 
Encapsulates the aggregation framework $bucket-operation.
Base class for bucket operations that support output expressions the aggregation framework.
Builder for SpEL expression-based BucketOperationSupport.Output.
Output field that uses a Mongo operation (expression object) to generate an output field value.
Encapsulates an output field in a bucket aggregation stage.
Base class for BucketOperationSupport.Output builders that result in a BucketOperationSupport providing the built BucketOperationSupport.Output.
Is thrown when errors occur during bulk operations.
Bulk operations for insert/update/remove actions on a collection.
Mode for bulk operation.
Cancelable allows stopping long running tasks and freeing underlying resources.
Message implementation specific to MongoDB Change Streams.
Options applicable to MongoDB Change Streams.
Builder for creating ChangeStreamOptions.
SubscriptionRequest implementation to be used for listening to Change Streams via a MessageListenerContainer using the synchronous MongoDB Java driver.
Builder for creating ChangeStreamRequest.
NonTransientDataAccessException specific to MongoDB ClientSession related data access failures such as reading data using an already closed session.
Provider interface to obtain CodecRegistry from the underlying MongoDB Java driver.
Collation allows to define the rules used for language-specific string comparison.
Central abstraction for MongoDB collation support.
 
 
 
ICU locale abstraction for usage with MongoDB Collation.
Abstraction for the ICU Comparison Levels.
Primary-strength Collation.ICUComparisonLevel.
Secondary-strength Collation.ICUComparisonLevel.
Tertiary-strength Collation.ICUComparisonLevel.
Callback interface for executing actions against a MongoCollection.
Provides a simple wrapper to encapsulate the variety of settings you can use when creating a collection.
Encapsulation of options applied to define collections change stream behaviour.
Options applicable to Time Series collections.
Encapsulation of ValidationOptions options.
Gateway to comparison expressions.
 
Mark a class to use compound indexes.
Index definition to span multiple keys.
Container annotation that allows to collect multiple CompoundIndex annotations.
Gateway to conditional expressions that evaluate their argument expressions as booleans to a value.
Encapsulates the aggregation framework $cond operator.
 
 
 
 
Encapsulates the aggregation framework $ifNull operator.
 
 
 
Encapsulates the aggregation framework case document inside a $switch-operation.
 
JMX Metrics for Connections
Parse a String to a ConnectionString.
Factory to create a ContextProvider to propagate the request context across tasks.
Custom ParameterAccessor that uses a MongoWriter to serialize parameters into Mongo format.
Custom Iterator that adds a method to access elements in a converted manner.
Gateway to convert aggregation operations.
AggregationExpression for $convert that converts a value to a specified type.
 
AggregationExpression for $degreesToRadians that converts an input value measured in degrees to radians.
AggregationExpression for $toBool that converts a value to boolean.
AggregationExpression for $toDate that converts a value to date.
AggregationExpression for $toDecimal that converts a value to decimal.
AggregationExpression for $toDouble that converts a value to double.
AggregationExpression for $toInt that converts a value to integer.
AggregationExpression for $toLong that converts a value to long.
AggregationExpression for $toObjectId that converts a value to objectId.
AggregationExpression for $toString that converts a value to string.
Encapsulates the aggregation framework $count-operation.
Builder for CountOperation.
Annotation to declare finder count queries directly on repository methods.
Central class for creating queries.
MongoDB specific bitwise query operators like $bitsAllClear, $bitsAllSet,... for usage with Criteria.bits() and Query.
 
Simple callback interface to allow customization of a FindIterable.
Gateway to data type expressions.
Gateway to Date aggregation operations.
AggregationExpression for $dateAdd.
NOTE: Requires MongoDB 5.0 or later.
AggregationExpression for $dateDiff.
NOTE: Requires MongoDB 5.0 or later.
AggregationExpression for $dateFromParts.
NOTE: Requires MongoDB 3.6 or later.
 
 
AggregationExpression for $dateFromString.
NOTE: Requires MongoDB 3.6 or later.
 
 
AggregationExpression for $dateSubtract.
NOTE: Requires MongoDB 5.0 or later.
AggregationExpression for $dateToParts.
NOTE: Requires MongoDB 3.6 or later.
AggregationExpression for $dateToString.
 
AggregationExpression for $dateTrunc.
NOTE: Requires MongoDB 5.0 or later.
AggregationExpression for $dayOfMonth.
AggregationExpression for $dayOfWeek.
AggregationExpression for $dayOfYear.
AggregationExpression for $dateFromParts using ISO week date.
NOTE: Requires MongoDB 3.6 or later.
 
AggregationExpression for $isoDayOfWeek.
AggregationExpression for $isoWeek.
AggregationExpression for $isoWeekYear.
AggregationExpression for $millisecond.
Interface defining a temporal unit for date operators.
Timezone represents a MongoDB timezone abstraction which can be represented with a timezone ID or offset as a String.
AggregationExpression capable of setting a given DateOperators.Timezone.
AggregationExpression for $tsIncrement.
AggregationExpression for $tsSecond.
Callback interface for executing actions against a MongoDatabase.
 
An annotation that indicates the annotated field is to be stored using a DBRef.
 
Used to resolve associations annotated with DBRef.
Callback interface to be used in conjunction with DbRefResolver.
A DbRefResolver that resolves DBRefs by delegating to a DbRefResolverCallback than is able to generate lazy loading proxies.
Default implementation of IndexOperations.
Simple Executor based MessageListenerContainer implementation for running tasks like listening to MongoDB Change Streams and tailable cursors.
Default implementation of MongoTypeMapper allowing configuration of the key to lookup and store type information in Document.
TypeAliasAccessor to store aliases in a Document.
Default implementation of ReactiveIndexOperations.
ReferenceResolver implementation that uses a given ReferenceLookupDelegate to load and convert entity associations expressed via a persitent property.
Annotation to declare finder delete queries directly on repository methods.
Encapsulates the aggregation framework $densify-operation.
DensifyOperation.Range implementation holding lower and upper bound values.
 
Base DensifyOperation.Range implementation.
The actual time unit to apply to a DensifyOperation.Range.
Quick access to available units.
The DensifyOperation.Range specifies how the data is densified.
Identifies a domain object to be persisted to MongoDB.
An interface used by MongoTemplate for processing documents returned from a MongoDB query on a per-document basis.
Gateway to document expressions such as $rank, $documentNumber, etc.
DocumentOperators.DenseRank resolves the current document position (the rank) relative to other documents.
DocumentOperators.DocumentNumber resolves the current document position.
 
DocumentOperators.Rank resolves the current document position (the rank) relative to other documents.
Shift applies an expression to a document in a specified position relative to the current document.
A custom pointer to a linked document to be used along with DocumentReference for storing the linkage value.
A DocumentReference allows referencing entities in MongoDB using a flexible schema.
The source object to resolve document references upon.
Value object representing a dot path.
Annotation to enable auditing in MongoDB via annotation configuration.
Annotation to activate MongoDB repositories.
Annotation to enable auditing in MongoDB using reactive infrastructure via annotation configuration.
Annotation to activate reactive MongoDB repositories.
Encrypted provides data required for MongoDB Client Side Field Level Encryption that is applied during schema resolution.
Encryption algorithms supported by MongoDB Client Side Field Level Encryption.
Internal utility class for dealing with encryption related matters.
Gateway to evaluation operators such as $expr.
 
Allows the use of aggregation expressions within the query language.
Sets null and missing values to the last non-null value.
ExecutableAggregationOperation allows creation and execution of MongoDB aggregation operations in a fluent API style.
Define the aggregation with pipeline stages.
Collection override (Optional).
 
Trigger execution by calling one of the terminating methods.
ExecutableFindOperation allows creation and execution of MongoDB find operations in a fluent API style.
Result type override.
Result restrictions.
ExecutableFindOperation.ExecutableFind provides methods for constructing lookup operations in a fluent way.
Distinct Find support.
Collection override (Optional).
Result type override (Optional).
Terminating operations invoking the actual query execution.
Terminating distinct find operations.
Trigger find execution by calling one of the terminating methods.
Trigger geonear execution by calling one of the terminating methods.
ExecutableInsertOperation allows creation and execution of MongoDB insert and bulk insert operations in a fluent API style.
 
 
Collection override (optional).
Trigger bulk insert execution by calling one of the terminating methods.
Trigger insert execution by calling one of the terminating methods.
ExecutableMapReduceOperation allows creation and execution of MongoDB mapReduce operations in a fluent API style.
ExecutableMapReduceOperation.ExecutableMapReduce provides methods for constructing mapReduce operations in a fluent way.
Collection override (Optional).
Provide the Javascript function() used to map matching documents.
Deprecated.
Result type override (Optional).
Input document filter query (Optional).
Provide the Javascript function() used to reduce matching documents.
Trigger mapReduce execution by calling one of the terminating methods.
Deprecated.
since 2.2.
ExecutableRemoveOperation allows creation and execution of MongoDB remove / findAndRemove operations in a fluent API style.
 
Collection override (optional).
 
 
ExecutableUpdateOperation allows creation and execution of MongoDB update / findAndModify / findAndReplace operations in a fluent API style.
 
Result type override (Optional).
Trigger findAndModify execution by calling one of the terminating methods.
Trigger findOneAndReplace execution by calling one of the terminating methods.
Trigger update execution by calling one of the terminating methods.
Explicitly define the name of the collection to perform operation in.
Define a filter query for the Update.
Declare the Update to apply.
Annotation to declare finder exists queries directly on repository methods.
Value object to capture the fields exposed by an AggregationOperation.
A reference to an ExposedFields.ExposedField.
A value object for nodes in an expression.
The context for an ExpressionNode transformation.
SPI interface to implement components that can transform an ExpressionTransformationContextSupport into an object.
Internal utility class for dealing with Expression and potential ones.
Encapsulates the aggregation framework $facet-operation.
Builder for FacetOperation by adding existing and the new pipeline of AggregationOperation to the new FacetOperation.
Abstraction for a field.
Annotation to define custom metadata for document fields.
Field projection.
Intermediate builder part for projecting a MongoExpression to a result field.
Enumeration of write strategies to define when a property is included for write conversion.
Value object to capture a list of Field instances.
AggregationOperation that exposes ExposedFields that can be used for later aggregation pipeline AggregationOperations.
Marker interface for AggregationOperation that inherits fields from previous operations.
Enumeration of field value types that can be used to represent a Document field value.
 
Options for findOneAndReplace.
Simple callback interface to allow customization of a FindPublisher.
Stripped down interface providing access to a fluent API that specifies a basic set of MongoDB operations.
Wrapper around a Shape to allow appropriate query rendering.
GeoJson<T extends Iterable<?>>
Interface definition for structures defined in GeoJSON format.
Configuration class to expose GeoJsonModule as a Spring bean.
Defines a GeoJsonGeometryCollection that consists of a List of GeoJson objects.
GeoJsonLineString is defined as list of at least 2 Points.
A Jackson Module to register custom JsonDeserializers for GeoJSON types.
GeoJsonMultiPoint is defined as list of Points.
GeoJsonMultiPolygon is defined as a list of GeoJsonPolygons.
GeoJson representation of Point.
GeoJson representation of Polygon.
Represents a geoNear aggregation operation.
Value object to capture data to create a geo index.
Mark a field to be indexed using MongoDB's geospatial indexing feature.
Geoposatial index type.
JMX Metrics for Global Locks
Granularities available for Time Series data.
The Granularity of time series data that is closest to the time span between incoming measurements.
Encapsulates the aggregation framework $graphLookup-operation.
 
 
 
 
 
GridFs-specific helper class to define Criterias.
A common interface when dealing with GridFs items using Spring Data.
Additional, context relevant information.
Collection of operations to store and read files from MongoDB GridFS.
GridFSFile based Resource implementation.
GridFsOperations implementation to store content into MongoDB GridFS.
Upload descriptor for a GridFS file upload.
Builder to create GridFsUpload in a fluent way.
Encapsulates the aggregation framework $group-operation.
Builder for GroupOperations on a field.
IndexDefinition implementation for MongoDB Hashed Indexes maintaining entries with hashes of the values of the indexed field.
Annotation for a property that should be used as key for a Hashed Index.
JsonSchemaProperty implementation.
Convenience JsonSchemaProperty implementation for a type : 'array' property.
Convenience JsonSchemaProperty implementation for a type : 'boolean' property.
Convenience JsonSchemaProperty implementation for a type : 'date' property.
JsonSchemaProperty implementation for encrypted fields.
Convenience JsonSchemaProperty implementation for a type : 'null' property.
Convenience JsonSchemaProperty implementation for a type : 'number' property.
Convenience JsonSchemaProperty implementation for a type : 'object' property.
Delegating JsonSchemaProperty implementation having a required flag for evaluation during schema creation process.
Convenience JsonSchemaProperty implementation for a type : 'string' property.
Convenience JsonSchemaProperty implementation for a type : 'timestamp' property.
Convenience JsonSchemaProperty implementation without a type property.
 
 
 
Mark a field to be indexed using MongoDB's indexing feature.
Value object for an index field.
Use IndexFilter to create the partial filter expression used when creating Partial Indexes.
Index information for a MongoDB index.
Index operations on a collection.
Adapter for creating synchronous IndexOperations.
Provider interface to obtain IndexOperations by MongoDB collection name.
 
IndexResolver finds those IndexDefinitions to be created for a given class.
 
JsonSchemaMapper allows mapping a given Document containing a $jsonSchema to the fields of a given domain type.
Interface that can be implemented by objects that know how to serialize themselves to JSON schema using JsonSchemaObject.toDocument().
Type represents either a JSON schema type or a MongoDB specific bsonType.
 
 
A property or patternProperty within a JsonSchemaObject of type : 'object'.
Mark property as language field.
 
Allows direct interaction with the underlying LazyLoadingInterceptor.
 
ProxyFactory to create a proxy for PersistentProperty.getType() to resolve a reference lazily.
 
Encapsulates the $limit-operation.
A node representing a literal in an expression.
Gateway to literal aggregation operations.
AggregationExpression for $literal.
 
ApplicationListener for Mongo mapping events logging the events.
Encapsulates the aggregation framework $lookup-operation.
 
 
 
 
Builder for fluent LookupOperation creation.
A MongoDB document in its mapped state.
MongoConverter that uses a MappingContext to do sophisticated mapping of domain objects to Document.
Conversion context defining an interface for graph-traversal-based conversion of documents.
Conversion context holding references to simple MappingMongoConverter.DefaultConversionContext.ValueConverter and MappingMongoConverter.DefaultConversionContext.ContainerValueConverter.
Bean definition parser for the mapping-converter element.
MongoEntityInformation implementation using a MongoPersistentEntity instance to lookup the necessary information.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Encapsulates the $match-operation.
JMX Metrics for Memory
Encapsulates the $merge-operation.
Builder API to construct a MergeOperation.
Value Object representing the into field of a $merge aggregation stage.
Value object representing the unique id used during the merge operation to identify duplicates in the target collection.
Value Object specifying how to deal with a result document that do not match an existing document in the collection based on the fields of the on property describing the unique identifier.
Value Object specifying how to deal with a result document that matches an existing document in the collection based on the fields of the on property describing the unique identifier.
General message abstraction for any type of Event / Message published by MongoDB server to the client.
 
Listener interface to receive delivery of Messages.
Internal abstraction used by the framework representing a message listener container.
Meta-data for Query instances.
 
Meta.CursorOption represents OP_QUERY wire protocol flags to change the behavior of queries.
An ExpressionNode representing a method reference.
 
The actual argument type to use when mapping parameters to MongoDB specific format.
Metric and Distance conversions using the metric system.
Represents an action taken against the collection.
Enumeration for operations on a collection.
Mongo server administration exposed via JMX annotations
 
Annotation processor to create Querydsl query types for QueryDsl annotated classes.
 
BeanDefinitionParser to register a AuditingEntityCallback to transparently set auditing information on an entity.
Convenient factory for configuring MongoDB.
Parser for mongo-client definitions.
A factory bean for construction of a MongoClientSettings instance to be used with a MongoDB driver.
MongoClientVersion holds information about the used mongo-java client and is used to distinguish between different versions.
Helper class featuring helper methods for working with MongoDb collections.
Base class for Spring Data MongoDB to be extended for JavaConfiguration usage.
ValueConversionContext that allows to delegate read/write to an underlying MongoConverter.
Central Mongo specific converter interface which combines MongoWriter and EntityReader.
Parse a String to a Collection of MongoCredential.
Value object to capture custom conversion.
Interface for factories creating MongoDatabase instances.
ReferenceLoader implementation using a MongoDatabaseFactory to obtain raw documents for linked entities via a ReferenceLoader.DocumentReferenceQuery.
Common base class for usage with both MongoClients defining common properties such as database name and exception translator.
Helper class for managing a MongoDatabase instances via MongoDatabaseFactory.
MongoDbErrorCodes holds MongoDB specific error codes outlined in mongo/base/error_codes.err.
BeanDefinitionParser to parse db-factory elements into BeanDefinitions.
FactoryBean for creating AutoEncryptionSettings using the AutoEncryptionSettings.Builder.
Mongo specific EntityInformation.
Extension of EntityMetadata to additionally expose the collection name an entity shall be persisted to.
Mapper from Example to a query Document.
Wrapper object for MongoDB expressions like $toUpper : $name that manifest as Document when passed on to the driver.
ObservationConvention for MongoHandlerContext.
MongoId represents a MongoDB specific Id annotation that allows customizing id conversion.
 
Interface defining MongoDB-specific JSON schema object.
A resolution function that is called on conflicting paths when trying to merge properties with different values into a single value.
 
The result after processing a conflict when merging schemas.
MongoJsonSchema.MongoJsonSchemaBuilder provides a fluent API for defining a MongoJsonSchema.
MongoJsonSchemaCreator extracts the MongoJsonSchema for a given Class by applying the following mapping rules.
The context in which a specific MongoJsonSchemaCreator.JsonSchemaPropertyContext.getProperty() is encountered during schema creation.
 
JsonSchemaMapper implementation using the conversion and mapping infrastructure for mapping fields to the provided domain type.
 
Default implementation of a MappingContext for MongoDB using BasicMongoPersistentEntity and BasicMongoPersistentProperty as primary abstractions.
Base ApplicationEvent triggered by Spring Data MongoDB.
An implementation of ApplicationEventPublisher that will only fire MappingContextEvents for use by the index creator when MongoTemplate is used 'stand-alone', that is not declared inside a Spring ApplicationContext.
NamespaceHandler for Mongo DB configuration.
Implement MongoDB's CommandListener using Micrometer's Observation API.
Interface that specifies a basic set of MongoDB operations.
Mongo-specific ParameterAccessor exposing a maximum distance parameter.
Custom extension of Parameters discovering additional
Mongo-specific ParametersParameterAccessor to allow access to the Distance parameter.
MongoDB specific PersistentEntity abstraction.
Component that inspects MongoPersistentEntity instances contained in the given MongoMappingContext for indexing metadata and ensures the indexes to be available.
IndexResolver implementation inspecting MongoPersistentEntity for MongoPersistentEntity to be indexed.
 
Implementation of IndexDefinition holding additional (property)path information used for creating the index.
MongoDB specific PersistentProperty extension.
Simple Converter implementation to transform a MongoPersistentProperty into its field name.
Mongo specific implementation of QueryMethod.
 
Match modes for treatment of String values.
Mongo specific Repository interface.
CdiRepositoryBean to create Mongo repository instances.
NamespaceHandler to register repository configuration.
CDI extension to export Mongo repositories.
Factory to create MongoRepository instances.
FactoryBean to create MongoRepository instances.
FactoryBean for creating ServerApi using the ServerApi.Builder.
A simple interface for obtaining a ClientSession to be consumed by MongoOperations and MongoDB native operations that support causal consistency and transactions.
Simple constant holder for a SimpleTypeHolder enriched with Mongo specific simple types.
Primary implementation of MongoOperations.
A specific ClientSessionException related to issues with a transaction such as aborted or non existing transactions.
A PlatformTransactionManager implementation that manages ClientSession based transactions for a single MongoDatabaseFactory.
MongoDB specific transaction object, representing a MongoResourceHolder.
Mongo-specific TypeMapper exposing that Documents might contain a type key.
MongoDB-specific PropertyValueConverter extension.
A MongoWriter is responsible for converting an object of type T to the native MongoDB representation Document.
Deprecated.
since 2.2.
Annotation to be used for disambiguing method parameters that shall be used to trigger geo near queries.
Builder class to build near-queries.
No-Operation DBRef resolver throwing UnsupportedOperationException when attempting to resolve database references.
 
AggregationExpression for $getField.
AggregationExpression for $mergeObjects that combines multiple documents into a single document.
 
AggregationExpression for $objectToArray that converts a document to an array of documents that each contains two fields k and v.
AggregationExpression for $setField.
JMX Metrics for Operation counters
An ExpressionNode representing an operator.
Encapsulates the $out-operation.
The mode for merging the aggregation pipeline output.
Reusable context for binding parameters to a placeholder or a SpEL expression within a JSON structure.
A Codec implementation that allows binding parameters to placeholders or SpEL expressions when decoding a JSON String.
Reads a JSON and evaluates placehoders and SpEL expressions.
IndexFilter implementation for usage with plain Document as well as CriteriaDefinition filter expressions.
RepositoryQuery implementation for Mongo.
Simple helper to be able to wire the PersistentEntities from a MappingMongoConverter bean available in the application context.
Utility to translate a MongoPersistentProperty into a corresponding property from a different MongoPersistentEntity by looking it up by name.
AggregationOperationContext implementation prefixing non-command keys on root level with the given prefix.
Encapsulates the aggregation framework $project-operation.
Builder for array projections.
An ProjectionOperation.ProjectionOperationBuilder that is used for SpEL expression based projections.
Builder for ProjectionOperations on a field.
MongoDB Query object representing criteria, projection, sorting and query hints.
Annotation to declare finder queries directly on repository methods.
MongoDB-specific QuerydslPredicateExecutor that allows execution Predicates in various forms.
Base class to create repository implementations based on Querydsl.
A helper class to encapsulate any modifications of a Query object before it gets submitted to the database.
Converter to skip all properties after an association property was rendered.
Value object to represent a field and its meta-information.
Extension of QueryMapper.Field to be backed with mapping metadata.
Callback being invoked after a domain object is materialized from a Document when reading results.
Entity callback triggered after save of a Document.
ReactiveAggregationOperation allows creation and execution of reactive MongoDB aggregation operations in a fluent API style.
Define the aggregation with pipeline stages.
Collection override (optional).
 
Trigger execution by calling one of the terminating methods.
Reactive EntityCallback to populate auditing related fields on an entity about to be saved.
Callback being invoked before a domain object is converted to be persisted.
Entity callback triggered before save of a document.
ReactiveChangeStreamOperation allows creation and execution of reactive MongoDB Change Stream operations in a fluent API style.
Collection override (optional).
Provide a filter for limiting results (optional).
Provide some options.
ReactiveChangeStreamOperation.ReactiveChangeStream provides methods for constructing change stream operations in a fluent way.
Resume a change stream.
Compose change stream execution by calling one of the terminating methods.
 
 
ReactiveFindOperation allows creation and execution of reactive MongoDB find operations in a fluent API style.
Result type override.
Result restrictions.
Distinct Find support.
Collection override (optional).
Result type override (optional).
Provide a Query override (optional).
ReactiveFindOperation.ReactiveFind provides methods for constructing lookup operations in a fluent way.
Terminating distinct find operations.
Compose find execution by calling one of the terminating methods.
Compose geonear execution by calling one of the terminating methods.
Stripped down interface providing access to a fluent API that specifies a basic set of reactive MongoDB operations.
Collection of operations to store and read files from MongoDB GridFS using reactive infrastructure.
Reactive GridFSFile based Resource implementation.
ReactiveGridFsOperations implementation to store content into MongoDB GridFS.
Upload descriptor for a GridFS file upload.
Builder to create ReactiveGridFsUpload in a fluent way.
Index operations on a collection.
Provider interface to obtain ReactiveIndexOperations by MongoDB collection name.
ReactiveInsertOperation allows creation and execution of reactive MongoDB insert and bulk insert operations in a fluent API style.
Collection override (optional).
 
Compose insert execution by calling one of the terminating methods.
ReactiveMapReduceOperation allows creation and execution of MongoDB mapReduce operations in a fluent API style.
Collection override (Optional).
Provide the Javascript function() used to map matching documents.
Additional mapReduce options (Optional).
Result type override (Optional).
Input document filter query (Optional).
Provide the Javascript function() used to reduce matching documents.
ReactiveMapReduceOperation.ReactiveMapReduce provides methods for constructing reactive mapReduce operations in a fluent way.
Trigger mapReduce execution by calling one of the terminating methods.
Convenient factory for configuring a reactive streams MongoClient.
ReactiveMongoContext utilizes and enriches the Reactor Context with information potentially required for e.g.
Interface for factories creating reactive MongoDatabase instances.
Helper class for managing reactive MongoDatabase instances via ReactiveMongoDatabaseFactory.
Interface that specifies a basic set of MongoDB operations executed in a reactive way.
Component that inspects MongoPersistentEntity instances contained in the given MongoMappingContext for indexing metadata and ensures the indexes to be available using reactive infrastructure.
Reactive specific implementation of MongoQueryMethod.
Mongo specific Repository interface with reactive support.
Reactive RepositoryConfigurationExtension for MongoDB.
Factory to create ReactiveMongoRepository instances.
Primary implementation of ReactiveMongoOperations.
A ReactiveTransactionManager implementation that manages ClientSession based transactions for a single ReactiveMongoDatabaseFactory.
MongoDB specific transaction object, representing a MongoResourceHolder.
Reactive PartTree RepositoryQuery implementation for Mongo.
MongoDB-specific QuerydslPredicateExecutor that allows execution Predicates in various forms.
ReactiveRemoveOperation allows creation and execution of reactive MongoDB remove / findAndRemove operations in a fluent API style.
 
Collection override (optional).
Provide a Query override (optional).
Compose remove execution by calling one of the terminating methods.
Callback interface for executing operations within a ClientSession using reactive infrastructure.
Gateway interface to execute ClientSession bound operations against MongoDB via a ReactiveSessionCallback.
A reactive RepositoryQuery to use a plain JSON String to create an aggregation pipeline to actually execute.
Query to use a plain JSON String to create the Query to actually execute.
ReactiveUpdateOperation allows creation and execution of reactive MongoDB update / findAndModify / findAndReplace operations in a fluent API style.
Define FindAndModifyOptions (optional).
Result type override (Optional).
 
Compose findAndModify execution by calling one of the terminating methods.
Compose findAndReplace execution by calling one of the terminating methods.
Compose update execution by calling one of the terminating methods.
Explicitly define the name of the collection to perform operation in (optional).
Define a filter query for the Update (optional).
Declare the Update to apply.
Parse a String to a ReadConcern.
Interface to be implemented by any object that wishes to expose the ReadPreference.
Parse a String to a ReadPreference.
RedactOperation allows to restrict the content of a Document based on information stored within itself.
Builder to create new instance of RedactOperation.
The ReferenceLoader obtains raw documents for linked entities via a ReferenceLoader.DocumentReferenceQuery.
The ReferenceLoader.DocumentReferenceQuery defines the criteria by which documents should be matched applying potentially given order criteria.
A common delegate for ReferenceResolver implementations to resolve a reference to one/many target documents that are converted to entities.
The ReferenceResolver allows to load and convert linked entities.
Domain type conversion callback interface that allows to read the source object into a mapped object.
ReferenceResolver.ReferenceCollection is a value object that contains information about the target database and collection name of an association.
Utility to translate regex flags to MongoDB regex options and vice versa.
A TypeBasedAggregationOperationContext with less restrictive field reference handling, suppressing InvalidPersistentPropertyPath exceptions when resolving mapped field names.
Encapsulates the aggregation framework $replaceRoot-operation.
Replacement object that results in a replacement document or an expression that results in a document.
Encapsulates the aggregation framework $replaceRoot-operation to result in a composable replacement document.
Builder for ReplaceRootOperation.ReplaceRootDocumentOperation to populate ReplaceRootOperation.ReplacementDocument
Encapsulates the aggregation framework $replaceRoot-operation.
Encapsulates the $sample-operation.
Deprecated.
since 2.2.
Gateway to $function and $accumulator aggregation operations.
ScriptOperators.Accumulator defines a custom aggregation $accumulator operator, one that maintains its state (e.g. totals, maximums, minimums, and related data) as documents progress through the pipeline, in JavaScript.
 
 
 
 
 
 
ScriptOperators.Function defines a custom aggregation $function in JavaScript.
Gateway to selection operators such as $bottom.
AbstractAggregationExpression to return the bottom element according to the specified order.
AbstractAggregationExpression to return the $firstN elements.
AbstractAggregationExpression to return the $lastN elements.
AbstractAggregationExpression to return the top element according to the specified order.
Utility methods for JSON serialization.
Parse a String to a ServerAddress array.
Expose basic server information via JMX
MethodInterceptor implementation looking up and invoking an alternative target method having ClientSession as its first argument.
Represents an operation upon two operands of the same type, producing a result of the same type as the operands accepting ClientSession.
Callback interface for executing operations within a ClientSession.
Gateway interface to execute ClientSession bound operations against MongoDB via a SessionCallback.
SessionSynchronization is used along with MongoTemplate to define in which type of transactions to participate if any.
Adds new fields to documents.
 
 
Gateway to Set expressions which perform set operation on arrays, treating arrays as sets.
AggregationExpression for $allElementsTrue.
AggregationExpression for $anyElementTrue.
AggregationExpression for $setDifference.
AggregationExpression for $setEquals.
AggregationExpression for $setIntersection.
AggregationExpression for $setIsSubset.
 
AggregationExpression for $setUnion.
Encapsulates the setWindowFields-operation.
A Field that the result of a computation done via an AggregationExpression.
SetWindowFieldsOperation.Window implementation based on the current document.
SetWindowFieldsOperation.Window implementation based on the sort fields.
A fluent builder to create a SetWindowFieldsOperation.
Interface to capture field name used to capture the computation result.
Interface to capture an optional SetWindowFieldsOperation.Window applicable to the field computation.
SetWindowFieldsOperation.WindowOutput defines output of $setWindowFields stage by defining the field(s) to append to the documents in the output.
Quick access to documents and RangeWindow range windows.
The actual time unit to apply to a SetWindowFieldsOperation.Window.
Quick access to available units.
The Sharded annotation provides meta information about the actual distribution of data.
 
Value object representing an entities Shard Key used to distribute documents across a sharded MongoDB cluster.
Factory to create MongoDatabase instances from a MongoClient instance.
Repository base implementation for Mongo.
Factory to create MongoDatabase instances from a MongoClient instance.
Reactive repository base implementation for Mongo.
Encapsulates the aggregation framework $skip-operation.
Encapsulates the aggregation framework $sortByCount-operation.
Encapsulates the aggregation framework $sort-operation.
Represents a geospatial sphere value.
Class that exposes the SpringData MongoDB specific information like the current Version or driver information.
Spring Data specific simple Fetchable Query implementation.
AbstractMongoQuery implementation to run string-based aggregations using Aggregation.
Query to use a plain JSON String to create the Query to actually execute.
Gateway to String aggregation operations.
AggregationExpression for $indexOfBytes.
 
AggregationExpression for $indexOfCP.
 
AggregationExpression for $ltrim which removes whitespace or the specified characters from the beginning of a string.
AggregationExpression for $regexFind which applies a regular expression (regex) to a string and returns information on the first matched substring.
AggregationExpression for $regexFindAll which applies a regular expression (regex) to a string and returns information on all the matched substrings.
AggregationExpression for $regexMatch which applies a regular expression (regex) to a string and returns a boolean that indicates if a match is found or not.
AggregationExpression for $replaceAll which replaces all instances of a search string in an input string with a replacement string.
AggregationExpression for $replaceOne which replaces the first instance of a search string in an input string with a replacement string.
AggregationExpression for $rtrim which removes whitespace or the specified characters from the end of a string.
AggregationExpression for $strcasecmp.
 
AggregationExpression for $strLenBytes.
AggregationExpression for $strLenCP.
AggregationExpression for $substrCP.
AggregationExpression for $toLower.
AggregationExpression for $toUpper.
AggregationExpression for $trim which removes whitespace or the specified characters from the beginning and end of a string.
Converter to create WriteConcern instances from String representations.
The Subscription is the link between the SubscriptionRequest and the actual running Task.
Options for specifying the behaviour of the SubscriptionRequest.
Describes the system variables available in MongoDB aggregation framework pipeline expressions.
Annotation to declare an infinite stream using MongoDB's tailable cursors.
SubscriptionRequest implementation to be used to listen to query results in a Capped Collection using a Tailable Cursor.
Builder for creating TailableCursorRequest.
The actual Task to run within the MessageListenerContainer.
The Task.State defining the lifecycle phase the actual Task.
A Term defines one or multiple words Term.Type.WORD or phrases Term.Type.PHRASE to be used in the context of full text search.
 
 
Implementation of CriteriaDefinition to be used for full text search.
IndexDefinition to span multiple keys for text search.
 
TextIndexed marks a field to be part of the text index.
Query implementation to be used to for performing full text searches.
TextScore marks the property to be considered as the on server calculated textScore when doing full text search.
Identifies a domain object to be persisted to a MongoDB Time Series collection.
AggregationOperationContext aware of a particular type and a MappingContext to potentially translate property references into document field names.
A TypedAggregation is a special Aggregation that holds information of the input aggregation type.
JsonSchemaObject implementation of type : 'array' schema elements.
Provides programmatic access to schema specifics like range, minItems, maxItems,... via a fluent API producing immutable schema objects.
JsonSchemaObject implementation of type : 'boolean' schema elements.
Provides programmatic access to schema specifics via a fluent API producing immutable schema objects.
JsonSchemaObject implementation of type : 'number', bsonType : 'int', bsonType : 'long', bsonType : 'double' and bsonType : 'decimal128' schema elements.
Provides programmatic access to schema specifics like multipleOf, minimum, maximum,... via a fluent API producing immutable schema objects.
JsonSchemaObject implementation of type : 'object' schema elements.
Provides programmatic access to schema specifics like required, properties, patternProperties,... via a fluent API producing immutable schema objects.
JsonSchemaObject implementation of type : 'string' schema elements.
Provides programmatic access to schema specifics like minLength, maxLength, pattern,... via a fluent API producing immutable schema objects.
 
The $unionWith aggregation stage (available since MongoDB 4.4) performs a union of two collections by combining pipeline results, potentially containing duplicates, into a single result set that is handed over to the next stage.
Removes fields from documents.
ExampleMatcher implementation for query by example (QBE).
Common base for JsonSchemaObject with shared types and JsonSchemaObject.toDocument() implementation.
Encapsulates the aggregation framework $unwind-operation.
 
 
 
Builder for fluent UnwindOperation creation.
The annotation to configure a value object as flattened out in the target document.
Shortcut for an empty unwrapped property.
Shortcut for a nullable unwrapped property.
Load strategy to be used Unwrapped.onEmpty().
Class to easily construct MongoDB update clauses.
Annotation to declare update operators directly on repository methods.
 
Marker interface of nested commands.
Modifiers holds a distinct collection of Update.Modifier
 
Interface fixing must have operations for updates as implemented via Update.
A filter to specify which elements to modify in an array field.
A subclass of QueryMapper that retains type information on the mongo types.
Parse a String to a UuidRepresentation.
javax.validation dependant entities validator.
Provides a validator object to be used for collection validation via CollectionOptions.ValidationOptions.
A value provider to retrieve bindable values by their parameter index.
Gateway to variable aggregation operations.
AggregationExpression for $let that binds AggregationExpression to variables for use in the specified in expression, and returns the result of the expression.
 
 
 
 
Immutable object holding additional options to be applied when creating a MongoDB views.
WildcardIndex is a specific Index that can be used to include all fields into an index based on the $**" : 1 pattern on a root object (the one typically carrying the Document annotation).
Annotation for an entity or property that should be used as key for a Wildcard Index.
Parse a string to a WriteConcern.
A strategy interface to determine the WriteConcern to use for a given MongoAction.
Enum to represent how strict the check of WriteConcernResult shall be.