<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_252) on Fri Jul 16 09:39:06 UTC 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>RelationTableMechanism (EclipseLink 3.0.2, API Reference)</title>
<meta name="date" content="2021-07-16">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="RelationTableMechanism (EclipseLink 3.0.2, API Reference)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10,"i19":10,"i20":10,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":10,"i27":10,"i28":10,"i29":10,"i30":10,"i31":10,"i32":10,"i33":10,"i34":10,"i35":10,"i36":10,"i37":10,"i38":10,"i39":10,"i40":10,"i41":10,"i42":10,"i43":10,"i44":10,"i45":10,"i46":10,"i47":10,"i48":10,"i49":10,"i50":10,"i51":10,"i52":10,"i53":10,"i54":10,"i55":10,"i56":10,"i57":10,"i58":10,"i59":10,"i60":10,"i61":10,"i62":10,"i63":10,"i64":10,"i65":10,"i66":10,"i67":10,"i68":10,"i69":10,"i70":10,"i71":10,"i72":10,"i73":10,"i74":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">EclipseLink 3.0.2, API Reference</div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/eclipse/persistence/mappings/RelationalMapping.html" title="interface in org.eclipse.persistence.mappings"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../org/eclipse/persistence/mappings/TransformationMapping.html" title="class in org.eclipse.persistence.mappings"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/eclipse/persistence/mappings/RelationTableMechanism.html" target="_top">Frames</a></li>
<li><a href="RelationTableMechanism.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.eclipse.persistence.mappings</div>
<h2 title="Class RelationTableMechanism" class="title">Class RelationTableMechanism</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.eclipse.persistence.mappings.RelationTableMechanism</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io">Serializable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Cloneable.html?is-external=true" title="class or interface in java.lang">Cloneable</a></dd>
</dl>
<hr>
<br>
<pre>public class <span class="typeNameLabel">RelationTableMechanism</span>
extends <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>
implements <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Cloneable.html?is-external=true" title="class or interface in java.lang">Cloneable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io">Serializable</a></pre>
<div class="block"><p><b>Purpose</b>: Contains relation table functionality
 that was originally defined in ManyToManyMapping
 and now is shared with OneToOneMapping.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../serialized-form.html#org.eclipse.persistence.mappings.RelationTableMechanism">Serialized Form</a></dd>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#deleteQuery">deleteQuery</a></span></code>
<div class="block">Query used for single row deletion.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#hasCustomDeleteQuery">hasCustomDeleteQuery</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#hasCustomInsertQuery">hasCustomInsertQuery</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#insertQuery">insertQuery</a></span></code>
<div class="block">Used for insertion.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="../../../../org/eclipse/persistence/queries/ReadQuery.html" title="class in org.eclipse.persistence.queries">ReadQuery</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#lockRelationTableQuery">lockRelationTableQuery</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected org.eclipse.persistence.internal.helper.DatabaseTable</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#relationTable">relationTable</a></span></code>
<div class="block">The intermediate relation table.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#sourceKeyFields">sourceKeyFields</a></span></code>
<div class="block">The field in the source table that corresponds to the key in the relation table</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#sourceRelationKeyFields">sourceRelationKeyFields</a></span></code>
<div class="block">The field in the intermediate table that corresponds to the key in the source table</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#targetKeyFields">targetKeyFields</a></span></code>
<div class="block">The field in the target table that corresponds to the key in the relation table</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#targetRelationKeyFields">targetRelationKeyFields</a></span></code>
<div class="block">The field in the intermediate table that corresponds to the key in the target table</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#RelationTableMechanism--">RelationTableMechanism</a></span>()</code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addRelationTableSourceRow-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.internal.sessions.AbstractRecord-">addRelationTableSourceRow</a></span>(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;sourceRow,
                         org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;databaseRow)</code>
<div class="block">INTERNAL:
 Add to a row source relation fields with values extracted from the source row.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addRelationTableSourceRow-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.mappings.ForeignReferenceMapping-">addRelationTableSourceRow</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sourceObject,
                         org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                         org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;databaseRow,
                         <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Add to a row source relation fields with values extracted from the source object.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addRelationTableTargetRow-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.mappings.ForeignReferenceMapping-">addRelationTableTargetRow</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;targetObject,
                         org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                         org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;databaseRow,
                         <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Add to a row target relation fields with values extracted from the target object.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addSourceRelationKeyField-org.eclipse.persistence.internal.helper.DatabaseField-org.eclipse.persistence.internal.helper.DatabaseField-">addSourceRelationKeyField</a></span>(org.eclipse.persistence.internal.helper.DatabaseField&nbsp;sourceRelationKeyField,
                         org.eclipse.persistence.internal.helper.DatabaseField&nbsp;sourcePrimaryKeyField)</code>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the source table.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addSourceRelationKeyFieldName-java.lang.String-java.lang.String-">addSourceRelationKeyFieldName</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sourceRelationKeyFieldName,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sourcePrimaryKeyFieldName)</code>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the source table.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addTargetRelationKeyField-org.eclipse.persistence.internal.helper.DatabaseField-org.eclipse.persistence.internal.helper.DatabaseField-">addTargetRelationKeyField</a></span>(org.eclipse.persistence.internal.helper.DatabaseField&nbsp;targetRelationKeyField,
                         org.eclipse.persistence.internal.helper.DatabaseField&nbsp;targetPrimaryKeyField)</code>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the target table.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#addTargetRelationKeyFieldName-java.lang.String-java.lang.String-">addTargetRelationKeyFieldName</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;targetRelationKeyFieldName,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;targetPrimaryKeyFieldName)</code>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the target table.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>protected <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#buildBatchCriteria-org.eclipse.persistence.expressions.ExpressionBuilder-org.eclipse.persistence.queries.ObjectLevelReadQuery-">buildBatchCriteria</a></span>(<a href="../../../../org/eclipse/persistence/expressions/ExpressionBuilder.html" title="class in org.eclipse.persistence.expressions">ExpressionBuilder</a>&nbsp;builder,
                  <a href="../../../../org/eclipse/persistence/queries/ObjectLevelReadQuery.html" title="class in org.eclipse.persistence.queries">ObjectLevelReadQuery</a>&nbsp;query)</code>
