Public

Constructs a new JDOObjectNotFoundException with the specified detail message,
nested Throwables, an

<init>

getFailedObject

getMessage

Reactive rest calls using spring rest template

Signals a general, I/O-related error. Error details may be specified when
calling the constructor, a

java.io.IOException

A Uniform Resource Locator that identifies the location of an Internet resource
as specified by RFC 

java.net.URL

A charset is a named mapping between Unicode characters and byte sequences.
Every Charset can decode

java.nio.charset.Charset

Thrown when trying to retrieve an element past the end of an Enumeration or
Iterator.

java.util.NoSuchElementException

The Modifier class provides static methods and constants to decode class and
member access modifiers

javassist.Modifier

org.hibernate.mapping.Join

notifyDataSetChanged

setScale

setContentView

// extract information about the failed object from the JDOException, if available

"Test_021.testRefreshFailedObjects(), ignoring test for concurrent delete"

//It is not clear what the supposed behaviour of JDO is. It seems that there is no way of 

//recovering from a deleted object, commit() will always fail because refresh() is not 

//assertEquals(oid2, JDOHelper.getObjectId(e2.getFailedObject()));

/**
     * Accessor for an object given the object id. Checks the inheritance level of the object
     * @param id Id of the object.
     * @param fv Field values for the object
     * @return The Object
     */

// className is null when id class exists, and object has been

// not found in cache, will get a Hollow instance

// Extract information about the failed object from the JDOException, if available.

/**
     * Method performing the retrieval of the record from the datastore. Takes
     * the constructed retrieval query and populates with the specific record
     * information.
     *
     * @param sm The state manager for the record to be retrieved
     **/

// application identity - provide primary key fields

/**
     * Convenience method to update the contents of a BLOB column.
     * Oracle requires that a BLOB is initialised with EMPTY_BLOB() and then you retrieve
     * the column and update its BLOB value. Performs a statement
     * <pre>
     * SELECT {blobColumn} FROM TABLE WHERE ID=? FOR UPDATE
     * </pre>
     * and then updates the Blob value returned.
     * @param sm StateManager of the object
     * @param datastoreContainer Table storing the BLOB column
     * @param mapping Datastore mapping for the BLOB column
     * @param bytes The bytes to store in the BLOB
     * @throws JDOObjectNotFoundException
     * @throws JDODataStoreException
     */

// Generate "SELECT {blobColumn} FROM TABLE WHERE ID=? FOR UPDATE" statement

// Oracle JDBC drivers version 9 and below use some sh*tty Oracle-specific BLOB type

// we have to cast to that, face west, pray whilst saying ommmmmmmmmmm

// Oracle JDBC drivers 10 and above supposedly use the JDBC standard class for Blobs

/**
     * Convenience method to update the contents of a CLOB column.
     * Oracle requires that a CLOB is initialised with EMPTY_CLOB() and then you retrieve
     * the column and update its CLOB value. Performs a statement
     * <pre>
     * SELECT {clobColumn} FROM TABLE WHERE ID=? FOR UPDATE
     * </pre>
     * and then updates the Clob value returned.
     * @param sm StateManager of the object
     * @param datastoreContainer Table storing the CLOB column
     * @param mapping Datastore mapping for the CLOB column
     * @param value The value to store in the CLOB
     * @throws JDOObjectNotFoundException
     * @throws JDODataStoreException
     */

// Generate "SELECT {clobColumn} FROM TABLE WHERE ID=? FOR UPDATE" statement

// Oracle JDBC drivers version 9 and below use some sh*tty Oracle-specific CLOB type

// Oracle JDBC drivers 10 and above supposedly use the JDBC standard class for Clobs

// Debug information about what we are retrieving

// Execute any mapping actions now that we have fetched the element

/**
     * Look to the database to determine which
     * class this object is. This parameter is a hint. Set false, if it's
     * already determined the correct pcClass for this pc "object" in a certain
     * level in the hierarchy. Set to true and it will look to the database.
     * @param fv the initial field values of the object.
     */

// Inheritance case, check the level of the instance

// className is null when id class exists, and object has been validated and doesn't exist.

//load the class and make sure the class is initialized

"StateManager.GetObjectByIdClassNotFound"

"This constructor is only for objects using application identity."

// Note that this will mean the fields are loaded twice (loaded earlier in this method)

// and also that postLoad will be called twice

/**
     * Accessor for an object given the object id. If validate is false, we return the object
     * if found in the cache, or otherwise a Hollow object with that id. If validate is true
     * we check with the datastore and return an object with the FetchPlan fields loaded (unless
     * the object doesnt exist in the datastore, where we throw an ObjectNotFoundException).
     * @param id Id of the object.
     * @param validate Whether to validate the object state
     * @param checkInheritance Whether look to the database to determine which
     * class this object is.
     * @param objectClassName Class name for the object with this id (if known, optional)
     * @return The Object with this id
     */

// Object not found in cache(s) with this identity

// OID, so check that the implied class is managed

// SingleFieldIdentity, so check that the implied class is managed

// Object class name specified so use that directly

// We dont know the object class so try to deduce it from what is known by the StoreManager

// Verify if correct class inheritance level is set

// We just checked the name of the class in the section above so just use that

// Inheritance checking has found a different inherited

// object with this identity so create new id

// Create new OID using correct target class

// try again to read object from cache with this id

// Create new SingleFieldIdentity using correct targetClass

// Object not found in Cache even after inheritance updates so create a Hollow instance

// User requests validation of the instance so go to the datastore to validate it

// loading any fetchplan fields that are needed in the process.

// Cache the object (update it if already present)

/**
     * Convenience method to convert an exception into a JDO exception.
     * If the incoming exception has a "failed object" then create the new exception with
     * a failed object. Otherwise if the incoming exception has nested exceptions then
     * create this exception with those nested exceptions. Else create this exception with
     * the incoming exception as its nested exception.
     * @param ne NucleusException
     * @return The JDOException
     */

// No JDOReadOnlyException so JDO1.0-JDO2.1

//sadly JDOFatalDataStoreException dont allow nested exceptions and failed objects together

How to useJDOObjectNotFoundException in javax.jdo

Best Java code snippets using javax.jdo.JDOObjectNotFoundException (Showing top 12 results out of 315)

How to use
JDOObjectNotFoundException
in
javax.jdo