Package org.eclipse.persistence.mappings

Class VariableOneToOneMapping

  • All Implemented Interfaces:
    Serializable, Cloneable, RelationalMapping
    public class VariableOneToOneMapping
extends ObjectReferenceMapping
implements RelationalMapping

    Purpose: Variable one to one mappings are used to represent a pointer references between a java object and an implementer of an interface. This mapping is usually represented by a single pointer (stored in an instance variable) between the source and target objects. In the relational database tables, these mappings are normally implemented using a foreign key and a type code.

    Since:
    TOPLink/Java 2.0
    Author:
    Sati
    See Also:
    Serialized Form

    • Constructor Detail

      • VariableOneToOneMapping

        public VariableOneToOneMapping()
        PUBLIC: Default constructor.

    • Method Detail

      • addClassIndicator

        public void addClassIndicator​(Class implementer,
                              Object typeIndicator)
        PUBLIC: Add a type indicator conversion to this mapping.

      • addClassNameIndicator

        public void addClassNameIndicator​(String className,
                                  Object typeIndicator)
        INTERNAL: Add indicators by classname. For use by the Mapping Workbench to avoid classpath dependencies

      • addForeignQueryKeyName

        public void addForeignQueryKeyName​(org.eclipse.persistence.internal.helper.DatabaseField sourceForeignKeyField,
                                   String targetQueryKeyName)
        PUBLIC: A foreign key from the source table and abstract query key from the interface descriptor are added to the mapping. This method is used if there are multiple foreign keys.

      • addForeignQueryKeyName

        public void addForeignQueryKeyName​(String sourceForeignKeyFieldName,
                                   String targetQueryKeyName)
        PUBLIC: A foreign key from the source table and abstract query key from the interface descriptor are added to the mapping. This method is used if there are multiple foreign keys.

      • addTargetForeignQueryKeyName

        public void addTargetForeignQueryKeyName​(String targetForeignQueryKeyName,
                                         String sourcePrimaryKeyFieldName)
        PUBLIC: Define the target foreign key relationship in the Variable 1-1 mapping. This method is used for composite target foreign key relationships, that is the target object's table has multiple foreign key fields to the source object's primary key fields. Both the target foreign key query name and the source primary key field name must be specified. The distinction between a foreign key and target foreign key is that the variable 1-1 mapping will not populate the target foreign key value when written (because it is in the target table). Normally 1-1's are through foreign keys but in bi-directional 1-1's the back reference will be a target foreign key. In obscure composite legacy data models a 1-1 may consist of a foreign key part and a target foreign key part, in this case both method will be called with the correct parts.

      • clone

        public Object clone()
        INTERNAL: This methods clones all the fields and ensures that each collection refers to the same clones.
        Overrides:
        clone in class ForeignReferenceMapping

      • getClassIndicatorAssociations

        public Vector getClassIndicatorAssociations()
        INTERNAL: Return the class indicator associations for XML. List of class-name/value associations.

      • getDescriptorForTarget

        public ClassDescriptor getDescriptorForTarget​(Object targetObject,
                                              org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: Return a descriptor for the target of this mapping For normal ObjectReferenceMappings, we return the reference descriptor. For a VariableOneToOneMapping, the reference descriptor is often a descriptor for an interface and does not contain adequate information. As a result, we look up the descriptor for the specific class we are looking for Bug 2612571
        Overrides:
        getDescriptorForTarget in class ObjectReferenceMapping
        See Also:
        Bug 2612571

      • getFieldClassification

        public Class getFieldClassification​(org.eclipse.persistence.internal.helper.DatabaseField fieldToClassify)
        INTERNAL: Return the classification for the field contained in the mapping. This is used to convert the row value to a consistent java value.
        Overrides:
        getFieldClassification in class DatabaseMapping

      • getForeignKeyFieldNames

        public Vector getForeignKeyFieldNames()
        PUBLIC: Return the foreign key field names associated with the mapping. These are only the source fields that are writable.

      • getSourceToTargetQueryKeyFieldAssociations

        public Vector getSourceToTargetQueryKeyFieldAssociations()
        PUBLIC: Return a collection of the field to query key associations.

      • getSourceToTargetQueryKeyNames

        public Map getSourceToTargetQueryKeyNames()
        INTERNAL: Returns the source keys to target keys fields association.

      • getTypeField

        public org.eclipse.persistence.internal.helper.DatabaseField getTypeField()

      • getTypeFieldName

        public String getTypeFieldName()
        PUBLIC: This method returns the name of the typeField of the mapping. The type field is used to store the type of object the relationship is referencing.

      • getTypeIndicatorTranslation

        public Map getTypeIndicatorTranslation()
        INTERNAL: Return the type indicators.

      • getTypeIndicatorNameTranslation

        public Map getTypeIndicatorNameTranslation()
        INTERNAL: Return the typeIndicatorName translation Used by the Mapping Workbench to avoid classpath dependencies

      • convertClassNamesToClasses

        public void convertClassNamesToClasses​(ClassLoader classLoader)
        INTERNAL: Convert all the class-name-based settings in this mapping to actual class-based settings. This method is used when converting a project that has been built with class names to a project with classes.
        Overrides:
        convertClassNamesToClasses in class ForeignReferenceMapping

      • initialize

        public void initialize​(org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: Initialize the mapping.
        Overrides:
        initialize in class ForeignReferenceMapping

      • initializeSelectionCriteria

        public void initializeSelectionCriteria​(org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: Selection criteria is created with source foreign keys and target keys. This criteria is then used to read target records from the table.

      • rehashFieldDependancies

        public void rehashFieldDependancies​(org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: Rehash any maps based on fields. This is used to clone descriptors for aggregates, which hammer field names.
        Overrides:
        rehashFieldDependancies in class DatabaseMapping

      • setClassIndicatorAssociations

        public void setClassIndicatorAssociations​(Vector classIndicatorAssociations)
        PUBLIC: Set the class indicator associations.

      • setForeignKeyFieldNames

        public void setForeignKeyFieldNames​(Vector fieldNames)
        PUBLIC: Return the foreign key field names associated with the mapping. These are only the source fields that are writable.

      • setForeignQueryKeyName

        public void setForeignQueryKeyName​(String sourceForeignKeyFieldName,
                                   String targetQueryKeyName)
        PUBLIC: A foreign key from the source table and abstract query key from the interface descriptor are added to the mapping. This method is used if foreign key is not composite.

      • setSourceToTargetQueryKeyFieldAssociations

        public void setSourceToTargetQueryKeyFieldAssociations​(Vector sourceToTargetQueryKeyFieldAssociations)
        PUBLIC: Set a collection of the source to target query key/field associations.

      • setTypeField

        public void setTypeField​(org.eclipse.persistence.internal.helper.DatabaseField typeField)
        INTERNAL: This method set the typeField of the mapping to the parameter field

      • setTypeFieldName

        public void setTypeFieldName​(String typeFieldName)
        PUBLIC: This method sets the name of the typeField of the mapping. The type field is used to store the type of object the relationship is referencing.

      • valueFromObject

        public Object valueFromObject​(Object object,
                              org.eclipse.persistence.internal.helper.DatabaseField field,
                              org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: Get a value from the object and set that in the respective field of the row.
        Overrides:
        valueFromObject in class DatabaseMapping

      • valueFromRow

        public Object valueFromRow​(org.eclipse.persistence.internal.sessions.AbstractRecord row,
                           org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                           ObjectBuildingQuery sourceQuery,
                           org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey,
                           org.eclipse.persistence.internal.sessions.AbstractSession executionSession,
                           boolean isTargetProtected,
                           Boolean[] wasCacheUsed)
                    throws DatabaseException
        INTERNAL: Return the value of the field from the row or a value holder on the query to obtain the object. Check for batch + aggregation reading.
        Overrides:
        valueFromRow in class ForeignReferenceMapping
        Throws:
        DatabaseException

      • writeFromObjectIntoRow

        public void writeFromObjectIntoRow​(Object object,
                                   org.eclipse.persistence.internal.sessions.AbstractRecord record,
                                   org.eclipse.persistence.internal.sessions.AbstractSession session,
                                   DatabaseMapping.WriteType writeType)
        INTERNAL: Get a value from the object and set that in the respective field of the row. If the mapping id target foreign key, you must only write the type into the roe, the rest will be updated when the object itself is written
        Overrides:
        writeFromObjectIntoRow in class DatabaseMapping

      • writeFromObjectIntoRowWithChangeRecord

        public void writeFromObjectIntoRowWithChangeRecord​(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                                                   org.eclipse.persistence.internal.sessions.AbstractRecord record,
                                                   org.eclipse.persistence.internal.sessions.AbstractSession session,
                                                   DatabaseMapping.WriteType writeType)
        INTERNAL: Get a value from the object and set that in the respective field of the row. If the mapping id target foreign key, you must only write the type into the roe, the rest will be updated when the object itself is written
        Overrides:
        writeFromObjectIntoRowWithChangeRecord in class DatabaseMapping

      • writeFromObjectIntoRowForShallowInsert

        public void writeFromObjectIntoRowForShallowInsert​(Object object,
                                                   org.eclipse.persistence.internal.sessions.AbstractRecord record,
                                                   org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: This row is built for shallow insert which happens in case of bidirectional inserts. The foreign keys must be set to null to avoid constraints.
        Overrides:
        writeFromObjectIntoRowForShallowInsert in class DatabaseMapping

      • writeFromObjectIntoRowForUpdateAfterShallowInsert

        public void writeFromObjectIntoRowForUpdateAfterShallowInsert​(Object object,
                                                              org.eclipse.persistence.internal.sessions.AbstractRecord row,
                                                              org.eclipse.persistence.internal.sessions.AbstractSession session,
                                                              org.eclipse.persistence.internal.helper.DatabaseTable table)
        INTERNAL: This row is built for update after shallow insert which happens in case of bidirectional inserts. It contains the foreign keys with non null values that were set to null for shallow insert. If mapping overrides writeFromObjectIntoRowForShallowInsert method it must override this one, too.
        Overrides:
        writeFromObjectIntoRowForUpdateAfterShallowInsert in class DatabaseMapping

      • writeFromObjectIntoRowForShallowInsertWithChangeRecord

        public void writeFromObjectIntoRowForShallowInsertWithChangeRecord​(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                                                                   org.eclipse.persistence.internal.sessions.AbstractRecord record,
                                                                   org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: This row is built for shallow insert which happens in case of bidirectional inserts. The foreign keys must be set to null to avoid constraints.
        Overrides:
        writeFromObjectIntoRowForShallowInsertWithChangeRecord in class DatabaseMapping

      • writeInsertFieldsIntoRow

        public void writeInsertFieldsIntoRow​(org.eclipse.persistence.internal.sessions.AbstractRecord record,
                                     org.eclipse.persistence.internal.sessions.AbstractSession session)
        INTERNAL: Write fields needed for insert into the template for with null values.
        Overrides:
        writeInsertFieldsIntoRow in class DatabaseMapping