<div class="block">INTERNAL:
 Return the selection criteria used to IN batch fetching.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#buildRelationTableSourceAndTargetRow-org.eclipse.persistence.internal.sessions.AbstractRecord-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">buildRelationTableSourceAndTargetRow</a></span>(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;sourceRow,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;targetObject,
                                    org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                    <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source row
 and target relation fields with values extracted from the target object.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#buildRelationTableSourceAndTargetRow-java.lang.Object-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">buildRelationTableSourceAndTargetRow</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sourceObject,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;targetObject,
                                    org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                    <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source object
 and target relation fields with values extracted from the target object.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#buildRelationTableSourceRow-org.eclipse.persistence.internal.sessions.AbstractRecord-">buildRelationTableSourceRow</a></span>(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;sourceRow)</code>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source row.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.sessions.AbstractRecord</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#buildRelationTableSourceRow-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">buildRelationTableSourceRow</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sourceObject,
                           org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                           <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source object.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#buildSelectionCriteriaAndAddFieldsToQueryInternal-org.eclipse.persistence.mappings.ForeignReferenceMapping-org.eclipse.persistence.expressions.Expression-boolean-boolean-">buildSelectionCriteriaAndAddFieldsToQueryInternal</a></span>(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping,
                                                 <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;criteria,
                                                 boolean&nbsp;shouldAddTargetFields,
                                                 boolean&nbsp;shouldAddFieldsToQuery)</code>
<div class="block">INTERNAL:
 Build the selection criteria to join the source, relation, and target tables.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#clone--">clone</a></span>()</code>
<div class="block">INTERNAL:
 The mapping clones itself to create deep copy.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#cloneFields-java.util.Vector-">cloneFields</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fields)</code>
<div class="block">INTERNAL:
 Helper method to clone vector of fields (used in aggregate initialization cloning).</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#collectQueryParameters-java.util.Set-">collectQueryParameters</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;cacheFields)</code>
<div class="block">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</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#extractBatchKeyFromRow-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.internal.sessions.AbstractSession-">extractBatchKeyFromRow</a></span>(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;row,
                      org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session)</code>
<div class="block">INTERNAL:
 Extract the foreign key value from the source row.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#extractKeyFromTargetRow-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.internal.sessions.AbstractSession-">extractKeyFromTargetRow</a></span>(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;row,
                       org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session)</code>
<div class="block">INTERNAL:
 Extract the source primary key value from the relation row.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>protected <a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getDeleteQuery--">getDeleteQuery</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>protected <a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getInsertQuery--">getInsertQuery</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.helper.DatabaseField</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getRelationFieldForTargetField-org.eclipse.persistence.internal.helper.DatabaseField-">getRelationFieldForTargetField</a></span>(org.eclipse.persistence.internal.helper.DatabaseField&nbsp;targetField)</code>
<div class="block">INTERNAL:
 Return the relation field for the target field.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>org.eclipse.persistence.internal.helper.DatabaseTable</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getRelationTable--">getRelationTable</a></span>()</code>
<div class="block">INTERNAL:
 Return the relation table associated with the mapping.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getRelationTableName--">getRelationTableName</a></span>()</code>
<div class="block">PUBLIC:
 Return the relation table name associated with the mapping.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getRelationTableQualifiedName--">getRelationTableQualifiedName</a></span>()</code>
<div class="block">PUBLIC:
 Return the relation table qualified name associated with the mapping.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getSourceKeyFieldNames--">getSourceKeyFieldNames</a></span>()</code>
<div class="block">PUBLIC:
 Return the source key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getSourceKeyFields--">getSourceKeyFields</a></span>()</code>
<div class="block">INTERNAL:
 Return all the source key fields associated with the mapping.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getSourceRelationKeyFieldNames--">getSourceRelationKeyFieldNames</a></span>()</code>
<div class="block">PUBLIC:
 Return the source relation key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getSourceRelationKeyFields--">getSourceRelationKeyFields</a></span>()</code>
<div class="block">INTERNAL:
 Return all the source relation key fields associated with the mapping.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getTargetKeyFieldNames--">getTargetKeyFieldNames</a></span>()</code>
<div class="block">PUBLIC:
 Return the target key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getTargetKeyFields--">getTargetKeyFields</a></span>()</code>
<div class="block">INTERNAL:
 Return all the target keys associated with the mapping.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getTargetRelationKeyFieldNames--">getTargetRelationKeyFieldNames</a></span>()</code>
<div class="block">PUBLIC:
 Return the target relation key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#getTargetRelationKeyFields--">getTargetRelationKeyFields</a></span>()</code>
<div class="block">INTERNAL:
 Return all the target relation key fields associated with the mapping.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code>protected boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#hasCustomDeleteQuery--">hasCustomDeleteQuery</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code>protected boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#hasCustomInsertQuery--">hasCustomInsertQuery</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#hasRelationTable--">hasRelationTable</a></span>()</code>
<div class="block">INTERNAL:
 Indicates whether the mechanism has relation table.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initialize-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initialize</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
          <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Initialize</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeDeleteQuery-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeDeleteQuery</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                     <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Initialize delete query.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeExtendPessipisticLockScope-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeExtendPessipisticLockScope</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                    <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Initialize extendPessimisticLockeScope and lockRelationTableQuery (if required).</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeInsertQuery-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeInsertQuery</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                     <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Initialize insert query.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeLockRelationTableQuery-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-org.eclipse.persistence.expressions.Expression-">initializeLockRelationTableQuery</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping,
                                <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;startCriteria)</code>
