All Classes and Interfaces
Class
Description
Evaluator for the function ABS(numExpr).
Abstract implementation of a metadata annotations reader.
Abstract representation of an autostart mechanism.
Abstract implementation of a lazy load list for candidates.
Abstract representation of the MetaData of a class/interface.
Abstract representation of a ValueGenerator requiring a connection to a datastore.
Abstract implementation of a ConnectionFactory for a DataNucleus-supported datastore.
This element specifies the mapping for the element component of arrays and collections.
Abstract base for any emulated XAResource implementations for the store plugins.
Abstract evaluator for an expression.
Abstract representation of a JDO Extent.
Base field manager for handling the fetching of fields.
Exception thrown when we reach the end of the fetch depth in a branch of the object graph
Abstract field manager for retrieval of objects.
Abstract representation of a field manager.
Abstract value generator.
Abstract representation of a Java-based query.
Abstract representation of a JDOQL query.
Abstract representation of a JPQL query used by DataNucleus.
Abstract implementation of a lazy loaded list of (persistent) objects.
Abstract starting point for a third-party L2 cache plugin.
Abstract implementation of a managed connection.
Abstract representation of a query results cache for the query based on a map.
Abstract representation of MetaData for a field/property of a class/interface.
Abstract base for any naming factory, providing convenience facilities like truncation.
Base implementation of a NucleusContext, providing configuration, metadata management, type management, plugin management and ClassLoader services.
Abstract query parser.
Abstract representation of a persistence handler, to be extended by datastores own variant.
Abstract representation of a cache of generic query compilations.
Abstract representation of a query compilation cache for the query specific to the datastore.
Abstract representation of a QueryResult.
Abstract implementation of an iterator for query results.
Root implementation of a query results cache, providing provessing of common persistence properties.
Abstract referenced implementation of a Level 2 cache, to be used as the base for weak/soft variants.
Abstract mapper for getting results from a query.
Abstract base class for a statistics object.
Simple Moving Average
Abstract representation of a stored procedure query.
Abstract field manager for storage of objects.
An abstract representation of a Store Manager.
Abstract base for any StoreSchemaHandler.
Base symbol resolver, to be extended for particular query languages.
Value generator for a UUID format.
Abstract handler for XML MetaData parsing.
Representation of a field/method that is annotated.
Interface defining the access to MetaData derived from Annotations.
Manager for annotations.
Wrapper for an annotation and its various properties etc.
Interface defining the access to MetaData derived from Annotations.
A visitor to visit a Java annotation.
An
AnnotationVisitor that generates a corresponding 'annotation' or 'type_annotation'
structure, as defined in the Java Virtual Machine Specification (JVMS).Adapter to allow the core runtime to expose multiple APIs to clients.
Factory of API adapters.
Simple class to handle the copying of PK fields from an object id to an object.
Evaluator for the function ACOS(numExpr).
Evaluator for the function ASIN(numExpr).
Evaluator for the function ATAN2(numExpr).
Evaluator for the function ATAN(numExpr).
Evaluator for the method "{arrayExpr}.contains(elemExpr)".
Helper class providing conversion methods for use with arrays.
Expression representing an input array of expressions (or at least some of the array is of expressions).
A mutable second-class ArrayList object.
A mutable second-class ArrayList object.
Representation of the Meta-Data for an Array.
Evaluator for the method "{arrayExpr}.size()".
Interface representation of the backing store for an array.
Locator for the TransactionManager for Atomikos.
Utility class to handle the attach of fields.
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine
Specification (JVMS).
A set of attribute prototypes (attributes with the same type are considered equal).
This generator uses a Java implementation of DCE UUIDs to create unique
identifiers without the overhead of additional database transactions or even
an open database connection.
An almost unique ID.
This class represents the current state of the AUID generator.
Interface defining an Auto-Start Mechanism.
Convenience methods to assist in use of AutoStartMechanism(s).
Interface implemented by backed SCOs.
Interface implemented by a StoreManager when it supports "backed" SCO wrappers (i.e SCO fields have a
connection to the datastore via a "backing store" to support more efficient connectivity).
Basic property store implementation, allowing setting of properties
Handles the integration of "javax.validation" Bean Validation API (JSR 303).
Resolver for traversal of validation.
Expression representing a BigDecimal, used in evaluation of aggregates.
Convenience class to handle Java serialisation of a BigDecimal[] object to/from ByteBuffer.
Class to handle the conversion between java.math.BigDecimal and a Double form.
Class to handle the conversion between java.math.BigDecimal and a String form.
Expression representing a BigInteger, used in evaluation of aggregates.
Convenience class to handle Java serialisation of a BigInteger[] object to/from ByteBuffer.
Class to handle the conversion between java.math.BigInteger and a Long form.
Class to handle the conversion between java.math.BigInteger and a String form.
A mutable second-class BitSet object.
Class to handle the conversion between java.util.BitSet and a String form.
Convenience class to handle Java serialisation of a boolean[] object to/from ByteBuffer.
Class to handle the conversion between java.lang.Boolean and an Integer (0, 1) form.
Validator for a property that represents a boolean.
Class to handle the conversion between java.lang.Boolean and a Character ("Y", "N") form.
Locator for the TransactionManager for BTM (Bitronix).
Convenience class to handle Java serialisation of a BufferedImage object to/from byte[].
Convenience class to handle Java serialisation of a BufferedImage object to/from ByteBuffer.
A Plug-in (OSGi Bundle) definition.
Description of bundles.
Bundle Version - according to OSGi spec 3.0 $3.2.4
Bundle Range - according to OSGi spec 3.0 $3.2.5
Convenience class to handle Java serialisation of a byte[] object to/from ByteBuffer.
This class is for identity with a single byte field.
Convenience class to handle Java serialisation of a Byte[] object to/from ByteBuffer.
A dynamically extensible vector of bytes.
An object that is stored in the Level2 Cache keyed by the identity of the persistable object.
Key representing a unique key for a persistable object.
Class to handle the conversion between java.util.Calendar and (Long, String) being the time in millisecs plus the timezone.
Class to handle the conversion between java.util.Calendar and a java.util.Date form.
Class to handle the conversion between java.util.Calendar and a String form.
Class to handle the conversion between java.util.Calendar and a java.sql.Timestamp.
CallBack handlers receive notification of events on persistent objects.
QueryResult taking in the list of identities of the objects of candidate type.
Expression representing a case series of when expressions and their action expressions.
Handles the integration of "javax.enterprise.inject" CDI API.
Evaluator for the function CEIL(numExpr).
Class to handle the conversion between Character and a String form.
Convenience class to handle Java serialisation of a char[] object to/from ByteBuffer.
This class is for identity with a single character field.
Interface defining a handler for class annotations.
Constants with classes (class created to reduce overhead on calling Class.class *performance*)
Interface representation of an enhancer of a class.
Class enhancer using ASM (see http://asm.objectweb.org but included in DataNucleus core repackaged).
Convenience class to look up the class name for a file.
An auto-starter mechanism that uses a defined list of classes to be loaded at start.
Expression representing a candidate in a FROM clause.
Representation of a field that an enhanced class requires.
Class to allow resolution and loading of classes in a persistence framework.
A basic implementation of a ClassLoaderResolver.
Representation of the MetaData of a class.
Representation of a method that an enhanced class requires.
Constants with classes names (created to reduce overhead on calling Class.class.getName()), namely performance.
A ClassNotDetachableException is thrown if an attempt is
made to detach an object whose class is not detachable.
An exception thrown when an operation is invoked that requires a persistable object yet the object passed in
is not suitable.
A ClassNotResolvedException is thrown if an attempt is
made to load a class that cannot be found by the ClassLoaderResolver.
Definition of the options for persistence-modifier of a class.
A parser to make a
ClassVisitor visit a ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).Class to handle the conversion between java.lang.Class and a String form.
Exception thrown when the constant pool of a class produced by a
ClassWriter is too
large.Utilities for handling classes.
A visitor to visit a Java class.
A
ClassVisitor that generates a corresponding ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).Method to generate a default "clone" method, using ASM, that has the effect of nulling the state manager etc.
Evaluator for the function COALESCE(numExpr[, numExpr2[, numExpr3] etc]).
A mutable second-class Collection object.
A mutable second-class Collection object.
Add operation for a collection where we have a backing store.
Clear operation for a collection where we have a backing store.
Evaluator for the method "{collExpr}.contains(elemExpr)".
Representation of the MetaData of a collection.
Remove operation for a collection.
Interface representation of the backing store for a Collection.
TypeConverter for storing a java.awt.Color as its 4 components (red, green, blue, alpha).
Class to handle the conversion between java.awt.Color (RGBA) and a String form.
Interface representing a column in a table.
Representation of a column in a table.
Interface implemented by a TypeConverter if it has default length values for any of its datastore columns.
Representation of the Meta-Data for a column mapping of a field.
Interface defining an object that contains Columns.
Enum defining the types of columns.
Command line option parser.
No argument option class.
CommandLine option base class
Use argment option class.
Helper used by
DataNucleusEnhancer.main(String[]) to process the command line arguments.A CommitStateTransitionException is thrown when an error occurs
transitioning from one lifecycle state to another.
Enum defining the component of a query being compiled.
Interface to be implemented by an "optimiser" for the query compilation process.
Representation of a table for a class where the class is stored in "complete-table" inheritance (or in JPA "TablePerClass")
whereby all members (in this class and superclasses) are handled in this table.
Evaluator for the function CONCAT(strExpr1, strExpr2).
An advanced hash table supporting configurable garbage collection semantics of keys and values, optional
referential-equality, full concurrency of retrievals, and adjustable expected concurrency for updates.
ConcurrentReferenceHashMap list entry.
An option specifying which Java reference type should be used to refer to a key and/or value.
Segments are specialized versions of hash tables.
A soft-key reference which stores the key hash needed for reclamation.
A weak-key reference which stores the key hash needed for reclamation.
Class providing configuration for the context.
Convenience class wrapping the plugin property specification information.
Represents XML elements declared nested in the extension element
Interface to be implemented by an decryption provider allowing encrypted passwords
in persistence properties.
Factory for connections to the datastore.
Exception thrown if a named connection factory cannot be found using its JNDI name.
Manager of connections for a StoreManager, allowing ManagedConnection pooling, enlistment in transaction.
Manager of connections for a datastore, allowing caching of ManagedConnections, enlistment in transaction.
Resource type of the connection.
A constant whose value is computed at runtime, with a bootstrap method.
Defines additional JVM opcodes, access flags and constants which are not part of the ASM public
API.
Representation of an ORM constraint.
An adapter for container classes allowing DN to operate on them in a generic form instead of
depending directly on the JDK containers.
Representation of the details of an object stored in a container.
Provides support for SCO Containers types in DN.
Evaluator for the method "{contExpr}.isEmpty()".
Representation of the Meta-Data for a container.
Evaluator for the method "{contExpr}.size()".
Information about a class being parsed in a
ClassReader.Method to generate the method "dnCopyField" using ASM.
Method to generate the method "dnCopyFields" using ASM.
Method to generate the method "dnCopyKeyFieldsFromObjectId" using ASM.
Method to generate the method "dnCopyKeyFieldsFromObjectId" using ASM.
Method to generate the method "dnCopyKeyFieldsToObjectId" using ASM.
Method to generate the method "dnCopyKeyFieldsToObjectId" using ASM.
Validator for persistence properties used by core.
Evaluator for the function COSH(numExpr).
Evaluator for the function COS(numExpr).
Evaluator for the function COT(numExpr).
Expression representing something like "new X.Y.Z([param1[,param2[,param3]]])".
Class to handle the conversion between java.util.Currency and a String form.
Evaluator for the function CURRENT_DATE().
Information about the input stack map frame at the "current" instruction of a method.
Evaluator for the function CURRENT_TIME().
Evaluator for the function CURRENT_TIMESTAMP().
Provides the current user in order to support 'CreateUser', 'UpdateUser' audit features.
Locator for the TransactionManager in a user-defined JNDI location defined by persistence properties.
Entry Point (as per Java) for transforming classes at runtime.
DataNucleus Byte-Code Enhancer.
Interface for a datastore-identity class to implement.
Meta-Data for the datastore-identity of a class.
An object identifier, typically used for datastore identity.
Object identifier, typically used for datastore identity.
Object identifier, typically used for datastore identity.
Representation of an error encountered initialising a datastore.
Exception thrown when trying to update a datastores contents when it is read-only.
Identity for use with datastore-identity where the datastore provides a unique "identity" long key per object
and hence doesn't need the class name.
A DatastoreValidationException is thrown if a mismatch is discovered
between what the JDO runtime thinks the datastore should look like and what it
actually looks like.
A mutable second-class date object.
Expression representing a "java.util.Date" (and subclasses), used in evaluation of aggregates.
Evaluator for the method "{dateExpr}.getDay()".
Evaluator for the method "{dateExpr}.getDayOfWeek()".
Evaluator for the method "{dateExpr}.getHours()".
Evaluator for the method "{dateExpr}.getMinutes()".
Evaluator for the method "{dateExpr}.getMonth()".
Evaluator for the method "{dateExpr}.getSeconds()".
Evaluator for the method "{dateExpr}.getTime()".
Evaluator for the method "{dateExpr}.getYear()".
Class to handle the conversion between java.util.Date and a Long form.
Class to handle the conversion between java.util.Date and a String form.
Extent that does a simple JDOQL query for the candidate with/without subclasses.
Method to generate a default Constructor using ASM.
Fallback StoreSchemaHandler that simply provides access to the schema flags.
Evaluator for the function DEGREES(numExpr).
Field manager that deletes all "dependent" PC objects referenced from the source object.
Flush operation for a delete of the specified object.
This interface is implemented by classes that can be detached from the persistence context and later
attached.
FieldManager to handle the detachment of fields with persistable objects.
Listener hook for detachment events, as an alternative to the JDO standard process of throwing a NucleusUserException.
Holder for the detachment state control for the detachment process.
Representation of a discriminator in an inheritance strategy.
Representation of the values for discriminator "strategy".
Naming factory used by DataNucleus v3.x onwards.
StateManager for DataNucleus systems for a managed object, extending the basic enhancement contract for a StateManager.
Expression representing a Double, used in evaluation of aggregates.
Convenience class to handle Java serialisation of a double[] object to/from ByteBuffer.
Class to handle the conversion between java.time.Duration and a Double form.
Class to handle the conversion between java.time.Duration and a Long form.
Class to handle the conversion between java.time.Duration and a String form.
Expression between two other expressions and an operation.
An edge in the control flow graph of a method.
This element specifies the mapping for the element component of arrays and collections.
This element specifies the mapping for an embedded type.
Interface implemented by any StoreManager that wants to provide a hook to encrypt field data
prior to persistence.
Helper class for the DN bytecode enhancement contract.
Helper class to manage persistable classes.
Interface defining the naming of fields/classes used in enhancement.
NucleusContext to use when enhancing.
Adapter visitor class for providing enhancement of an existing class using ASM.
Visitor used to check the enhancement state of a class.
ClassLoader for newly defined classes.
Adapter for clone() method in persistence-enabled classes.
Adapter for methods in persistence-enabled classes allowing enhancement of direct access to user fields.
Adapter for property getter methods in persistence-enabled classes.
Adapter for property setter methods in persistence-enabled classes.
Enhancer Ant Task.
Utility class for bytecode enhancement using ASM.
Helper class providing conversion methods for use with enums.
Evaluator for the method "{enumExpr}.matches(expr)".
Evaluator for the method "{enumExpr}.ordinal()".
Evaluator for the method "{enumExpr}.toString()".
Listener for events, following the JPA/Jakarta model.
Context of execution for persistence operations.
Interface to be implemented by a listener for the closure of the ExecutionContext.
Manager for persistence/retrieval of objects within an execution context, equating to the work required by JDO PersistenceManager and JPA EntityManager.
Callback handler that does nothing.
Context info for a particular thread.
Listener for closure of an ExecutionContext.
Pool of ExecutionContext objects.
Reference for an ExecutionContext, for use in the enhancement contract.
ExecutionContext to attempt to handle multi-threaded PM/EM cases.
Evaluator for the function EXP(numExpr).
A Scalar expression in a Query.
"Dyadic" operator performs operation on one or two operands.
"Monadic" operator performs a function on one operand.
Representation of an Operator.
Compiler for expressions.
Interface for an evaluator of an expression.
Extension declared in a plug-in.
Extension Point declared in a plug-in.
Extent of objects within DataNucleus.
TransactionManager locator using a factory class.
Statistics for a factory of persistence (PMF/EMF).
Interface defining the MBean for a persistence factory.
JDOQL query that is federated across multiple datastores
Persistence handler for federated datastores.
Manager for queries for federated datastores.
A federated StoreManager orchestrates the persistence/retrieval for multiple datastores.
Group of fields for fetching, to be used by a FetchPlan.
Manager for dynamic fetch groups.
Metadata defining a member of a fetch-group.
A fetch group defines a particular loaded state for an object graph.
FetchPlan for fields for use internally.
Representation of the fetch plan for a particular class, defining the members that are to be fetched.
FetchPlan defined in MetaData.
Holder for the state control for FetchPlan processing.
Provide methods to fetch from/to a persistable object to/from StateManager/DataStore.
Representation of the Meta-Data for a field of a class.
Class defining the possibilities for persistence, in terms of the type of
persistence, and the types that are capable to be supported.
Series of roles that fields can be performing in the (ORM) mapping process.
Interface for field values.
A visitor to visit a Java field.
A
FieldVisitor that generates a corresponding 'field_info' structure, as defined in the
Java Virtual Machine Specification (JVMS).Representation of a Meta-Data file.
Expression representing a Float, used in evaluation of aggregates.
Convenience class to handle Java serialisation of a float[] object to/from ByteBuffer.
Evaluator for the function FLOOR(numExpr).
Flush mode for the persistence process.
Flush method for cases where the datastore doesn't use referential integrity so we can send batches
of deletes, then batches of inserts, then any updates to optimise the persistence.
Flush process that processes the objects in the order that they became dirty.
Representation of a persistence flush process.
Foreign keys represent a consistency constraint in the database that must be
maintained.
Foreign keys in metadata serve two quite different purposes.
The input and output stack map frames of a basic block.
Class for providing faster access to properties that are rarely set but often read.
Method to generate the method "dnGetExecutionContext" using ASM.
Method to generate the method "__dnGetInheritedFieldCount" using ASM.
Method to generate the method "dnGetManagedFieldCount" using ASM.
Method to generate the method "dnGetZZZ" using ASM for NORMAL_GET fields.
Method to generate the method "dnGetObjectId" using ASM.
Method to generate the method "dnGetStateManager" using ASM.
Method to generate the method "dnGetTransactionalObjectId" using ASM.
Method to generate the method "dnGetVersion" using ASM.
Method to generate the method "dnGetZZZ" using ASM for CHECK_READ fields.
Method to generate the method "dnGetZZZ" using ASM for MEDIATE_READ fields.
A mutable second-class GregorianCalendar object.
A reference to a field or a method.
Information about an exception handler.
A mutable second-class HashMap object.
A mutable second-class HashMap object.
A mutable second-class HashSet object.
A mutable second-class HashSet object.
A mutable second-class Hashtable object.
A mutable second-class Hashtable object.
Translator for object identities where the user wants to input identities that are not strict
key forms, so this returns a valid identity.
Manager for identity creation etc.
Manager for identity operations.
Simple identity being a reference to the object itself.
Translator for object identities where the user wants to input identities that are not strict
JDO standard toString() forms, so this converts them.
Representation of the values for identity-type.
Series of utilities for handling identities of objects.
A IllegalStateTransitionException is thrown if a life-cycle
state attempts a transition that is illegal.
Create instances of persistable objects.
Creator of persistable objects using the ASM bytecode manipulation library.
Implementation generator using ASM bytecode manipulation library.
The implements element declares a persistence-capable interface implemented by the
persistence-capable class that contains this element.
Utility class handling Imports.
A IncompatibleFieldTypeException is thrown if an incompatible field
type is specified in the construction of a second-class object instance.
Representation of whether an item is indexed or not.
For schema generation, it might be useful to specify that a column or columns
be indexed, and to provide the name of the index.
Representation of the Meta-Data defining inherited classes.
Representation of the values for inheritance "strategy".
Method to generate a static initialisation block for the class using ASM.
Method to generate the method "__dnFieldNamesInit" using ASM.
Class providing evaluation of java "string-based" queries in-memory.
Class representing a failure in the in-memory evaluation process.
Simple wrapper to results generated by the in-memory query process suitable for use by JDO/JPA.
Class to handle the conversion between java.time.Instant and java.util.Date.
Class to handle the conversion between java.time.Instant and Long (of the epoch millisecs).
Class to handle the conversion between java.time.Instant and a String form.
Class to handle the conversion between java.time.Instant and java.sql.Timestamp
Convenience class to handle Java serialisation of a int[] object to/from ByteBuffer.
Expression representing an Integer, used in evaluation of aggregates.
Validator for a property that represents an integer.
Class to handle the conversion between java.lang.Integer and a String form.
Representation of the MetaData of a "persistent-interface".
This class is for identity with a single int field.
Exception thrown when an annotation has been specified that is invalid in the circumstances.
Exception thrown when meta-data specific to a class is invalid.
Exception thrown when meta-data specific to a member of a class is invalid.
Representation of an exception thrown when an error occurs in Meta-Data definition.
Exception thrown when a primary key class is found to be invalid for some reason.
Interface representing an evaluator for an invocation of a method/function.
Expression representing invocation of a method.
Method to generate the method "dnIsDeleted" using ASM.
Method to generate the method "dnIsDetached" using ASM.
Method to generate the method "dnIsDirty" using ASM.
Method to generate the method "dnIsNew" using ASM.
Method to generate the method "dnIsPersistent" using ASM.
Method to generate the method "dnIsTransactional" using ASM.
Base method to use for dnIsXXX methods providing the majority of the enhancement.
Typical implementation of a compiler for a java-based query language.
Class to evaluate a Java "string-based" query in whole or part.
Simple implementation of a plugin for use of javax.cache (v0.61+) product with DataNucleus.
Query compilation cache using javax.cache for implementation.
Query compilation (datastore) cache using javax.cache for implementation.
Implementation of a query results cache using javax.cache (v0.3+) interface.
Locator for the TransactionManager for JBoss.
Representation of the jdbc-type of a column.
Definition of enhancement naming, for use with the JDO API.
Implementation of a compiler for JDOQL (JSR0012, JSR0243).
Class to evaluate a JDOQL query in whole or part.
Implementation of a parser for JDOQL query language.
JDOQL query helper class providing key information about the language etc.
Class to map the results of a JDOQL query to the result class.
Parser for handling JDOQL Single-String queries.
Tokenizer that provides access to current token.
Symbol resolver for JDOQL.
Locator for a JTA TransactionManager using JNDI context namings.
Expression representing a join between a candidate class, and the class of a field of the first class.
Secondary tables and join tables are mapped using a join condition that
associates a column or columns in the secondary or join table with a column
or columns in the primary table, typically the primary tables primary key
columns.
Locator for the TransactionManager for JOnAS.
Locator for the TransactionManager for JOTM.
Definition of enhancement naming for use with the JPA/Jakarta APIs.
Naming factory following JPA specification rules.
Implementation of a compiler for JPQL (JSR0220, JSR0317).
Class to evaluate a JPQL query in whole or part.
Implementation of a parser for JPQL query language.
JPQL query helper class providing key information about the language etc.
Class to map the results of a JPQL query to the result class.
Parser for handling JPQL Single-String queries.
Tokenizer that provides access to current token.
Symbol resolver for JPQL.
JRE logger (java.util.logging) implementation of a NucleusLogger.
A transaction that is synchronised with a Java Transaction Service (JTA) transaction with JCA.
Wrapper around TransactionSynchronizationRegistry (only present JTA1.1+).
Exception thrown by construction of JTATransactionSyncRegistry when it is not available.
Transaction that is synchronized with a Java Transaction Service (JTA) transaction.
This element specifies the mapping for the key component of maps.
FieldManager responsible for populating the provided CachedPC object.
FieldManager responsible for retrieving the values from the provided CachedPC object.
A position in the bytecode of a method.
Evaluator for the function LENGTH(stringExpr).
Provides an interface for Level 1 caches.
Interface for any Level 2 Cache used internally.
Lexer for a Query.
Base Class representing the life cycle state.
A mutable second-class LinkedHashMap object.
A mutable second-class LinkedHashMap object.
A mutable second-class LinkedHashSet object.
A mutable second-class LinkedHashSet object.
A mutable second-class LinkedList object.
A mutable second-class LinkedList object.
A mutable second-class List object.
A mutable second-class List object.
Add operation at a position for a list where we have a backing store.
Evaluator for the method "{listExpr}.get(idxExpr)".
Evaluator for the method "{listExpr}.indexOf(elemExpr)".
Remove operation for a list at a particular index where we have a backing store.
Set operation for a list where we have a backing store.
Interface representation of the backing store for a List.
Interface representing schema information for the datastore.
Literal of some type (String, Double, Long, BigDecimal, etc).
Method to generate the method "loadClass" using ASM.
Field Manager to handle loading all fields of all objects in the fetch plan.
Class to handle the conversion between java.time.LocalDate and java.util.Date.
Evaluator for the function LOCAL_DATE().
Evaluator for the method "{localDateExpr}.getDayOfMonth()".
Evaluator for the method "{localDateExpr}.getDayOfWeek()".
Evaluator for the method "{localDateExpr}.getMonthValue()".
Evaluator for the method "{localDateExpr}.getYear()".
Class to handle the conversion between java.time.LocalDate and java.sql.Date.
Class to handle the conversion between java.time.LocalDate and a String form.
Class to handle the conversion between java.time.LocalDateTime and java.util.Date.
Evaluator for the function LOCAL_DATETIME().
Evaluator for the method "{localDateTimeExpr}.getDayOfMonth()".
Evaluator for the method "{localDateTimeExpr}.getDayOfMonthWeek()".
Evaluator for the method "{localDateTimeExpr}.getHour()".
Evaluator for the method "{localDateTimeExpr}.getMinute()".
Evaluator for the method "{localDateTimeExpr}.getMonthValue()".
Evaluator for the method "{localDateTimeExpr}.getSecond()".
Evaluator for the method "{localDateTimeExpr}.getYear()".
Class to handle the conversion between java.time.LocalDateTime and a String form.
Class to handle the conversion between java.time.LocalDateTime and java.sql.Timestamp
Class to handle the conversion between java.util.Locale and a String form.
Localiser for messages in the DataNucleus system.
Class to handle the conversion between java.time.LocalTime and java.util.Date.
Evaluator for the function LOCAL_TIME().
Evaluator for the method "{localTimeExpr}.getHour()".
Evaluator for the method "{localTimeExpr}.getMinute()".
Evaluator for the method "{localTimeExpr}.getSecond()".
Class to handle the conversion between java.time.LocalTime and a long form (nanos of day).
Class to handle the conversion between java.time.LocalTime and java.sql.Time.
Class to handle the conversion between java.time.LocalTime and a String form.
Evaluator for the function LOCATE(strExpr1, strExpr2, pos).
Interface defining a manager for locking of objects.
Implementation of a lock manager for objects.
Locking modes for persistable objects.
Log4J v2 implementation of a NucleusLogger.
Log4J implementation of a NucleusLogger.
Evaluator for the function LOG(numExpr).
Expression representing a Long, used in evaluation of aggregates.
Convenience class to handle Java serialisation of a long[] object to/from ByteBuffer.
This class is for identity with a single long field.
Class to handle the conversion between java.lang.Long and a String form.
Evaluator for the function LOWER(stringExpr).
Macro String Utilities
Inner class : Identifier Macro
Inner class : Macro Handler
Inner class : Parameter Macro
Method to generate the method "dnMakeDirty" using ASM.
Field Manager to handle the making transient of fields.
Wrapper for a connection to the datastore, allowing management.
Listener for the relation between a ManagedConnection and a resource using that ManagedConnection.
Handler to process "managed relations".
Management interface for DataNucleus.
Management Server for MBeans.
Statistics for a manager of persistence (PersistenceManager/EntityManager).
Interface defining the MBean for a persistence manager.
A mutable second-class Map object.
A mutable second-class Map object.
Clear operation for a map where we have a backing store.
Evaluator for the method "{mapExpr}.containsEntry(keyExpr,valueExpr)".
Evaluator for the method "{mapExpr}.containsKey(keyExpr)".
Evaluator for the method "{mapExpr}.containsValue(valueExpr)".
Evaluator for the method "{mapExpr}.get(keyExpr)".
Representation of the Meta-Data for a Map.
Put operation for a map where we have a backing store.
Remove operation for a map where we have a backing store.
Interface representation of the backing store for a Map, providing its interface with the datastore.
Interface representing schema information for the datastore.
Evaluator for mathematical function XYZ(numExpr).
Wrapper for a field or a method (property) that is annotated.
Interface defining a handler for field/property annotations.
Mapping definition for a member (field/property) representing the column(s) that it maps to.
Mapping definition for a member (field/property) representing the column(s) that it maps to.
Base class for all MetaData.
An auto-starter mechanism that uses a defined list of metadata files to be loaded at startup.
Enum for the different types of metadata "files".
Listener for registering interest when metadata for a class is loaded.
Manager for metadata in DataNucleus.
Manager of metadata information in DataNucleus having scope of an NucleusContext.
Simple comparator that orders the implementations of an interface so that the initial implementations are first, and the subclasses later.
Convenience class to handle the merging of MetaData.
Scanner for persistable classes, typically provided by a JEE environment to locate classes
not easily/efficiently locatable using the builtin file scanner.
Utilities needed for the processing of MetaData.
Exception thrown when the Code attribute of a method produced by a
ClassWriter is too
large.A visitor to visit a Java method.
A
MethodVisitor that generates a corresponding 'method_info' structure, as defined in the
Java Virtual Machine Specification (JVMS).Evaluator for the function MOD(numExpr1, numExpr2).
A visitor to visit a Java module.
A
ModuleVisitor that generates the corresponding Module, ModulePackages and
ModuleMainClass attributes, as defined in the Java Virtual Machine Specification (JVMS).Class to handle the conversion between java.time.MonthDay and int[] (the month and the day).
Class to handle the conversion between java.time.MonthDay and java.util.Date.
Evaluator for the method "{monthDayExpr}.getDayOfMonth()".
Evaluator for the method "{monthDayExpr}.getMonthValue()".
Class to handle the conversion between java.time.MonthDay and java.sql.Date.
Class to handle the conversion between java.time.MonthDay and String.
Interface implemented by a TypeConverter when it converts a member to multiple columns, providing the
information about what types the columns store.
MetaData representation for a multitenancy discriminator.
Interface to be implemented where the user wants to allocate a "tenantId" for each datastore access.
Enum defining the types of cases that component identifiers can be stored in.
Representation of a naming factory for schema components (tables, columns, etc).
Optimiser for query compilation that searches for navigation through relations, and adds "not null" checks.
Method to generate the method "dnNewInstance" using ASM.
Method to generate the method "dnNewInstance" using ASM.
Method to generate the method "dnNewObjectIdInstance" using ASM.
Method to generate the method "dnNewObjectIdInstance" using ASM.
Representation of a node in a tree of nodes.
Enum of node types.
A NoExtentException is thrown if an attempt is made to perform an
operation using a class that is not backed by an extent (ie table or view)
in the database and the operation is not supported on such classes.
Manages the registry of Extensions and Extension Points outside any OSGI container.
Sorter for extensions that puts DataNucleus extensions first, then any vendor extension.
Exception thrown when a class is required to have persistence information (metadata/annotations) yet none
can be found.
Exception thrown from internal query mechanism if no results are returned.
Exception thrown when an pc instance instance is not yet flushed to the datastore, but it was expected to already be.
Exception thrown when a retriable error occurs.
Access to the underlying DataStore Connection.
Representation of a datastore connection.
Representation of the context being run within DataNucleus.
Exception thrown when a datastore occurs.
Exception thrown during enhancement when an error occurs.
Base exception thrown by DataNucleus.
Exception thrown when a user error occurs and is fatal.
Logging framework for DataNucleus.
Exception thrown when an object doesn't exist in the datastore.
Exception thrown when a transaction fails due to optimistic verification checks.
Sequence of values.
Basic generic implementation of a datastore sequence.
Exception thrown when a particular option has been selected but isnt supported.
Exception thrown when a user error occurs.
Evaluator for the function NULLIF(numExpr, numExpr2).
Manager that nullifies any Collection/Map/PC fields of the object.
Null implementation of a Level 2 Cache.
Null implementation of a NucleusLogger.
Enum for how to handle null values when ordering a query based on a column.
Representation of how to handle a null value (in a field).
A ObjectDetachedException is thrown if an attempt is
made to use the object in a process that doesn't allow detached objects.
Evaluator for the function getClass(obj).
This class is for identity with a single Object type field.
Construct an instance of a key class using a String as input.
Interface to be implemented by any StoreManager that provides objects that are actually created by the underlying datastore.
Locator for the TransactionManager for OC4J (Oracle) app server.
Class to handle the conversion between java.time.OffsetDateTime and java.util.Date.
Class to handle the conversion between java.time.OffsetDateTime and a String form.
Class to handle the conversion between java.time.OffsetDateTime and java.sql.Timestamp
Class to handle the conversion between java.time.OffsetTime and a long form (nanos of day).
Class to handle the conversion between java.time.OffsetTime and java.sql.Time.
Class to handle the conversion between java.time.OffsetTime and a String form.
The JVM opcodes, access flags and array type codes.
Interface for an operation to be flushed.
Queue of operations to be performed when operating in MANUAL FlushMode.
Evaluator for the method "{optionalExpr}.get()".
Evaluator for the method "{optionalExpr}.isPresent()".
Evaluator for the method "{optionalExpr}.orElse()".
Expression as part of an ordering clause.
Representation of Order MetaData - the ordering of the elements of a List.
Definition of ordering using a field.
Locator for the TransactionManager for Orion.
Sorter for extensions that puts DataNucleus extensions first, then any vendor extension.
Representation of the Meta-Data for a package.
Expression representing a parameter.
Node representing a parameter.
Interface for a parser of a query.
Class to handle the conversion between java.time.Period and int[] (year, month and day).
Evaluator for the method "{periodExpr}.getDays()".
Evaluator for the method "{periodExpr}.getMonths()".
Evaluator for the method "{periodExpr}.getYears()".
Class to handle the conversion between java.time.Period and a String form.
A class that can be managed by DataNucleus must implement this interface.
This interface is used to store fields from the Object id instance.
This interface is used to provide fields to the Object id instance.
Definition of the type of a persistable object.
Representation of the relation between two persistable objects.
Interface to be implemented by any persistence encryption provider.
Representation of a Meta-Data "persistence.xml" file.
Context for use in the persistence process.
Extends the basic DataNucleus context, adding on services for
creating ExecutionContext objects to handle persistence.
MetaData representation of a "persistence.xml" persistence unit.
XML parser handler for "persistence.xml" files to convert them into a PersistenceFileMetaData.
Field manager that persists all unpersisted PC objects referenced from the source object.
Flush operation for a persist of the specified object.
Wrapper for the JRE "Platform" JMX server.
Manages the registry of Extensions and Extension Points for the plugin mechanism.
Comparator for comparing ConfigurationElements by their priority attribute.
Parser for "manifest.mf" and "plugin.xml" files.
Parser for a list of Bundle-Description
Loader and registry of Extensions and Extension Points.
Factory for PluginRegistry.
Evaluator for the function POWER(numExpr, numExpr2).
Method to generate the method "dnPreSerialize" using ASM.
Expression for a primary object.
Exception thrown when compiling a PrimaryExpression and we find that it really represents
a Class literal, and so should be swapped in the expression tree.
Exception thrown when compiling a PrimaryExpression and we find that it really represents
a static field of a Class (literal), and so should be swapped in the Node tree.
Exception thrown when compiling a PrimaryExpression and we find that it really represents
an invocation of a method, and so should be swapped in the expression tree.
Exception thrown when compiling a PrimaryExpression and we find that it really represents
an implicit variable, and so should be swapped in the expression tree.
Class to handle the generation of a PK class for a persistable class.
Representation of a primary key constraint.
A mutable second-class PriorityQueue object.
A mutable second-class PriorityQueue object.
A mutable second-class Properties object.
A mutable second-class Properties object.
The property element declares mapping between a virtual field of an implemented
interface and the corresponding persistent field of a persistence-capable class.
Utility providing convenience naming of core persistence properties.
Representation of a store of properties.
Symbol representing a property/identifier in a query.
Exception thrown when trying to access a property as a specific type yet it is not possible
to return as that type.
Interface defining a validator for a DataNucleus property.
Method to generate the method "dnProvideField" using ASM.
Method to generate the method "dnProvideFields" using ASM.
Abstract implementation for all queries in DataNucleus.
Simple representation of a subquery, its candidate, params and variables.
Representation of the components of a compiled java "string-based" query.
Cache for query compilations (generic).
Exception thrown when a query compiler finds an error relative to the expected syntax.
Cache for query compilations (datastore-specific).
Exception thrown when a query execution is interrupted.
Exception thrown when invalid arguments/parameters are given.
Representation of the primary query languages.
Interface providing a way of creating instances of queries for datastores, caching of generic and datastore compilations,
as well as caching query results.
Manages the creation, compilation and results of queries.
Representation of the MetaData of a named Query.
This exception is thrown when a user runs a Query and has marked it as UNIQUE, but
it returns more than 1 object.
Lazy collection results from a Query.
Representation of the mapping of (SQL) Query results into a desired output form.
Class to wrap the mapping for a constructor type.
Class to wrap the mapping for a persistent type.
Cache for query results.
Exception thrown when a query times out beyond some specified timeout duration.
Utilities for use in queries.
A mutable second-class Queue object.
A mutable second-class Queue object.
Evaluator for the function RADIANS(numExpr).
Handler to process "persistence-by-reachability" at commit.
Field manager that runs reachability on all PC objects referenced from the source object.
An exception that is thrown when we have a relation to another persistable object that is not yet persistent
and where the relation is not marked as cascade-persist.
A visitor to visit a record component.
Implementation of a StateManager for use where insertion ordering is important (such as RDBMS).
Converter for a "matches" regular expression replacing the Java regular expression
constructs with datastore-specific constructs.
Manager for (bidirectional) relationships of an object (StateManager).
Manager for (bidirectional) relationships of an object (StateManager).
Definition of a change in a relation.
Utility class providing enums for the different relation types.
Method to generate the method "dnReplaceDetachedState" using ASM.
Method to generate the method "dnReplaceField" using ASM.
Method to generate the method "dnReplaceFields" using ASM.
Method to generate the method "dnReplaceFlags" using ASM.
Method to generate the method "dnReplaceStateManager" using ASM.
Locator for the TransactionManager for Resin.
Transaction allowing resources to be enlisted, with branches and phased commit, following the style of an Open/XA transaction.
TransactionManager provides a facade for creating (Open/XA) transactions.
Exception thrown when an error occurs in the rollback process of a state change.
Evaluator for the function ROUND(numExpr, numExpr2).
Class that will enhance a class at runtime, called via "javaagent".
This classloader is used to load any classes that are necessary during enhancement process,
and avoid using application classloaders to load classes
Locator for the TransactionManager for SAPWeb app server
Definition of the saved state of a Persistable object.
Interface to be implemented by all store managers that manage a "schema".
Enum of the types of schema components that we need to create names for.
Interface to be implemented by all store managers that support execution of scripts on the schema.
SchemaTool providing an interface for the maintenance of schemas.
SchemaTool Ant Task.
Representation of a verifier for schema information.
Representation of a wrapper/proxy for a mutable SCO type (e.g Date, Collection, Map).
Representation of a wrapper for a mutable Collection SCO type supported.
An iterator for a SCO Collection object.
Representation of a SCO that contains other (persistable) objects.
Object identifier for use with nondurable objects to guarantee uniqueness in the JVM (but not in datastore).
Representation of a wrapper for a mutable List SCO type supported.
An iterator for a SCO List object.
Representation of a wrapper for a mutable Map SCO type supported.
(Queued) operation performed on a backing store.
Collection of utilities for second class wrappers and objects.
Representation of the MetaData of a named Sequence (JDO, or JPA).
Representation of strategy of a Sequence.
Convenience class to handle Java serialisation of a Serializable object to/from byte[].
Convenience class to handle Java serialisation of a Serializable object to/from ByteBuffer.
Convenience class to handle Java serialisation of a Serializable object to/from String.
A mutable second-class Set object.
A mutable second-class Set object.
Expression for the aggregation of a set of object values.
Method to generate the method "setZZZ" using ASM for NORMAL fields.
Interface representation of the backing store for a Set.
Method to generate the method "setZZZ" using ASM for CHECK_WRITE fields.
Method to generate the method "dnSetZZZ" using ASM for MEDIATE_WRITE fields.
Expression representing a Short, used in evaluation of aggregates.
Convenience class to handle Java serialisation of a short[] object to/from ByteBuffer.
This class is for identity with a single short field.
Evaluator for the function SIGN(numExpr).
Evaluator for the function SIN(numExpr).
This class is the abstract base class for all single field identity classes.
A simple field manager that stores/fetches a single field value per type
in memory.
Field manager for single field.
Evaluator for the function SINH(numExpr).
Evaluator for the function SIZE(collExpr).
MetaData representation for a soft delete indicator column.
Soft implementation of a Level 2 cache.
Soft-reference implementation of a generic query compilation cache.
Weak-referenced implementation of datastore query compilation cache.
Soft-reference implementation of a query results cache.
Level 1 Cache using Soft referenced objects in a Map.
A mutable second-class SortedMap object.
A mutable second-class SortedMap object.
A mutable second-class SortedSet object.
A mutable second-class SortedSet object.
A mutable second-class SQL date object.
Class to handle the conversion between java.sql.Date and a java.util.Date form.
Class to handle the conversion between java.sql.Date and a Long form.
Class to handle the conversion between java.sql.Date and a String form.
A mutable second-class SQLTime object.
Class to handle the conversion between java.sql.Time and a java.util.Date form.
Class to handle the conversion between java.sql.Time and a Long form.
A mutable second-class SQL timestamp object.
Class to handle the conversion between java.sql.Timestamp and a java.util.Date form.
Class to handle the conversion between java.sql.Timestamp and a Long form.
Class to handle the conversion between java.sql.Timestamp and a String form.
Class to handle the conversion between java.sql.Time and a String form.
Evaluator for the function SQRT(numExpr).
A mutable second-class Stack object.
A mutable second-class Stack object.
This interface is the point of contact between managed instances of
Persistable classes and DataNucleus.Factory for StateManagers.
Factory for StateManagers.
Implementation of a StateManager, supporting the bytecode enhancement contract of DataNucleus.
Pool of StateManager objects.
Interface representation of the backing store for a Collection or Map.
Basic store information about an object that is stored in a datastore.
Manager for store information.
Metadata representation of a named stored proc query.
Metadata representation of a parameter for a named stored proc query.
Mode of usage of a stored procedure query parameter.
Interface defining management of a datastore.
Helper methods for StoreManager operations.
Interface defining persistence operations of a StoreManager.
Enum for the type of a batched operation
Interface representing definition of some schema information in the datastore.
Interface defining schema operation for a StoreManager.
Expression representing a String, used in evaluation of aggregates.
Class to handle the conversion between java.lang.StringBuffer and a String form.
Class to handle the conversion between java.lang.StringBuilder and a String form.
Evaluator for the method "{stringExpr}.charAt(numExpr)".
Evaluator for the method "{stringExpr}.concat(extraStr)".
Evaluator for the method "{stringExpr}.endsWith(strExpr)".
Evaluator for the method "{stringExpr}.equalsIgnoreCase(strExpr)".
Evaluator for the method "{stringExpr}.equals(strExpr)".
This class is for identity with a single String field.
Evaluator for the method "{stringExpr}.indexOf(strExpr [,numExpr])".
Evaluator for the method "{stringExpr}.length()".
Evaluator for the method "{stringExpr}.matches(expr)".
Validator for a property that represents a String.
Evaluator for the method "{stringExpr}.startsWith(strExpr [,pos])".
Evaluator for the method "{stringExpr}.substring(posStart [,posEnd])".
Evaluator for the method "{stringExpr}.toLowerCase()".
Evaluator for the method "{stringExpr}.toUpperCase()".
Evaluator for the method "{stringExpr}.trimLeft([trimChar])".
Evaluator for the method "{stringExpr}.trim()".
Evaluator for the method "{stringExpr}.trimRight([trimChar])".
Utilities for String manipulation.
Strong-reference implementation of a generic query compilation cache.
Strong-referenced implementation of datastore query compilation cache.
Strong-reference implementation of a query results cache.
Implementation of a Level 1 cache keeping strong references to the objects.
Expression containing a subquery.
Evaluator for the function SUBSTRING(str, num1, num2).
Locator for the TransactionManager for Sun ONE.
Enum defining the types of surrogate columns for a class.
An entry of the constant pool, of the BootstrapMethods attribute, or of the (ASM specific) type
table of a class.
A symbol in a query.
Interface for use in the resolution of symbols during query compilation.
The constant pool entries, the BootstrapMethods attribute entries and the (ASM specific) type
table entries of a class.
Table of symbols in a query.
An entry of a SymbolTable.
Representation of a table for a class.
Representation of the MetaData of a TableGenerator (JPA).
Evaluator for the function TAN(numExpr).
Evaluator for the function TANH(numExpr).
Evaluator for the method "DAY({dateExpr})".
Evaluator for the method "HOUR({dateExpr})".
Evaluator for the method "MINUTE({dateExpr})".
Evaluator for the method "MONTH_JAVA({dateExpr})".
Evaluator for the method "MONTH({dateExpr})".
Evaluator for the method "SECOND({dateExpr})".
Evaluator for the method "YEAR({dateExpr})".
Value generator for timestamps.
Value generator for timestamp values (millisecs).
Class to handle the conversion between java.util.TimeZone and a String form.
Representation of an ExecutionContext transaction within DataNucleus.
An exception thrown when active is invoked on an ExecutionContext yet the transaction is already active.
An exception thrown when close is invoked on an ExecutionContext yet the transaction is still active.
Listener of events raised on transaction begin, commit, rollback and flush.
Implementation of a (local) transaction for an ExecutionContext, for a datastore.
Definition of the transaction isolation levels considered by DataNucleus.
An exception thrown when an unsupported transaction isolation level is requested.
Entry point for locating a JTA TransactionManager.
Locator for a JTA TransactionManager.
An exception thrown when commit/rollback is invoked on an ExecutionContext yet the transaction is not active.
An TransactionNotReadableException is thrown if an operation needs either of
an active transaction or non-transactional read and neither is true.
An TransactionNotReadableException is thrown if an operation needs either of
an active transaction or non-transactional read and neither is true.
Representation of a transaction type.
Utility methods relating to transactions.
A mutable second-class TreeMap object.
A mutable second-class TreeMap object.
A mutable second-class TreeSet object.
A mutable second-class TreeSet object.
Evaluator for the function TRIM(strExpr).
A Java field or method type.
Class with methods for type conversion.
Converter for a java type to another type suitable for the datastore.
Expression representing a the type of the contained expression.
Registry of java type support.
Implementation of registry of java type support.
The path to a type argument, wildcard bound, array element type, or static inner type within an
enclosing type.
A reference to a type appearing in a class, field or method declaration, or on an instruction.
MetaData representing a unique constraint.
FieldManager to unset the owner fields of any SCO wrapped fields.
Exception thrown if a configured connection factory is not of a supported factory type.
Flush operation for an update of the value of a member of the specified object.
Evaluator for the function UPPER(stringExpr).
Class to handle the conversion between java.net.URI and a String form.
Class to handle the conversion between java.net.URL and a String form.
Value generator for a String utilising the JDK UUID class (128-bit, 36 character).
Value generator for a UUID hexadecimal format.
Value generator for a UUID utilising the JDK UUID class (128-bit, 36 character).
Class to handle the conversion between java.util.UUID and a String form.
Value generator for a UUID String format.
Handler for the javax.validation @NotNull annotation.
Handler for the javax.validation @Size annotation.
Representation of a block of values.
Connection provider for a ValueGenerator that requires connections to their datastore.
General class to throw exceptions in generators.
Manager for the creation of ValueGenerators.
Manager for the creation of ValueGenerators.
Value generation "strategy".
Generator interface for values.
This element specifies the mapping for the value component of maps.
Expression representing a variable.
Exception representing a variable not having its value currently set in the query.
Optimiser for query compilation that searches for variable equality like "var == this".
A mutable second-class Vector object.
A mutable second-class Vector object.
Three common strategies for versioning instances are supported by standard metadata.
Three common strategies for versioning instances are supported by standard
metadata.
Weak referenced implementation of a Level 2 cache.
Weak-reference implementation of a generic query compilation cache.
Weak-referenced implementation of datastore query compilation cache.
Weak-reference implementation of a query results cache.
Level 1 Cache using Weak referenced objects in a Map.
Locator for the TransactionManager for BEA WebLogic.
Locator for the TransactionManager for IBM WebsFear 4 and 5.
Method to generate the method "writeObject" using ASM.
Identity translator that allows for some combinations that Xcalia XIC allowed.
Implementation of an entity resolver for XML MetaData files.
Class to provide the parsing framework for parsing XML metadata files.
Class to handle the conversion between java.time.Year and Integer.
Class to handle the conversion between java.time.YearMonth and int[] (the year and the month).
Class to handle the conversion between java.time.YearMonth and java.util.Date.
Evaluator for the method "{yearMonthExpr}.getMonthValue()".
Evaluator for the method "{yearMonthExpr}.getYear()".
Class to handle the conversion between java.time.YearMonth and java.sql.Date.
Class to handle the conversion between java.time.YearMonth and String.
Class to handle the conversion between java.time.Year and String.
Class to handle the conversion between java.time.ZonedDateTime and a String form.
Class to handle the conversion between java.time.ZonedDateTime and java.sql.Timestamp.
Class to handle the conversion between java.time.ZoneId and String.
Class to handle the conversion between java.time.ZoneOffset and String.