Class OneToManyMapping

    • Constructor Detail

      • OneToManyMapping

        public OneToManyMapping()
        PUBLIC: Default constructor.
    • Method Detail

      • addTargetForeignKeyField

        public void addTargetForeignKeyField​(org.eclipse.persistence.internal.helper.DatabaseField targetForeignKeyField,
                                             org.eclipse.persistence.internal.helper.DatabaseField sourceKeyField)
        INTERNAL: Add the associated fields to the appropriate collections.
        Overrides:
        addTargetForeignKeyField in class ForeignReferenceMapping
      • addTargetForeignKeyFieldName

        public void addTargetForeignKeyFieldName​(java.lang.String targetForeignKeyFieldName,
                                                 java.lang.String sourceKeyFieldName)
        PUBLIC: Define the target foreign key relationship in the one-to-many mapping. This method is used for composite target foreign key relationships. That is, the target object's table has multiple foreign key fields that are references to the source object's (typically primary) key fields. Both the target foreign key field name and the corresponding source primary key field name must be specified. Because the target object's table must store a foreign key to the source table, the target object must map that foreign key, this is normally done through a one-to-one mapping back-reference. Other options include:
        • use a DirectToFieldMapping and maintain the foreign key fields directly in the target
        • use a ManyToManyMapping
        • use an AggregateCollectionMapping
        See Also:
        DirectToFieldMapping, ManyToManyMapping, AggregateCollectionMapping
      • buildSelectionCriteria

        public Expression buildSelectionCriteria()
        This method would allow customers to get the potential selection criteria for a mapping prior to initialization. This would allow them to more easily create an amendment method that would amend the SQL for the join. CR#3922 - This method is almost the same as buildDefaultSelectionCriteria() the difference is that TargetForeignKeysToSourceKeys contains more information after login then SourceKeyFields contains before login.
      • collectQueryParameters

        public void collectQueryParameters​(java.util.Set<org.eclipse.persistence.internal.helper.DatabaseField> cacheFields)
        INTERNAL: This method is used to store the FK fields that can be cached that correspond to noncacheable mappings the FK field values will be used to re-issue the query when cloning the shared cache entity
        Overrides:
        collectQueryParameters in class CollectionMapping
      • createMapComponentFromRow

        public java.lang.Object createMapComponentFromRow​(org.eclipse.persistence.internal.sessions.AbstractRecord dbRow,
                                                          ObjectBuildingQuery query,
                                                          org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                                          org.eclipse.persistence.internal.sessions.AbstractSession session,
                                                          boolean isTargetProtected)
        INTERNAL Called when a DatabaseMapping is used to map the key in a collection. Returns the key.
        Specified by:
        createMapComponentFromRow in interface MapComponentMapping
      • getSourceKeyFieldNames

        public java.util.Vector getSourceKeyFieldNames()
        PUBLIC: Return the source key field names associated with the mapping. These are in-order with the targetForeignKeyFieldNames.
      • getSourceKeyFields

        public java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> getSourceKeyFields()
        INTERNAL: Return the source key fields.
      • getSourceKeysToTargetForeignKeys

        public java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,​org.eclipse.persistence.internal.helper.DatabaseField> getSourceKeysToTargetForeignKeys()
        INTERNAL: Return the source/target key fields.
      • getTargetPrimaryKeyFields

        public java.util.List<org.eclipse.persistence.internal.helper.DatabaseField> getTargetPrimaryKeyFields()
        INTERNAL: Primary keys of targetForeignKeyTable.
        Overrides:
        getTargetPrimaryKeyFields in class CollectionMapping
      • getTargetForeignKeyFieldNames

        public java.util.Vector getTargetForeignKeyFieldNames()
        INTERNAL: Return the target foreign key field names associated with the mapping. These are in-order with the targetForeignKeyFieldNames.
      • getTargetForeignKeyFields

        public java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> getTargetForeignKeyFields()
        INTERNAL: Return the target foreign key fields.
      • getTargetForeignKeysToSourceKeys

        public java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,​org.eclipse.persistence.internal.helper.DatabaseField> getTargetForeignKeysToSourceKeys()
        INTERNAL: Return the target/source key fields.
      • getTargetForeignKeyToSourceKeys

        public java.util.Map getTargetForeignKeyToSourceKeys()
        INTERNAL: Maintain for backward compatibility. This is 'public' so StoredProcedureGenerator does not have to use the custom query expressions.
      • hasInverseConstraintDependency

        public boolean hasInverseConstraintDependency()
        INTERNAL: Return whether the mapping has any inverse constraint dependencies, such as foreign keys and join tables.
        Overrides:
        hasInverseConstraintDependency in class DatabaseMapping
      • requiresDataModificationEvents

        public boolean requiresDataModificationEvents()
        INTERNAL: Returns whether this mapping uses data modification events to complete its writes
        See Also:
        UnidirectionalOneToManyMapping
      • setCustomAddTargetQuery

        public void setCustomAddTargetQuery​(DataModifyQuery query)
        PUBLIC: The default add target query for mapping can be overridden by specifying the new query. This query must set new value to target foreign key.
      • setAddTargetSQLString

        public void setAddTargetSQLString​(java.lang.String sqlString)
        PUBLIC:
      • setCustomRemoveTargetQuery

        public void setCustomRemoveTargetQuery​(DataModifyQuery query)
        PUBLIC: The default remove target query for mapping can be overridden by specifying the new query. In case target foreign key references the source, this query must set target foreign key to null.
      • setCustomRemoveAllTargetsQuery

        public void setCustomRemoveAllTargetsQuery​(DataModifyQuery query)
        PUBLIC: The default remove all targets query for mapping can be overridden by specifying the new query. This query must set all target foreign keys that reference the source to null.
      • setDeleteAllSQLString

        public void setDeleteAllSQLString​(java.lang.String sqlString)
        PUBLIC: Set the SQL string used by the mapping to delete the target objects. This allows the developer to override the SQL generated by TopLink with a custom SQL statement or procedure call. The arguments are translated from the fields of the source row, by replacing the field names marked by '#' with the values for those fields at execution time. A one-to-many mapping will only use this delete all optimization if the target objects can be deleted in a single SQL call. This is possible when the target objects are in a single table, do not using locking, do not contain other privately-owned parts, do not read subclasses, etc.

        Example: "delete from PHONE where OWNER_ID = #EMPLOYEE_ID"

        Overrides:
        setDeleteAllSQLString in class CollectionMapping
      • setSessionName

        public void setSessionName​(java.lang.String name)
        PUBLIC: Set the name of the session to execute the mapping's queries under. This can be used by the session broker to override the default session to be used for the target class.
        Overrides:
        setSessionName in class CollectionMapping
      • setSourceKeyFieldNames

        public void setSourceKeyFieldNames​(java.util.Vector fieldNames)
        INTERNAL: Set the source key field names associated with the mapping. These must be in-order with the targetForeignKeyFieldNames.
      • setSourceKeyFields

        public void setSourceKeyFields​(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)
        INTERNAL: Set the source key fields.
      • setTargetForeignKeyFieldName

        public void setTargetForeignKeyFieldName​(java.lang.String targetForeignKeyFieldName)
        PUBLIC: Define the target foreign key relationship in the one-to-many mapping. This method can be used when the foreign and primary keys have only a single field each. (Use #addTargetForeignKeyFieldName(String, String) for "composite" keys.) Only the target foreign key field name is specified and the source (primary) key field is assumed to be the primary key of the source object. Because the target object's table must store a foreign key to the source table, the target object must map that foreign key, this is normally done through a one-to-one mapping back-reference. Other options include:
        • use a DirectToFieldMapping and maintain the foreign key fields directly in the target
        • use a ManyToManyMapping
        • use an AggregateCollectionMapping
        See Also:
        DirectToFieldMapping, ManyToManyMapping, AggregateCollectionMapping
      • setTargetForeignKeyFieldNames

        public void setTargetForeignKeyFieldNames​(java.lang.String[] targetForeignKeyFieldNames,
                                                  java.lang.String[] sourceKeyFieldNames)
        PUBLIC: Define the target foreign key relationship in the one-to-many 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 (typically primary) key fields. Both the target foreign key field names and the corresponding source primary key field names must be specified.
      • setTargetForeignKeyFieldNames

        public void setTargetForeignKeyFieldNames​(java.util.Vector fieldNames)
        INTERNAL: Set the target key field names associated with the mapping. These must be in-order with the sourceKeyFieldNames.
      • setTargetForeignKeyFields

        public void setTargetForeignKeyFields​(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyFields)
        INTERNAL: Set the target fields.
      • isCascadedLockingSupported

        public boolean isCascadedLockingSupported()
        INTERNAL Return true if this mapping supports cascaded version optimistic locking.
        Overrides:
        isCascadedLockingSupported in class DatabaseMapping
      • updateTargetRowPostInsertSource

        public void updateTargetRowPostInsertSource​(WriteObjectQuery query)
                                             throws DatabaseException
        INTERNAL: Update target foreign keys after a new source was inserted. This follows following steps.
        Throws:
        DatabaseException
      • updateTargetForeignKeyPostUpdateSource_ObjectAdded

        public void updateTargetForeignKeyPostUpdateSource_ObjectAdded​(ObjectLevelModifyQuery query,
                                                                       java.lang.Object objectAdded,
                                                                       java.util.Map extraData)
                                                                throws DatabaseException
        INTERNAL: Update target foreign key after a target object was added to the source. This follows following steps.

        - Extract primary key and its value from the source object.

        - Extract target key and its value from the target object.

        - Construct an update statement with above fields and values for target table.

        - execute the statement.

        Throws:
        DatabaseException
      • updateTargetForeignKeyPostUpdateSource_ObjectRemoved

        public void updateTargetForeignKeyPostUpdateSource_ObjectRemoved​(ObjectLevelModifyQuery query,
                                                                         java.lang.Object objectRemoved)
                                                                  throws DatabaseException
        INTERNAL: Update target foreign key after a target object was removed from the source. This follows following steps.

        - Extract primary key and its value from the source object.

        - Extract target key and its value from the target object.

        - Construct an update statement with above fields and values for target table.

        - execute the statement.

        Throws:
        DatabaseException
      • updateTargetRowPreDeleteSource

        public void updateTargetRowPreDeleteSource​(ObjectLevelModifyQuery query)
                                            throws DatabaseException
        INTERNAL: Update target foreign key after a target object was removed from the source. This follows following steps.

        - Extract primary key and its value from the source object.

        - Extract target key and its value from the target object.

        - Construct an update statement with above fields and values for target table.

        - execute the statement.

        Throws:
        DatabaseException
      • verifyDelete

        public boolean verifyDelete​(java.lang.Object object,
                                    org.eclipse.persistence.internal.sessions.AbstractSession session)
                             throws DatabaseException
        INTERNAL: Used to verify whether the specified object is deleted or not.
        Overrides:
        verifyDelete in class CollectionMapping
        Throws:
        DatabaseException