<div class="block">INTERNAL:
 Initialize lockRelationTableQuery.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeRelationTable-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeRelationTable</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                       <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 Set the table qualifier on the relation table if required</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeSourceKeys-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeSourceKeys</a></span>(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 All the source key field names are converted to DatabaseField and stored.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeSourceKeysWithDefaults-org.eclipse.persistence.mappings.DatabaseMapping-">initializeSourceKeysWithDefaults</a></span>(<a href="../../../../org/eclipse/persistence/mappings/DatabaseMapping.html" title="class in org.eclipse.persistence.mappings">DatabaseMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 If a user does not specify the source key then the primary keys of the source table are used.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeSourceRelationKeys-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeSourceRelationKeys</a></span>(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 All the source relation key field names are converted to DatabaseField and stored.</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeTargetKeys-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeTargetKeys</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                    <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 All the target key field names are converted to DatabaseField and stored.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeTargetKeysWithDefaults-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeTargetKeysWithDefaults</a></span>(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 If a user does not specify the target key then the primary keys of the target table are used.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#initializeTargetRelationKeys-org.eclipse.persistence.mappings.ForeignReferenceMapping-">initializeTargetRelationKeys</a></span>(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</code>
<div class="block">INTERNAL:
 All the target relation key field names are converted to DatabaseField and stored.</div>
</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code>protected boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#isSingleSourceRelationKeySpecified--">isSingleSourceRelationKeySpecified</a></span>()</code>
<div class="block">INTERNAL:
 Checks if a single source key was specified.</div>
</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code>protected boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#isSingleTargetRelationKeySpecified--">isSingleTargetRelationKeySpecified</a></span>()</code>
<div class="block">INTERNAL:
 Checks if a single target key was specified.</div>
</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#joinRelationTableField-org.eclipse.persistence.expressions.Expression-org.eclipse.persistence.expressions.Expression-">joinRelationTableField</a></span>(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;expression,
                      <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;baseExpression)</code>
<div class="block">INTERNAL:
 Adds to the passed expression a single relation table field joined to source field.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#postPrepareNestedBatchQuery-org.eclipse.persistence.queries.ReadQuery-org.eclipse.persistence.queries.ObjectLevelReadQuery-">postPrepareNestedBatchQuery</a></span>(<a href="../../../../org/eclipse/persistence/queries/ReadQuery.html" title="class in org.eclipse.persistence.queries">ReadQuery</a>&nbsp;batchQuery,
                           <a href="../../../../org/eclipse/persistence/queries/ObjectLevelReadQuery.html" title="class in org.eclipse.persistence.queries">ObjectLevelReadQuery</a>&nbsp;query)</code>
<div class="block">INTERNAL:
 Add the addition join fields to the batch query.</div>
</td>
</tr>
<tr id="i51" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setCustomDeleteQuery-org.eclipse.persistence.queries.DataModifyQuery-">setCustomDeleteQuery</a></span>(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;query)</code>
<div class="block">PUBLIC:
 The default delete query for mapping can be overridden by specifying the new query.</div>
</td>
</tr>
<tr id="i52" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setCustomInsertQuery-org.eclipse.persistence.queries.DataModifyQuery-">setCustomInsertQuery</a></span>(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;query)</code>
<div class="block">PUBLIC:
 The default insert query for mapping can be overridden by specifying the new query.</div>
</td>
</tr>
<tr id="i53" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setDeleteCall-org.eclipse.persistence.queries.Call-">setDeleteCall</a></span>(<a href="../../../../org/eclipse/persistence/queries/Call.html" title="interface in org.eclipse.persistence.queries">Call</a>&nbsp;call)</code>
<div class="block">PUBLIC:
 Set the receiver's delete Call.</div>
</td>
</tr>
<tr id="i54" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setDeleteQuery-org.eclipse.persistence.queries.DataModifyQuery-">setDeleteQuery</a></span>(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;deleteQuery)</code>&nbsp;</td>
</tr>
<tr id="i55" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setDeleteSQLString-java.lang.String-">setDeleteSQLString</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sqlString)</code>
<div class="block">PUBLIC:
 Set the receiver's delete SQL string.</div>
</td>
</tr>
<tr id="i56" class="altColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setHasCustomDeleteQuery-boolean-">setHasCustomDeleteQuery</a></span>(boolean&nbsp;hasCustomDeleteQuery)</code>&nbsp;</td>
</tr>
<tr id="i57" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setHasCustomInsertQuery-boolean-">setHasCustomInsertQuery</a></span>(boolean&nbsp;bool)</code>&nbsp;</td>
</tr>
<tr id="i58" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setInsertCall-org.eclipse.persistence.queries.Call-">setInsertCall</a></span>(<a href="../../../../org/eclipse/persistence/queries/Call.html" title="interface in org.eclipse.persistence.queries">Call</a>&nbsp;call)</code>
<div class="block">PUBLIC:
 Set the receiver's insert Call.</div>
</td>
</tr>
<tr id="i59" class="rowColor">
<td class="colFirst"><code>protected void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setInsertQuery-org.eclipse.persistence.queries.DataModifyQuery-">setInsertQuery</a></span>(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;insertQuery)</code>&nbsp;</td>
</tr>
<tr id="i60" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setInsertSQLString-java.lang.String-">setInsertSQLString</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sqlString)</code>
<div class="block">PUBLIC:
 Set the receiver's insert SQL string.</div>
</td>
</tr>
<tr id="i61" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setRelationTable-org.eclipse.persistence.internal.helper.DatabaseTable-">setRelationTable</a></span>(org.eclipse.persistence.internal.helper.DatabaseTable&nbsp;relationTable)</code>
<div class="block">PUBLIC:
 Set the relational table.</div>
</td>
</tr>
<tr id="i62" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setRelationTableLockingClause-org.eclipse.persistence.queries.ObjectLevelReadQuery-org.eclipse.persistence.queries.ObjectBuildingQuery-">setRelationTableLockingClause</a></span>(<a href="../../../../org/eclipse/persistence/queries/ObjectLevelReadQuery.html" title="class in org.eclipse.persistence.queries">ObjectLevelReadQuery</a>&nbsp;targetQuery,
                             <a href="../../../../org/eclipse/persistence/queries/ObjectBuildingQuery.html" title="class in org.eclipse.persistence.queries">ObjectBuildingQuery</a>&nbsp;sourceQuery)</code>
<div class="block">INTERNAL:
 Return relation table locking clause.</div>
</td>
</tr>
<tr id="i63" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setRelationTableName-java.lang.String-">setRelationTableName</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;tableName)</code>
<div class="block">PUBLIC:
 Set the name of the relational table.</div>
</td>
</tr>
<tr id="i64" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setSessionName-java.lang.String-">setSessionName</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">PUBLIC:
 Set the name of the session to execute the mapping's queries under.</div>
</td>
</tr>
<tr id="i65" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setSourceKeyFieldNames-java.util.Vector-">setSourceKeyFieldNames</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</code>
<div class="block">PUBLIC:
 Set the source key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i66" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setSourceKeyFields-java.util.Vector-">setSourceKeyFields</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;sourceKeyFields)</code>
<div class="block">INTERNAL:
 Set the source fields.</div>
</td>
</tr>
<tr id="i67" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setSourceRelationKeyFieldName-java.lang.String-">setSourceRelationKeyFieldName</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sourceRelationKeyFieldName)</code>
<div class="block">PUBLIC:
 Set the source key field in the relation table.</div>
</td>
</tr>
<tr id="i68" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setSourceRelationKeyFieldNames-java.util.Vector-">setSourceRelationKeyFieldNames</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</code>
<div class="block">PUBLIC:
 Set the source relation key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i69" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setSourceRelationKeyFields-java.util.Vector-">setSourceRelationKeyFields</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;sourceRelationKeyFields)</code>
<div class="block">INTERNAL:
 Set the source fields.</div>
</td>
</tr>
<tr id="i70" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setTargetKeyFieldNames-java.util.Vector-">setTargetKeyFieldNames</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</code>
<div class="block">INTERNAL:
 Set the target key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i71" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setTargetKeyFields-java.util.Vector-">setTargetKeyFields</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;targetKeyFields)</code>
<div class="block">INTERNAL:
 Set the target fields.</div>
</td>
</tr>
<tr id="i72" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setTargetRelationKeyFieldName-java.lang.String-">setTargetRelationKeyFieldName</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;targetRelationKeyFieldName)</code>
<div class="block">PUBLIC:
 Set the target key field in the relation table.</div>
</td>
</tr>
<tr id="i73" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setTargetRelationKeyFieldNames-java.util.Vector-">setTargetRelationKeyFieldNames</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</code>
<div class="block">INTERNAL:
 Set the target relation key field names associated with the mapping.</div>
</td>
</tr>
<tr id="i74" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/eclipse/persistence/mappings/RelationTableMechanism.html#setTargetRelationKeyFields-java.util.Vector-">setTargetRelationKeyFields</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;targetRelationKeyFields)</code>
<div class="block">INTERNAL:
 Set the target fields.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize--" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode--" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString--" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="relationTable">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>relationTable</h4>
<pre>protected&nbsp;org.eclipse.persistence.internal.helper.DatabaseTable relationTable</pre>
<div class="block">The intermediate relation table.</div>
</li>
</ul>
<a name="sourceKeyFields">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sourceKeyFields</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt; sourceKeyFields</pre>
<div class="block">The field in the source table that corresponds to the key in the relation table</div>
</li>
</ul>
<a name="targetKeyFields">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>targetKeyFields</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt; targetKeyFields</pre>
<div class="block">The field in the target table that corresponds to the key in the relation table</div>
</li>
</ul>
<a name="sourceRelationKeyFields">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sourceRelationKeyFields</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt; sourceRelationKeyFields</pre>
<div class="block">The field in the intermediate table that corresponds to the key in the source table</div>
</li>
</ul>
<a name="targetRelationKeyFields">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>targetRelationKeyFields</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt; targetRelationKeyFields</pre>
<div class="block">The field in the intermediate table that corresponds to the key in the target table</div>
</li>
</ul>
<a name="deleteQuery">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteQuery</h4>
<pre>protected&nbsp;<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a> deleteQuery</pre>
<div class="block">Query used for single row deletion.</div>
</li>
</ul>
<a name="hasCustomDeleteQuery">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hasCustomDeleteQuery</h4>
<pre>protected&nbsp;boolean hasCustomDeleteQuery</pre>
</li>
</ul>
<a name="insertQuery">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>insertQuery</h4>
<pre>protected&nbsp;<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a> insertQuery</pre>
<div class="block">Used for insertion.</div>
</li>
</ul>
<a name="hasCustomInsertQuery">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hasCustomInsertQuery</h4>
<pre>protected&nbsp;boolean hasCustomInsertQuery</pre>
</li>
</ul>
<a name="lockRelationTableQuery">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>lockRelationTableQuery</h4>
<pre>protected&nbsp;<a href="../../../../org/eclipse/persistence/queries/ReadQuery.html" title="class in org.eclipse.persistence.queries">ReadQuery</a> lockRelationTableQuery</pre>
</li>
</ul>
</li>
</ul>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="RelationTableMechanism--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>RelationTableMechanism</h4>
<pre>public&nbsp;RelationTableMechanism()</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="addSourceRelationKeyField-org.eclipse.persistence.internal.helper.DatabaseField-org.eclipse.persistence.internal.helper.DatabaseField-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addSourceRelationKeyField</h4>
<pre>public&nbsp;void&nbsp;addSourceRelationKeyField(org.eclipse.persistence.internal.helper.DatabaseField&nbsp;sourceRelationKeyField,
                                      org.eclipse.persistence.internal.helper.DatabaseField&nbsp;sourcePrimaryKeyField)</pre>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the source table. This method is used if the keys are composite.</div>
</li>
</ul>
<a name="addSourceRelationKeyFieldName-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addSourceRelationKeyFieldName</h4>
<pre>public&nbsp;void&nbsp;addSourceRelationKeyFieldName(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sourceRelationKeyFieldName,
                                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sourcePrimaryKeyFieldName)</pre>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the source table. This method is used if the keys are composite.</div>
</li>
</ul>
<a name="addTargetRelationKeyField-org.eclipse.persistence.internal.helper.DatabaseField-org.eclipse.persistence.internal.helper.DatabaseField-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addTargetRelationKeyField</h4>
<pre>public&nbsp;void&nbsp;addTargetRelationKeyField(org.eclipse.persistence.internal.helper.DatabaseField&nbsp;targetRelationKeyField,
                                      org.eclipse.persistence.internal.helper.DatabaseField&nbsp;targetPrimaryKeyField)</pre>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the target table. This method is used if the keys are composite.</div>
</li>
</ul>
<a name="addTargetRelationKeyFieldName-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addTargetRelationKeyFieldName</h4>
<pre>public&nbsp;void&nbsp;addTargetRelationKeyFieldName(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;targetRelationKeyFieldName,
                                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;targetPrimaryKeyFieldName)</pre>
<div class="block">PUBLIC:
 Add the fields in the intermediate table that corresponds to the primary
 key in the target table. This method is used if the keys are composite.</div>
</li>
</ul>
<a name="buildSelectionCriteriaAndAddFieldsToQueryInternal-org.eclipse.persistence.mappings.ForeignReferenceMapping-org.eclipse.persistence.expressions.Expression-boolean-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildSelectionCriteriaAndAddFieldsToQueryInternal</h4>
<pre>public&nbsp;<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;buildSelectionCriteriaAndAddFieldsToQueryInternal(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping,
                                                                    <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;criteria,
                                                                    boolean&nbsp;shouldAddTargetFields,
                                                                    boolean&nbsp;shouldAddFieldsToQuery)</pre>
<div class="block">INTERNAL:
 Build the selection criteria to join the source, relation, and target tables.</div>
</li>
</ul>
<a name="collectQueryParameters-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>collectQueryParameters</h4>
<pre>protected&nbsp;void&nbsp;collectQueryParameters(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;cacheFields)</pre>
<div class="block">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</div>
</li>
</ul>
<a name="clone--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clone</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;clone()</pre>
<div class="block">INTERNAL:
 The mapping clones itself to create deep copy.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone--" title="class or interface in java.lang">clone</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></dd>
</dl>
</li>
</ul>
<a name="cloneFields-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cloneFields</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;cloneFields(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fields)</pre>
<div class="block">INTERNAL:
 Helper method to clone vector of fields (used in aggregate initialization cloning).</div>
</li>
</ul>
<a name="getDeleteQuery--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getDeleteQuery</h4>
<pre>protected&nbsp;<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;getDeleteQuery()</pre>
</li>
</ul>
<a name="setRelationTableLockingClause-org.eclipse.persistence.queries.ObjectLevelReadQuery-org.eclipse.persistence.queries.ObjectBuildingQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setRelationTableLockingClause</h4>
<pre>public&nbsp;void&nbsp;setRelationTableLockingClause(<a href="../../../../org/eclipse/persistence/queries/ObjectLevelReadQuery.html" title="class in org.eclipse.persistence.queries">ObjectLevelReadQuery</a>&nbsp;targetQuery,
                                          <a href="../../../../org/eclipse/persistence/queries/ObjectBuildingQuery.html" title="class in org.eclipse.persistence.queries">ObjectBuildingQuery</a>&nbsp;sourceQuery)</pre>
<div class="block">INTERNAL:
 Return relation table locking clause.</div>
</li>
</ul>
<a name="getInsertQuery--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getInsertQuery</h4>
<pre>protected&nbsp;<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;getInsertQuery()</pre>
</li>
</ul>
<a name="getRelationTable--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRelationTable</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.helper.DatabaseTable&nbsp;getRelationTable()</pre>
<div class="block">INTERNAL:
 Return the relation table associated with the mapping.</div>
</li>
</ul>
<a name="getRelationTableName--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRelationTableName</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getRelationTableName()</pre>
<div class="block">PUBLIC:
 Return the relation table name associated with the mapping.</div>
</li>
</ul>
<a name="getRelationTableQualifiedName--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRelationTableQualifiedName</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getRelationTableQualifiedName()</pre>
<div class="block">PUBLIC:
 Return the relation table qualified name associated with the mapping.</div>
</li>
</ul>
<a name="getSourceKeyFieldNames--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSourceKeyFieldNames</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getSourceKeyFieldNames()</pre>
<div class="block">PUBLIC:
 Return the source key field names associated with the mapping.
 These are in-order with the sourceRelationKeyFieldNames.</div>
</li>
</ul>
<a name="buildBatchCriteria-org.eclipse.persistence.expressions.ExpressionBuilder-org.eclipse.persistence.queries.ObjectLevelReadQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildBatchCriteria</h4>
<pre>protected&nbsp;<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;buildBatchCriteria(<a href="../../../../org/eclipse/persistence/expressions/ExpressionBuilder.html" title="class in org.eclipse.persistence.expressions">ExpressionBuilder</a>&nbsp;builder,
                                        <a href="../../../../org/eclipse/persistence/queries/ObjectLevelReadQuery.html" title="class in org.eclipse.persistence.queries">ObjectLevelReadQuery</a>&nbsp;query)</pre>
<div class="block">INTERNAL:
 Return the selection criteria used to IN batch fetching.</div>
</li>
</ul>
<a name="postPrepareNestedBatchQuery-org.eclipse.persistence.queries.ReadQuery-org.eclipse.persistence.queries.ObjectLevelReadQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>postPrepareNestedBatchQuery</h4>
<pre>public&nbsp;void&nbsp;postPrepareNestedBatchQuery(<a href="../../../../org/eclipse/persistence/queries/ReadQuery.html" title="class in org.eclipse.persistence.queries">ReadQuery</a>&nbsp;batchQuery,
                                        <a href="../../../../org/eclipse/persistence/queries/ObjectLevelReadQuery.html" title="class in org.eclipse.persistence.queries">ObjectLevelReadQuery</a>&nbsp;query)</pre>
<div class="block">INTERNAL:
 Add the addition join fields to the batch query.</div>
</li>
</ul>
<a name="extractBatchKeyFromRow-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.internal.sessions.AbstractSession-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>extractBatchKeyFromRow</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;extractBatchKeyFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;row,
                                        org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session)</pre>
<div class="block">INTERNAL:
 Extract the foreign key value from the source row.</div>
</li>
</ul>
<a name="extractKeyFromTargetRow-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.internal.sessions.AbstractSession-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>extractKeyFromTargetRow</h4>
<pre>protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;extractKeyFromTargetRow(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;row,
                                         org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session)</pre>
<div class="block">INTERNAL:
 Extract the source primary key value from the relation row.
 Used for batch reading, most following same order and fields as in the mapping.</div>
</li>
</ul>
<a name="getSourceKeyFields--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSourceKeyFields</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;getSourceKeyFields()</pre>
<div class="block">INTERNAL:
 Return all the source key fields associated with the mapping.</div>
</li>
</ul>
<a name="getSourceRelationKeyFieldNames--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSourceRelationKeyFieldNames</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getSourceRelationKeyFieldNames()</pre>
<div class="block">PUBLIC:
 Return the source relation key field names associated with the mapping.
 These are in-order with the sourceKeyFieldNames.</div>
</li>
</ul>
<a name="getSourceRelationKeyFields--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSourceRelationKeyFields</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;getSourceRelationKeyFields()</pre>
<div class="block">INTERNAL:
 Return all the source relation key fields associated with the mapping.</div>
</li>
</ul>
<a name="getTargetKeyFieldNames--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getTargetKeyFieldNames</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getTargetKeyFieldNames()</pre>
<div class="block">PUBLIC:
 Return the target key field names associated with the mapping.
 These are in-order with the targetRelationKeyFieldNames.</div>
</li>
</ul>
<a name="getRelationFieldForTargetField-org.eclipse.persistence.internal.helper.DatabaseField-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRelationFieldForTargetField</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.helper.DatabaseField&nbsp;getRelationFieldForTargetField(org.eclipse.persistence.internal.helper.DatabaseField&nbsp;targetField)</pre>
<div class="block">INTERNAL:
 Return the relation field for the target field.</div>
</li>
</ul>
<a name="getTargetKeyFields--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getTargetKeyFields</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;getTargetKeyFields()</pre>
<div class="block">INTERNAL:
 Return all the target keys associated with the mapping.</div>
</li>
</ul>
<a name="getTargetRelationKeyFieldNames--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getTargetRelationKeyFieldNames</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;getTargetRelationKeyFieldNames()</pre>
<div class="block">PUBLIC:
 Return the target relation key field names associated with the mapping.
 These are in-order with the targetKeyFieldNames.</div>
</li>
</ul>
<a name="getTargetRelationKeyFields--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getTargetRelationKeyFields</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;getTargetRelationKeyFields()</pre>
<div class="block">INTERNAL:
 Return all the target relation key fields associated with the mapping.</div>
</li>
</ul>
<a name="hasCustomDeleteQuery--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hasCustomDeleteQuery</h4>
<pre>protected&nbsp;boolean&nbsp;hasCustomDeleteQuery()</pre>
</li>
</ul>
<a name="hasCustomInsertQuery--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hasCustomInsertQuery</h4>
<pre>protected&nbsp;boolean&nbsp;hasCustomInsertQuery()</pre>
</li>
</ul>
<a name="hasRelationTable--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hasRelationTable</h4>
<pre>public&nbsp;boolean&nbsp;hasRelationTable()</pre>
<div class="block">INTERNAL:
 Indicates whether the mechanism has relation table.</div>
</li>
</ul>
<a name="initialize-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initialize</h4>
<pre>public&nbsp;void&nbsp;initialize(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                       <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)
                throws <a href="../../../../org/eclipse/persistence/exceptions/DescriptorException.html" title="class in org.eclipse.persistence.exceptions">DescriptorException</a></pre>
<div class="block">INTERNAL:
 Initialize</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/DescriptorException.html" title="class in org.eclipse.persistence.exceptions">DescriptorException</a></code></dd>
</dl>
</li>
</ul>
<a name="initializeDeleteQuery-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeDeleteQuery</h4>
<pre>protected&nbsp;void&nbsp;initializeDeleteQuery(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                     <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Initialize delete query. This query is used to delete a specific row from the join table in uow,
 given the objects on both sides of the relation.</div>
</li>
</ul>
<a name="initializeExtendPessipisticLockScope-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeExtendPessipisticLockScope</h4>
<pre>protected&nbsp;void&nbsp;initializeExtendPessipisticLockScope(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                    <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Initialize extendPessimisticLockeScope and lockRelationTableQuery (if required).</div>
</li>
</ul>
<a name="initializeInsertQuery-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeInsertQuery</h4>
<pre>protected&nbsp;void&nbsp;initializeInsertQuery(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                     <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Initialize insert query. This query is used to insert the collection of objects into the
 relation table.</div>
</li>
</ul>
<a name="initializeLockRelationTableQuery-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-org.eclipse.persistence.expressions.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeLockRelationTableQuery</h4>
<pre>protected&nbsp;void&nbsp;initializeLockRelationTableQuery(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping,
                                                <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;startCriteria)</pre>
<div class="block">INTERNAL:
 Initialize lockRelationTableQuery.</div>
</li>
</ul>
<a name="initializeRelationTable-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeRelationTable</h4>
<pre>protected&nbsp;void&nbsp;initializeRelationTable(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                       <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)
                                throws <a href="../../../../org/eclipse/persistence/exceptions/DescriptorException.html" title="class in org.eclipse.persistence.exceptions">DescriptorException</a></pre>
<div class="block">INTERNAL:
 Set the table qualifier on the relation table if required</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/DescriptorException.html" title="class in org.eclipse.persistence.exceptions">DescriptorException</a></code></dd>
</dl>
</li>
</ul>
<a name="initializeSourceKeys-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeSourceKeys</h4>
<pre>protected&nbsp;void&nbsp;initializeSourceKeys(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 All the source key field names are converted to DatabaseField and stored.</div>
</li>
</ul>
<a name="initializeSourceKeysWithDefaults-org.eclipse.persistence.mappings.DatabaseMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeSourceKeysWithDefaults</h4>
<pre>protected&nbsp;void&nbsp;initializeSourceKeysWithDefaults(<a href="../../../../org/eclipse/persistence/mappings/DatabaseMapping.html" title="class in org.eclipse.persistence.mappings">DatabaseMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 If a user does not specify the source key then the primary keys of the source table are used.</div>
</li>
</ul>
<a name="initializeSourceRelationKeys-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeSourceRelationKeys</h4>
<pre>protected&nbsp;void&nbsp;initializeSourceRelationKeys(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)
                                     throws <a href="../../../../org/eclipse/persistence/exceptions/DescriptorException.html" title="class in org.eclipse.persistence.exceptions">DescriptorException</a></pre>
<div class="block">INTERNAL:
 All the source relation key field names are converted to DatabaseField and stored.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/eclipse/persistence/exceptions/DescriptorException.html" title="class in org.eclipse.persistence.exceptions">DescriptorException</a></code></dd>
</dl>
</li>
</ul>
<a name="initializeTargetKeys-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeTargetKeys</h4>
<pre>protected&nbsp;void&nbsp;initializeTargetKeys(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                    <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 All the target key field names are converted to DatabaseField and stored.</div>
</li>
</ul>
<a name="initializeTargetKeysWithDefaults-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeTargetKeysWithDefaults</h4>
<pre>protected&nbsp;void&nbsp;initializeTargetKeysWithDefaults(org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 If a user does not specify the target key then the primary keys of the target table are used.</div>
</li>
</ul>
<a name="initializeTargetRelationKeys-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>initializeTargetRelationKeys</h4>
<pre>protected&nbsp;void&nbsp;initializeTargetRelationKeys(<a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 All the target relation key field names are converted to DatabaseField and stored.</div>
</li>
</ul>
<a name="isSingleSourceRelationKeySpecified--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isSingleSourceRelationKeySpecified</h4>
<pre>protected&nbsp;boolean&nbsp;isSingleSourceRelationKeySpecified()</pre>
<div class="block">INTERNAL:
 Checks if a single source key was specified.</div>
</li>
</ul>
<a name="isSingleTargetRelationKeySpecified--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isSingleTargetRelationKeySpecified</h4>
<pre>protected&nbsp;boolean&nbsp;isSingleTargetRelationKeySpecified()</pre>
<div class="block">INTERNAL:
 Checks if a single target key was specified.</div>
</li>
</ul>
<a name="joinRelationTableField-org.eclipse.persistence.expressions.Expression-org.eclipse.persistence.expressions.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>joinRelationTableField</h4>
<pre>public&nbsp;<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;joinRelationTableField(<a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;expression,
                                         <a href="../../../../org/eclipse/persistence/expressions/Expression.html" title="class in org.eclipse.persistence.expressions">Expression</a>&nbsp;baseExpression)</pre>
<div class="block">INTERNAL:
 Adds to the passed expression a single relation table field joined to source field.
 Used to extend pessimistic locking clause in source query.</div>
</li>
</ul>
<a name="setCustomDeleteQuery-org.eclipse.persistence.queries.DataModifyQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCustomDeleteQuery</h4>
<pre>public&nbsp;void&nbsp;setCustomDeleteQuery(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;query)</pre>
<div class="block">PUBLIC:
 The default delete query for mapping can be overridden by specifying the new query.
 This query must delete the row from the M-M join table.</div>
</li>
</ul>
<a name="setCustomInsertQuery-org.eclipse.persistence.queries.DataModifyQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCustomInsertQuery</h4>
<pre>public&nbsp;void&nbsp;setCustomInsertQuery(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;query)</pre>
<div class="block">PUBLIC:
 The default insert query for mapping can be overridden by specifying the new query.
 This query must insert the row into the M-M join table.</div>
</li>
</ul>
<a name="setDeleteQuery-org.eclipse.persistence.queries.DataModifyQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDeleteQuery</h4>
<pre>protected&nbsp;void&nbsp;setDeleteQuery(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;deleteQuery)</pre>
</li>
</ul>
<a name="setDeleteSQLString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDeleteSQLString</h4>
<pre>public&nbsp;void&nbsp;setDeleteSQLString(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sqlString)</pre>
<div class="block">PUBLIC:
 Set the receiver's delete SQL string. This allows the user to override the SQL
 generated by TOPLink, with there own SQL or procedure call. The arguments are
 translated from the fields of the source row, through replacing the field names
 marked by '#' with the values for those fields.
 This is used to delete a single entry from the M-M join table.
 Example, 'delete from PROJ_EMP where PROJ_ID = #PROJ_ID AND EMP_ID = #EMP_ID'.</div>
</li>
</ul>
<a name="setDeleteCall-org.eclipse.persistence.queries.Call-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDeleteCall</h4>
<pre>public&nbsp;void&nbsp;setDeleteCall(<a href="../../../../org/eclipse/persistence/queries/Call.html" title="interface in org.eclipse.persistence.queries">Call</a>&nbsp;call)</pre>
<div class="block">PUBLIC:
 Set the receiver's delete Call. This allows the user to override the SQL
 generated by TOPLink, with there own SQL or procedure call. The arguments are
 translated from the fields of the source row.
 This is used to delete a single entry from the M-M join table.
 Example, 'new SQLCall("delete from PROJ_EMP where PROJ_ID = #PROJ_ID AND EMP_ID = #EMP_ID")'.</div>
</li>
</ul>
<a name="setHasCustomDeleteQuery-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setHasCustomDeleteQuery</h4>
<pre>protected&nbsp;void&nbsp;setHasCustomDeleteQuery(boolean&nbsp;hasCustomDeleteQuery)</pre>
</li>
</ul>
<a name="setHasCustomInsertQuery-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setHasCustomInsertQuery</h4>
<pre>protected&nbsp;void&nbsp;setHasCustomInsertQuery(boolean&nbsp;bool)</pre>
</li>
</ul>
<a name="setInsertQuery-org.eclipse.persistence.queries.DataModifyQuery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setInsertQuery</h4>
<pre>protected&nbsp;void&nbsp;setInsertQuery(<a href="../../../../org/eclipse/persistence/queries/DataModifyQuery.html" title="class in org.eclipse.persistence.queries">DataModifyQuery</a>&nbsp;insertQuery)</pre>
</li>
</ul>
<a name="setInsertSQLString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setInsertSQLString</h4>
<pre>public&nbsp;void&nbsp;setInsertSQLString(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sqlString)</pre>
<div class="block">PUBLIC:
 Set the receiver's insert SQL string. This allows the user to override the SQL
 generated by TOPLink, with there own SQL or procedure call. The arguments are
 translated from the fields of the source row, through replacing the field names
 marked by '#' with the values for those fields.
 This is used to insert an entry into the M-M join table.
 Example, 'insert into PROJ_EMP (EMP_ID, PROJ_ID) values (#EMP_ID, #PROJ_ID)'.</div>
</li>
</ul>
<a name="setInsertCall-org.eclipse.persistence.queries.Call-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setInsertCall</h4>
<pre>public&nbsp;void&nbsp;setInsertCall(<a href="../../../../org/eclipse/persistence/queries/Call.html" title="interface in org.eclipse.persistence.queries">Call</a>&nbsp;call)</pre>
<div class="block">PUBLIC:
 Set the receiver's insert Call. This allows the user to override the SQL
 generated by TOPLink, with there own SQL or procedure call. The arguments are
 translated from the fields of the source row.
 This is used to insert an entry into the M-M join table.
 Example, 'new SQLCall("insert into PROJ_EMP (EMP_ID, PROJ_ID) values (#EMP_ID, #PROJ_ID)")'.</div>
</li>
</ul>
<a name="setRelationTable-org.eclipse.persistence.internal.helper.DatabaseTable-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setRelationTable</h4>
<pre>public&nbsp;void&nbsp;setRelationTable(org.eclipse.persistence.internal.helper.DatabaseTable&nbsp;relationTable)</pre>
<div class="block">PUBLIC:
 Set the relational table.
 This is the join table that store both the source and target primary keys.</div>
</li>
</ul>
<a name="setRelationTableName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setRelationTableName</h4>
<pre>public&nbsp;void&nbsp;setRelationTableName(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;tableName)</pre>
<div class="block">PUBLIC:
 Set the name of the relational table.
 This is the join table that store both the source and target primary keys.</div>
</li>
</ul>
<a name="setSessionName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSessionName</h4>
<pre>public&nbsp;void&nbsp;setSessionName(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">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.</div>
</li>
</ul>
<a name="setSourceKeyFieldNames-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSourceKeyFieldNames</h4>
<pre>public&nbsp;void&nbsp;setSourceKeyFieldNames(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</pre>
<div class="block">PUBLIC:
 Set the source key field names associated with the mapping.
 These must be in-order with the sourceRelationKeyFieldNames.</div>
</li>
</ul>
<a name="setSourceKeyFields-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSourceKeyFields</h4>
<pre>public&nbsp;void&nbsp;setSourceKeyFields(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;sourceKeyFields)</pre>
<div class="block">INTERNAL:
 Set the source fields.</div>
</li>
</ul>
<a name="setSourceRelationKeyFieldName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSourceRelationKeyFieldName</h4>
<pre>public&nbsp;void&nbsp;setSourceRelationKeyFieldName(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;sourceRelationKeyFieldName)</pre>
<div class="block">PUBLIC:
 Set the source key field in the relation table.
 This is the name of the foreign key in the relation table to the source's primary key field.
 This method is used if the source primary key is a singleton only.</div>
</li>
</ul>
<a name="setSourceRelationKeyFieldNames-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSourceRelationKeyFieldNames</h4>
<pre>public&nbsp;void&nbsp;setSourceRelationKeyFieldNames(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</pre>
<div class="block">PUBLIC:
 Set the source relation key field names associated with the mapping.
 These must be in-order with the sourceKeyFieldNames.</div>
</li>
</ul>
<a name="setSourceRelationKeyFields-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSourceRelationKeyFields</h4>
<pre>public&nbsp;void&nbsp;setSourceRelationKeyFields(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;sourceRelationKeyFields)</pre>
<div class="block">INTERNAL:
 Set the source fields.</div>
</li>
</ul>
<a name="setTargetKeyFieldNames-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTargetKeyFieldNames</h4>
<pre>public&nbsp;void&nbsp;setTargetKeyFieldNames(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</pre>
<div class="block">INTERNAL:
 Set the target key field names associated with the mapping.
 These must be in-order with the targetRelationKeyFieldNames.</div>
</li>
</ul>
<a name="setTargetKeyFields-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTargetKeyFields</h4>
<pre>public&nbsp;void&nbsp;setTargetKeyFields(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;targetKeyFields)</pre>
<div class="block">INTERNAL:
 Set the target fields.</div>
</li>
</ul>
<a name="setTargetRelationKeyFieldName-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTargetRelationKeyFieldName</h4>
<pre>public&nbsp;void&nbsp;setTargetRelationKeyFieldName(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;targetRelationKeyFieldName)</pre>
<div class="block">PUBLIC:
 Set the target key field in the relation table.
 This is the name of the foreign key in the relation table to the target's primary key field.
 This method is used if the target's primary key is a singleton only.</div>
</li>
</ul>
<a name="setTargetRelationKeyFieldNames-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTargetRelationKeyFieldNames</h4>
<pre>public&nbsp;void&nbsp;setTargetRelationKeyFieldNames(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&nbsp;fieldNames)</pre>
<div class="block">INTERNAL:
 Set the target relation key field names associated with the mapping.
 These must be in-order with the targetKeyFieldNames.</div>
</li>
</ul>
<a name="setTargetRelationKeyFields-java.util.Vector-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTargetRelationKeyFields</h4>
<pre>public&nbsp;void&nbsp;setTargetRelationKeyFields(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html?is-external=true" title="class or interface in java.util">Vector</a>&lt;org.eclipse.persistence.internal.helper.DatabaseField&gt;&nbsp;targetRelationKeyFields)</pre>
<div class="block">INTERNAL:
 Set the target fields.</div>
</li>
</ul>
<a name="buildRelationTableSourceRow-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildRelationTableSourceRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;buildRelationTableSourceRow(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sourceObject,
                                                                                            org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                                                            <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source object.</div>
</li>
</ul>
<a name="addRelationTableSourceRow-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addRelationTableSourceRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;addRelationTableSourceRow(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sourceObject,
                                                                                          org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                                                          org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;databaseRow,
                                                                                          <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Add to a row source relation fields with values extracted from the source object.</div>
</li>
</ul>
<a name="buildRelationTableSourceRow-org.eclipse.persistence.internal.sessions.AbstractRecord-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildRelationTableSourceRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;buildRelationTableSourceRow(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;sourceRow)</pre>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source row.</div>
</li>
</ul>
<a name="addRelationTableSourceRow-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.internal.sessions.AbstractRecord-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addRelationTableSourceRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;addRelationTableSourceRow(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;sourceRow,
                                                                                          org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;databaseRow)</pre>
<div class="block">INTERNAL:
 Add to a row source relation fields with values extracted from the source row.</div>
</li>
</ul>
<a name="addRelationTableTargetRow-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.internal.sessions.AbstractRecord-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addRelationTableTargetRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;addRelationTableTargetRow(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;targetObject,
                                                                                          org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                                                          org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;databaseRow,
                                                                                          <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Add to a row target relation fields with values extracted from the target object.</div>
</li>
</ul>
<a name="buildRelationTableSourceAndTargetRow-java.lang.Object-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildRelationTableSourceAndTargetRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;buildRelationTableSourceAndTargetRow(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sourceObject,
                                                                                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;targetObject,
                                                                                                     org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                                                                     <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source object
 and target relation fields with values extracted from the target object.</div>
</li>
</ul>
<a name="buildRelationTableSourceAndTargetRow-org.eclipse.persistence.internal.sessions.AbstractRecord-java.lang.Object-org.eclipse.persistence.internal.sessions.AbstractSession-org.eclipse.persistence.mappings.ForeignReferenceMapping-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>buildRelationTableSourceAndTargetRow</h4>
<pre>public&nbsp;org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;buildRelationTableSourceAndTargetRow(org.eclipse.persistence.internal.sessions.AbstractRecord&nbsp;sourceRow,
                                                                                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;targetObject,
                                                                                                     org.eclipse.persistence.internal.sessions.AbstractSession&nbsp;session,
                                                                                                     <a href="../../../../org/eclipse/persistence/mappings/ForeignReferenceMapping.html" title="class in org.eclipse.persistence.mappings">ForeignReferenceMapping</a>&nbsp;mapping)</pre>
<div class="block">INTERNAL:
 Create a row that contains source relation fields with values extracted from the source row
 and target relation fields with values extracted from the target object.</div>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">EclipseLink 3.0.2, API Reference</div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/eclipse/persistence/mappings/RelationalMapping.html" title="interface in org.eclipse.persistence.mappings"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../org/eclipse/persistence/mappings/TransformationMapping.html" title="class in org.eclipse.persistence.mappings"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/eclipse/persistence/mappings/RelationTableMechanism.html" target="_top">Frames</a></li>
<li><a href="RelationTableMechanism.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2007&#x2013;2021 <a href="http://www.eclipse.org/eclipselink">Eclipse.org - EclipseLink Project</a>. All rights reserved.</small></p>
</body>
</html>
