If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may apply to your use of any object code in the Content. Check the Redistributor’s license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise indicated below, the terms and conditions of the EPL and EDL still apply to any source code in the Content and such source code may be obtained at http://www.eclipse.org.
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE,
REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
OF THIS AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a)
in the case of the initial Contributor, the initial code and documentation
distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i)
changes to the Program, and
ii)
additions to the Program;
where
such changes and/or additions to the Program originate from and are distributed
by that particular Contributor. A Contribution 'originates' from a Contributor
if it was added to the Program by such Contributor itself or anyone acting on
such Contributor's behalf. Contributions do not include additions to the
Program which: (i) are separate modules of software distributed in conjunction
with the Program under their own license agreement, and (ii) are not derivative
works of the Program.
"Contributor" means any person or
entity that distributes the Program.
"Licensed Patents " mean patent
claims licensable by a Contributor which are necessarily infringed by the use
or sale of its Contribution alone or when combined with the Program.
"Program" means the Contributions
distributed in accordance with this Agreement.
"Recipient" means anyone who
receives the Program under this Agreement, including all Contributors.
2. GRANT OF RIGHTS
a)
Subject to the terms of this Agreement, each Contributor hereby grants Recipient
a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare
derivative works of, publicly display, publicly perform, distribute and sublicense
the Contribution of such Contributor, if any, and such derivative works, in source
code and object code form.
b)
Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free
patent license under Licensed Patents to make, use, sell, offer to sell, import
and otherwise transfer the Contribution of such Contributor, if any, in source
code and object code form. This patent license shall apply to the combination
of the Contribution and the Program if, at the time the Contribution is added
by the Contributor, such addition of the Contribution causes such combination
to be covered by the Licensed Patents. The patent license shall not apply to
any other combinations which include the Contribution. No hardware per se is
licensed hereunder.
c)
Recipient understands that although each Contributor grants the licenses to its
Contributions set forth herein, no assurances are provided by any Contributor
that the Program does not infringe the patent or other intellectual property
rights of any other entity. Each Contributor disclaims any liability to Recipient
for claims brought by any other entity based on infringement of intellectual
property rights or otherwise. As a condition to exercising the rights and
licenses granted hereunder, each Recipient hereby assumes sole responsibility
to secure any other intellectual property rights needed, if any. For example,
if a third party patent license is required to allow Recipient to distribute
the Program, it is Recipient's responsibility to acquire that license before
distributing the Program.
d)
Each Contributor represents that to its knowledge it has sufficient copyright
rights in its Contribution, if any, to grant the copyright license set forth in
this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the
Program in object code form under its own license agreement, provided that:
a)
it complies with the terms and conditions of this Agreement; and
b)
its license agreement:
i)
effectively disclaims on behalf of all Contributors all warranties and
conditions, express and implied, including warranties or conditions of title
and non-infringement, and implied warranties or conditions of merchantability
and fitness for a particular purpose;
ii)
effectively excludes on behalf of all Contributors all liability for damages,
including direct, indirect, special, incidental and consequential damages, such
as lost profits;
iii)
states that any provisions which differ from this Agreement are offered by that
Contributor alone and not by any other party; and
iv)
states that source code for the Program is available from such Contributor, and
informs licensees how to obtain it in a reasonable manner on or through a
medium customarily used for software exchange.
When the Program is made available in source
code form:
a)
it must be made available under this Agreement; and
b) a
copy of this Agreement must be included with each copy of the Program.
Contributors may not remove or alter any
copyright notices contained within the Program.
Each Contributor must identify itself as the
originator of its Contribution, if any, in a manner that reasonably allows
subsequent Recipients to identify the originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may
accept certain responsibilities with respect to end users, business partners
and the like. While this license is intended to facilitate the commercial use
of the Program, the Contributor who includes the Program in a commercial
product offering should do so in a manner which does not create potential
liability for other Contributors. Therefore, if a Contributor includes the
Program in a commercial product offering, such Contributor ("Commercial
Contributor") hereby agrees to defend and indemnify every other
Contributor ("Indemnified Contributor") against any losses, damages and
costs (collectively "Losses") arising from claims, lawsuits and other
legal actions brought by a third party against the Indemnified Contributor to
the extent caused by the acts or omissions of such Commercial Contributor in
connection with its distribution of the Program in a commercial product
offering. The obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In order
to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
Contributor in writing of such claim, and b) allow the Commercial Contributor
to control, and cooperate with the Commercial Contributor in, the defense and
any related settlement negotiations. The Indemnified Contributor may participate
in any such claim at its own expense.
For example, a Contributor might include the
Program in a commercial product offering, Product X. That Contributor is then a
Commercial Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance claims and
warranties are such Commercial Contributor's responsibility alone. Under this
section, the Commercial Contributor would have to defend claims against the
other Contributors related to those performance claims and warranties, and if a
court requires any other Contributor to pay any damages as a result, the
Commercial Contributor must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS
AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
responsible for determining the appropriateness of using and distributing the
Program and assumes all risks associated with its exercise of rights under this
Agreement , including but not limited to the risks and costs of program errors,
compliance with applicable laws, damage to or loss of data, programs or
equipment, and unavailability or interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS
AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid
or unenforceable under applicable law, it shall not affect the validity or
enforceability of the remainder of the terms of this Agreement, and without
further action by the parties hereto, such provision shall be reformed to the
minimum extent necessary to make such provision valid and enforceable.
If Recipient institutes patent litigation
against any entity (including a cross-claim or counterclaim in a lawsuit)
alleging that the Program itself (excluding combinations of the Program with
other software or hardware) infringes such Recipient's patent(s), then such
Recipient's rights granted under Section 2(b) shall terminate as of the date
such litigation is filed.
All Recipient's rights under this Agreement
shall terminate if it fails to comply with any of the material terms or
conditions of this Agreement and does not cure such failure in a reasonable
period of time after becoming aware of such noncompliance. If all Recipient's
rights under this Agreement terminate, Recipient agrees to cease use and
distribution of the Program as soon as reasonably practicable. However,
Recipient's obligations under this Agreement and any licenses granted by
Recipient relating to the Program shall continue and survive.
Everyone is permitted to copy and distribute
copies of this Agreement, but in order to avoid inconsistency the Agreement is
copyrighted and may only be modified in the following manner. The Agreement
Steward reserves the right to publish new versions (including revisions) of
this Agreement from time to time. No one other than the Agreement Steward has
the right to modify this Agreement. The Eclipse Foundation is the initial
Agreement Steward. The Eclipse Foundation may assign the responsibility to
serve as the Agreement Steward to a suitable separate entity. Each new version
of the Agreement will be given a distinguishing version number. The Program
(including Contributions) may always be distributed subject to the version of
the Agreement under which it was received. In addition, after a new version of
the Agreement is published, Contributor may elect to distribute the Program
(including its Contributions) under the new version. Except as expressly stated
in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
the intellectual property of any Contributor under this Agreement, whether
expressly, by implication, estoppel or otherwise. All rights in the Program not
expressly granted under this Agreement are reserved.
This Agreement is governed by the laws of the
State of New York and the intellectual property laws of the United States of
America. No party to this Agreement will bring a legal action under this
Agreement more than one year after the cause of action arose. Each party waives
its rights to a jury trial in any resulting litigation.
Copyright (c) 2007, Eclipse Foundation, Inc. and its licensors.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
Neither the name of the Eclipse Foundation, Inc. nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The EclipseLink project's
goal is to provide a complete persistence framework that is both comprehensive
and universal. It will run in any Java environment and read and write objects to
virtually any type of data source, including relational databases, XML, JSON, or EIS
systems. EclipseLink will focus on providing leading edge support, including
advanced feature extensions, for the dominant persistence standards for each
target data source; Java Persistence API (JPA) for relational databases, Java
API for XML Binding (JAXB) for XML, Java Connector Architecture (JCA) for EIS
and other types of legacy systems, and Service Data Objects (SDO).
For tips on getting started with EclipseLink, please see the following
resources:
The EclipseLink project's
goal is to provide a complete persistence framework that is both comprehensive
and universal. It will run in any Java environment and read and write objects
to virtually any type of data source, including relational databases, and XML.
EclipseLink will focus on providing leading edge support, including advanced
feature extensions, for the dominant persistence standards for each target data
source; Java Persistence API (JPA) for relational databases, Java API for XML
Binding (JAXB) for XML, Service Data Objects (SDO), and Database Web services
(DBWS).
For tips on getting started with EclipseLink, please see the following resources:
The Eclipse Foundation makes available all content in this plug-in ("Content").
Unless otherwise indicated below, the Content is provided to you under the terms
and conditions of the Eclipse Public License Version 1.0 ("EPL") and
Eclipse Distribution License Version 1.0 (“EDL”). A copy of the EPL is available at
http://www.eclipse.org/legal/epl-v10.html
and a copy of the EDL is available at
http://www.eclipse.org/org/documents/edl-v10.php. For purposes of the EPL, "Program"
will mean the Content.
If you did not receive this Content directly from the Eclipse Foundation, the
Content is being redistributed by another party ("Redistributor")
and different terms and conditions may apply to your use of any object code
in the Content. Check the Redistributor’s license that was provided with
the Content. If no such license exists, contact the Redistributor. Unless otherwise
indicated below, the terms and conditions of the EPL and EDL still apply to any source
code in the Content and such source code may be obtained at http://www.eclipse.org.
Third Party Content
The Content includes items that have been sourced from third parties as set
out below. If you did not receive this Content directly from the Eclipse Foundation,
the following is provided for informational purposes only, and you should look
to the Redistributor’s license for terms and conditions of use.
The EclipseLink Project includes ASM for the purpose of
byte code weaving. The AMS library is re-packaged within the source of the
project (org.persistence.eclipse.internal.libraries.asm.*) to avoid version
collisions with other usage of ASM.
The source code is available within the project's subversion repository.
The binaries are distributed within the eclipselink.jar and in the org.eclipse.persistence.asm_*.jar
bundle.
Copyright (c) 2000-2005 INRIA, France Telecom, All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
Neither the name of the copyright holders nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS"AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THEIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSEARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
BELIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, ORCONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OFSUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER INCONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OFTHE POSSIBILITY OF SUCH DAMAGE.
ANTLR v3.2
The ANTLR library (license)
is included within EclipseLink Project to enable parsing of the Java Persistence
Query language (JP QL). The ANTLR library is re-packaged within the project
in the org.eclipse.persistence.internal.libraries.antlr.* packages.
The source is available with the project's subversion repository. The binaries
are distributed within the eclipselink.jar and in the org.eclipse.persistence.antlr_3.2.0.v*.jar
bundle.
Java Architecture for XML Binding (JAXB) v2.2
The JAXB libraries distributed
under CDDL v1.0
are included within the EclipseLink Project to enable the MOXy component's
implementation of JAXB.
EclipseLink is the Java Persistence (JPA) 2.1 Reference Implementation
(JSR 338). The JPA 2.1
specification API is included in EclipseLink under the EPL and EDL licenses.
Java Mail v1.4.0
The Java Mail library (mail.jar) can be downloaded from java.sun.com
under CDDL
v1.0 and is included within the EclipseLink Project distribution
to support Web Services attachment handling in the MOXy component. It is only
required when using Java SE 5 (Java Mail is included in Java SE 6).
Java Activation Framework v1.1
The Java Activation Framework (activation.jar) is distributed with the JAXB
v2.2 under CDDL
v1.0 and is included within the EclipseLink Project distribution to support
Web Services attachment handling in the MOXy component. It is only required
when using Java SE 5 (The Java Activation Framework is included in Java SE
6).
Streaming API for XML (StAX) v1.0.1
The Streaming API for XML (StAX) library (jsr173_1.0_api.jar) is distributed
with the JAXB v2.2 under
CDDL v1.0
and is included within the EclipseLink Project distribution as an optional
XML processing approach in the MOXy component.
This jar is being shipped and required by the Workbench only. When using
EclipseLink in a container where JCA integration is required that container
will provide the necessary API libraries.
This jar is only required at design time for the DBWS Builder utility.
WSDL4j v1.6.2
WSDL4J 1.6.2 is available for download from the wsdl4j
project. It distributed under
CPLv1.0 .
This jar is only required at design time for the DBWS Builder utility.
eclipselink-2.5.1.orig/org/ 0000755 0000000 0000000 00000000000 12216174372 012442 5 ustar eclipselink-2.5.1.orig/org/eclipse/ 0000755 0000000 0000000 00000000000 12216174372 014066 5 ustar eclipselink-2.5.1.orig/org/eclipse/persistence/ 0000755 0000000 0000000 00000000000 12216174372 016412 5 ustar eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/ 0000775 0000000 0000000 00000000000 12216174372 020232 5 ustar eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/Association.java 0000664 0000000 0000000 00000003730 12216173130 023343 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.util.*;
/**
*
Purpose: Generic association object.
* This can be used to map hashtable/map containers where the key and value primitives or independent objects.
*
* @author James Sutherland
* @since TOPLink/Java 3.0
*/
public class Association implements Map.Entry {
protected Object key;
protected Object value;
/**
* Default constructor.
*/
public Association() {
super();
}
/**
* PUBLIC:
* Create an association.
*/
public Association(Object key, Object value) {
this.key = key;
this.value = value;
}
/**
* PUBLIC:
* Return the key.
*/
public Object getKey() {
return key;
}
/**
* PUBLIC:
* Return the value.
*/
public Object getValue() {
return value;
}
/**
* PUBLIC:
* Set the key.
*/
public void setKey(Object key) {
this.key = key;
}
/**
* PUBLIC:
* Set the value.
*/
public Object setValue(Object value) {
Object oldValue = this.value;
this.value = value;
return oldValue;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/VariableOneToOneMapping.java 0000664 0000000 0000000 00000124524 12216173130 025544 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.indirection.ValueHolder;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.queries.JoinedAttributeManager;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.mappings.querykeys.*;
/**
*
Purpose: Variable one to one mappings are used to represent a pointer references
* between a java object and an implementer of an interface. This mapping is usually represented by a single pointer
* (stored in an instance variable) between the source and target objects. In the relational
* database tables, these mappings are normally implemented using a foreign key and a type code.
*
* @author Sati
* @since TOPLink/Java 2.0
*/
public class VariableOneToOneMapping extends ObjectReferenceMapping implements RelationalMapping {
protected DatabaseField typeField;
protected Map sourceToTargetQueryKeyNames;
protected Map typeIndicatorTranslation;
/** parallel table typeIndicatorTranslation used prior to initialization to avoid type indicators on Mapping Workbench */
protected Map typeIndicatorNameTranslation;
/**
* PUBLIC:
* Default constructor.
*/
public VariableOneToOneMapping() {
this.selectionQuery = new ReadObjectQuery();
this.sourceToTargetQueryKeyNames = new HashMap(2);
this.typeIndicatorTranslation = new HashMap(5);
this.typeIndicatorNameTranslation = new HashMap(5);
this.foreignKeyFields = NonSynchronizedVector.newInstance(1);
//right now only ForeignKeyRelationships are supported
this.isForeignKeyRelationship = false;
}
/**
* INTERNAL:
*/
@Override
public boolean isRelationalMapping() {
return true;
}
/**
* PUBLIC:
* Add a type indicator conversion to this mapping.
*/
public void addClassIndicator(Class implementer, Object typeIndicator) {
if (typeIndicator == null) {
typeIndicator = Helper.NULL_VALUE;
}
getTypeIndicatorTranslation().put(implementer, typeIndicator);
getTypeIndicatorTranslation().put(typeIndicator, implementer);
}
/**
* INTERNAL:
* Add indicators by classname. For use by the Mapping Workbench to avoid classpath dependencies
*/
public void addClassNameIndicator(String className, Object typeIndicator) {
if (typeIndicator == null) {
typeIndicator = Helper.NULL_VALUE;
}
getTypeIndicatorNameTranslation().put(className, typeIndicator);
}
/**
* PUBLIC:
* A foreign key from the source table and abstract query key from the interface descriptor are added to the
* mapping. This method is used if there are multiple foreign keys.
*/
public void addForeignQueryKeyName(DatabaseField sourceForeignKeyField, String targetQueryKeyName) {
getSourceToTargetQueryKeyNames().put(sourceForeignKeyField, targetQueryKeyName);
getForeignKeyFields().addElement(sourceForeignKeyField);
this.setIsForeignKeyRelationship(true);
}
/**
* PUBLIC:
* A foreign key from the source table and abstract query key from the interface descriptor are added to the
* mapping. This method is used if there are multiple foreign keys.
*/
public void addForeignQueryKeyName(String sourceForeignKeyFieldName, String targetQueryKeyName) {
addForeignQueryKeyName(new DatabaseField(sourceForeignKeyFieldName), targetQueryKeyName);
}
/**
* PUBLIC:
* Define the target foreign key relationship in the Variable 1-1 mapping.
* This method is used for composite target foreign key relationships,
* that is the target object's table has multiple foreign key fields to
* the source object's primary key fields.
* Both the target foreign key query name and the source primary key field name
* must be specified.
* The distinction between a foreign key and target foreign key is that the variable 1-1
* mapping will not populate the target foreign key value when written (because it is in the target table).
* Normally 1-1's are through foreign keys but in bi-directional 1-1's
* the back reference will be a target foreign key.
* In obscure composite legacy data models a 1-1 may consist of a foreign key part and
* a target foreign key part, in this case both method will be called with the correct parts.
*/
public void addTargetForeignQueryKeyName(String targetForeignQueryKeyName, String sourcePrimaryKeyFieldName) {
DatabaseField sourceField = new DatabaseField(sourcePrimaryKeyFieldName);
getSourceToTargetQueryKeyNames().put(sourceField, targetForeignQueryKeyName);
}
/**
* INTERNAL:
* Possible for future development, not currently supported.
*
* Retrieve the value through using batch reading.
* This executes a single query to read the target for all of the objects and stores the
* result of the batch query in the original query to allow the other objects to share the results.
*/
@Override
protected Object batchedValueFromRow(AbstractRecord row, ObjectLevelReadQuery query, CacheKey parentCacheKey) {
throw QueryException.batchReadingNotSupported(this, query);
}
/**
* INTERNAL:
* This methods clones all the fields and ensures that each collection refers to
* the same clones.
*/
@Override
public Object clone() {
VariableOneToOneMapping clone = (VariableOneToOneMapping)super.clone();
Map setOfKeys = new HashMap(getSourceToTargetQueryKeyNames().size());
Map sourceToTarget = new HashMap(getSourceToTargetQueryKeyNames().size());
Vector foreignKeys = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(getForeignKeyFields().size());
if (getTypeField() != null) {
clone.setTypeField(this.getTypeField().clone());
}
for (Iterator enumtr = getSourceToTargetQueryKeyNames().keySet().iterator(); enumtr.hasNext();) {
// Clone the SourceKeyFields
DatabaseField field = (DatabaseField)enumtr.next();
DatabaseField clonedField = field.clone();
setOfKeys.put(field, clonedField);
// on the next line I'm cloning the query key names
sourceToTarget.put(clonedField, getSourceToTargetQueryKeyNames().get(field));
}
for (Enumeration enumtr = getForeignKeyFields().elements(); enumtr.hasMoreElements();) {
DatabaseField field = (DatabaseField)enumtr.nextElement();
foreignKeys.addElement(setOfKeys.get(field));
}
clone.setSourceToTargetQueryKeyFields(sourceToTarget);
clone.setForeignKeyFields(foreignKeys);
clone.setTypeIndicatorTranslation(new HashMap(this.getTypeIndicatorTranslation()));
return clone;
}
/**
* INTERNAL:
* Return all the fields populated by this mapping.
*/
@Override
protected Vector collectFields() {
DatabaseField type = getTypeField();
//Get a shallow copy of the Vector
if (type != null) {
Vector sourceFields = (Vector)getForeignKeyFields().clone();
sourceFields.addElement(type);
return sourceFields;
} else {
return getForeignKeyFields();
}
}
/**
* INTERNAL:
* Compare the references of the two objects are the same, not the objects themselves.
* Used for independent relationships.
* This is used for testing and validation purposes.
*
* Must get separate fields for the objects because we may be adding a different class to the
* attribute because of the interface
*/
@Override
protected boolean compareObjectsWithoutPrivateOwned(Object firstObject, Object secondObject, AbstractSession session) {
Object firstPrivateObject = getRealAttributeValueFromObject(firstObject, session);
Object secondPrivateObject = getRealAttributeValueFromObject(secondObject, session);
if ((firstPrivateObject == null) && (secondPrivateObject == null)) {
return true;
}
if ((firstPrivateObject == null) || (secondPrivateObject == null)) {
return false;
}
if (firstPrivateObject.getClass() != secondPrivateObject.getClass()) {
return false;
}
Iterator targetKeys = getSourceToTargetQueryKeyNames().values().iterator();
ClassDescriptor descriptor = session.getDescriptor(firstPrivateObject.getClass());
ClassDescriptor descriptor2 = session.getDescriptor(secondPrivateObject.getClass());
while (targetKeys.hasNext()) {
String queryKey = (String)targetKeys.next();
DatabaseField field = descriptor.getObjectBuilder().getFieldForQueryKeyName(queryKey);
Object firstObjectField = descriptor.getObjectBuilder().extractValueFromObjectForField(firstPrivateObject, field, session);
DatabaseField field2 = descriptor2.getObjectBuilder().getFieldForQueryKeyName(queryKey);
Object secondObjectField = descriptor2.getObjectBuilder().extractValueFromObjectForField(secondPrivateObject, field2, session);
if (!((firstObjectField == null) && (secondObjectField == null))) {
if ((firstObjectField == null) || (secondObjectField == null)) {
return false;
}
if (!firstObjectField.equals(secondObjectField)) {
return false;
}
}
}
return true;
}
/**
* INTERNAL:
* Return the class indicator associations for XML.
* List of class-name/value associations.
*/
public Vector getClassIndicatorAssociations() {
Vector associations = new Vector();
Iterator classesEnum = getTypeIndicatorNameTranslation().keySet().iterator();
Iterator valuesEnum = getTypeIndicatorNameTranslation().values().iterator();
while (classesEnum.hasNext()) {
Object className = classesEnum.next();
// If the project was built in runtime is a class, MW is a string.
if (className instanceof Class) {
className = ((Class)className).getName();
}
Object value = valuesEnum.next();
associations.addElement(new TypedAssociation(className, value));
}
return associations;
}
/**
* INTERNAL:
* Return a descriptor for the target of this mapping
* For normal ObjectReferenceMappings, we return the reference descriptor. For
* a VariableOneToOneMapping, the reference descriptor is often a descriptor for an
* interface and does not contain adequate information. As a result, we look up
* the descriptor for the specific class we are looking for
* Bug 2612571
*/
@Override
public ClassDescriptor getDescriptorForTarget(Object targetObject, AbstractSession session) {
return session.getDescriptor(targetObject);
}
/**
* INTERNAL:
* Return the classification for the field contained in the mapping.
* This is used to convert the row value to a consistent java value.
*/
@Override
public Class getFieldClassification(DatabaseField fieldToClassify) {
if ((getTypeField() != null) && (fieldToClassify.equals(getTypeField()))) {
return getTypeField().getType();
}
String queryKey = (String)getSourceToTargetQueryKeyNames().get(fieldToClassify);
if (queryKey == null) {
return null;
}
// Search any of the implementor descriptors for a mapping for the query-key.
Iterator iterator = getReferenceDescriptor().getInterfacePolicy().getChildDescriptors().iterator();
if (iterator.hasNext()) {
ClassDescriptor firstChild = (ClassDescriptor)iterator.next();
DatabaseMapping mapping = firstChild.getObjectBuilder().getMappingForAttributeName(queryKey);
if ((mapping != null) && (mapping.isDirectToFieldMapping())) {
return ((AbstractDirectMapping)mapping).getAttributeClassification();
}
QueryKey targetQueryKey = firstChild.getQueryKeyNamed(queryKey);
if ((targetQueryKey != null) && (targetQueryKey.isDirectQueryKey())) {
return firstChild.getObjectBuilder().getFieldClassification(((DirectQueryKey)targetQueryKey).getField());
}
}
return null;
}
/**
* PUBLIC:
* Return the foreign key field names associated with the mapping.
* These are only the source fields that are writable.
*/
public Vector getForeignKeyFieldNames() {
Vector fieldNames = new Vector(getForeignKeyFields().size());
for (Enumeration fieldsEnum = getForeignKeyFields().elements();
fieldsEnum.hasMoreElements();) {
fieldNames.addElement(((DatabaseField)fieldsEnum.nextElement()).getQualifiedName());
}
return fieldNames;
}
/**
* INTERNAL:
* Return the implementor for a specified type
*/
protected Object getImplementorForType(Object type, AbstractSession session) {
if (type == null) {
return getTypeIndicatorTranslation().get(Helper.NULL_VALUE);
}
// Must ensure the type is the same, i.e. Integer != BigDecimal.
try {
type = session.getDatasourcePlatform().convertObject(type, getTypeField().getType());
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
}
return getTypeIndicatorTranslation().get(type);
}
/**
* PUBLIC:
* Return a collection of the field to query key associations.
*/
public Vector getSourceToTargetQueryKeyFieldAssociations() {
Vector associations = new Vector(getSourceToTargetQueryKeyNames().size());
Iterator sourceFieldEnum = getSourceToTargetQueryKeyNames().keySet().iterator();
Iterator targetQueryKeyEnum = getSourceToTargetQueryKeyNames().values().iterator();
while (sourceFieldEnum.hasNext()) {
Object fieldValue = ((DatabaseField)sourceFieldEnum.next()).getQualifiedName();
Object attributeValue = targetQueryKeyEnum.next();
associations.addElement(new Association(fieldValue, attributeValue));
}
return associations;
}
/**
* INTERNAL:
* Returns the source keys to target keys fields association.
*/
public Map getSourceToTargetQueryKeyNames() {
return sourceToTargetQueryKeyNames;
}
public DatabaseField getTypeField() {
return typeField;
}
/**
* PUBLIC:
* This method returns the name of the typeField of the mapping.
* The type field is used to store the type of object the relationship is referencing.
*/
public String getTypeFieldName() {
if (getTypeField() == null) {
return null;
}
return getTypeField().getQualifiedName();
}
/**
* INTERNAL:
* Return the type for a specified implementor
*/
protected Object getTypeForImplementor(Class implementor) {
Object type = getTypeIndicatorTranslation().get(implementor);
if (type == Helper.NULL_VALUE) {
type = null;
}
return type;
}
/**
* INTERNAL:
* Return the type indicators.
*/
public Map getTypeIndicatorTranslation() {
return typeIndicatorTranslation;
}
/**
* INTERNAL:
* Return the typeIndicatorName translation
* Used by the Mapping Workbench to avoid classpath dependencies
*/
public Map getTypeIndicatorNameTranslation() {
if (typeIndicatorNameTranslation.isEmpty() && !typeIndicatorTranslation.isEmpty()) {
Iterator keysEnum = typeIndicatorTranslation.keySet().iterator();
Iterator valuesEnum = typeIndicatorTranslation.values().iterator();
while (keysEnum.hasNext()) {
Object key = keysEnum.next();
Object value = valuesEnum.next();
if (key instanceof Class) {
String className = ((Class)key).getName();
typeIndicatorNameTranslation.put(className, value);
}
}
}
return typeIndicatorNameTranslation;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this mapping to actual class-based
* settings. This method is used when converting a project that has been built
* with class names to a project with classes.
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader){
super.convertClassNamesToClasses(classLoader);
Iterator iterator = getTypeIndicatorNameTranslation().entrySet().iterator();
this.typeIndicatorTranslation = new HashMap();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
String referenceClassName = (String)entry.getKey();
Object indicator = entry.getValue();
Class referenceClass = null;
try{
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
try {
referenceClass = (Class)AccessController.doPrivileged(new PrivilegedClassForName(referenceClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(referenceClassName, exception.getException());
}
} else {
referenceClass = PrivilegedAccessHelper.getClassForName(referenceClassName, true, classLoader);
}
} catch (ClassNotFoundException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(referenceClassName, exception);
}
addClassIndicator(referenceClass, indicator);
}
}
/**
* INTERNAL:
* Initialize the mapping.
*/
@Override
public void initialize(AbstractSession session) {
super.initialize(session);
initializeForeignKeys(session);
setFields(collectFields());
if (usesIndirection()) {
for (DatabaseField field : this.fields) {
field.setKeepInRow(true);
}
}
if (getTypeField() != null) {
setTypeField(getDescriptor().buildField(getTypeField()));
}
if (shouldInitializeSelectionCriteria()) {
initializeSelectionCriteria(session);
}
}
/**
* INTERNAL:
* The foreign key names and their primary keys are converted to DatabaseField and stored.
*/
protected void initializeForeignKeys(AbstractSession session) {
HashMap newSourceToTargetQueryKeyNames = new HashMap(getSourceToTargetQueryKeyNames().size());
Iterator iterator = getSourceToTargetQueryKeyNames().entrySet().iterator();
while(iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
DatabaseField field = getDescriptor().buildField((DatabaseField)entry.getKey());
newSourceToTargetQueryKeyNames.put(field, entry.getValue());
}
this.sourceToTargetQueryKeyNames = newSourceToTargetQueryKeyNames;
}
/**
* INTERNAL:
* Selection criteria is created with source foreign keys and target keys.
* This criteria is then used to read target records from the table.
*/
public void initializeSelectionCriteria(AbstractSession session) {
Expression selectionCriteria = null;
Expression expression;
ExpressionBuilder expBuilder = new ExpressionBuilder();
Iterator sourceKeysEnum = getSourceToTargetQueryKeyNames().keySet().iterator();
while (sourceKeysEnum.hasNext()) {
DatabaseField sourceKey = (DatabaseField)sourceKeysEnum.next();
String target = (String)this.getSourceToTargetQueryKeyNames().get(sourceKey);
expression = expBuilder.getParameter(sourceKey).equal(expBuilder.get(target));
if (selectionCriteria == null) {
selectionCriteria = expression;
} else {
selectionCriteria = expression.and(selectionCriteria);
}
}
setSelectionCriteria(selectionCriteria);
}
/**
* INTERNAL:
*/
@Override
public boolean isVariableOneToOneMapping() {
return true;
}
/**
* INTERNAL:
*/
@Override
protected Object getPrimaryKeyForObject(Object object, AbstractSession session) {
return session.getId(object);
}
/**
* INTERNAL:
* Set the type field classification through searching the indicators hashtable.
*/
@Override
public void preInitialize(AbstractSession session) throws DescriptorException {
super.preInitialize(session);
if (getTypeIndicatorTranslation().isEmpty()) {
return;
}
Class type = null;
for (Iterator typeValuesEnum = getTypeIndicatorTranslation().values().iterator();
typeValuesEnum.hasNext() && (type == null);) {
Object value = typeValuesEnum.next();
if ((value != Helper.NULL_VALUE) && (!(value instanceof Class))) {
type = value.getClass();
}
}
getTypeField().setType(type);
}
/**
* INTERNAL:
* Rehash any maps based on fields.
* This is used to clone descriptors for aggregates, which hammer field names.
*/
@Override
public void rehashFieldDependancies(AbstractSession session) {
setSourceToTargetQueryKeyFields(Helper.rehashMap(getSourceToTargetQueryKeyNames()));
}
/**
* PUBLIC:
* Set the class indicator associations.
*/
public void setClassIndicatorAssociations(Vector classIndicatorAssociations) {
setTypeIndicatorNameTranslation(new HashMap(classIndicatorAssociations.size() + 1));
setTypeIndicatorTranslation(new HashMap((classIndicatorAssociations.size() * 2) + 1));
for (Enumeration associationsEnum = classIndicatorAssociations.elements();
associationsEnum.hasMoreElements();) {
Association association = (Association)associationsEnum.nextElement();
Object classValue = association.getKey();
if (classValue instanceof Class) {
// 904 projects will be a class type.
addClassIndicator((Class)association.getKey(), association.getValue());
} else {
addClassNameIndicator((String)association.getKey(), association.getValue());
}
}
}
/**
* PUBLIC:
* Return the foreign key field names associated with the mapping.
* These are only the source fields that are writable.
*/
public void setForeignKeyFieldNames(Vector fieldNames) {
Vector fields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(fieldNames.size());
for (Enumeration fieldNamesEnum = fieldNames.elements(); fieldNamesEnum.hasMoreElements();) {
fields.addElement(new DatabaseField((String)fieldNamesEnum.nextElement()));
}
setForeignKeyFields(fields);
if (!fields.isEmpty()) {
setIsForeignKeyRelationship(true);
}
}
/**
* PUBLIC:
* A foreign key from the source table and abstract query key from the interface descriptor are added to the
* mapping. This method is used if foreign key is not composite.
*/
public void setForeignQueryKeyName(String sourceForeignKeyFieldName, String targetQueryKeyName) {
addForeignQueryKeyName(sourceForeignKeyFieldName, targetQueryKeyName);
}
/**
* PUBLIC:
* Set a collection of the source to target query key/field associations.
*/
public void setSourceToTargetQueryKeyFieldAssociations(Vector sourceToTargetQueryKeyFieldAssociations) {
setSourceToTargetQueryKeyFields(new HashMap(sourceToTargetQueryKeyFieldAssociations.size() + 1));
for (Enumeration associationsEnum = sourceToTargetQueryKeyFieldAssociations.elements();
associationsEnum.hasMoreElements();) {
Association association = (Association)associationsEnum.nextElement();
Object sourceField = new DatabaseField((String)association.getKey());
String targetQueryKey = (String)association.getValue();
getSourceToTargetQueryKeyNames().put(sourceField, targetQueryKey);
}
}
/**
* INTERNAL:
* Set the source keys to target keys fields association.
*/
protected void setSourceToTargetQueryKeyFields(Map sourceToTargetQueryKeyNames) {
this.sourceToTargetQueryKeyNames = sourceToTargetQueryKeyNames;
}
/**
* INTERNAL:
* This method set the typeField of the mapping to the parameter field
*/
public void setTypeField(DatabaseField typeField) {
this.typeField = typeField;
}
/**
* PUBLIC:
* This method sets the name of the typeField of the mapping.
* The type field is used to store the type of object the relationship is referencing.
*/
public void setTypeFieldName(String typeFieldName) {
setTypeField(new DatabaseField(typeFieldName));
}
/**
* INTERNAL:
* Set the typeIndicatorTranslations hashtable to the new Hashtable translations
*/
protected void setTypeIndicatorTranslation(Map translations) {
this.typeIndicatorTranslation = translations;
}
/**
* INTERNAL:
* For avoiding classpath dependencies on the Mapping Workbench
*/
protected void setTypeIndicatorNameTranslation(Map translations) {
this.typeIndicatorNameTranslation = translations;
}
/**
* INTERNAL:
* Get a value from the object and set that in the respective field of the row.
*/
@Override
public Object valueFromObject(Object object, DatabaseField field, AbstractSession session) {
// First check if the value can be obtained from the value holder's row.
AbstractRecord referenceRow = getIndirectionPolicy().extractReferenceRow(getAttributeValueFromObject(object));
if (referenceRow != null) {
Object value = referenceRow.get(field);
// Must ensure the classification to get a cache hit.
try {
value = session.getDatasourcePlatform().convertObject(value, getFieldClassification(field));
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
}
return value;
}
//2.5.1.6 PWK. added to support batch reading on variable one to ones
Object referenceObject = getRealAttributeValueFromObject(object, session);
String queryKeyName = (String)getSourceToTargetQueryKeyNames().get(field);
ClassDescriptor objectDescriptor = session.getDescriptor(referenceObject.getClass());
DatabaseField targetField = objectDescriptor.getObjectBuilder().getTargetFieldForQueryKeyName(queryKeyName);
if (targetField == null) {
// Bug 326091 - return the type value if the field passed is the type indicator field
if (referenceObject != null && this.typeField != null && field.equals(this.typeField)) {
return getTypeForImplementor(referenceObject.getClass());
} else {
return null;
}
}
return objectDescriptor.getObjectBuilder().extractValueFromObjectForField(referenceObject, targetField, session);
}
/**
* INTERNAL:
* Return the value of the field from the row or a value holder on the query to obtain the object.
* Check for batch + aggregation reading.
*/
@Override
public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, CacheKey cacheKey, AbstractSession executionSession, boolean isTargetProtected, Boolean[] wasCacheUsed) throws DatabaseException {
if (this.descriptor.getCachePolicy().isProtectedIsolation()) {
if (this.isCacheable && isTargetProtected && cacheKey != null) {
//cachekey will be null when isolating to uow
//used cached collection
Object result = null;
Object cached = cacheKey.getObject();
if (cached != null) {
if (wasCacheUsed != null){
wasCacheUsed[0] = Boolean.TRUE;
}
return this.getAttributeValueFromObject(cached);
}
} else if (!this.isCacheable && !isTargetProtected && cacheKey != null) {
return this.indirectionPolicy.buildIndirectObject(new ValueHolder(null));
}
}
if (row.hasSopObject()) {
return getAttributeValueFromObject(row.getSopObject());
}
// If any field in the foreign key is null then it means there are no referenced objects
for (DatabaseField field : getFields()) {
if (row.get(field) == null) {
return getIndirectionPolicy().nullValueFromRow();
}
}
if (getTypeField() != null) {
// If the query used batched reading, return a special value holder,
// or retrieve the object from the query property.
if (sourceQuery.isObjectLevelReadQuery() && (((ObjectLevelReadQuery)sourceQuery).isAttributeBatchRead(this.descriptor, getAttributeName())
|| (sourceQuery.isReadAllQuery() && shouldUseBatchReading()))) {
return batchedValueFromRow(row, ((ObjectLevelReadQuery)sourceQuery), cacheKey);
}
//If the field is empty we cannot load the object because we do not know what class it will be
if (row.get(getTypeField()) == null) {
return getIndirectionPolicy().nullValueFromRow();
}
Class implementerClass = (Class)getImplementorForType(row.get(getTypeField()), executionSession);
ReadObjectQuery query = (ReadObjectQuery)getSelectionQuery().clone();
query.setReferenceClass(implementerClass);
query.setSelectionCriteria(getSelectionCriteria());
query.setDescriptor(null);// Must set to null so the right descriptor is used
if (sourceQuery.isObjectLevelReadQuery() && (sourceQuery.shouldCascadeAllParts() || (sourceQuery.shouldCascadePrivateParts() && isPrivateOwned()) || (sourceQuery.shouldCascadeByMapping() && this.cascadeRefresh)) ) {
query.setShouldRefreshIdentityMapResult(sourceQuery.shouldRefreshIdentityMapResult());
query.setCascadePolicy(sourceQuery.getCascadePolicy());
query.setShouldMaintainCache(sourceQuery.shouldMaintainCache());
// For flashback.
if (((ObjectLevelReadQuery)sourceQuery).hasAsOfClause()) {
query.setAsOfClause(((ObjectLevelReadQuery)sourceQuery).getAsOfClause());
}
//CR #4365 - used to prevent infinit recursion on refresh object cascade all
query.setQueryId(sourceQuery.getQueryId());
}
return getIndirectionPolicy().valueFromQuery(query, row, executionSession);
} else {
return super.valueFromRow(row, joinManager, sourceQuery, cacheKey, executionSession, isTargetProtected, wasCacheUsed);
}
}
/**
* INTERNAL:
* Get a value from the object and set that in the respective field of the row.
*/
protected void writeFromNullObjectIntoRow(AbstractRecord record) {
if (isReadOnly()) {
return;
}
if (isForeignKeyRelationship()) {
Enumeration foreignKeys = getForeignKeyFields().elements();
while (foreignKeys.hasMoreElements()) {
record.put((DatabaseField)foreignKeys.nextElement(), null);
// EL Bug 319759 - if a field is null, then the update call cache should not be used
record.setNullValueInFields(true);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), null);
record.setNullValueInFields(true);
}
}
/**
* INTERNAL:
* Get a value from the object and set that in the respective field of the row.
* If the mapping id target foreign key, you must only write the type into the roe, the rest will be updated
* when the object itself is written
*/
@Override
public void writeFromObjectIntoRow(Object object, AbstractRecord record, AbstractSession session, WriteType writeType) {
if (isReadOnly()) {
return;
}
Object referenceObject = getRealAttributeValueFromObject(object, session);
if (referenceObject == null) {
writeFromNullObjectIntoRow(record);
} else {
if (isForeignKeyRelationship()) {
Enumeration sourceFields = getForeignKeyFields().elements();
ClassDescriptor descriptor = session.getDescriptor(referenceObject.getClass());
while (sourceFields.hasMoreElements()) {
DatabaseField sourceKey = (DatabaseField)sourceFields.nextElement();
String targetQueryKey = (String)getSourceToTargetQueryKeyNames().get(sourceKey);
DatabaseField targetKeyField = descriptor.getObjectBuilder().getFieldForQueryKeyName(targetQueryKey);
if (targetKeyField == null) {
throw DescriptorException.variableOneToOneMappingIsNotDefinedProperly(this, descriptor, targetQueryKey);
}
Object referenceValue = descriptor.getObjectBuilder().extractValueFromObjectForField(referenceObject, targetKeyField, session);
// EL Bug 319759 - if a field is null, then the update call cache should not be used
if (referenceValue == null) {
record.setNullValueInFields(true);
}
record.put(sourceKey, referenceValue);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), getTypeForImplementor(referenceObject.getClass()));
}
}
}
/**
* INTERNAL:
* Get a value from the object and set that in the respective field of the row.
* If the mapping id target foreign key, you must only write the type into the roe, the rest will be updated
* when the object itself is written
*/
@Override
public void writeFromObjectIntoRowWithChangeRecord(ChangeRecord changeRecord, AbstractRecord record, AbstractSession session, WriteType writeType) {
if (isReadOnly()) {
return;
}
ObjectChangeSet changeSet = (ObjectChangeSet)((ObjectReferenceChangeRecord)changeRecord).getNewValue();
if (changeSet == null) {
writeFromNullObjectIntoRow(record);
} else {
Object referenceObject = changeSet.getUnitOfWorkClone();
if (isForeignKeyRelationship()) {
Enumeration sourceFields = getForeignKeyFields().elements();
ClassDescriptor descriptor = session.getDescriptor(referenceObject.getClass());
while (sourceFields.hasMoreElements()) {
DatabaseField sourceKey = (DatabaseField)sourceFields.nextElement();
String targetQueryKey = (String)getSourceToTargetQueryKeyNames().get(sourceKey);
DatabaseField targetKeyField = descriptor.getObjectBuilder().getFieldForQueryKeyName(targetQueryKey);
if (targetKeyField == null) {
throw DescriptorException.variableOneToOneMappingIsNotDefinedProperly(this, descriptor, targetQueryKey);
}
Object referenceValue = descriptor.getObjectBuilder().extractValueFromObjectForField(referenceObject, targetKeyField, session);
// EL Bug 319759 - if a field is null, then the update call cache should not be used
if (referenceValue == null) {
record.setNullValueInFields(true);
}
record.put(sourceKey, referenceValue);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), getTypeForImplementor(referenceObject.getClass()));
}
}
}
/**
* INTERNAL:
* This row is built for shallow insert which happens in case of bidirectional inserts.
* The foreign keys must be set to null to avoid constraints.
*/
@Override
public void writeFromObjectIntoRowForShallowInsert(Object object, AbstractRecord record, AbstractSession session) {
writeFromNullObjectIntoRow(record);
}
/**
* INTERNAL:
* This row is built for update after shallow insert which happens in case of bidirectional inserts.
* It contains the foreign keys with non null values that were set to null for shallow insert.
* If mapping overrides writeFromObjectIntoRowForShallowInsert method it must override this one, too.
*/
public void writeFromObjectIntoRowForUpdateAfterShallowInsert(Object object, AbstractRecord row, AbstractSession session, DatabaseTable table) {
if (!getFields().get(0).getTable().equals(table)) {
return;
}
writeFromObjectIntoRow(object, row, session, WriteType.UPDATE);
}
/**
* INTERNAL:
* This row is built for shallow insert which happens in case of bidirectional inserts.
* The foreign keys must be set to null to avoid constraints.
*/
@Override
public void writeFromObjectIntoRowForShallowInsertWithChangeRecord(ChangeRecord changeRecord, AbstractRecord record, AbstractSession session) {
writeFromNullObjectIntoRow(record);
}
/**
* INTERNAL:
* Get a value from the object and set that in the respective field of the row.
*/
@Override
public void writeFromObjectIntoRowForWhereClause(ObjectLevelModifyQuery query, AbstractRecord record) {
if (isReadOnly()) {
return;
}
Object object;
if (query.isDeleteObjectQuery()) {
object = query.getObject();
} else {
object = query.getBackupClone();
}
Object referenceObject = getRealAttributeValueFromObject(object, query.getSession());
if (referenceObject == null) {
writeFromNullObjectIntoRow(record);
} else {
if (isForeignKeyRelationship()) {
Enumeration sourceFields = getForeignKeyFields().elements();
ClassDescriptor descriptor = query.getSession().getDescriptor(referenceObject.getClass());
while (sourceFields.hasMoreElements()) {
DatabaseField sourceKey = (DatabaseField)sourceFields.nextElement();
String targetQueryKey = (String)getSourceToTargetQueryKeyNames().get(sourceKey);
DatabaseField targetKeyField = descriptor.getObjectBuilder().getFieldForQueryKeyName(targetQueryKey);
if (targetKeyField == null) {
throw DescriptorException.variableOneToOneMappingIsNotDefinedProperly(this, descriptor, targetQueryKey);
}
Object referenceValue = descriptor.getObjectBuilder().extractValueFromObjectForField(referenceObject, targetKeyField, query.getSession());
if (referenceValue == null) {
// EL Bug 319759 - if a field is null, then the update call cache should not be used
record.setNullValueInFields(true);
}
record.put(sourceKey, referenceValue);
}
}
if (getTypeField() != null) {
Object typeForImplementor = getTypeForImplementor(referenceObject.getClass());
record.put(getTypeField(), typeForImplementor);
}
}
}
/**
* INTERNAL:
* Write fields needed for insert into the template for with null values.
*/
@Override
public void writeInsertFieldsIntoRow(AbstractRecord record, AbstractSession session) {
writeFromNullObjectIntoRow(record);
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/ 0000775 0000000 0000000 00000000000 12216174372 022424 5 ustar eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/ClassInstanceConverter.java 0000664 0000000 0000000 00000011031 12216173130 027674 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import org.eclipse.persistence.mappings.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.sessions.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedNewInstanceFromClass;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
* Purpose: Allows a class name to be converted to and from a new instance of the class.
*
* When using a ClassInstanceConverter, the database will store the Class name and the java object
* model will contain an instance of that class initialized with its default constructor
*
* @author James Sutherland
* @since OracleAS TopLink 10g (10.0.3)
*/
public class ClassInstanceConverter implements Converter {
protected DatabaseMapping mapping;
/**
* PUBLIC:
* Default constructor.
*/
public ClassInstanceConverter() {
}
/**
* INTERNAL:
* Convert the class name to a class, then create an instance of the class.
*/
public Object convertDataValueToObjectValue(Object fieldValue, Session session) {
Object attributeValue = null;
if (fieldValue != null) {
Class attributeClass = (Class)((AbstractSession)session).getDatasourcePlatform().convertObject(fieldValue, ClassConstants.CLASS);
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
attributeValue = AccessController.doPrivileged(new PrivilegedNewInstanceFromClass(attributeClass));
} catch (PrivilegedActionException exception) {
throw ConversionException.couldNotBeConverted(fieldValue, attributeClass, exception.getException());
}
} else {
attributeValue = PrivilegedAccessHelper.newInstanceFromClass(attributeClass);
}
} catch (Exception exception) {
throw ConversionException.couldNotBeConverted(fieldValue, attributeClass, exception);
}
}
return attributeValue;
}
/**
* INTERNAL:
* Convert to the field class.
*/
public Object convertObjectValueToDataValue(Object attributeValue, Session session) {
if (attributeValue == null) {
return null;
}
return attributeValue.getClass().getName();
}
/**
* INTERNAL:
* Set the mapping.
*/
public void initialize(DatabaseMapping mapping, Session session) {
this.mapping = mapping;
// CR#... Mapping must also have the field classification.
if (getMapping().isDirectToFieldMapping()) {
AbstractDirectMapping directMapping = (AbstractDirectMapping)getMapping();
// Allow user to specify field type to override computed value. (i.e. blob, nchar)
if (directMapping.getFieldClassification() == null) {
directMapping.setFieldClassification(ClassConstants.STRING);
}
}
}
/**
* INTERNAL:
* Return the mapping.
*/
protected DatabaseMapping getMapping() {
return mapping;
}
/**
* INTERNAL:
* If the converter converts the value to a non-atomic value, i.e.
* a value that can have its' parts changed without being replaced,
* then it must return false, serialization can be non-atomic.
*/
public boolean isMutable() {
return false;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/EnumTypeConverter.java 0000664 0000000 0000000 00000015160 12216173130 026717 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* * 30/05/2012-2.4 Guy Pelletier
* - 354678: Temp classloader is still being used during metadata processing
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.EnumSet;
import java.util.Iterator;
import org.eclipse.persistence.sessions.Session;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
/**
* Purpose: Object type converter is used to match a fixed number of
* database data values to a Java enum object value. It can be used when the
* values on the database and in the Java differ. To create an object type
* converter, simply specify the set of conversion value pairs. A default value
* and one-way conversion are also supported for legacy data situations.
*
* @author Guy Pelletier
* @since Toplink 10.1.4RI
*/
public class EnumTypeConverter extends ObjectTypeConverter {
private Class m_enumClass;
private String m_enumClassName;
private boolean m_useOrdinalValues;
/**
* PUBLIC:
* Creating an enum converter this way will create the conversion values
* for you using ordinal or name values.
*/
public EnumTypeConverter(DatabaseMapping mapping, Class enumClass, boolean useOrdinalValues) {
super(mapping);
m_enumClass = enumClass;
m_enumClassName = enumClass.getName();
m_useOrdinalValues = useOrdinalValues;
initializeConversions(m_enumClass);
}
/**
* PUBLIC:
* Creating an enum converter this way will create the conversion values
* for you using ordinal or name values.
*/
public EnumTypeConverter(DatabaseMapping mapping, String enumClassName, boolean useOrdinalValues) {
this(mapping, enumClassName);
m_useOrdinalValues = useOrdinalValues;
}
/**
* PUBLIC:
* Creating an enum converter this way expects that you will provide
* the conversion values separately.
*/
public EnumTypeConverter(DatabaseMapping mapping, String enumClassName) {
super(mapping);
m_enumClassName = enumClassName;
}
protected void initializeConversions(Class enumClass) {
// Initialize conversion if not already set by Converter
if (getFieldToAttributeValues().isEmpty()) {
EnumSet theEnums = EnumSet.allOf(enumClass);
Iterator i = theEnums.iterator();
while (i.hasNext()) {
Enum theEnum = i.next();
if (m_useOrdinalValues) {
addConversionValue(theEnum.ordinal(), theEnum.name());
} else {
addConversionValue(theEnum.name(), theEnum.name());
}
}
}
}
public Class getEnumClass() {
return m_enumClass;
}
public String getEnumClassName() {
return m_enumClassName;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this converter to actual
* class-based settings. This method is used when converting a project
* that has been built with class names to a project with classes.
* @param classLoader
*/
public void convertClassNamesToClasses(ClassLoader classLoader) {
super.convertClassNamesToClasses(classLoader);
// convert if enumClass is null or if different classLoader
if (m_enumClass == null ||
(m_enumClass != null && !m_enumClass.getClassLoader().equals(classLoader))) {
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
m_enumClass = (Class)AccessController.doPrivileged(
new PrivilegedClassForName(m_enumClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(
m_enumClassName, exception.getException());
}
} else {
m_enumClass = PrivilegedAccessHelper.getClassForName(m_enumClassName, true,
classLoader);
}
} catch (ClassNotFoundException exception){
throw ValidationException.classNotFoundWhileConvertingClassNames(m_enumClassName,
exception);
}
}
initializeConversions(m_enumClass);
}
/**
* INTERNAL:
* Returns the corresponding attribute value for the specified field value.
* Wraps the super method to return an Enum type from the string conversion.
*/
public Object convertDataValueToObjectValue(Object fieldValue, Session session) {
Object obj = super.convertDataValueToObjectValue(fieldValue, session);
if (fieldValue == null || obj == null) {
return obj;
} else {
return Enum.valueOf(m_enumClass, (String) obj);
}
}
/**
* INTERNAL:
* Convert Enum object to the data value. Internal enums are stored as
* strings (names) so this method wraps the super method in that if
* breaks down the enum to a string name before converting it.
*/
public Object convertObjectValueToDataValue(Object attributeValue, Session session) {
if (attributeValue == null) {
return super.convertObjectValueToDataValue(null, session);
} else {
return super.convertObjectValueToDataValue(((Enum)attributeValue).name(), session);
}
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/ObjectTypeConverter.java 0000664 0000000 0000000 00000047733 12216173130 027234 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* * 30/05/2012-2.4 Guy Pelletier
* - 354678: Temp classloader is still being used during metadata processing
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.lang.reflect.Constructor;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;
import org.eclipse.persistence.mappings.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.descriptors.TypeMapping;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.sessions.*;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.security.PrivilegedGetConstructorFor;
import org.eclipse.persistence.internal.security.PrivilegedInvokeConstructor;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
* Purpose: Object type converter is used to match a fixed number of database data values
* to Java object value. It can be used when the values on the database and in the Java differ.
* To create an object type converter, simply specify the set of conversion value pairs.
* A default value and one-way conversion are also supported for legacy data situations.
*
* @author James Sutherland
* @since Toplink 10
*/
public class ObjectTypeConverter implements Converter {
// String type names and values set from JPA processing.
protected String converterName;
protected Class dataType;
protected String dataTypeName;
protected Class objectType;
protected String objectTypeName;
protected Map conversionValueStrings;
protected Map addToAttributeOnlyConversionValueStrings;
protected DatabaseMapping mapping;
protected transient Map fieldToAttributeValues;
protected Map attributeToFieldValues;
protected transient Object defaultAttributeValue;
protected String defaultAttributeValueString;
protected transient Class fieldClassification;
protected transient String fieldClassificationName;
/**
* PUBLIC:
* Default constructor.
*/
public ObjectTypeConverter() {
this.attributeToFieldValues = new HashMap(10);
this.fieldToAttributeValues = new HashMap(10);
this.conversionValueStrings = new HashMap(10);
this.addToAttributeOnlyConversionValueStrings = new HashMap(10);
}
/**
* PUBLIC:
* Default constructor.
*/
public ObjectTypeConverter(DatabaseMapping mapping) {
this();
this.mapping = mapping;
}
/**
* PUBLIC:
* A type conversion value is a two-way mapping from the database to the object.
* The database value will be substituted for the object value when read,
* and the object value will be substituted for database value when written.
* Note that each field/attribute value must have one and only one attribute/field value to maintain a two-way mapping.
*/
public void addConversionValue(Object fieldValue, Object attributeValue) {
if (fieldValue == null) {
fieldValue = Helper.NULL_VALUE;
}
if (attributeValue == null) {
attributeValue = Helper.NULL_VALUE;
}
getFieldToAttributeValues().put(fieldValue, attributeValue);
getAttributeToFieldValues().put(attributeValue, fieldValue);
}
/**
* INTERNAL:
* Set from JPA processing where we deal with strings only to avoid
* class loader conflicts.
*/
public void addConversionValueStrings(String dataValue, String objectValue) {
this.conversionValueStrings.put(dataValue, objectValue);
}
/**
* PUBLIC:
* An attribute only conversion value is a one-way mapping from the database to the object.
* This can be used if multiple database values are desired to be mapped to the same object value.
* Note that when written only the default value will be used for the attribute, not this value.
*/
public void addToAttributeOnlyConversionValue(Object fieldValue, Object attributeValue) {
if (fieldValue == null) {
fieldValue = Helper.NULL_VALUE;
}
if (attributeValue == null) {
attributeValue = Helper.NULL_VALUE;
}
getFieldToAttributeValues().put(fieldValue, attributeValue);
}
/**
* INTERNAL:
* Set from JPA processing where we deal with strings only to avoid
* class loader conflicts.
*/
public void addToAttributeOnlyConversionValueStrings(String dataValue, String objectValue) {
this.addToAttributeOnlyConversionValueStrings.put(dataValue, objectValue);
}
/**
* INTERNAL:
* Get the attribute to field mapping.
*/
public Map getAttributeToFieldValues() {
return attributeToFieldValues;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this converter to actual
* class-based settings. This method is used when converting a project
* that has been built with class names to a project with classes.
* @param classLoader
*/
public void convertClassNamesToClasses(ClassLoader classLoader){
if (dataTypeName != null) {
dataType = loadClass(dataTypeName, classLoader);
}
if (objectTypeName != null) {
objectType = loadClass(objectTypeName, classLoader);
}
if (objectType != null && dataType != null) {
// Process the data to object mappings. The object and data values
// should be primitive wrapper types so we can initialize the
// conversion values now.
for (String dataValue : conversionValueStrings.keySet()) {
String objectValue = conversionValueStrings.get(dataValue);
addConversionValue(initObject(dataType, dataValue, true), initObject(objectType, objectValue, false));
}
for (String dataValue : addToAttributeOnlyConversionValueStrings.keySet()) {
String objectValue = addToAttributeOnlyConversionValueStrings.get(dataValue);
addToAttributeOnlyConversionValue(initObject(dataType, dataValue, true), initObject(objectType, objectValue, false));
}
if (defaultAttributeValueString != null) {
setDefaultAttributeValue(initObject(objectType, defaultAttributeValueString, false));
}
}
}
/**
* Load the given class name with the given loader.
*/
protected Class loadClass(String className, ClassLoader classLoader) {
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
return (Class) AccessController.doPrivileged(new PrivilegedClassForName(className, true, classLoader));
} catch (PrivilegedActionException e) {
throw ValidationException.classNotFoundWhileConvertingClassNames(className, e.getException());
}
} else {
return org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(className, true, classLoader);
}
} catch (Exception exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(className, exception);
}
}
/**
* INTERNAL:
* Returns the corresponding attribute value for the specified field value.
*/
public Object convertDataValueToObjectValue(Object fieldValue, Session session) {
Object attributeValue = null;
if (fieldValue == null) {
attributeValue = getFieldToAttributeValues().get(Helper.NULL_VALUE);
} else {
try {
fieldValue = ((AbstractSession)session).getDatasourcePlatform().getConversionManager().convertObject(fieldValue, getFieldClassification());
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(mapping, mapping.getDescriptor(), e);
}
attributeValue = getFieldToAttributeValues().get(fieldValue);
if (attributeValue == null) {
if (getDefaultAttributeValue() != null) {
attributeValue = getDefaultAttributeValue();
} else {
// CR#3779
throw DescriptorException.noFieldValueConversionToAttributeValueProvided(fieldValue, getMapping().getField(), getMapping());
}
}
}
return attributeValue;
}
/**
* PUBLIC:
* The default value can be used if the database can possibly store additional values then those that
* have been mapped. Any value retreived from the database that is not mapped will be substitued for the default value.
*/
public Object getDefaultAttributeValue() {
return defaultAttributeValue;
}
/**
* INTERNAL:
* Return the mapping.
*/
protected DatabaseMapping getMapping() {
return mapping;
}
/**
* INTERNAL:
* Set the mapping.
*/
protected void setMapping(DatabaseMapping mapping) {
this.mapping = mapping;
}
/**
* INTERNAL:
* Set from JPA processing where we deal with strings only to avoid
* class loader conflicts.
*/
public void setObjectTypeName(String objectTypeName) {
this.objectTypeName = objectTypeName;
}
/**
* INTERNAL:
* Get the type of the field value to allow conversion from the database.
*/
public Class getFieldClassification() {
return fieldClassification;
}
public String getFieldClassificationName() {
if ((fieldClassificationName == null) && (fieldClassification != null)) {
fieldClassificationName = fieldClassification.getName();
}
return fieldClassificationName;
}
/**
* INTERNAL:
* Return the classifiction for the field contained in the mapping.
* This is used to convert the row value to a consistent java value.
* By default this is null which means unknown.
*/
public Class getFieldClassification(DatabaseField fieldToClassify) {
return getFieldClassification();
}
/**
* INTERNAL:
* Return a collection of the field to attribute value associations.
*/
public Vector getFieldToAttributeValueAssociations() {
Vector associations = new Vector(getFieldToAttributeValues().size());
Iterator fieldValueEnum = getFieldToAttributeValues().keySet().iterator();
Iterator attributeValueEnum = getFieldToAttributeValues().values().iterator();
while (fieldValueEnum.hasNext()) {
Object fieldValue = fieldValueEnum.next();
if (fieldValue == Helper.NULL_VALUE) {
fieldValue = null;
}
Object attributeValue = attributeValueEnum.next();
if (attributeValue == Helper.NULL_VALUE) {
attributeValue = null;
}
associations.addElement(new TypeMapping(fieldValue, attributeValue));
}
return associations;
}
/**
* INTERNAL:
* Get the field to attribute mapping.
*/
public Map getFieldToAttributeValues() {
if (fieldToAttributeValues == null) {
fieldToAttributeValues = new HashMap(10);
}
return fieldToAttributeValues;
}
/**
* INTERNAL:
* Convert to the data value.
*/
public Object convertObjectValueToDataValue(Object attributeValue, Session session) {
Object fieldValue;
if (attributeValue == null) {
fieldValue = getAttributeToFieldValues().get(Helper.NULL_VALUE);
} else {
fieldValue = getAttributeToFieldValues().get(attributeValue);
if (fieldValue == null) {
throw DescriptorException.noAttributeValueConversionToFieldValueProvided(attributeValue, getMapping());
}
}
return fieldValue;
}
/**
* PUBLIC:
* This is a very specific protocol which maps fieldValues "T" and "F"
* to true and false respectively.
*/
public void mapBooleans() {
addConversionValue("F", Boolean.FALSE);
addConversionValue("T", Boolean.TRUE);
}
/**
* PUBLIC:
* This is a very specific protocol which maps fieldValues "F" and "M"
* to "Female" and "Male" respectively.
*/
public void mapGenders() {
addConversionValue("F", "Female");
addConversionValue("M", "Male");
}
/**
* PUBLIC:
* This is a very specific protocol which maps fieldValues "Y" and "N"
* to "Yes" and "No" respectively.
*/
public void mapResponses() {
addConversionValue("Y", "Yes");
addConversionValue("N", "No");
}
/**
* INTERNAL:
* Set the field classification through searching the fields map.
*/
public void initializeFieldClassification(Session session) throws DescriptorException {
if (getFieldToAttributeValues().isEmpty()) {
return;
}
Class type = null;
Iterator fieldValuesEnum = getFieldToAttributeValues().keySet().iterator();
while (fieldValuesEnum.hasNext() && (type == null)) {
Object value = fieldValuesEnum.next();
if (value != Helper.NULL_VALUE) {
type = value.getClass();
}
}
setFieldClassification(type);
// CR#... Mapping must also have the field classification.
if (getMapping().isDirectToFieldMapping()) {
AbstractDirectMapping directMapping = (AbstractDirectMapping)getMapping();
// Allow user to specify field type to override computed value. (i.e. blob, nchar)
if (directMapping.getFieldClassification() == null) {
directMapping.setFieldClassification(type);
}
}
}
/**
* INTERNAL:
* Used to initialize string based conversion values set from JPA processing.
*/
private Object initObject(Class type, String value, boolean isData) {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
try {
Constructor constructor = (Constructor) AccessController.doPrivileged(new PrivilegedGetConstructorFor(type, new Class[] {String.class}, false));
return AccessController.doPrivileged(new PrivilegedInvokeConstructor(constructor, new Object[] {value}));
} catch (PrivilegedActionException exception) {
throwInitObjectException(exception, type, value, isData);
}
} else {
try {
Constructor constructor = PrivilegedAccessHelper.getConstructorFor(type, new Class[] {String.class}, false);
return PrivilegedAccessHelper.invokeConstructor(constructor, new Object[] {value});
} catch (Exception exception) {
throwInitObjectException(exception, type, value, isData);
}
}
return null; // keep compiler happy, will never hit.
}
/**
* INTERNAL:
* Set the mapping.
*/
public void initialize(DatabaseMapping mapping, Session session) {
this.mapping = mapping;
initializeFieldClassification(session);
}
/**
* INTERNAL:
* Set the attribute to field mapping.
*/
public void setAttributeToFieldValues(Map attributeToFieldValues) {
this.attributeToFieldValues = attributeToFieldValues;
}
/**
* INTERNAL:
* Set from JPA processing where we deal with strings only to avoid
* class loader conflicts.
*/
public void setConverterName(String converterName) {
this.converterName = converterName;
}
/**
* INTERNAL:
* Set from JPA processing where we deal with strings only to avoid
* class loader conflicts.
*/
public void setDataTypeName(String dataTypeName) {
this.dataTypeName = dataTypeName;
}
/**
* PUBLIC:
* The default value can be used if the database can possibly store additional values then those that
* have been mapped. Any value retreived from the database that is not mapped will be substitued for the default value.
*/
public void setDefaultAttributeValue(Object defaultAttributeValue) {
this.defaultAttributeValue = defaultAttributeValue;
}
/**
* INTERNAL:
* Set from JPA processing where we deal with strings only to avoid
* class loader conflicts.
*/
public void setDefaultAttributeValueString(String defaultAttributeValueString) {
this.defaultAttributeValueString = defaultAttributeValueString;
}
/**
* INTERNAL:
* Set the type of the field value to allow conversion from the database.
*/
public void setFieldClassification(Class fieldClassification) {
this.fieldClassification = fieldClassification;
}
public void setFieldClassificationName(String fieldClassificationName) {
this.fieldClassificationName = fieldClassificationName;
}
/**
* INTERNAL:
* Set a collection of the field to attribute value associations.
*/
public void setFieldToAttributeValueAssociations(Vector fieldToAttributeValueAssociations) {
setFieldToAttributeValues(new HashMap(fieldToAttributeValueAssociations.size() + 1));
setAttributeToFieldValues(new HashMap(fieldToAttributeValueAssociations.size() + 1));
for (Enumeration associationsEnum = fieldToAttributeValueAssociations.elements();
associationsEnum.hasMoreElements();) {
Association association = (Association)associationsEnum.nextElement();
addConversionValue(association.getKey(), association.getValue());
}
}
/**
* INTERNAL:
* Set the field to attribute mapping.
*/
public void setFieldToAttributeValues(Map fieldToAttributeValues) {
this.fieldToAttributeValues = fieldToAttributeValues;
}
/**
* INTERNAL:
* If the converter converts the value to a non-atomic value, i.e.
* a value that can have its' parts changed without being replaced,
* then it must return false, serialization can be non-atomic.
*/
public boolean isMutable() {
return false;
}
/**
* INTERNAL:
*/
protected void throwInitObjectException(Exception exception, Class type, String value, boolean isData) {
if (isData) {
throw ValidationException.errorInstantiatingConversionValueData(converterName, value, type, exception);
} else {
throw ValidationException.errorInstantiatingConversionValueObject(converterName, value, type, exception);
}
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/ConverterClass.java 0000664 0000000 0000000 00000021041 12216173130 026211 0 ustar /*******************************************************************************
* Copyright (c) 2012, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* 10/09/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 10/25/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 10/30/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 11/28/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 06/03/2013-2.5.1 Guy Pelletier
* - 402380: 3 jpa21/advanced tests failed on server with
* "java.lang.NoClassDefFoundError: org/eclipse/persistence/testing/models/jpa21/advanced/enums/Gender"
* 07/16/2013-2.5.1 Guy Pelletier
* - 412384: Applying Converter for parameterized basic-type for joda-time's DateTime does not work
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.localization.ExceptionLocalization;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.security.PrivilegedNewInstanceFromClass;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.mappings.DirectCollectionMapping;
import org.eclipse.persistence.mappings.DirectMapMapping;
import org.eclipse.persistence.mappings.DirectToFieldMapping;
import org.eclipse.persistence.mappings.converters.Converter;
import org.eclipse.persistence.sessions.Session;
import javax.persistence.AttributeConverter;
import javax.persistence.PersistenceException;
/**
* A JPA attribute converter class wrapped with an EclipseLink converter. This
* class is placed directly on mappings.
*
* @author Guy Pelletier
* @since Eclipselink 2.5
*/
public class ConverterClass implements Converter {
protected boolean isForMapKey;
protected boolean disableConversion;
protected Class fieldClassification;
protected String fieldClassificationName;
protected String attributeConverterClassName;
protected AttributeConverter attributeConverter;
/**
* INTERNAL:
* This method will be called when creating a converter for an embedded
* mapping attribute. The isForMapKey information will need to be known
* for proper initialization.
*/
public ConverterClass(String attributeConverterClassName, boolean isForMapKey, String fieldClassificationName, boolean disableConversion) {
this.isForMapKey = isForMapKey;
this.disableConversion = disableConversion;
this.fieldClassificationName = fieldClassificationName;
this.attributeConverterClassName = attributeConverterClassName;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this converter to actual
* class-based settings. This method is used when converting a project
* that has been built with class names to a project with classes.
*/
public void convertClassNamesToClasses(ClassLoader classLoader){
Class attributeConverterClass = null;
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
try {
attributeConverterClass = (Class) AccessController.doPrivileged(new PrivilegedClassForName(attributeConverterClassName, true, classLoader));
attributeConverter = AccessController.doPrivileged(new PrivilegedNewInstanceFromClass(attributeConverterClass));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(attributeConverterClassName, exception.getException());
}
} else {
attributeConverterClass = PrivilegedAccessHelper.getClassForName(attributeConverterClassName, true, classLoader);
attributeConverter = (AttributeConverter) PrivilegedAccessHelper.newInstanceFromClass(attributeConverterClass);
}
} catch (ClassNotFoundException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(attributeConverterClassName, exception);
} catch (IllegalAccessException exception) {
throw ValidationException.errorInstantiatingClass(attributeConverterClass, exception);
} catch (InstantiationException exception) {
throw ValidationException.errorInstantiatingClass(attributeConverterClass, exception);
}
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
fieldClassification = (Class) AccessController.doPrivileged(new PrivilegedClassForName(fieldClassificationName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(fieldClassificationName, exception.getException());
}
} else {
fieldClassification = PrivilegedAccessHelper.getClassForName(fieldClassificationName, true, classLoader);
}
} catch (ClassNotFoundException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(attributeConverterClassName, exception);
}
}
/**
* INTERNAL:
*/
@Override
public Object convertDataValueToObjectValue(Object dataValue, Session session) {
try {
return attributeConverter.convertToEntityAttribute(dataValue);
} catch (RuntimeException re) {
throw new PersistenceException(ExceptionLocalization.buildMessage("wrap_convert_exception",
new Object[]{"convertToEntityAttribute", attributeConverterClassName, dataValue}), re);
}
}
/**
* INTERNAL:
*/
@Override
public Object convertObjectValueToDataValue(Object objectValue, Session session) {
try {
return attributeConverter.convertToDatabaseColumn(objectValue);
} catch (RuntimeException re) {
throw new PersistenceException(ExceptionLocalization.buildMessage("wrap_convert_exception",
new Object[]{"convertToDatabaseColumn", attributeConverterClassName, objectValue}), re);
}
}
/**
* INTERNAL:
*/
@Override
public void initialize(DatabaseMapping mapping, Session session) {
// Ensure the mapping has the correct field classification set.
if (mapping.isDirectToFieldMapping()) {
DirectToFieldMapping m = (DirectToFieldMapping) mapping;
if (disableConversion) {
m.setConverter(null);
} else {
m.setConverter(this);
m.setFieldClassification(fieldClassification);
m.setFieldClassificationClassName(fieldClassificationName);
}
} else if (mapping.isDirectMapMapping() && isForMapKey) {
DirectMapMapping m = (DirectMapMapping) mapping;
if (disableConversion) {
m.setKeyConverter(null);
} else {
m.setKeyConverter(this);
m.setDirectKeyFieldClassification(fieldClassification);
m.setDirectKeyFieldClassificationName(fieldClassificationName);
}
} else if (mapping.isDirectCollectionMapping()) {
DirectCollectionMapping m = (DirectCollectionMapping) mapping;
if (disableConversion) {
m.setValueConverter(null);
} else {
m.setValueConverter(this);
m.setDirectFieldClassification(fieldClassification);
m.setDirectFieldClassificationName(fieldClassificationName);
}
} else {
// TODO: what else could it be???
}
}
/**
* INTERNAL:
*/
@Override
public boolean isMutable() {
return false;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/TypeConversionConverter.java 0000664 0000000 0000000 00000022276 12216173130 030146 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 06/03/2013-2.5.1 Guy Pelletier
* - 402380: 3 jpa21/advanced tests failed on server with
* "java.lang.NoClassDefFoundError: org/eclipse/persistence/testing/models/jpa21/advanced/enums/Gender"
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import org.eclipse.persistence.mappings.*;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.sessions.*;
import org.eclipse.persistence.exceptions.ConversionException;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
* Purpose: Type conversion converters are used to explicitly map a database type to a
* Java type.
*
* @author James Sutherland
* @since OracleAS TopLink 10g (10.0.3)
*/
public class TypeConversionConverter implements Converter {
protected DatabaseMapping mapping;
/** Field type */
protected Class dataClass;
protected String dataClassName;
/** Object type */
protected Class objectClass;
protected String objectClassName;
/**
* PUBLIC:
* Default constructor.
*/
public TypeConversionConverter() {
}
/**
* PUBLIC:
* Default constructor.
*/
public TypeConversionConverter(DatabaseMapping mapping) {
this.mapping = mapping;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this converter to actual class-based
* settings. This method is used when converting a project that has been built
* with class names to a project with classes.
* This method is implemented by subclasses as necessary.
* @param classLoader
*/
public void convertClassNamesToClasses(ClassLoader classLoader){
Class dataClass = null;
Class objectClass = null;
try{
if (dataClassName != null){
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
dataClass = (Class)AccessController.doPrivileged(new PrivilegedClassForName(dataClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(dataClassName, exception.getException());
}
} else {
dataClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(dataClassName, true, classLoader);
}
setDataClass(dataClass);
}
} catch (ClassNotFoundException exc){
throw ValidationException.classNotFoundWhileConvertingClassNames(dataClassName, exc);
}
try {
if (objectClassName != null){
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
objectClass = (Class)AccessController.doPrivileged(new PrivilegedClassForName(objectClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(objectClassName, exception.getException());
}
} else {
objectClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(objectClassName, true, classLoader);
}
setObjectClass(objectClass);
}
} catch (ClassNotFoundException exc){
throw ValidationException.classNotFoundWhileConvertingClassNames(objectClassName, exc);
}
};
/**
* INTERNAL:
* The field value must first be converted to the field type, then the attribute type.
*/
public Object convertDataValueToObjectValue(Object fieldValue, Session session) {
Object attributeValue = fieldValue;
if (attributeValue != null) {
try {
attributeValue = ((AbstractSession)session).getDatasourcePlatform().convertObject(attributeValue, getDataClass());
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(mapping, mapping.getDescriptor(), e);
}
try {
attributeValue = ((AbstractSession)session).getDatasourcePlatform().convertObject(attributeValue, getObjectClass());
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(mapping, mapping.getDescriptor(), e);
}
}
return attributeValue;
}
/**
* PUBLIC:
* Returns the class type of the object value.
*/
public Class getObjectClass() {
return objectClass;
}
/**
* INTERNAL:
* Return the name of the object type for the MW usage.
*/
public String getObjectClassName() {
if ((objectClassName == null) && (objectClass != null)) {
objectClassName = objectClass.getName();
}
return objectClassName;
}
/**
* PUBLIC:
* Returns the class type of the data value.
*/
public Class getDataClass() {
return dataClass;
}
/**
* INTERNAL:
* Return the name of the data type for the MW usage.
*/
public String getDataClassName() {
if ((dataClassName == null) && (dataClass != null)) {
dataClassName = dataClass.getName();
}
return dataClassName;
}
/**
* PUBLIC:
* Set the class type of the data value.
*/
public void setDataClass(Class dataClass) {
this.dataClass = dataClass;
}
/**
* INTERNAL:
* Set the name of the data type for the MW usage.
*/
public void setDataClassName(String dataClassName) {
this.dataClassName = dataClassName;
}
/**
* PUBLIC:
* Set the class type of the object value.
*/
public void setObjectClass(Class objectClass) {
this.objectClass = objectClass;
}
/**
* INTERNAL:
* Set the name of the object type for the MW usage.
*/
public void setObjectClassName(String objectClassName) {
this.objectClassName = objectClassName;
}
/**
* INTERNAL:
* Convert to the field class.
*/
public Object convertObjectValueToDataValue(Object attributeValue, Session session) {
try {
return ((AbstractSession)session).getDatasourcePlatform().convertObject(attributeValue, getDataClass());
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(mapping, mapping.getDescriptor(), e);
}
}
/**
* INTERNAL:
* Set the mapping.
*/
public void initialize(DatabaseMapping mapping, Session session) {
this.mapping = mapping;
// CR#... Mapping must also have the field classification.
if (getMapping().isDirectToFieldMapping()) {
AbstractDirectMapping directMapping = (AbstractDirectMapping)getMapping();
// Allow user to specify field type to override computed value. (i.e. blob, nchar)
if (directMapping.getFieldClassification() == null) {
directMapping.setFieldClassification(getDataClass());
}
// Set the object class from the attribute, if null.
if (getObjectClass() == null) {
setObjectClass(directMapping.getAttributeClassification());
}
} else if (getMapping().isDirectCollectionMapping()) {
((DirectCollectionMapping) getMapping()).setAttributeClassification(getObjectClass());
}
}
/**
* INTERNAL:
* Return the mapping.
*/
protected DatabaseMapping getMapping() {
return mapping;
}
/**
* INTERNAL:
* If the converter converts the value to a non-atomic value, i.e.
* a value that can have its' parts changed without being replaced,
* then it must return false, serialization can be non-atomic.
*/
public boolean isMutable() {
return false;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/Converter.java 0000664 0000000 0000000 00000005543 12216173130 025234 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.io.Serializable;
import org.eclipse.persistence.core.mappings.converters.CoreConverter;
import org.eclipse.persistence.mappings.*;
import org.eclipse.persistence.sessions.Session;
/**
*
Purpose: Conversion interface to allow conversion between object and data types.
* This can be used in any mapping to convert between the object and data types without requiring code
* placed in the object model.
* TopLink provides several common converters, but the application can also define it own.
*
* @see DirectToFieldMapping#setConverter(Converter)
* @see DirectCollectionMapping#setConverter(Converter)
* @see ObjectTypeConverter
* @see TypeConversionConverter
*
* @author James Sutherland
* @since OracleAS TopLink 10g (10.0.3)
*/
public interface Converter extends CoreConverter, Serializable {
/**
* PUBLIC:
* Convert the object's representation of the value to the databases' data representation.
* For example this could convert between a Calendar Java type and the sql.Time datatype.
*/
@Override
Object convertObjectValueToDataValue(Object objectValue, Session session);
/**
* PUBLIC:
* Convert the databases' data representation of the value to the object's representation.
* For example this could convert between an sql.Time datatype and the Java Calendar type.
*/
@Override
Object convertDataValueToObjectValue(Object dataValue, Session session);
/**
* PUBLIC:
* If the converter converts the value to a mutable value, i.e.
* a value that can have its' parts changed without being replaced,
* then it must return true. If the value is not mutable, cannot be changed without
* replacing the whole value then false must be returned.
* This is used within the UnitOfWork to determine how to clone.
*/
public boolean isMutable();
/**
* PUBLIC:
* Allow for any initialization.
*/
@Override
void initialize(DatabaseMapping mapping, Session session);
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/converters/SerializedObjectConverter.java 0000664 0000000 0000000 00000011501 12216173130 030366 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings.converters;
import java.io.*;
import org.eclipse.persistence.mappings.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.sessions.*;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
*
Purpose: The serialized object converter can be used to store an arbitrary object or set of objects into a database blob field.
* It uses the Java serializer so the target must be serializable.
*
* @author James Sutherland
* @since OracleAS TopLink 10g (10.0.3)
*/
public class SerializedObjectConverter implements Converter {
protected DatabaseMapping mapping;
/**
* PUBLIC:
* Default constructor.
*/
public SerializedObjectConverter() {
}
/**
* PUBLIC:
* Default constructor.
*/
public SerializedObjectConverter(DatabaseMapping mapping) {
this.mapping = mapping;
}
/**
* INTERNAL:
* The fieldValue will be a byte array. Create a ByteArrayInputStream
* on the fieldValue. Create an ObjectInputStream on the ByteArrayInputStream
* to read in the objects.
*/
public Object convertDataValueToObjectValue(Object fieldValue, Session session) throws DescriptorException {
if (fieldValue == null) {
return null;
}
byte[] bytes;
try {
bytes = (byte[])((AbstractSession)session).getDatasourcePlatform().convertObject(fieldValue, ClassConstants.APBYTE);
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(mapping, mapping.getDescriptor(), e);
}
if ((bytes == null) || (bytes.length == 0)) {
return null;
}
ByteArrayInputStream byteIn = new ByteArrayInputStream(bytes);
Object object = null;
try {
// BUG# 2813583
CustomObjectInputStream objectIn = new CustomObjectInputStream(byteIn, session);
object = objectIn.readObject();
} catch (Exception exception) {
throw DescriptorException.notDeserializable(getMapping(), exception);
}
return object;
}
/**
* INTERNAL:
* Convert the object to a byte array through serialize.
*/
public Object convertObjectValueToDataValue(Object attributeValue, Session session) {
if (attributeValue == null) {
return null;
}
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
try {
ObjectOutputStream objectOut = new ObjectOutputStream(byteOut);
objectOut.writeObject(attributeValue);
objectOut.flush();
} catch (IOException exception) {
throw DescriptorException.notSerializable(getMapping(), exception);
}
return byteOut.toByteArray();
}
/**
* INTERNAL:
* Set the mapping.
*/
public void initialize(DatabaseMapping mapping, Session session) {
this.mapping = mapping;
// CR#... Mapping must also have the field classification.
if (getMapping().isDirectToFieldMapping()) {
AbstractDirectMapping directMapping = (AbstractDirectMapping)getMapping();
// Allow user to specify field type to override computed value. (i.e. blob, nchar)
if (directMapping.getFieldClassification() == null) {
directMapping.setFieldClassification(ClassConstants.APBYTE);
}
}
}
/**
* INTERNAL:
* Return the mapping.
*/
protected DatabaseMapping getMapping() {
return mapping;
}
/**
* INTERNAL:
* If the converter converts the value to a non-atomic value, i.e.
* a value that can have its' parts changed without being replaced,
* then it must return false, serialization can be non-atomic.
*/
public boolean isMutable() {
return true;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/xdb/ 0000775 0000000 0000000 00000000000 12216174372 021007 5 ustar eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/xdb/DirectToXMLTypeMapping.java 0000664 0000000 0000000 00000016145 12216173130 026124 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 11/10/2011-2.4 Guy Pelletier
* - 357474: Address primaryKey option from tenant discriminator column
******************************************************************************/
package org.eclipse.persistence.mappings.xdb;
import org.eclipse.persistence.exceptions.ConversionException;
import org.eclipse.persistence.exceptions.DescriptorException;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.internal.platform.database.XMLTypePlaceholder;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.mappings.DirectToFieldMapping;
import org.eclipse.persistence.platform.xml.XMLComparer;
import org.eclipse.persistence.platform.xml.XMLPlatformFactory;
import org.eclipse.persistence.platform.xml.XMLTransformer;
import org.eclipse.persistence.platform.xml.XMLParser;
import org.eclipse.persistence.sessions.Session;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
/**
* Purpose: Mapping used to map from a DOM (org.w3c.Document) or XML String into
* an Oracle XMLType field, in Oracle 9i XDB.
*
* @since Toplink 10.1.3
*/
public class DirectToXMLTypeMapping extends DirectToFieldMapping {
/**
* Indicates if we should initialize the whole DOM on a read.
* This is only used if the user is mapping from an Oracle Document implementation.
*/
protected boolean shouldReadWholeDocument = false;
/**
* Used to convert the DOM to a String.
*/
private XMLTransformer xmlTransformer;
/**
* Used to determine if the XML document has been modified.
*/
private XMLComparer xmlComparer;
/**
* Used to convert the String to a DOM
*/
private XMLParser xmlParser;
/**
* INTERNAL:
* Default to mutable if mapped as a DOM.
*/
public void preInitialize(AbstractSession session) throws DescriptorException {
if (this.attributeClassification == null) {
this.attributeClassification = getAttributeAccessor().getAttributeClass();
}
if ((this.isMutable == null) && (this.attributeClassification != ClassConstants.STRING)) {
setIsMutable(true);
}
super.preInitialize(session);
}
/**
* INTERNAL:
* The mapping is initialized with the given session. This mapping is fully initialized
* after this.
*/
@Override
public void initialize(AbstractSession session) throws DescriptorException {
super.initialize(session);
setFieldClassification(XMLTypePlaceholder.class);
}
public DirectToXMLTypeMapping() {
super();
this.xmlTransformer = XMLPlatformFactory.getInstance().getXMLPlatform().newXMLTransformer();
this.xmlTransformer.setFormattedOutput(false);
this.xmlParser = XMLPlatformFactory.getInstance().getXMLPlatform().newXMLParser();
this.xmlComparer = new XMLComparer();
}
/**
* PUBLIC:
* @param boolean - determines if the Oracle XDB DOM should be fully initialized
* on a read.
*/
public void setShouldReadWholeDocument(boolean readWholeDocument) {
this.shouldReadWholeDocument = readWholeDocument;
}
/**
* PUBLIC:
* @return boolean - returns true if currently initializing DOMs on reads.
*/
public boolean shouldReadWholeDocument() {
return shouldReadWholeDocument;
}
/**
* INTERNAL:
* Get the attribute value for the given field value. If we're mapping to a
* Document, we need to check if we should return the Oracle DOM or build a
* new one.
*/
@Override
public Object getObjectValue(Object fieldValue, Session session) throws ConversionException {
Object attributeValue = fieldValue;
try {
if (attributeValue != null) {
if (this.attributeClassification != ClassConstants.STRING) {
String xml = (String)attributeValue;
java.io.StringReader reader = new java.io.StringReader(xml);
return this.xmlParser.parse(reader);
}
}
} catch (Exception ex) {
throw ConversionException.couldNotBeConverted(fieldValue, this.attributeClassification, ex);
}
if ((attributeValue == null) && (this.nullValue != null)) {// Translate default null value
return this.nullValue;
}
// Allow for user defined conversion to the object value.
if (this.converter != null) {
attributeValue = this.converter.convertDataValueToObjectValue(attributeValue, session);
}
return attributeValue;
}
@Override
public boolean isDirectToXMLTypeMapping() {
return true;
}
/**
* INTERNAL:
* Clone the DOM Document if required.
*/
@Override
protected Object buildCloneValue(Object attributeValue, AbstractSession session) {
Object newAttributeValue = attributeValue;
if (isMutable() && attributeValue != null) {
if ((getAttributeClassification() == ClassConstants.DOCUMENT) || (getAttributeClassification() == ClassConstants.NODE)) {
Document doc = (Document)attributeValue;
newAttributeValue = doc.cloneNode(true);
}
}
return newAttributeValue;
}
/**
* INTERNAL:
* Compare the attribute values.
* Compare Nodes if mapped as a DOM.
*/
@Override
protected boolean compareObjectValues(Object firstValue, Object secondValue, AbstractSession session) {
// PERF: Check identity before conversion.
if (firstValue == secondValue) {
return true;
}
if ((firstValue == null) && (secondValue == null)) {
return true;
}
if ((firstValue == null) || (secondValue == null)) {
return false;
}
if (getAttributeClassification() == ClassConstants.STRING) {
return firstValue.equals(secondValue);
} else {
Object one = getFieldValue(firstValue, session);
Object two = getFieldValue(secondValue, session);
if (one instanceof Node && two instanceof Node) {
return this.xmlComparer.isNodeEqual((Node)one, (Node)two);
}
return one.equals(two);
}
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/ManyToOneMapping.java 0000664 0000000 0000000 00000002506 12216173130 024254 0 ustar /*******************************************************************************
* Copyright (c) 2011, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* James Sutherland - initial API and implementation
******************************************************************************/
package org.eclipse.persistence.mappings;
/**
*
Purpose: Define the relationship to be a ManyToOne.
* This is mainly functionally the same as OneToOneMapping.
*
* @author James Sutherland
* @since EclipseLink 2.1
*/
public class ManyToOneMapping extends OneToOneMapping {
/**
* PUBLIC:
* Default constructor.
*/
public ManyToOneMapping() {
super();
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isManyToOneMapping() {
return true;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/DatabaseMapping.java 0000664 0000000 0000000 00000223256 12216173130 024116 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 11/10/2011-2.4 Guy Pelletier
* - 357474: Address primaryKey option from tenant discriminator column
* 30/05/2012-2.4 Guy Pelletier
* - 354678: Temp classloader is still being used during metadata processing
* 06/03/2013-2.5.1 Guy Pelletier
* - 402380: 3 jpa21/advanced tests failed on server with
* "java.lang.NoClassDefFoundError: org/eclipse/persistence/testing/models/jpa21/advanced/enums/Gender"
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.beans.PropertyChangeListener;
import java.io.*;
import java.util.*;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import org.eclipse.persistence.core.mappings.CoreMapping;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.indirection.*;
import org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor;
import org.eclipse.persistence.internal.databaseaccess.DatabasePlatform;
import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.sessions.remote.*;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.mappings.converters.Converter;
import org.eclipse.persistence.mappings.converters.ConverterClass;
import org.eclipse.persistence.mappings.converters.ObjectTypeConverter;
import org.eclipse.persistence.mappings.converters.TypeConversionConverter;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.sessions.remote.*;
import org.eclipse.persistence.sessions.CopyGroup;
import org.eclipse.persistence.sessions.Project;
/**
*
Purpose: Defines how an attribute of an object maps to and from the database
*
*
Responsibilities:
*
Define type of relationship (1:1/1:M/M:M/etc.)
*
Define instance variable name and fields names required
*
Define any additional properties (ownership, indirection, read only, etc.)
*
Control building the value for the instance variable from the database row
*
Control building the database fields from the object
*
Control any pre/post updating/inserting/deleting required to maintain the relationship
*
Merges object changes for unit of work.
*
Clones objects for unit of work.
*
cache computed information to optimize performance
*
*
* @author Sati
* @since TOPLink/Java 1.0
*/
public abstract class DatabaseMapping extends CoreMapping implements Cloneable, Serializable {
public enum WriteType { INSERT, UPDATE, UNDEFINED }
/** Used to reduce memory for mappings with no fields. */
protected static final Vector NO_FIELDS = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(0);
/** Used to share integer instance to reduce memory. */
protected static final Integer NO_WEIGHT = Integer.valueOf(Integer.MAX_VALUE);
protected static final Integer WEIGHT_DIRECT = Integer.valueOf(1);
protected static final Integer WEIGHT_TRANSFORM = Integer.valueOf(100);
protected static final Integer WEIGHT_AGGREGATE = Integer.valueOf(200);
protected static final Integer WEIGHT_TO_ONE = Integer.valueOf(400);
/** ClassDescriptor to which this mapping belongs to */
protected ClassDescriptor descriptor;
/** Wrapper to store the reference objects. */
protected AttributeAccessor attributeAccessor;
/** Makes this mapping read only. No write are performed on it. Default is false */
protected boolean isReadOnly;
/** Specifies whether this mapping is optional (i.e. field may be null). Used for DDL generation. */
protected boolean isOptional;
/** Specifies whether this mapping is lazy, this means not included in the default fetch group. */
protected Boolean isLazy;
/** Fields associated with the mappings are cached */
protected Vector fields;
/** It is needed only in remote initialization and mapping is in parent descriptor */
protected boolean isRemotelyInitialized;
/** This is a TopLink defined attribute that allows us to sort the mappings */
protected Integer weight = NO_WEIGHT;
/** Allow user defined properties. */
protected Map properties;
/** Allow the user to defined un-converted properties which will be initialized at runtime. */
protected Map> unconvertedProperties;
/**
* Used by the CMP3Policy to see if this mapping should be used in
* processing pk classes for find methods
*/
protected boolean derivesId;
/**
*
*/
protected boolean isJPAId = false;
/**
* A mapsId value.
*/
protected String mapsIdValue;
/**
* The id mapping this mapping derives. Used by the CMP3Policy to see if
* this mapping should be used in processing pk classes for find methods.
*/
protected DatabaseMapping derivedIdMapping;
/**
* PERF: Used as a quick check to see if this mapping is a primary key mapping,
* set by the object builder during initialization.
*/
protected boolean isPrimaryKeyMapping = false;
/**
* PERF: Cache the mappings attribute name.
*/
protected String attributeName;
/**
* Records if this mapping is being used as a MapKeyMapping. This is important for recording main mappings
*/
protected boolean isMapKeyMapping = false;
//used by the object build/merge code to control building/merging into the
//shared cache.
protected boolean isCacheable = true;
/**
* Irrelevant (and not set) unless descriptor has SerializedObjectPolicy (SOP).
* If descriptor has SOP, then ObjectLevelReadQuery (with shouldUseSerializedObjectPolicy flag set to true)
* reads in row that contain both field/value pairs and sopObject.
* This flag indicates whether the data for this mapping is contained in the row's sopObject or in fields/values.
* Boolean.TRUE - sopObject (in sopObject)
* Boolean.FALSE - fields/values (out sopObject);
* null - both sopObject and fields/values (both in and out sopObject).
* While writing to the data base the mapping will be used for writing into sopObject unless this flag is set to Boolean.FALSE;
*/
protected Boolean isInSopObject;
/**
* PUBLIC:
* Default constructor.
*/
public DatabaseMapping() {
this.isOptional = true;
this.isReadOnly = false;
this.attributeAccessor = new InstanceVariableAttributeAccessor();
}
/**
* PUBLIC:
* Add an unconverted property (to be initialiazed at runtime)
*/
public void addUnconvertedProperty(String propertyName, String propertyValue, String propertyType) {
List valuePair = new ArrayList(2);
valuePair.add(propertyValue);
valuePair.add(propertyType);
getUnconvertedProperties().put(propertyName, valuePair);
}
/**
* INTERNAL:
* Clone the attribute from the clone and assign it to the backup.
*/
public abstract void buildBackupClone(Object clone, Object backup, UnitOfWorkImpl unitOfWork);
/**
* INTERNAL:
* Require for cloning, the part must be cloned.
*/
public Object buildBackupCloneForPartObject(Object attributeValue, Object clone, Object backup, UnitOfWorkImpl unitOfWork) {
throw DescriptorException.invalidMappingOperation(this, "buildBackupCloneForPartObject");
}
/**
* INTERNAL:
* Clone the attribute from the original and assign it to the clone.
*/
public abstract void buildClone(Object original, CacheKey cacheKey, Object clone, Integer refreshCascade, AbstractSession cloningSession);
/**
* INTERNAL:
* A combination of readFromRowIntoObject and buildClone.
*
* buildClone assumes the attribute value exists on the original and can
* simply be copied.
*
* readFromRowIntoObject assumes that one is building an original.
*
* Both of the above assumptions are false in this method, and actually
* attempts to do both at the same time.
*
* Extract value from the row and set the attribute to this value in the
* working copy clone.
* In order to bypass the shared cache when in transaction a UnitOfWork must
* be able to populate working copies directly from the row.
*/
public abstract void buildCloneFromRow(AbstractRecord databaseRow, JoinedAttributeManager joinManager, Object clone, CacheKey sharedCacheKey, ObjectBuildingQuery sourceQuery, UnitOfWorkImpl unitOfWork, AbstractSession executionSession);
/**
* INTERNAL:
* Builds a shallow original object. Only direct attributes and primary
* keys are populated. In this way the minimum original required for
* instantiating a working copy clone can be built without placing it in
* the shared cache (no concern over cycles).
*/
public void buildShallowOriginalFromRow(AbstractRecord databaseRow, Object original, JoinedAttributeManager joinManager, ObjectBuildingQuery query, AbstractSession executionSession) {
return;
}
/**
* INTERNAL:
* Require for cloning, the part must be cloned.
*/
public Object buildCloneForPartObject(Object attributeValue, Object original, CacheKey cacheKey, Object clone, AbstractSession cloningSession, Integer refreshCascade, boolean isExisting, boolean isFromSharedCache) {
throw DescriptorException.invalidMappingOperation(this, "buildCloneForPartObject");
}
/**
* INTERNAL:
* Performs a first level clone of the attribute. This generally means on the container will be cloned.
*/
public Object buildContainerClone(Object attributeValue, AbstractSession cloningSession){
return attributeValue;
}
/**
* INTERNAL:
* Copy of the attribute of the object.
* This is NOT used for unit of work but for templatizing an object.
*/
public void buildCopy(Object copy, Object original, CopyGroup group) {
}
/**
* INTERNAL:
* In case Query By Example is used, this method builds and returns an expression that
* corresponds to a single attribue and it's value.
*/
public Expression buildExpression(Object queryObject, QueryByExamplePolicy policy, Expression expressionBuilder, Map processedObjects, AbstractSession session) {
return null;
}
/**
* INTERNAL:
* Used to allow object level comparisons.
*/
public Expression buildObjectJoinExpression(Expression base, Object value, AbstractSession session) {
throw QueryException.unsupportedMappingForObjectComparison(this, base);
}
/**
* INTERNAL:
* Used to allow object level comparisons.
*/
public Expression buildObjectJoinExpression(Expression base, Expression argument, AbstractSession session) {
throw QueryException.unsupportedMappingForObjectComparison(this, base);
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
abstract public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects);
/**
* INTERNAL:
* Cascade removal of orphaned private owned objects from the UnitOfWorkChangeSet
*/
public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
// no-op by default
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
abstract public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects);
/**
* INTERNAL:
* Cascade discover and persist new objects during commit.
*/
public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors) {
// Do nothing by default, (direct and xml mappings do not require anything).
}
/**
* INTERNAL:
* Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes
* as apposed to detected changes. If an attribute can not be change tracked it's
* changes can be detected through this process.
*/
public void calculateDeferredChanges(ChangeRecord changeRecord, AbstractSession session){
throw DescriptorException.invalidMappingOperation(this, "calculatedDeferredChanges");
}
/**
* INTERNAL:
* Clones itself.
*/
@Override
public Object clone() {
// Bug 3037701 - clone the AttributeAccessor
DatabaseMapping mapping = null;
try {
mapping = (DatabaseMapping)super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
mapping.setAttributeAccessor((AttributeAccessor)attributeAccessor.clone());
return mapping;
}
/**
* INTERNAL:
* Helper method to clone vector of fields (used in aggregate initialization cloning).
*/
protected Vector cloneFields(Vector fields) {
Vector clonedFields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance();
for (Enumeration fieldsEnum = fields.elements(); fieldsEnum.hasMoreElements();) {
clonedFields.addElement(((DatabaseField)fieldsEnum.nextElement()).clone());
}
return clonedFields;
}
/**
* This method must be overwritten in the subclasses to return a vector of all the
* fields this mapping represents.
*/
protected Vector collectFields() {
return NO_FIELDS;
}
/**
* 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
*/
public void collectQueryParameters(Set record){
//no-op for mappings that do not support PROTECTED cache isolation
}
/**
* INTERNAL:
* This method was created in VisualAge.
* @return prototype.changeset.ChangeRecord
*/
abstract public ChangeRecord compareForChange(Object clone, Object backup, ObjectChangeSet owner, AbstractSession session);
/**
* INTERNAL:
* Compare the attributes belonging to this mapping for the objects.
*/
public abstract boolean compareObjects(Object firstObject, Object secondObject, AbstractSession session);
/**
* INTERNAL:
* Convert all the class-name-based settings in this mapping to actual class-based
* settings
* This method is implemented by subclasses as necessary.
* @param classLoader
*/
public void convertClassNamesToClasses(ClassLoader classLoader) {
if (hasUnconvertedProperties()) {
for (String propertyName : getUnconvertedProperties().keySet()) {
List valuePair = getUnconvertedProperties().get(propertyName);
String value = valuePair.get(0);
String valueTypeName = valuePair.get(1);
Class valueType = String.class;
// Have to initialize the valueType now
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
try {
valueType = (Class) AccessController.doPrivileged(new PrivilegedClassForName(valueTypeName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(valueTypeName, exception.getException());
}
} else {
valueType = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(valueTypeName, true, classLoader);
}
} catch (Exception exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(valueTypeName, exception);
}
// Add the converted property. If the value type is the same
// as the source (value) type, no conversion is made.
getProperties().put(propertyName, ConversionManager.getDefaultManager().convertObject(value, valueType));
}
}
}
/**
* Convenience method to ensure converters have an opportunity to convert
* any class names to classes during project setup.
*/
protected void convertConverterClassNamesToClasses(Converter converter, ClassLoader classLoader) {
if (converter != null) {
if (converter instanceof TypeConversionConverter) {
((TypeConversionConverter)converter).convertClassNamesToClasses(classLoader);
} else if (converter instanceof ObjectTypeConverter) {
// To avoid 1.5 dependencies with the EnumTypeConverter check
// against ObjectTypeConverter.
((ObjectTypeConverter) converter).convertClassNamesToClasses(classLoader);
} else if (converter instanceof ConverterClass) {
((ConverterClass) converter).convertClassNamesToClasses(classLoader);
}
}
}
/**
* INTERNAL:
* Builder the unit of work value holder.
* @param buildDirectlyFromRow indicates that we are building the clone directly
* from a row as opposed to building the original from the row, putting it in
* the shared cache, and then cloning the original.
*/
public DatabaseValueHolder createCloneValueHolder(ValueHolderInterface attributeValue, Object original, Object clone, AbstractRecord row, AbstractSession cloningSession, boolean buildDirectlyFromRow) {
throw DescriptorException.invalidMappingOperation(this, "createUnitOfWorkValueHolder");
}
/**
* ADVANCED:
* Returns true if the mapping references a JPA ID attribute for the CMP3Policy and JPA ID classes.
*/
public boolean derivesId() {
return derivesId;
}
/**
* INTERNAL:
* This method is called to update collection tables prior to commit.
*/
public void earlyPreDelete(DeleteObjectQuery query, Object object) {
}
/**
* INTERNAL:
* Extract the nested attribute expressions that apply to this mapping.
* This is used for partial objects and joining.
* @param rootExpressionsAllowed true if newRoot itself can be one of the
* expressions returned
*/
protected List extractNestedExpressions(List expressions, ExpressionBuilder newRoot, boolean rootExpressionsAllowed) {
List nestedExpressions = new ArrayList(expressions.size());
/*
* need to work on all expressions with at least 2 nestings off the base expression builder, excluding
* aggregateObjectMapping expressions from the count (only ForeignReferenceMapping expressions count). For those
* expressions, If the expression closest to to the Builder is for this mapping, that expression is rebuilt using
* newRoot and added to the nestedExpressions list.
*/
for (Expression next : expressions) {
// The expressionBuilder can be one of the locked expressions in
// the ForUpdateOfClause.
if (!next.isQueryKeyExpression()) {
continue;
}
QueryKeyExpression expression = (QueryKeyExpression)next;
ObjectExpression base = expression;
boolean afterBase = false;
boolean done = false;
ObjectExpression prevExpression = base;
while (!base.getBaseExpression().isExpressionBuilder()&& !done) {
base = (ObjectExpression)base.getBaseExpression();
while (!base.isExpressionBuilder() && (base.getMapping() != null && base.getMapping().isAggregateObjectMapping())) {
base = (ObjectExpression)base.getBaseExpression();
}
if (base.isExpressionBuilder()){
done = true;
//use the one closest to the expression builder that wasn't an aggregate
base = prevExpression;
} else {
prevExpression = base;
afterBase = true;
}
}
if (afterBase && base.getName().equals(getAttributeName())) {
nestedExpressions.add(expression.rebuildOn(base, newRoot));
} else if (rootExpressionsAllowed && expression.getBaseExpression().isExpressionBuilder() && expression.getName().equals(getAttributeName())) {
nestedExpressions.add(newRoot);
}
}
return nestedExpressions;
}
/**
* INTERNAL:
* If there is root expression in the list then indicates whether it shouldUseOuterJoin,
* otherwise return false.
*/
protected boolean hasRootExpressionThatShouldUseOuterJoin(List expressions) {
for (Iterator expressionsEnum = expressions.iterator();
expressionsEnum.hasNext();) {
Expression next = (Expression)expressionsEnum.next();
// The expressionBuilder can be one of the locked expressions in
// the ForUpdateOfClause.
if (!next.isQueryKeyExpression()) {
continue;
}
QueryKeyExpression expression = (QueryKeyExpression)next;
if (expression.getBaseExpression().isExpressionBuilder() && expression.getName().equals(getAttributeName())) {
return expression.shouldUseOuterJoin();
}
}
return false;
}
/**
* INTERNAL:
* Used to store un-converted properties, which are subsequenctly converted
* at runtime (through the convertClassNamesToClasses method.
*/
public boolean hasUnconvertedProperties() {
return unconvertedProperties != null;
}
/**
* INTERNAL:
* An object has been serialized from the server to the client.
* Replace the transient attributes of the remote value holders
* with client-side objects.
*/
public abstract void fixObjectReferences(Object object, Map objectDescriptors, Map processedObjects, ObjectLevelReadQuery query, DistributedSession session);
/**
* INTERNAL:
* At this point, we realize we don't have indirection;
* so we need to replace the reference object(s) with
* the corresponding object(s) from the remote session.
* The default is to do nothing.
*/
public void fixRealObjectReferences(Object object, Map objectInformation, Map processedObjects, ObjectLevelReadQuery query, DistributedSession session) {
// do nothing
}
/**
* ADVANCED:
* Return the attributeAccessor.
* The attribute accessor is responsible for setting and retrieving the attribute value
* from the object for this mapping.
*/
@Override
public AttributeAccessor getAttributeAccessor() {
return attributeAccessor;
}
/**
* PUBLIC:
* The classification type for the attribute this mapping represents
*/
@Override
public Class getAttributeClassification() {
return null;
}
/**
* PUBLIC:
* Return the name of the attribute set in the mapping.
*/
@Override
public String getAttributeName() {
// The attribute name on the attributeAccessor will always override any attribute already set
// Use the attributeAccessor attribute over the current attribute name
if (attributeName == null) {
attributeName = getAttributeAccessor().getAttributeName();
}
return attributeName;
}
/**
* INTERNAL:
* Return the value of an attribute which this mapping represents for an object.
*/
@Override
public Object getAttributeValueFromObject(Object object) throws DescriptorException {
try {
// PERF: direct-access.
return this.attributeAccessor.getAttributeValueFromObject(object);
} catch (DescriptorException exception) {
exception.setMapping(this);
throw exception;
}
}
/**
* INTERNAL:
* Return the mapping's containerPolicy.
*/
@Override
public ContainerPolicy getContainerPolicy() {
throw DescriptorException.invalidMappingOperation(this, "getContainerPolicy");
}
/**
* ADVANCED:
* Set the maps id value
*/
public DatabaseMapping getDerivedIdMapping() {
return derivedIdMapping;
}
/**
* INTERNAL:
* Return the descriptor to which this mapping belongs
*/
public ClassDescriptor getDescriptor() {
return descriptor;
}
/**
* INTERNAL:
* Return the field associated with this mapping if there is exactly one.
* This is required for object relational mapping to print them, but because
* they are defined in in an Enterprise context they cannot be cast to.
* Mappings that have a field include direct mappings and object relational mappings.
*/
@Override
public DatabaseField getField() {
return null;
}
/**
* INTERNAL:
* Return the classification for the field contained in the mapping.
* This is used to convert the row value to a consistent java value.
* By default this is unknown.
*/
public Class getFieldClassification(DatabaseField fieldToClassify) {
return null;
}
/**
* INTERNAL:
* Returns the set of fields that should be selected to build this mapping's value(s).
* This is used by expressions to determine which fields to include in the select clause for non-object expressions.
*/
public Vector getSelectFields() {
return getFields();
}
/**
* INTERNAL:
* Returns the table(s) that should be selected to build this mapping's value(s).
* This is used by expressions to determine which tables to include in the from clause for non-object expressions.
*/
public Vector getSelectTables() {
return new NonSynchronizedVector(0);
}
/**
* INTERNAL:
* Returns a vector of all the fields this mapping represents.
*/
@Override
public Vector getFields() {
return this.fields;
}
/**
* INTERNAL:
* Return the list of fields that should be used if this mapping is used in an order by.
* null means this mapping does not need to normalize it fields (it is a field).
*/
public List getOrderByNormalizedExpressions(Expression base) {
return null;
}
/**
* PUBLIC:
* This method is invoked reflectively on the reference object to return the value of the
* attribute in the object. This method returns the name of the getMethodName or null if not using method access.
*/
public String getGetMethodName() {
if (!getAttributeAccessor().isMethodAttributeAccessor()) {
return null;
}
return ((MethodAttributeAccessor)getAttributeAccessor()).getGetMethodName();
}
/**
* ADVANCED:
* Set the mapped by id value
*/
public boolean hasMapsIdValue() {
return mapsIdValue != null;
}
/**
* ADVANCED:
* Set the mapped by id value
*/
public String getMapsIdValue() {
return mapsIdValue;
}
/**
* INTERNAL:
* return the object on the client corresponding to the specified object.
* The default is to simply return the object itself, without worrying about
* maintaining object identity.
*/
public Object getObjectCorrespondingTo(Object object, DistributedSession session, Map objectDescriptors, Map processedObjects, ObjectLevelReadQuery query) {
return object;
}
/**
* INTERNAL:
* used as a temporary store for custom SDK usage
*/
public Map getProperties() {
if (properties == null) {//Lazy initialize to conserve space and allocation time.
properties = new HashMap(5);
}
return properties;
}
/**
* ADVANCED:
* Allow user defined properties.
*/
public Object getProperty(Object property) {
if (properties == null) {
return null;
}
return getProperties().get(property);
}
/**
* INTERNAL:
* Return the value of an attribute unwrapping value holders if required.
*/
public Object getRealAttributeValueFromObject(Object object, AbstractSession session) throws DescriptorException {
return getRealAttributeValueFromAttribute(getAttributeValueFromObject(object), object, session);
}
/**
* INTERNAL:
* Return the value of an attribute unwrapping value holders if required.
*/
public Object getRealAttributeValueFromAttribute(Object attributeValue, Object object, AbstractSession session) throws DescriptorException {
return attributeValue;
}
/**
* INTERNAL:
* Trigger the instantiation of the attribute if lazy.
*/
public void instantiateAttribute(Object object, AbstractSession session) {
// Not lazy by default.
}
/**
* INTERNAL:
* Return whether the specified object is instantiated.
*/
public boolean isAttributeValueFromObjectInstantiated(Object object) {
return true;
}
/**
* INTERNAL:
* Return the value of an attribute, unwrapping value holders if necessary.
* If the value is null, build a new container.
*/
public Object getRealCollectionAttributeValueFromObject(Object object, AbstractSession session) throws DescriptorException {
throw DescriptorException.invalidMappingOperation(this, "getRealCollectionAttributeValueFromObject");
}
/**
* PUBLIC:
* Return the referenceDescriptor. This is a descriptor which is associated with
* the reference class.
*/
@Override
public ClassDescriptor getReferenceDescriptor() {
return null;
}
/**
* INTERNAL:
* Return the relationshipPartner mapping for this bi-directional mapping. If the relationshipPartner is null then
* this is a uni-directional mapping.
*/
public DatabaseMapping getRelationshipPartner() {
return null;
}
/**
* PUBLIC:
* This method is invoked reflectively on the reference object to set the value of the
* attribute in the object. This method returns the name of the setMethodName or null if not using method access.
*/
public String getSetMethodName() {
if (!getAttributeAccessor().isMethodAttributeAccessor()) {
return null;
}
return ((MethodAttributeAccessor)getAttributeAccessor()).getSetMethodName();
}
/**
* INTERNAL:
* Used to store un-converted properties, which are subsequenctly converted
* at runtime (through the convertClassNamesToClasses method.
*/
public Map> getUnconvertedProperties() {
if (unconvertedProperties == null) {
unconvertedProperties = new HashMap>(5);
}
return unconvertedProperties;
}
/**
* INTERNAL:
* extract and return the appropriate value from the
* specified remote value holder
*/
public Object getValueFromRemoteValueHolder(RemoteValueHolder remoteValueHolder) {
throw DescriptorException.invalidMappingOperation(this, "getValueFromRemoteValueHolder");
}
/**
* INTERNAL:
* Return the weight of the mapping, used to sort mappings to ensure that
* DirectToField Mappings get merged first
*/
public Integer getWeight() {
return this.weight;
}
/**
* INTERNAL:
* The returns if the mapping has any constraint dependencies, such as foreign keys and join tables.
*/
public boolean hasConstraintDependency() {
return false;
}
/**
* PUBLIC:
* Return if method access is used.
*/
public boolean isUsingMethodAccess() {
return getAttributeAccessor().isMethodAttributeAccessor();
}
/**
* INTERNAL:
* Return if the mapping has any ownership or other dependency over its target object(s).
*/
public boolean hasDependency() {
return false;
}
/**
* INTERNAL:
* The returns if the mapping has any inverse constraint dependencies, such as foreign keys and join tables.
*/
public boolean hasInverseConstraintDependency() {
return false;
}
/**
* INTERNAL:
* Allow for initialization of properties and validation.
*/
public void initialize(AbstractSession session) throws DescriptorException {
;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isAggregateCollectionMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isAggregateMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isAggregateObjectMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isCollectionMapping() {
return false;
}
/**
* INTERNAL:
*/
public boolean isDatabaseMapping() {
return true;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isDirectCollectionMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isDirectMapMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isDirectToFieldMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isElementCollectionMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isForeignReferenceMapping() {
return false;
}
/**
* INTERNAL:
* Return whether this mapping should be traversed when we are locking
* @return
*/
public boolean isLockableMapping(){
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isManyToManyMapping() {
return false;
}
/**
* @return the isMapKeyMapping
*/
public boolean isMapKeyMapping() {
return isMapKeyMapping;
}
/**
* INTERNAL
*/
public boolean isMultitenantPrimaryKeyMapping() {
return false;
}
/**
* @param isMapKeyMapping the isMapKeyMapping to set
*/
public void setIsMapKeyMapping(boolean isMapKeyMapping) {
this.isMapKeyMapping = isMapKeyMapping;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isNestedTableMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isObjectReferenceMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isOneToManyMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isOneToOneMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isManyToOneMapping() {
return false;
}
/**
* Return whether the value of this mapping is optional (that is, can be
* null). This is a hint and is used when generating DDL.
*/
public boolean isOptional() {
return isOptional;
}
/**
* Returns true if this mapping is owned by the parent descriptor. This is generally based on mapping type
*/
public boolean isOwned(){
return false;
}
/**
* INTERNAL:
* Flags that this mapping is part of a JPA id mapping. It should be
* temporary though, as the CMP3Policy should be able to figure things
* out on its own. The problem being that the JPA mapped superclass
* descriptors are not initialized and do not have a CMP3Policy set by
* default.
*/
public boolean isJPAId() {
return isJPAId;
}
/**
* Return if this mapping is lazy.
* Lazy has different meaning for different mappings.
* For basic/direct mappings, this can be used exclude it from the descriptor's
* default fetch group. This means that queries will not include the field(s) required
* by this mapping by default.
* This can only be used if the descriptor has a FetchGroupManager and class implements
* the FetchGroupTracker interface (or is weaved).
*
* For relationship mappings this should normally be the same value as indirection,
* however for eager relationships this can be used with indirection to allow
* indirection locking and change tracking, but still always force instantiation.
*/
public boolean isLazy() {
if (isLazy == null) {
// False by default for mappings without indirection.
isLazy = Boolean.FALSE;
}
return isLazy;
}
/**
* INTERNAL:
* Flags that this mapping is part of a JPA id mapping. It should be
* temporary though, as the CMP3Policy should be able to figure things
* out on its own. The problem being that the JPA mapped superclass
* descriptors are not initialized and do not have a CMP3Policy set by
* default.
*/
public void setIsJPAId() {
this.isJPAId = true;
}
/**
* Set if this mapping is lazy.
* This can be used for any mapping type to exclude it from the descriptor's
* default fetch group. This means that queries will not include the field(s) required
* by this mapping by default.
* This can only be used if the descriptor has a FetchGroupManager and class implements
* the FetchGroupTracker interface (or is weaved).
* This is not the same as indirection on relationships (lazy relationships),
* as it defers the loading of the source object fields, not the relationship.
*/
public void setIsLazy(boolean isLazy) {
this.isLazy = isLazy;
}
/**
* INTERNAL:
* All EIS mappings should implement this method to return true.
*/
public boolean isEISMapping() {
return false;
}
/**
* INTERNAL:
* All relational mappings should implement this method to return true.
*/
public boolean isRelationalMapping() {
return false;
}
/**
* INTERNAL:
* All relational mappings should implement this method to return true.
*/
public boolean isXMLMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isAbstractDirectMapping() {
return false;
}
/**
* INTERNAL:
*/
public boolean isAbstractColumnMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isAbstractCompositeDirectCollectionMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isAbstractCompositeObjectMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isAbstractCompositeCollectionMapping() {
return false;
}
/**
* INTERNAL:
* Return if this mapping support joining.
*/
public boolean isJoiningSupported() {
return false;
}
/**
* INTERNAL:
* Return if this mapping requires its attribute value to be cloned.
*/
public boolean isCloningRequired() {
return true;
}
/**
* INTERNAL:
* Set by the Object builder during initialization returns true if this mapping
* is used as a primary key mapping.
*/
public boolean isPrimaryKeyMapping() {
return this.isPrimaryKeyMapping;
}
/**
* INTERNAL:
* Returns true if the mapping should be added to the UnitOfWork's list of private owned
* objects for private owned orphan removal.
*/
public boolean isCandidateForPrivateOwnedRemoval() {
return isPrivateOwned();
}
/**
* INTERNAL:
* Used when determining if a mapping supports cascaded version optimistic
* locking.
*/
public boolean isCascadedLockingSupported() {
return false;
}
/**
* INTERNAL:
* Return if this mapping supports change tracking.
*/
public boolean isChangeTrackingSupported(Project project) {
return false;
}
/**
* INTERNAL:
* Return if the mapping has ownership over its target object(s).
*/
public boolean isPrivateOwned() {
return false;
}
/**
* Used to signal that this mapping references a protected/isolated entity and requires
* special merge/object building behaviour.
*
*/
public boolean isCacheable() {
return this.isCacheable;
}
/**
* Used to signal that this mapping references a protected/isolated entity and requires
* special merge/object building behaviour.
*/
public void setIsCacheable(boolean cacheable) {
if (!cacheable) {
throw ValidationException.operationNotSupported("setIsCacheable");
}
}
/**
* INTERNAL:
* Returns true if mapping is read only else false.
*/
@Override
public boolean isReadOnly() {
return isReadOnly;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isReferenceMapping() {
return false;
}
protected boolean isRemotelyInitialized() {
return isRemotelyInitialized;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isStructureMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isTransformationMapping() {
return false;
}
/**
* INTERNAL:
*/
public boolean isUnidirectionalOneToManyMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isVariableOneToOneMapping() {
return false;
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
public boolean isDirectToXMLTypeMapping() {
return false;
}
/**
* INTERNAL:
* Some mappings support no attribute (transformation and multitenant primary key).
*/
@Override
public boolean isWriteOnly() {
return false;
}
/**
* INTERNAL:
* Iterate on the appropriate attribute value.
*/
public abstract void iterate(DescriptorIterator iterator);
/**
* INTERNAL:
* Iterate on the attribute value.
* The value holder has already been processed.
*/
public void iterateOnRealAttributeValue(DescriptorIterator iterator, Object realAttributeValue) {
throw DescriptorException.invalidMappingOperation(this, "iterateOnRealAttributeValue");
}
/**
* Force instantiation of the load group.
*/
public void load(final Object object, AttributeItem item, final AbstractSession session, final boolean fromFetchGroup) {
// Do nothing by default.
}
/**
* Force instantiation of all indirections.
*/
public void loadAll(Object object, AbstractSession session, IdentityHashSet loaded) {
// Do nothing by default.
}
/**
* INTERNAL:
* Merge changes from the source to the target object.
*/
public abstract void mergeChangesIntoObject(Object target, ChangeRecord changeRecord, Object source, MergeManager mergeManager, AbstractSession targetSession);
/**
* INTERNAL:
* Merge changes from the source to the target object.
*/
public abstract void mergeIntoObject(Object target, boolean isTargetUninitialized, Object source, MergeManager mergeManager, AbstractSession targetSession);
/**
* INTERNAL:
* Perform the commit event.
* This is used in the uow to delay data modifications.
*/
public void performDataModificationEvent(Object[] event, AbstractSession session) throws DatabaseException, DescriptorException {
throw DescriptorException.invalidDataModificationEvent(this);
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to delete the reference objects after the actual object is deleted.
*/
public void postDelete(DeleteObjectQuery query) throws DatabaseException {
return;
}
/**
* INTERNAL:
* Allow for initialization of properties and validation that have dependecies no the descriptor
* being initialized.
*/
public void postInitialize(AbstractSession session) throws DescriptorException {
// Nothing by default.
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to insert the reference objects after the actual object is inserted.
*/
public void postInsert(WriteObjectQuery query) throws DatabaseException {
return;
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to update the reference objects after the actual object is updated.
*/
public void postUpdate(WriteObjectQuery query) throws DatabaseException {
return;
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to delete the reference objects before the actual object is deleted.
*/
public void preDelete(DeleteObjectQuery query) throws DatabaseException {
return;
}
/**
* INTERNAL:
* Allow for initialization of properties and validation.
*/
public void preInitialize(AbstractSession session) throws DescriptorException {
try {
getAttributeAccessor().initializeAttributes(getDescriptor().getJavaClass());
} catch (DescriptorException exception) {
exception.setMapping(this);
session.getIntegrityChecker().handleError(exception);
}
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to insert the reference objects before the actual object is inserted.
*/
public void preInsert(WriteObjectQuery query) throws DatabaseException {
return;
}
/**
* INTERNAL:
* A subclass that supports cascade version optimistic locking should
* implement this method to properly prepare the locking policy for their
* mapping type.
*/
public void prepareCascadeLockingPolicy() {
return;
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to update the reference objects before the actual object is updated.
*/
public void preUpdate(WriteObjectQuery query) throws DatabaseException {
return;
}
/**
* INTERNAL:
* Extract value from the row and set the attribute to this value in the object.
* return value as this value will have been converted to the appropriate type for
* the object.
*/
public Object readFromRowIntoObject(AbstractRecord databaseRow, JoinedAttributeManager joinManager, Object targetObject, CacheKey parentCacheKey, ObjectBuildingQuery sourceQuery, AbstractSession executionSession, boolean isTargetProtected) throws DatabaseException {
Object attributeValue = valueFromRow(databaseRow, joinManager, sourceQuery, parentCacheKey, executionSession, isTargetProtected, null);
setAttributeValueInObject(targetObject, attributeValue);
return attributeValue;
}
/**
* INTERNAL:
* Extract values directly from the result-set.
* PERF: This is used for optimized object building directly from the result-set.
*/
public Object readFromResultSetIntoObject(ResultSet resultSet, Object targetObject, ObjectBuildingQuery query, AbstractSession session, DatabaseAccessor accessor, ResultSetMetaData metaData, int columnNumber, DatabasePlatform platform) throws SQLException {
Object attributeValue = valueFromResultSet(resultSet, query, session, accessor, metaData, columnNumber, platform);
setAttributeValueInObject(targetObject, attributeValue);
return attributeValue;
}
/**
* PUBLIC:
* To make mapping read only.
* Read-only mappings can be used if two attributes map to the same field.
* Read-only mappings cannot be used for the primary key or other required fields.
*/
public void readOnly() {
setIsReadOnly(true);
}
/**
* PUBLIC:
* The mapping can be dynamically made either readOnly or readWriteOnly. This makes mapping go back to
* default mode.
*/
public void readWrite() {
setIsReadOnly(false);
}
/**
* INTERNAL:
* Rehash any hashtables based on fields.
* This is used to clone descriptors for aggregates, which hammer field names,
* it is probably better not to hammer the field name and this should be refactored.
*/
public void rehashFieldDependancies(AbstractSession session) {
// Should be overwritten by any mapping with fields.
}
/**
* INTERNAL:
* Once descriptors are serialized to the remote session. All its mappings and reference descriptors are traversed. Usually
* mappings are initilaized and serialized reference descriptors are replaced with local descriptors if they already exist on the
* remote session.
*/
public void remoteInitialization(DistributedSession session) {
// Remote mappings is initilaized here again because while serializing only the uninitialized data is passed
// as the initialized data is not serializable.
if (!isRemotelyInitialized()) {
getAttributeAccessor().initializeAttributes(getDescriptor().getJavaClass());
remotelyInitialized();
}
}
/**
* Set the mapping to be initialized for the remote session.
*/
protected void remotelyInitialized() {
isRemotelyInitialized = true;
}
/**
* INTERNAL:
* replace the value holders in the specified reference object(s)
*/
public Map replaceValueHoldersIn(Object object, RemoteSessionController controller) {
// by default, do nothing
return null;
}
/**
* ADVANCED:
* Set the attributeAccessor.
* The attribute accessor is responsible for setting and retrieving the attribute value
* from the object for this mapping.
* This can be set to an implementor of AttributeAccessor if the attribute
* requires advanced conversion of the mapping value, or a real attribute does not exist.
*/
@Override
public void setAttributeAccessor(AttributeAccessor attributeAccessor) {
String attributeName = getAttributeName();
this.attributeAccessor = attributeAccessor;
if (attributeAccessor.getAttributeName() == null) {
attributeAccessor.setAttributeName(attributeName);
}
this.attributeName = null;
}
/**
* PUBLIC:
* Sets the name of the attribute in the mapping.
*/
@Override
public void setAttributeName(String attributeName) {
getAttributeAccessor().setAttributeName(attributeName);
// Clear the mapping attribute name until a getAttributeName() call copies the accessor attributeName
this.attributeName = null;
}
/**
* INTERNAL:
* Set the value of the attribute mapped by this mapping.
*/
@Override
public void setAttributeValueInObject(Object object, Object value) throws DescriptorException {
// PERF: Direct variable access.
try {
this.attributeAccessor.setAttributeValueInObject(object, value);
} catch (DescriptorException exception) {
exception.setMapping(this);
throw exception;
}
}
/**
* INTERNAL:
* Set the value of the attribute mapped by this mapping,
* placing it inside a value holder if necessary.
*/
public void setRealAttributeValueInObject(Object object, Object value) throws DescriptorException {
try {
this.setAttributeValueInObject(object, value);
} catch (DescriptorException exception) {
exception.setMapping(this);
throw exception;
}
}
/**
* INTERNAL:
* Set the descriptor to which this mapping belongs
*/
@Override
public void setDescriptor(ClassDescriptor descriptor) {
this.descriptor = descriptor;
}
/**
* INTERNAL:
* Set the mapping's field collection.
*/
@Override
protected void setFields(Vector fields) {
this.fields = fields;
}
/**
* PUBLIC:
* This method is invoked reflectively on the reference object to return the value of the
* attribute in the object. This method sets the name of the getMethodName.
*/
public void setGetMethodName(String methodName) {
if (methodName == null) {
return;
}
// This is done because setting attribute name by defaults create InstanceVariableAttributeAccessor
if (getAttributeAccessor() instanceof InstanceVariableAttributeAccessor) {
String attributeName = this.attributeAccessor.getAttributeName();
setAttributeAccessor(new MethodAttributeAccessor());
getAttributeAccessor().setAttributeName(attributeName);
}
((MethodAttributeAccessor)getAttributeAccessor()).setGetMethodName(methodName);
}
/**
* Used to specify whether the value of this mapping may be null.
* This is used when generating DDL.
*/
public void setIsOptional(boolean isOptional) {
this.isOptional = isOptional;
}
/**
* INTERNAL:
* Set by the Object builder during initialization returns true if this mapping
* is used as a primary key mapping.
*/
public void setIsPrimaryKeyMapping(boolean isPrimaryKeyMapping) {
this.isPrimaryKeyMapping = isPrimaryKeyMapping;
}
/**
* PUBLIC:
* Set this mapping to be read only.
* Read-only mappings can be used if two attributes map to the same field.
* Read-only mappings cannot be used for the primary key or other required fields.
*/
public void setIsReadOnly(boolean aBoolean) {
isReadOnly = aBoolean;
}
/**
* ADVANCED:
* Set the maps id value
*/
public void setMapsIdValue(String mapsIdValue) {
this.mapsIdValue = mapsIdValue;
}
/**
* INTERNAL:
* Allow user defined properties.
*/
public void setProperties(Map properties) {
this.properties = properties;
}
/**
* ADVANCED:
* Allow user defined properties.
*/
public void setProperty(Object property, Object value) {
getProperties().put(property, value);
}
/**
* PUBLIC:
* Set the methodName used to set the value for the mapping's attribute into the object.
*/
public void setSetMethodName(String methodName) {
if (methodName == null) {
return;
}
// This is done because setting attribute name by defaults create InstanceVariableAttributeAccessor
if (!getAttributeAccessor().isMethodAttributeAccessor()) {
String attributeName = this.attributeAccessor.getAttributeName();
setAttributeAccessor(new MethodAttributeAccessor());
getAttributeAccessor().setAttributeName(attributeName);
}
((MethodAttributeAccessor)getAttributeAccessor()).setSetMethodName(methodName);
}
/**
* ADVANCED:
* Set the weight of the mapping, used to sort mappings
* DirectToField Mappings have a default weight of 1 while all other Mappings have a
* default weight of MAXINT. Ordering of Mappings can be achieved by setting the weight of
* a particular mapping to a value within the above mentioned limits. By ordering mappings
* the user can control what order relationships are processed by TopLink.
*/
// CR 4097
public void setWeight(Integer newWeight) {
this.weight = newWeight;
}
/**
* ADVANCED:
* This method is used to add an object to a collection once the changeSet is applied.
* The referenceKey parameter should only be used for direct Maps.
*/
public void simpleAddToCollectionChangeRecord(Object referenceKey, Object changeSetToAdd, ObjectChangeSet changeSet, AbstractSession session) throws DescriptorException {
throw DescriptorException.invalidMappingOperation(this, "simpleAddToCollectionChangeRecord");
}
/**
* ADVANCED:
* This method is used to remove an object from a collection once the changeSet is applied.
* The referenceKey parameter should only be used for direct Maps.
*/
public void simpleRemoveFromCollectionChangeRecord(Object referenceKey, Object changeSetToAdd, ObjectChangeSet changeSet, AbstractSession session) throws DescriptorException {
throw DescriptorException.invalidMappingOperation(this, "simpleRemoveFromCollectionChangeRecord");
}
/**
* INTERNAL:
* Print the mapping attribute name, this is used in error messages.
*/
public String toString() {
return getClass().getName() + "[" + getAttributeName() + "]";
}
/**
* INTERNAL:
* Allow for subclasses to perform validation.
*/
public void validateAfterInitialization(AbstractSession session) throws DescriptorException {
}
/**
* INTERNAL:
* Allow for subclasses to perform validation.
*/
public void validateBeforeInitialization(AbstractSession session) throws DescriptorException {
}
/**
* INTERNAL:
* A subclass should extract the value from the object for the field, if it does not map the field then
* it should return null.
* Return the Value from the object.
*/
@Override
public Object valueFromObject(Object anObject, DatabaseField field, AbstractSession session) {
return null;
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Returns the value for the mapping from the database row.
*/
public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery query, boolean isTargetProtected) throws DatabaseException {
return valueFromRow(row, joinManager, query, null, query.getExecutionSession(), isTargetProtected, null);
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Returns the value for the mapping from the database row.
* The execution session is the session the query was executed on,
* and its platform should be used for data conversion.
*/
public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery query, CacheKey cacheKey, AbstractSession session, boolean isTargetProtected, Boolean[] wasCacheUsed) throws DatabaseException {
return null;
}
/**
* INTERNAL:
* Indicates whether the mapping is in SerializedObjectPolicy's sopObject.
*/
public boolean isInSopObject() {
return this.isInSopObject == null || this.isInSopObject;
}
/**
* INTERNAL:
* Indicates whether the mapping is in SerializedObjectPolicy's sopObject and not out of it.
*/
public boolean isInOnlySopObject() {
return this.isInSopObject != null && this.isInSopObject;
}
/**
* INTERNAL:
* Indicates whether the mapping is out of SerializedObjectPolicy's sopObject.
*/
public boolean isOutSopObject() {
return this.isInSopObject == null || !this.isInSopObject;
}
/**
* INTERNAL:
* Indicates whether the mapping is out of SerializedObjectPolicy's sopObject and not in it.
*/
public boolean isOutOnlySopObject() {
return this.isInSopObject != null && !this.isInSopObject;
}
/**
* INTERNAL:
* Indicates whether the mapping is both in and out of SerializedObjectPolicy's sopObject.
*/
public boolean isInAndOutSopObject() {
return this.isInSopObject == null;
}
/**
* INTERNAL:
* Set the mapping is in SerializedObjectPolicy's sopObject.
*/
public void setIsInSopObject() {
this.isInSopObject = Boolean.TRUE;
}
/**
* INTERNAL:
* Set the mapping is out of SerializedObjectPolicy's sopObject.
*/
public void setIsOutSopObject() {
this.isInSopObject = Boolean.FALSE;
}
/**
* INTERNAL:
* Set the mapping is both in and out of SerializedObjectPolicy's sopObject
*/
public void setIsInAndOutSopObject() {
this.isInSopObject = null;
}
/**
* INTERNAL:
* Indicates whether the mapping (or at least one of its nested mappings, at any nested depth)
* references an entity.
* To return true the mapping (or nested mapping) should be ForeignReferenceMapping with non-null and non-aggregate reference descriptor.
*/
public boolean hasNestedIdentityReference() {
return false;
}
/**
* INTERNAL:
* Returns the value for the mapping directly from the result-set.
* PERF: Used for optimized object building.
*/
public Object valueFromResultSet(ResultSet resultSet, ObjectBuildingQuery query, AbstractSession session, DatabaseAccessor accessor, ResultSetMetaData metaData, int columnNumber, DatabasePlatform platform) throws SQLException {
throw DescriptorException.invalidMappingOperation(this, "valueFromResultSet");
}
/**
* INTERNAL:
* To verify if the specified object has been deleted or not.
*/
public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException {
return true;
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Write the foreign key values from the attribute to the row.
*/
public void writeFromAttributeIntoRow(Object attribute, AbstractRecord row, AbstractSession session)
{
// Do nothing by default.
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Write the attribute value from the object to the row.
*/
public void writeFromObjectIntoRow(Object object, AbstractRecord row, AbstractSession session, WriteType writeType) {
// Do nothing by default.
}
/**
* INTERNAL:
* This row is built for shallow insert which happens in case of bidirectional inserts.
* If mapping overrides this method it must override writeFromObjectIntoRowForUpdateAfterShallowInsert method, too.
*/
public void writeFromObjectIntoRowForShallowInsert(Object object, AbstractRecord row, AbstractSession session) {
writeFromObjectIntoRow(object, row, session, WriteType.INSERT);
}
/**
* INTERNAL:
* This row is built for update after shallow insert which happens in case of bidirectional inserts.
* It contains the foreign keys with non null values that were set to null for shallow insert.
* If mapping overrides writeFromObjectIntoRowForShallowInsert method it must override this one, too.
*/
public void writeFromObjectIntoRowForUpdateAfterShallowInsert(Object object, AbstractRecord databaseRow, AbstractSession session, DatabaseTable table) {
// Do nothing by default.
}
/**
* INTERNAL:
* This row is built for update before shallow delete which happens in case of bidirectional inserts.
* It contains the same fields as the row built by writeFromObjectIntoRowForUpdateAfterShallowInsert, but all the values are null.
*/
public void writeFromObjectIntoRowForUpdateBeforeShallowDelete(Object object, AbstractRecord databaseRow, AbstractSession session, DatabaseTable table) {
// Do nothing by default.
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Write the attribute value from the object to the row.
*/
public void writeFromObjectIntoRowWithChangeRecord(ChangeRecord changeRecord, AbstractRecord row, AbstractSession session, WriteType writeType) {
// Do nothing by default.
}
/**
* INTERNAL:
* This row is built for shallow insert which happens in case of bidirectional inserts.
*/
public void writeFromObjectIntoRowForShallowInsertWithChangeRecord(ChangeRecord changeRecord, AbstractRecord row, AbstractSession session) {
writeFromObjectIntoRowWithChangeRecord(changeRecord, row, session, WriteType.INSERT);
}
/**
* INTERNAL:
*/
public void writeFromObjectIntoRowForUpdate(WriteObjectQuery query, AbstractRecord row) {
writeFromObjectIntoRow(query.getObject(), row, query.getSession(), WriteType.UPDATE);
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Write the attribute value from the object to the row.
*/
public void writeFromObjectIntoRowForWhereClause(ObjectLevelModifyQuery query, AbstractRecord row) {
Object object;
if (query.isDeleteObjectQuery()) {
object = query.getObject();
} else {
object = query.getBackupClone();
}
writeFromObjectIntoRow(object, row, query.getSession(), WriteType.UNDEFINED);
}
/**
* INTERNAL:
* Write fields needed for insert into the template for with null values.
*/
public void writeInsertFieldsIntoRow(AbstractRecord databaseRow, AbstractSession session) {
// Do nothing by default.
}
/**
* INTERNAL:
* Write fields needed for update into the template for with null values.
* By default inserted fields are used.
*/
public void writeUpdateFieldsIntoRow(AbstractRecord databaseRow, AbstractSession session) {
writeInsertFieldsIntoRow(databaseRow, session);
}
/**
* INTERNAL:
* Either create a new change record or update the change record with the new value.
* This is used by attribute change tracking.
*/
public void updateChangeRecord(Object clone, Object newValue, Object oldValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException {
throw DescriptorException.invalidMappingOperation(this, "updateChangeRecord");
}
/**
* INTERNAL:
* Add or removes a new value and its change set to the collection change record based on the event passed in. This is used by
* attribute change tracking.
*/
public void updateCollectionChangeRecord(org.eclipse.persistence.descriptors.changetracking.CollectionChangeEvent event, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException {
throw DescriptorException.invalidMappingOperation(this, "updateCollectionChangeRecord");
}
/**
* INTERNAL:
* Set the change listener if required.
* This is required for collections and aggregates or other change tracked mutable objects.
* This is used for resuming or flushing units of work.
*/
public void setChangeListener(Object clone, PropertyChangeListener listener, UnitOfWorkImpl uow) {
// Nothing by default.
}
/**
* ADVANCED:
* Used to indicate the mapping references a JPA ID or MapsId attribute
* for the CMP3Policy and JPA Id classes (as well as Embeddable Id classes).
* This is different from isPrimaryKeyMapping, as an ID mapping is user
* specified and can be read only, as long as another writable mapping for
* the field exists.
*/
public void setDerivesId(boolean derivesId) {
this.derivesId = derivesId;
}
/**
* ADVANCED:
* Used to indicate the mapping references a JPA ID or MapsId attribute
* for the CMP3Policy and JPA Id classes (as well as Embeddable Id classes).
* This is different from isPrimaryKeyMapping, as an ID mapping is user
* specified and can be read only, as long as another writable mapping for
* the field exists.
*/
public void setDerivedIdMapping(DatabaseMapping derivedIdMapping) {
this.derivedIdMapping = derivedIdMapping;
}
/**
* INTERNAL:
* Directly build a change record without comparison
*/
public ChangeRecord buildChangeRecord(Object newValue, ObjectChangeSet owner, AbstractSession session) throws DescriptorException {
throw DescriptorException.invalidMappingOperation(this, "buildChangeRecord");
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
public void postCalculateChanges(org.eclipse.persistence.sessions.changesets.ChangeRecord changeRecord, UnitOfWorkImpl uow) {
}
/**
* INTERNAL:
* Overridden by mappings that require objects to be deleted contribute to change set creation.
*/
public void postCalculateChangesOnDeleted(Object deletedObject, UnitOfWorkChangeSet uowChangeSet, UnitOfWorkImpl uow) {
}
/**
* INTERNAL:
* Overridden by mappings that require objects to be deleted contribute to change set creation.
*/
public void recordPrivateOwnedRemovals(Object object, UnitOfWorkImpl uow) {
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/TypedAssociation.java 0000664 0000000 0000000 00000005266 12216173130 024357 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings;
/**
*
Purpose: Generic association object.
* This can be used to map hashtable/map containers where the key and value are non-typed primitives.
*
* @author James Sutherland
* @since TOPLink/Java 3.0
*/
public class TypedAssociation extends Association {
protected Class keyType;
protected Class valueType;
/**
* Default constructor.
*/
public TypedAssociation() {
super();
}
/**
* PUBLIC:
* Create an association.
*/
public TypedAssociation(Object key, Object value) {
super(key, value);
if (key != null) {
this.keyType = key.getClass();
}
this.value = value;
if (value != null) {
this.valueType = value.getClass();
}
}
/**
* PUBLIC:
* Return the class of the key.
*/
public Class getKeyType() {
return keyType;
}
/**
* PUBLIC:
* Return the class of the value.
*/
public Class getValueType() {
return valueType;
}
/**
* INTERNAL:
* Handler for the descriptor post build event.
* Convert the key and values to their appropriate type.
*/
public void postBuild(org.eclipse.persistence.descriptors.DescriptorEvent event) {
setKey(event.getSession().getDatasourceLogin().getDatasourcePlatform().getConversionManager().convertObject(getKey(), getKeyType()));
setValue(event.getSession().getDatasourceLogin().getDatasourcePlatform().getConversionManager().convertObject(getValue(), getValueType()));
}
/**
* PUBLIC:
* Set the class of the key.
*/
public void setKeyType(Class keyType) {
this.keyType = keyType;
}
/**
* PUBLIC:
* Set the class of the value.
*/
public void setValueType(Class valueType) {
this.valueType = valueType;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/DirectMapMapping.java 0000664 0000000 0000000 00000154741 12216173130 024264 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 07/19/2011-2.2.1 Guy Pelletier
* - 338812: ManyToMany mapping in aggregate object violate integrity constraint on deletion
* * 30/05/2012-2.4 Guy Pelletier
* - 354678: Temp classloader is still being used during metadata processing
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.util.*;
import org.eclipse.persistence.descriptors.changetracking.ChangeTracker;
import org.eclipse.persistence.descriptors.changetracking.CollectionChangeEvent;
import org.eclipse.persistence.descriptors.changetracking.MapChangeEvent;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.Expression;
import org.eclipse.persistence.expressions.ExpressionBuilder;
import org.eclipse.persistence.indirection.IndirectCollection;
import org.eclipse.persistence.indirection.ValueHolder;
import org.eclipse.persistence.internal.descriptors.DescriptorIterator;
import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.descriptors.changetracking.AttributeChangeListener;
import org.eclipse.persistence.internal.descriptors.changetracking.ObjectChangeListener;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.mappings.converters.*;
import org.eclipse.persistence.mappings.foundation.MapComponentMapping;
import org.eclipse.persistence.queries.*;
/**
* Mapping for a collection of key-value pairs.
* The key and value must be simple types (String, Number, Date, etc.)
* and stored in a single table along with a foreign key to the source object.
* A converter can be used on the key and value if the desired object types
* do not match the data types.
*
* @see Converter
* @see ObjectTypeConverter
* @see TypeConversionConverter
* @see SerializedObjectConverter
*
* @author: Steven Vo
* @since TopLink 3.5
*/
public class DirectMapMapping extends DirectCollectionMapping implements MapComponentMapping {
/**
* DirectMapCollectionMapping constructor
*/
public DirectMapMapping() {
super();
DataReadQuery query = new DataReadQuery();
this.selectionQuery = query;
MappedKeyMapContainerPolicy mapPolicy = new MappedKeyMapContainerPolicy(ClassConstants.Hashtable_Class);
mapPolicy.setValueMapping(this);
this.containerPolicy = mapPolicy;
this.isListOrderFieldSupported = false;
}
/**
* ADVANCED:
* Configure the mapping to use a container policy.
* This must be a MappedKeyMapContainerPolicy policy.
* Set the valueMapping for the policy.
*/
public void setContainerPolicy(ContainerPolicy containerPolicy) {
super.setContainerPolicy(containerPolicy);
((MappedKeyMapContainerPolicy)containerPolicy).setValueMapping(this);
}
private MappedKeyMapContainerPolicy getMappedKeyMapContainerPolicy(){
return (MappedKeyMapContainerPolicy)containerPolicy;
}
/**
* PUBLIC:
* Return the converter on the mapping.
* A converter can be used to convert between the key's object value and database value.
*/
public Converter getKeyConverter() {
return getMappedKeyMapContainerPolicy().getKeyConverter();
}
/**
* PUBLIC:
* Set the converter on the mapping.
* A converter can be used to convert between the key's object value and database value.
*/
public void setKeyConverter(Converter keyConverter) {
getMappedKeyMapContainerPolicy().setKeyConverter(keyConverter, this);
}
/**
* INTERNAL:
* Set the converter class name on the mapping. Initialized in
* convertClassNamesToClasses.
* A converter can be used to convert between the key's object value and database value.
*/
public void setKeyConverterClassName(String keyConverterClassName) {
getMappedKeyMapContainerPolicy().setKeyConverterClassName(keyConverterClassName, this);
}
/**
* INTERNAL:
* Add a new value and its change set to the collection change record. This is used by
* attribute change tracking. If a value has changed then issue a remove first with the key
* then an add.
*/
public void addToCollectionChangeRecord(Object newKey, Object newValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException {
DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectMapChangeRecord(objectChangeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
objectChangeSet.addChange(collectionChangeRecord);
}
collectionChangeRecord.addAdditionChange(newKey, newValue);
}
/**
* INTERNAL:
* Require for cloning, the part must be cloned.
* Ignore the objects, use the attribute value.
*/
@Override
public Object buildCloneForPartObject(Object attributeValue, Object original, CacheKey cacheKey, Object clone, AbstractSession cloningSession, Integer refreshCascade, boolean isExisting, boolean isFromSharedCache) {
if (attributeValue == null) {
return containerPolicy.containerInstance(1);
}
Object clonedAttributeValue = containerPolicy.containerInstance(containerPolicy.sizeFor(attributeValue));
// I need to synchronize here to prevent the collection from changing while I am cloning it.
// This will occur when I am merging into the cache and I am instantiating a UOW valueHolder at the same time
// I can not synchronize around the clone, as this will cause deadlocks, so I will need to copy the collection then create the clones
// I will use a temporary collection to help speed up the process
Object temporaryCollection = null;
synchronized (attributeValue) {
temporaryCollection = containerPolicy.cloneFor(attributeValue);
}
for (Object keysIterator = containerPolicy.iteratorFor(temporaryCollection);
containerPolicy.hasNext(keysIterator);) {
Map.Entry entry = (Map.Entry)containerPolicy.nextEntry(keysIterator, cloningSession);
Object cloneKey = containerPolicy.buildCloneForKey(entry.getKey(), clone, cacheKey, null, cloningSession, isExisting, isFromSharedCache);
Object cloneValue = buildElementClone(entry.getValue(), clone, cacheKey, refreshCascade, cloningSession, isExisting, isFromSharedCache);
containerPolicy.addInto(cloneKey, cloneValue, clonedAttributeValue, cloningSession);
}
return clonedAttributeValue;
}
/**
* INTERNAL:
* Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes
* as opposed to detected changes. If an attribute can not be change tracked it's
* changes can be detected through this process.
*/
@Override
public void calculateDeferredChanges(ChangeRecord changeRecord, AbstractSession session) {
DirectMapChangeRecord collectionRecord = (DirectMapChangeRecord)changeRecord;
// TODO: Handle events that fired after collection was replaced.
compareCollectionsForChange(collectionRecord.getOriginalCollection(), collectionRecord.getLatestCollection(), collectionRecord, session);
}
/**
* INTERNAL:
* Cascade discover and persist new objects during commit.
*/
@Override
public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors) {
if (containerPolicy.isMappedKeyMapPolicy()){
Object values = getAttributeValueFromObject(object);
if (values != null){
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, uow);
containerPolicy.cascadeDiscoverAndPersistUnregisteredNewObjects(wrappedObject, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors);
}
}
}
}
/**
* INTERNAL:
* Cascade perform delete through mappings that require the cascade
*/
@Override
public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
if (containerPolicy.isMappedKeyMapPolicy()){
Object values = getAttributeValueFromObject(object);
if (values != null){
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, uow);
containerPolicy.cascadePerformRemoveIfRequired(wrappedObject, uow, visitedObjects);
}
}
}
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
@Override
public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
if (containerPolicy.isMappedKeyMapPolicy()){
Object values = getAttributeValueFromObject(object);
if (values != null){
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, uow);
containerPolicy.cascadeRegisterNewIfRequired(wrappedObject, uow, visitedObjects);
}
}
}
}
/**
* INTERNAL:
* This method is used to calculate the differences between two collections.
*/
@Override
public void compareCollectionsForChange(Object oldCollection, Object newCollection, ChangeRecord changeRecord, AbstractSession session) {
HashMap originalKeyValues = new HashMap(10);
HashMap cloneKeyValues = new HashMap(10);
if (oldCollection != null) {
Map backUpCollection = (Map)oldCollection;
Object backUpIter = containerPolicy.iteratorFor(backUpCollection);
while (containerPolicy.hasNext(backUpIter)) {// Make a lookup of the objects
Map.Entry entry = (Map.Entry)containerPolicy.nextEntry(backUpIter, session);
originalKeyValues.put(entry.getKey(), backUpCollection.get(entry.getKey()));
}
}
Map cloneObjectCollection = (Map)newCollection;
Object cloneIter = containerPolicy.iteratorFor(cloneObjectCollection);
while (containerPolicy.hasNext(cloneIter)) {//Compare them with the objects from the clone
Map.Entry wrappedFirstObject = (Map.Entry)containerPolicy.nextEntry(cloneIter, session);
Object firstValue = wrappedFirstObject.getValue();
Object firstKey = wrappedFirstObject.getKey();
Object backupValue = originalKeyValues.get(firstKey);
if (!originalKeyValues.containsKey(firstKey)) {
cloneKeyValues.put(firstKey, cloneObjectCollection.get(firstKey));
} else if (((backupValue == null) && (firstValue != null)) || (!backupValue.equals(firstValue))) {//the object was not in the backup
cloneKeyValues.put(firstKey, cloneObjectCollection.get(firstKey));
} else {
originalKeyValues.remove(firstKey);
}
}
((DirectMapChangeRecord)changeRecord).clearChanges();
((DirectMapChangeRecord)changeRecord).addAdditionChange(cloneKeyValues);
((DirectMapChangeRecord)changeRecord).addRemoveChange(originalKeyValues);
((DirectMapChangeRecord)changeRecord).setIsDeferred(false);
((DirectMapChangeRecord)changeRecord).setLatestCollection(null);
}
/**
* INTERNAL:
* This method compares the changes between two direct collections. Comparisons are made on equality
* not identity.
*/
@Override
public ChangeRecord compareForChange(Object clone, Object backUp, ObjectChangeSet owner, AbstractSession session) {
Object cloneAttribute = null;
Object backUpAttribute = null;
cloneAttribute = getAttributeValueFromObject(clone);
if ((cloneAttribute != null) && (!getIndirectionPolicy().objectIsInstantiated(cloneAttribute))) {
return null;
}
Map cloneObjectCollection = (Map)getRealCollectionAttributeValueFromObject(clone, session);
HashMap originalKeyValues = new HashMap(10);
HashMap cloneKeyValues = new HashMap(10);
Map backUpCollection = null;
if (!owner.isNew()) {
backUpAttribute = getAttributeValueFromObject(backUp);
if ((backUpAttribute == null) && (cloneAttribute == null)) {
return null;
}
backUpCollection = (Map)getRealCollectionAttributeValueFromObject(backUp, session);
}
DirectMapChangeRecord changeRecord = new DirectMapChangeRecord(owner);
changeRecord.setAttribute(getAttributeName());
changeRecord.setMapping(this);
compareCollectionsForChange(backUpCollection, cloneObjectCollection, changeRecord, session);
if (changeRecord.hasChanges()) {
changeRecord.setOriginalCollection(backUpCollection);
return changeRecord;
}
return null;
}
/**
* INTERNAL:
* Compare the attributes belonging to this mapping for the objects.
*/
@Override
public boolean compareObjects(Object firstObject, Object secondObject, AbstractSession session) {
Object firstObjectMap = getRealCollectionAttributeValueFromObject(firstObject, session);
Object secondObjectMap = getRealCollectionAttributeValueFromObject(secondObject, session);
return getMappedKeyMapContainerPolicy().compareContainers(firstObjectMap, secondObjectMap);
}
/*
* INTERNAL:
* Convert all the class-name-based settings in this mapping to actual
* class-based settings. This method is implemented by subclasses as
* necessary.
* @param classLoader
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader) {
super.convertClassNamesToClasses(classLoader);
if (getDirectKeyField() != null) {
getDirectKeyField().convertClassNamesToClasses(classLoader);
}
}
/**
* INTERNAL
* Called when a DatabaseMapping is used to map the key in a collection. Returns the key.
*/
public Object createMapComponentFromRow(AbstractRecord dbRow, ObjectBuildingQuery query, CacheKey parentCacheKey, AbstractSession session, boolean isTargetProtected){
Object key = dbRow.get(getDirectField());
if (getValueConverter() != null){
key = getValueConverter().convertDataValueToObjectValue(key, session);
}
return key;
}
/**
* INTERNAL:
*/
public DatabaseField getDirectKeyField() {
return getMappedKeyMapContainerPolicy().getDirectKeyField(null);
}
/**
* INTERNAL:
* Initialize and validate the mapping properties.
*/
@Override
public void initialize(AbstractSession session) throws DescriptorException {
getMappedKeyMapContainerPolicy().setDescriptorForKeyMapping(this.getDescriptor());
if (getKeyConverter() != null) {
getKeyConverter().initialize(this, session);
}
super.initialize(session);
}
@Override
protected void initializeDeleteQuery(AbstractSession session) {
if (!getDeleteQuery().hasSessionName()) {
getDeleteQuery().setSessionName(session.getName());
}
if (hasCustomDeleteQuery()) {
return;
}
Expression builder = new ExpressionBuilder();
Expression directKeyExp = null;
List identityFields = getContainerPolicy().getIdentityFieldsForMapKey();
Iterator i = identityFields.iterator();
while (i.hasNext()){
DatabaseField field = i.next();
Expression fieldExpression = builder.getField(field).equal(builder.getParameter(field));
if (directKeyExp == null){
directKeyExp = fieldExpression;
} else {
directKeyExp = directKeyExp.and(fieldExpression);
}
}
Expression expression = null;
SQLDeleteStatement statement = new SQLDeleteStatement();
// Construct an expression to delete from the relation table.
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Expression subExp1 = builder.getField(referenceKey);
Expression subExp2 = builder.getParameter(sourceKey);
Expression subExpression = subExp1.equal(subExp2);
expression = subExpression.and(expression);
}
expression = expression.and(directKeyExp);
statement.setWhereClause(expression);
statement.setTable(getReferenceTable());
getDeleteQuery().setSQLStatement(statement);
}
/**
* Initialize insert query. This query is used to insert the collection of objects into the
* reference table.
*/
@Override
protected void initializeInsertQuery(AbstractSession session) {
super.initializeInsertQuery(session);
getContainerPolicy().addFieldsForMapKey(getInsertQuery().getModifyRow());
}
@Override
protected void initializeSelectionStatement(AbstractSession session) {
if (this.selectionQuery.isReadAllQuery()){
((ReadAllQuery)this.selectionQuery).addAdditionalField(getDirectField().clone());
} else {
SQLSelectStatement statement = (SQLSelectStatement)this.selectionQuery.getSQLStatement();
statement.addTable(getReferenceTable());
statement.addField(getDirectField().clone());
getContainerPolicy().addAdditionalFieldsToQuery(this.selectionQuery, getAdditionalFieldsBaseExpression(this.selectionQuery));
statement.normalize(session, null);
}
if (this.selectionQuery.isDirectReadQuery()){
((DirectReadQuery)this.selectionQuery).setResultType(DataReadQuery.MAP);
}
}
/**
* INTERNAL:
* Iterate on the attribute value.
* The value holder has already been processed.
* PERF: Avoid iteration if not required.
*/
@Override
public void iterateOnRealAttributeValue(DescriptorIterator iterator, Object realAttributeValue) {
super.iterateOnRealAttributeValue(iterator, realAttributeValue);
ContainerPolicy cp = getContainerPolicy();
if (realAttributeValue != null && !iterator.shouldIterateOnPrimitives()) {
for (Object iter = cp.iteratorFor(realAttributeValue); cp.hasNext(iter);) {
Object wrappedObject = cp.nextEntry(iter, iterator.getSession());
cp.iterateOnMapKey(iterator, wrappedObject);
}
}
}
/**
* INTERNAL:
* Iterate on the specified element.
*/
@Override
public void iterateOnElement(DescriptorIterator iterator, Object element) {
super.iterateOnElement(iterator, element);
ContainerPolicy cp = getContainerPolicy();
for (Object iter = cp.iteratorFor(element); cp.hasNext(iter);) {
Object wrappedObject = cp.nextEntry(iter, iterator.getSession());
cp.iterateOnMapKey(iterator, wrappedObject);
}
}
/**
* INTERNAL:
* Related mapping should implement this method to return true.
*/
@Override
public boolean isDirectMapMapping() {
return true;
}
/**
* INTERNAL:
* Merge changes from the source to the target object.
* Because this is a collection mapping, values are added to or removed from the
* collection based on the changeset.
*/
@Override
public void mergeChangesIntoObject(Object target, ChangeRecord changeRecord, Object source, MergeManager mergeManager, AbstractSession targetSession) {
if (this.descriptor.getCachePolicy().isProtectedIsolation()&& !this.isCacheable && !targetSession.isProtectedSession()){
setAttributeValueInObject(target, this.indirectionPolicy.buildIndirectObject(new ValueHolder(null)));
return;
}
Map valueOfTarget = null;
AbstractSession session = mergeManager.getSession();
//collect the changes into a vector
HashMap addObjects = ((DirectMapChangeRecord)changeRecord).getAddObjects();
HashMap removeObjects = ((DirectMapChangeRecord)changeRecord).getRemoveObjects();
//Check to see if the target has an instantiated collection
if ((isAttributeValueInstantiated(target)) && (!changeRecord.getOwner().isNew())) {
valueOfTarget = (Map)getRealCollectionAttributeValueFromObject(target, session);
} else {
//if not create an instance of the map
valueOfTarget = (Map)containerPolicy.containerInstance(addObjects.size());
}
if (!isAttributeValueInstantiated(target)) {
if (mergeManager.shouldMergeChangesIntoDistributedCache()) {
return;
}
Object valueOfSource = getRealCollectionAttributeValueFromObject(source, session);
for (Object iterator = containerPolicy.iteratorFor(valueOfSource);
containerPolicy.hasNext(iterator);) {
Map.Entry entry = (Map.Entry)containerPolicy.nextEntry(iterator, session);
containerPolicy.addInto(entry.getKey(), entry.getValue(), valueOfTarget, session);
}
} else {
Object synchronizationTarget = valueOfTarget;
// For indirect containers the delegate must be synchronized on,
// not the wrapper as the clone synchs on the delegate, see bug#5685287.
if (valueOfTarget instanceof IndirectCollection) {
synchronizationTarget = ((IndirectCollection)valueOfTarget).getDelegateObject();
}
synchronized (synchronizationTarget) {
// Next iterate over the changes and add them to the container
for (Iterator i = removeObjects.keySet().iterator(); i.hasNext();) {
Object keyToRemove = i.next();
containerPolicy.removeFrom(keyToRemove, (Object)null, valueOfTarget, session);
}
for (Iterator i = addObjects.keySet().iterator(); i.hasNext();) {
Object keyToAdd = i.next();
Object nextItem = addObjects.get(keyToAdd);
if (mergeManager.shouldMergeChangesIntoDistributedCache()) {
//bug#4458089 and 4454532- check if collection contains new item before adding during merge into distributed cache
if (!containerPolicy.contains(nextItem, valueOfTarget, session)) {
containerPolicy.addInto(keyToAdd, nextItem, valueOfTarget, session);
}
} else {
containerPolicy.addInto(keyToAdd, nextItem, valueOfTarget, session);
}
}
}
}
setRealAttributeValueInObject(target, valueOfTarget);
}
/**
* INTERNAL:
* Merge changes from the source to the target object.
*/
@Override
public void mergeIntoObject(Object target, boolean isTargetUnInitialized, Object source, MergeManager mergeManager, AbstractSession targetSession) {
if (this.descriptor.getCachePolicy().isProtectedIsolation()&& !this.isCacheable && !targetSession.isProtectedSession()){
setAttributeValueInObject(target, this.indirectionPolicy.buildIndirectObject(new ValueHolder(null)));
return;
}
if (isTargetUnInitialized) {
// This will happen if the target object was removed from the cache before the commit was attempted
if (mergeManager.shouldMergeWorkingCopyIntoOriginal() && (!isAttributeValueInstantiated(source))) {
setAttributeValueInObject(target, getIndirectionPolicy().getOriginalIndirectionObject(getAttributeValueFromObject(source), targetSession));
return;
}
}
if (!shouldMergeCascadeReference(mergeManager)) {
// This is only going to happen on mergeClone, and we should not attempt to merge the reference
return;
}
if (mergeManager.shouldRefreshRemoteObject() && usesIndirection()) {
mergeRemoteValueHolder(target, source, mergeManager);
return;
}
if (mergeManager.isForRefresh()) {
if (!isAttributeValueInstantiated(target)) {
// This will occur when the clone's value has not been instantiated yet and we do not need
// the refresh that attribute
return;
}
} else if (!isAttributeValueInstantiated(source)) {
// I am merging from a clone into an original. No need to do merge if the attribute was never
// modified
return;
}
Map valueOfSource = (Map)getRealCollectionAttributeValueFromObject(source, mergeManager.getSession());
// trigger instantiation of target attribute
Object valueOfTarget = getRealCollectionAttributeValueFromObject(target, mergeManager.getSession());
Object newContainer = containerPolicy.containerInstance(containerPolicy.sizeFor(valueOfSource));
boolean fireChangeEvents = false;
if ((this.getDescriptor().getObjectChangePolicy().isObjectChangeTrackingPolicy()) && (target instanceof ChangeTracker) && (((ChangeTracker)target)._persistence_getPropertyChangeListener() != null)) {
fireChangeEvents = true;
//Collections may not be indirect list or may have been replaced with user collection.
Object iterator = containerPolicy.iteratorFor(valueOfTarget);
while (containerPolicy.hasNext(iterator)) {
Map.Entry entry = (Map.Entry)containerPolicy.nextEntry(iterator, mergeManager.getSession());
((ObjectChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener()).internalPropertyChange(new MapChangeEvent(target, getAttributeName(), valueOfTarget, entry.getKey(), entry.getValue(), CollectionChangeEvent.REMOVE, false));// make the remove change event fire.
}
if (newContainer instanceof ChangeTracker) {
((ChangeTracker)newContainer)._persistence_setPropertyChangeListener(((ChangeTracker)target)._persistence_getPropertyChangeListener());
}
if (valueOfTarget instanceof ChangeTracker) {
((ChangeTracker)valueOfTarget)._persistence_setPropertyChangeListener(null);//remove listener
}
}
valueOfTarget = newContainer;
for (Object sourceValuesIterator = containerPolicy.iteratorFor(valueOfSource);
containerPolicy.hasNext(sourceValuesIterator);) {
Map.Entry entry = (Map.Entry)containerPolicy.nextEntry(sourceValuesIterator, mergeManager.getSession());
if (fireChangeEvents) {
//Collections may not be indirect list or may have been replaced with user collection.
((ObjectChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener()).internalPropertyChange(new MapChangeEvent(target, getAttributeName(), valueOfTarget, entry.getKey(), entry.getValue(), CollectionChangeEvent.ADD, false));// make the add change event fire.
}
containerPolicy.addInto(entry.getKey(), entry.getValue(), valueOfTarget, mergeManager.getSession());
}
if (fireChangeEvents && (getDescriptor().getObjectChangePolicy().isAttributeChangeTrackingPolicy())) {
// check that there were changes, if not then remove the record.
ObjectChangeSet changeSet = ((AttributeChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener()).getObjectChangeSet();
if (changeSet != null) {
DirectMapChangeRecord changeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (changeRecord != null) {
if (!changeRecord.isDeferred()) {
if (!changeRecord.hasChanges()) {
changeSet.removeChange(getAttributeName());
}
} else {
// Must reset the latest collection.
changeRecord.setLatestCollection(valueOfTarget);
}
}
}
}
// Must re-set variable to allow for set method to re-morph changes if the collection is not being stored directly.
setRealAttributeValueInObject(target, valueOfTarget);
}
/**
* INTERNAL:
* Perform the commit event.
* This is used in the uow to delay data modifications.
* This is mostly dealt with in the superclass. Private Owned deletes require extra functionality
*/
@Override
public void performDataModificationEvent(Object[] event, AbstractSession session) throws DatabaseException, DescriptorException {
super.performDataModificationEvent(event, session);
if (event[0] == Delete && containerPolicy.shouldIncludeKeyInDeleteEvent()) {
session.deleteObject(event[3]);
}
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
@Override
public void postCalculateChanges(org.eclipse.persistence.sessions.changesets.ChangeRecord changeRecord, UnitOfWorkImpl uow) {
// no need for private owned check. This code is only registered for private owned mappings.
// targets are added to and/or removed to/from the source.
DirectMapChangeRecord mapChangeRecord = (DirectMapChangeRecord)changeRecord;
Iterator it = mapChangeRecord.getRemoveObjects().entrySet().iterator();
while(it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
containerPolicy.postCalculateChanges(entry.getKey(), entry.getValue(), referenceDescriptor, this, uow);
}
}
/**
* INTERNAL:
* Insert the private owned object.
*/
@Override
public void postInsert(WriteObjectQuery query) throws DatabaseException {
Object objects;
AbstractRecord databaseRow = new DatabaseRecord();
if (isReadOnly()) {
return;
}
objects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession());
if (this.containerPolicy.isEmpty(objects)) {
return;
}
prepareTranslationRow(query.getTranslationRow(), query.getObject(), query.getDescriptor(), query.getSession());
// Extract primary key and value from the source.
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Object sourceKeyValue = query.getTranslationRow().get(sourceKey);
databaseRow.put(referenceKey, sourceKeyValue);
}
// Extract target field and its value. Construct insert statement and execute it
Object keyIter = this.containerPolicy.iteratorFor(objects);
while (this.containerPolicy.hasNext(keyIter)) {
Map.Entry entry = (Map.Entry)this.containerPolicy.nextEntry(keyIter, query.getSession());
Object value = getFieldValue(entry.getValue(), query.getSession());
databaseRow.put(getDirectField(), value);
ContainerPolicy.copyMapDataToRow(getContainerPolicy().getKeyMappingDataForWriteQuery(entry, query.getSession()), databaseRow);
// In the uow data queries are cached until the end of the commit.
if (query.shouldCascadeOnlyDependentParts()) {
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = databaseRow.clone();
query.getSession().getCommitManager().addDataModificationEvent(this, event);
} else {
query.getSession().executeQuery(getInsertQuery(), databaseRow);
}
getContainerPolicy().propogatePostInsert(query, entry);
}
}
/**
* INTERNAL:
* Update private owned part.
*/
@Override
protected void postUpdateWithChangeSet(WriteObjectQuery writeQuery) throws DatabaseException {
ObjectChangeSet changeSet = writeQuery.getObjectChangeSet();
DirectMapChangeRecord changeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (changeRecord == null) {
return;
}
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Object sourceKeyValue = writeQuery.getTranslationRow().get(sourceKey);
writeQuery.getTranslationRow().put(referenceKey, sourceKeyValue);
}
for (Iterator iterator = changeRecord.getRemoveObjects().entrySet().iterator();
iterator.hasNext();) {
Object entry = iterator.next();
AbstractRecord thisRow = writeQuery.getTranslationRow().clone();
ContainerPolicy.copyMapDataToRow(containerPolicy.getKeyMappingDataForWriteQuery(entry, writeQuery.getSession()), thisRow);
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = null;
if (containerPolicy.shouldIncludeKeyInDeleteEvent()){
event = new Object[4];
event[3] = containerPolicy.keyFromEntry(entry);
} else {
event = new Object[3];
}
event[0] = Delete;
event[1] = getDeleteQuery();
event[2] = thisRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
for (Iterator iterator = changeRecord.getAddObjects().entrySet().iterator();
iterator.hasNext();) {
Map.Entry entry = (Map.Entry)iterator.next();
AbstractRecord thisRow = writeQuery.getTranslationRow().clone();
Object value = changeRecord.getAddObjects().get(entry.getKey());
value = getFieldValue(value, writeQuery.getSession());
ContainerPolicy.copyMapDataToRow(this.containerPolicy.getKeyMappingDataForWriteQuery(entry, writeQuery.getSession()), thisRow);
thisRow.add(getDirectField(), value);
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = thisRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
}
/**
* INTERNAL:
* Propagate the preDelete event through the container policy if necessary
*/
@Override
public void preDelete(DeleteObjectQuery query) throws DatabaseException {
if (getContainerPolicy().propagatesEventsToCollection()){
Object queryObject = query.getObject();
Object values = getAttributeValueFromObject(queryObject);
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, query.getSession());
containerPolicy.propogatePreDelete(query, wrappedObject);
}
}
super.preDelete(query);
}
/**
* INTERNAL:
* Rebuild select query.
*/
@Override
protected void initOrRebuildSelectQuery() {
this.selectionQuery = containerPolicy.buildSelectionQueryForDirectCollectionMapping();
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
@Override
public void recordPrivateOwnedRemovals(Object object, UnitOfWorkImpl uow) {
// no need for private owned check. This code is only registered for private owned mappings.
// targets are added to and/or removed to/from the source.
Iterator it = (Iterator) containerPolicy.iteratorFor(getRealAttributeValueFromObject(object, uow));
while (it.hasNext()) {
Object clone = it.next();
containerPolicy.recordPrivateOwnedRemovals(clone, referenceDescriptor, uow);
}
}
/**
* INTERNAL:
* Remove a value and its change set from the collection change record. This is used by
* attribute change tracking.
*/
protected void removeFromCollectionChangeRecord(Object newKey, Object newValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException {
DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectMapChangeRecord(objectChangeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
objectChangeSet.addChange(collectionChangeRecord);
}
collectionChangeRecord.addRemoveChange(newKey, newValue);
}
/**
* INTERNAL:
*/
public void setDirectKeyField(DatabaseField keyField) {
getMappedKeyMapContainerPolicy().setKeyField(keyField, descriptor);
}
/**
* ADVANCED:
* Set the class type of the field value.
* This can be used if field value differs from the object value,
* has specific typing requirements such as usage of java.sql.Blob or NChar.
* This must be called after the field name has been set.
*/
public void setDirectKeyFieldClassification(Class fieldType) {
getDirectKeyField().setType(fieldType);
}
/**
* ADVANCED:
* Set the class type name of the field value.
* This can be used if field value differs from the object value,
* has specific typing requirements such as usage of java.sql.Blob or NChar.
* This must be called after the direct key field has been set.
*/
public void setDirectKeyFieldClassificationName(String fieldTypeName) {
getDirectKeyField().setTypeName(fieldTypeName);
}
/**
* PUBLIC:
* Set the direct key field name in the reference table.
* This is the field that the primitive data value of the Map key is stored in.
*/
public void setDirectKeyFieldName(String fieldName) {
setDirectKeyField(new DatabaseField(fieldName));
}
/**
* INTERNAL:
* Either create a new change record or update the change record with the new value.
* This is used by attribute change tracking.
*/
@Override
public void updateChangeRecord(Object clone, Object newValue, Object oldValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException {
DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectMapChangeRecord(objectChangeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
objectChangeSet.addChange(collectionChangeRecord);
}
if (collectionChangeRecord.getOriginalCollection() == null) {
collectionChangeRecord.recreateOriginalCollection(oldValue, uow);
}
collectionChangeRecord.setLatestCollection(newValue);
collectionChangeRecord.setIsDeferred(true);
objectChangeSet.deferredDetectionRequiredOn(getAttributeName());
}
/**
* INTERNAL:
* Add or removes a new value and its change set to the collection change record based on the event passed in. This is used by
* attribute change tracking.
*/
@Override
public void updateCollectionChangeRecord(CollectionChangeEvent event, ObjectChangeSet changeSet, UnitOfWorkImpl uow) {
if (event != null ) {
//Letting the mapping create and add the ChangeSet to the ChangeRecord rather
// than the policy, since the policy doesn't know how to handle DirectCollectionChangeRecord.
// if ordering is to be supported in the future, check how the method in CollectionMapping is implemented
Object key = null;
if (event.getClass().equals(ClassConstants.MapChangeEvent_Class)){
key = ((MapChangeEvent)event).getKey();
}
if (event.getChangeType() == CollectionChangeEvent.ADD) {
addToCollectionChangeRecord(key, event.getNewValue(), changeSet, uow);
} else if (event.getChangeType() == CollectionChangeEvent.REMOVE) {
removeFromCollectionChangeRecord(key, event.getNewValue(), changeSet, uow);
} else {
throw ValidationException.wrongCollectionChangeEventType(event.getChangeType());
}
}
}
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
*
The default container class is java.util.Hashtable.
*
The container class must implements (directly or indirectly) the Map interface.
*
Note: Do not use both useMapClass(Class concreteClass), useTransparentMap(). The last use of one of the two methods will override the previous one.
*/
public void useMapClass(Class concreteClass) {
if (!Helper.classImplementsInterface(concreteClass, ClassConstants.Map_Class)) {
throw DescriptorException.illegalContainerClass(concreteClass);
}
containerPolicy.setContainerClass(concreteClass);
}
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
*
The container class must implement (directly or indirectly) the Map interface.
*
Note: Do not use both useMapClass(Class concreteClass), useTransparentMap(). The last use of one of the two methods will override the previous one.
*/
public void useTransparentMap() {
setIndirectionPolicy(new TransparentIndirectionPolicy());
useMapClass(ClassConstants.IndirectMap_Class);
}
/**
* PUBLIC:
* This is a helper method to set the key converter to a TypeConversionConverter.
* This ensures that the key value from the database is converted to the correct
* Java type. The converter can also be set directly.
* Note that setting the converter to another converter will overwrite this setting.
*/
public void setKeyClass(Class keyClass) {
TypeConversionConverter converter = new TypeConversionConverter(this);
converter.setObjectClass(keyClass);
setKeyConverter(converter);
}
/**
* PUBLIC:
* This is a helper method to get the object class from the key converter
* if it is a TypeConversionConverter.
* This returns null if not using a TypeConversionConverter key converter.
*/
public Class getKeyClass() {
if ((getKeyConverter() == null) || !(getKeyConverter() instanceof TypeConversionConverter)) {
return null;
}
return ((TypeConversionConverter)getKeyConverter()).getObjectClass();
}
/**
* PUBLIC:
* This is a helper method to set the value converter to a TypeConversionConverter.
* This ensures that the value from the database is converted to the correct
* Java type. The converter can also be set directly.
* Note that setting the converter to another converter will overwrite this setting.
*/
public void setValueClass(Class valueClass) {
TypeConversionConverter converter = new TypeConversionConverter(this);
converter.setObjectClass(valueClass);
setValueConverter(converter);
}
/**
* ADVANCED:
* This method is used to have an object add to a collection once the changeSet is applied
* The referenceKey parameter should only be used for direct Maps.
*/
@Override
public void simpleAddToCollectionChangeRecord(Object referenceKey, Object objectToAdd, ObjectChangeSet changeSet, AbstractSession session) {
DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectMapChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
collectionChangeRecord.getAddObjects().put(referenceKey, objectToAdd);
changeSet.addChange(collectionChangeRecord);
} else {
if (collectionChangeRecord.getRemoveObjects().containsKey(referenceKey)) {
collectionChangeRecord.getRemoveObjects().remove(referenceKey);
} else {
collectionChangeRecord.getAddObjects().put(referenceKey, objectToAdd);
}
}
}
/**
* ADVANCED:
* This method is used to have an object removed from a collection once the changeSet is applied
* The referenceKey parameter should only be used for direct Maps.
*/
@Override
public void simpleRemoveFromCollectionChangeRecord(Object referenceKey, Object objectToRemove, ObjectChangeSet changeSet, AbstractSession session) {
DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectMapChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
collectionChangeRecord.getRemoveObjects().put(referenceKey, objectToRemove);
changeSet.addChange(collectionChangeRecord);
} else {
if (collectionChangeRecord.getAddObjects().containsKey(referenceKey)) {
collectionChangeRecord.getAddObjects().remove(referenceKey);
} else {
collectionChangeRecord.getRemoveObjects().put(referenceKey, objectToRemove);
}
}
}
/**
* PUBLIC:
* This is a helper method to get the object class from the value converter
* if it is a TypeConversionConverter.
* This returns null if not using a TypeConversionConverter value converter.
*/
public Class getValueClass() {
if (!(getValueConverter() instanceof TypeConversionConverter)) {
return null;
}
return ((TypeConversionConverter)getValueConverter()).getObjectClass();
}
/**
* INTERNAL:
* Prepare and execute the batch query and store the
* results for each source object in a map keyed by the
* mappings source keys of the source objects.
*/
@Override
protected void executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceDataByKey, AbstractSession session, AbstractRecord translationRow) {
// Execute query and index resulting object sets by key.
List rows = (List)session.executeQuery(query, translationRow);
MappedKeyMapContainerPolicy mapContainerPolicy = getMappedKeyMapContainerPolicy();
for (AbstractRecord referenceRow : rows) {
Object referenceKey = null;
if (query.isObjectBuildingQuery()){
referenceKey = mapContainerPolicy.buildKey(referenceRow, (ObjectBuildingQuery)query, parentCacheKey, session, true);
} else {
referenceKey = mapContainerPolicy.buildKey(referenceRow, null, parentCacheKey, session, true);
}
Object referenceValue = referenceRow.get(this.directField);
Object eachCacheKey = extractKeyFromTargetRow(referenceRow, session);
Object container = referenceDataByKey.get(eachCacheKey);
if ((container == null) || (container == Helper.NULL_VALUE)) {
container = this.containerPolicy.containerInstance();
referenceDataByKey.put(eachCacheKey, container);
}
// Allow for value conversion.
if (this.valueConverter != null) {
referenceValue = this.valueConverter.convertDataValueToObjectValue(referenceValue, query.getSession());
}
this.containerPolicy.addInto(referenceKey, referenceValue, container, query.getSession());
}
}
/**
* INTERNAL:
* Return the value of the field from the row or a value holder on the query to obtain the object.
*/
@Override
protected Object valueFromRowInternalWithJoin(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, CacheKey parentCacheKey, AbstractSession executionSession, boolean isTargetProtected) throws DatabaseException {
ContainerPolicy policy = getContainerPolicy();
Object value = policy.containerInstance();
ObjectBuilder objectBuilder = getDescriptor().getObjectBuilder();
// Extract the primary key of the source object, to filter only the joined rows for that object.
Object sourceKey = objectBuilder.extractPrimaryKeyFromRow(row, executionSession);
// If the query was using joining, all of the result rows by primary key will have been computed.
List rows = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
// If no 1-m rows were fetch joined, then get the value normally,
// this can occur with pagination where the last row may not be complete.
if (rows == null) {
return valueFromRowInternal(row, joinManager, sourceQuery, executionSession);
}
// A set of direct values must be maintained to avoid duplicates from multiple 1-m joins.
Set directValues = new HashSet();
Converter valueConverter = getValueConverter();
// For each rows, extract the target row and build the target object and add to the collection.
int size = rows.size();
for (int index = 0; index < size; index++) {
AbstractRecord sourceRow = rows.get(index);
AbstractRecord targetRow = sourceRow;
// The field for many objects may be in the row,
// so build the subpartion of the row through the computed values in the query,
// this also helps the field indexing match.
targetRow = trimRowForJoin(targetRow, joinManager, executionSession);
// Partial object queries must select the primary key of the source and related objects.
// If the target joined rows in null (outerjoin) means an empty collection.
Object directKey = this.containerPolicy.buildKeyFromJoinedRow(targetRow, joinManager, sourceQuery, parentCacheKey, executionSession, isTargetProtected);
if (directKey == null) {
// A null direct value means an empty collection returned as nulls from an outerjoin.
return getIndirectionPolicy().valueFromRow(value);
}
// Only build/add the target object once, skip duplicates from multiple 1-m joins.
if (!directValues.contains(directKey)) {
directValues.add(directKey);
Object directValue = targetRow.get(this.directField);
// Allow for value conversion.
if (valueConverter != null) {
directValue = valueConverter.convertDataValueToObjectValue(directValue, executionSession);
}
policy.addInto(directKey, directValue, value, executionSession);
}
}
return getIndirectionPolicy().valueFromRow(value);
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/RelationalMapping.java 0000664 0000000 0000000 00000002000 12216173130 024462 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings;
/**
* INTERNAL
* All mappings which can be added to org.eclipse.persistence.mappings.Descriptor must
* implement this interface.
*
* @since OracleAS TopLink 10g (10.0.3)
*/
public interface RelationalMapping {
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/DirectCollectionMapping.java 0000664 0000000 0000000 00000436503 12216173130 025641 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 07/19/2011-2.2.1 Guy Pelletier
* - 338812: ManyToMany mapping in aggregate object violate integrity constraint on deletion
* 04/09/2012-2.4 Guy Pelletier
* - 374377: OrderBy with ElementCollection doesn't work
* 14/05/2012-2.4 Guy Pelletier
* - 376603: Provide for table per tenant support for multitenant applications
* 30/05/2012-2.4 Guy Pelletier
* - 354678: Temp classloader is still being used during metadata processing
* 08/01/2012-2.5 Chris Delahunt
* - 371950: Metadata caching
* 06/03/2013-2.5.1 Guy Pelletier
* - 402380: 3 jpa21/advanced tests failed on server with
* "java.lang.NoClassDefFoundError: org/eclipse/persistence/testing/models/jpa21/advanced/enums/Gender"
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.beans.PropertyChangeEvent;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;
import org.eclipse.persistence.annotations.BatchFetchType;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.TablePerMultitenantPolicy;
import org.eclipse.persistence.descriptors.changetracking.*;
import org.eclipse.persistence.internal.descriptors.changetracking.AttributeChangeListener;
import org.eclipse.persistence.internal.descriptors.changetracking.ObjectChangeListener;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.history.*;
import org.eclipse.persistence.indirection.IndirectCollection;
import org.eclipse.persistence.indirection.IndirectList;
import org.eclipse.persistence.indirection.ValueHolder;
import org.eclipse.persistence.internal.databaseaccess.DatasourcePlatform;
import org.eclipse.persistence.internal.databaseaccess.Platform;
import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.*;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.sessions.remote.*;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.security.PrivilegedNewInstanceFromClass;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.mappings.converters.*;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.sessions.remote.*;
import org.eclipse.persistence.sessions.CopyGroup;
import org.eclipse.persistence.sessions.DatabaseRecord;
/**
*
Purpose: This mapping is used to store a collection of simple types (String, Number, Date, etc.)
* into a single table. The table must store the value and a foreign key to the source object.
* A converter can be used if the desired object type and the data type do not match.
*
* @see Converter
* @see ObjectTypeConverter
* @see TypeConversionConverter
* @see SerializedObjectConverter
*
* @author Sati
* @since TOPLink/Java 1.0
*
* 09/18/2009-2.0 Michael O'Brien
* - 266912: JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
* add support for passing BasicMap value type to MapAttributeImpl via new attributeClassification field
*/
public class DirectCollectionMapping extends CollectionMapping implements RelationalMapping {
/** Used for data modification events. */
protected static final String Delete = "delete";
protected static final String Insert = "insert";
protected static final String DeleteAll = "deleteAll";
protected static final String DeleteAtIndex = "deleteAtIndex";
protected static final String UpdateAtIndex = "updateAtIndex";
/** Allows user defined conversion between the object value and the database value. */
protected Converter valueConverter;
protected String valueConverterClassName;
protected List orderByExpressions;
/** Stores the reference table*/
protected DatabaseTable referenceTable;
/** The direct field name is converted and stored */
protected DatabaseField directField;
protected Vector sourceKeyFields;
protected Vector referenceKeyFields;
/** Used for insertion for m-m and dc, not used in 1-m. */
protected DataModifyQuery insertQuery;
/** Used for deletion when ChangeSets are used */
protected ModifyQuery changeSetDeleteQuery;
protected transient ModifyQuery changeSetDeleteNullQuery; // Bug 306075
protected boolean hasCustomDeleteQuery;
protected boolean hasCustomInsertQuery;
protected HistoryPolicy historyPolicy;
/** Used (only in case listOrderField != null) to delete object with particular orderFieldValue */
protected ModifyQuery deleteAtIndexQuery;
/** Used (only in case listOrderField != null) to update orderFieldValue of object with particular orderFieldValue */
protected ModifyQuery updateAtIndexQuery;
protected boolean hasCustomDeleteAtIndexQuery;
protected boolean hasCustomUpdateAtIndexQuery;
/**
* @since Java Persistence API 2.0
* Referenced by MapAttributeImpl to pick up the BasicMap value parameter type
* To specify the conversion type
* */
protected transient Class attributeClassification;
protected String attributeClassificationName;
/**
* PUBLIC:
* Default constructor.
*/
public DirectCollectionMapping() {
this.insertQuery = new DataModifyQuery();
this.orderByExpressions = new ArrayList();
this.sourceKeyFields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(1);
this.referenceKeyFields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(1);
this.selectionQuery = new DirectReadQuery();
this.hasCustomInsertQuery = false;
this.isPrivateOwned = true;
this.isListOrderFieldSupported = true;
}
/**
* PUBLIC:
* Provide ascending order support for this direct collection mapping.
*/
public void addAscendingOrdering() {
this.hasOrderBy = true;
orderByExpressions.add(new ExpressionBuilder().getField(getDirectFieldName()).ascending());
}
/**
* PUBLIC:
* Provide descending order support for this direct collection mapping.
*/
public void addDescendingOrdering() {
this.hasOrderBy = true;
orderByExpressions.add(new ExpressionBuilder().getField(getDirectFieldName()).descending());
}
/**
* ADVANCED:
* Used this method to add custom ordering expressions when fetching
* the collection. This could be things like expressions using a functions
* like UPPER or NULLS LAST etc.
*/
public void addOrdering(Expression expression) {
this.orderByExpressions.add(expression);
}
@Override
public boolean isRelationalMapping() {
return true;
}
/**
* PUBLIC:
* Return the converter on the mapping.
* A converter can be used to convert between the direct collection's object value and database value.
*/
public Converter getValueConverter() {
return valueConverter;
}
/**
* PUBLIC:
* Set the converter on the mapping.
* A converter can be used to convert between the direct collection's object value and database value.
*/
public void setValueConverter(Converter valueConverter) {
this.valueConverter = valueConverter;
}
/**
* PUBLIC:
* Set the converter class name on the mapping. Initialized in
* convertClassNamesToClasses.
* A converter can be used to convert between the direct collection's object value and database value.
*/
public void setValueConverterClassName(String valueConverterClassName) {
this.valueConverterClassName = valueConverterClassName;
}
/**
* PUBLIC:
* Add the reference key field.
* This is used for composite reference keys.
* This is the foreign key field in the direct table referencing the primary key of the source object.
* Both the reference field and the source field that it references must be provided.
*/
public void addReferenceKeyField(DatabaseField referenceForeignKeyField, DatabaseField sourcePrimaryKeyField) {
getSourceKeyFields().addElement(sourcePrimaryKeyField);
getReferenceKeyFields().addElement(referenceForeignKeyField);
}
/**
* PUBLIC:
* Add the name of the reference key field.
* This is used for composite reference keys.
* This is the foreign key field in the direct table referencing the primary key of the source object.
* Both the reference field name and the name of the source field that it references must be provided.
*/
public void addReferenceKeyFieldName(String referenceForeignKeyFieldName, String sourcePrimaryKeyFieldName) {
addReferenceKeyField(new DatabaseField(referenceForeignKeyFieldName), new DatabaseField(sourcePrimaryKeyFieldName));
}
/**
* INTERNAL:
* Clone and prepare the selection query as a nested batch read query.
* This is used for nested batch reading.
*/
@Override
public ReadQuery prepareNestedBatchQuery(ObjectLevelReadQuery query) {
// For CR#2646-S.M. In case of inheritance the descriptor to use may not be that
// of the source query (the base class descriptor), but that of the subclass, if the
// attribute is only of the subclass. Thus in this case use the descriptor from the mapping.
// Also: for Bug 5478648 - Do not switch the descriptor if the query's descriptor is an aggregate
ClassDescriptor descriptorToUse = query.getDescriptor();
if ((descriptorToUse != this.descriptor) && (!descriptorToUse.getMappings().contains(this)) && (!this.descriptor.isDescriptorTypeAggregate())) {
descriptorToUse = this.descriptor;
}
DataReadQuery batchQuery = new DataReadQuery();
batchQuery.setName(getAttributeName());
// Join the query where clause with the mappings,
// this will cause a join that should bring in all of the target objects.
ExpressionBuilder builder;
Expression originalSelectionCriteria = null;
// 2612538 - the default size of Map (32) is appropriate
Map clonedExpressions = new IdentityHashMap();
builder = new ExpressionBuilder();
// For flashback.
if (query.hasAsOfClause()) {
builder.asOf(query.getAsOfClause());
}
Expression batchSelectionCriteria = null;
// Build the batch query, either using joining, or an exist sub-select.
BatchFetchType batchType = query.getBatchFetchPolicy().getType();
if (this.batchFetchType != null) {
batchType = this.batchFetchType;
}
if (batchType == BatchFetchType.EXISTS) {
// Using a EXISTS sub-select (WHERE EXIST ( AND AND )
ExpressionBuilder subBuilder = new ExpressionBuilder(descriptorToUse.getJavaClass());
subBuilder.setQueryClassAndDescriptor(descriptorToUse.getJavaClass(), descriptorToUse);
ReportQuery subQuery = new ReportQuery(descriptorToUse.getJavaClass(), subBuilder);
subQuery.setDescriptor(descriptorToUse);
subQuery.setShouldRetrieveFirstPrimaryKey(true);
Expression subCriteria = subBuilder.twist(getSelectionCriteria(), builder);
if (query.getSelectionCriteria() != null) {
// For bug 2612567, any query can have batch attributes, so the
// original selection criteria can be quite complex, with multiple
// builders (i.e. for parallel selects).
// Now uses cloneUsing(newBase) instead of rebuildOn(newBase).
subCriteria = query.getSelectionCriteria().cloneUsing(subBuilder).and(subCriteria);
}
subQuery.setSelectionCriteria(subCriteria);
batchSelectionCriteria = builder.exists(subQuery);
} else if (batchType == BatchFetchType.IN) {
// Using a IN with foreign key values (WHERE FK IN :QUERY_BATCH_PARAMETER)
batchSelectionCriteria = buildBatchCriteria(builder, query);
} else {
// For 2729729 must clone the original selection criteria first,
// otherwise the original query will be corrupted.
if (query.getSelectionCriteria() != null) {
originalSelectionCriteria = query.getSelectionCriteria().copiedVersionFrom(clonedExpressions);
builder = originalSelectionCriteria.getBuilder();
}
// Using a join, (WHERE AND )
if (this.selectionQuery.isReadAllQuery()) {
batchSelectionCriteria = builder.twist(this.selectionQuery.getSelectionCriteria(), builder);
} else {
batchSelectionCriteria = builder.twist(this.selectionQuery.getSQLStatement().getWhereClause(), builder);
}
// For 2729729, rebuildOn is not needed as the base is still the same.
if (originalSelectionCriteria != null) {
batchSelectionCriteria = batchSelectionCriteria.and(originalSelectionCriteria);
}
if (descriptorToUse.getQueryManager().getAdditionalJoinExpression() != null) {
batchSelectionCriteria = batchSelectionCriteria.and(query.getDescriptor().getQueryManager().getAdditionalJoinExpression().rebuildOn(builder));
}
if (this.historyPolicy != null) {
if (query.getSession().getAsOfClause() != null) {
builder.asOf(query.getSession().getAsOfClause());
} else if (builder.getAsOfClause() == null) {
builder.asOf(AsOfClause.NO_CLAUSE);
}
batchSelectionCriteria = batchSelectionCriteria.and(this.historyPolicy.additionalHistoryExpression(builder, builder));
}
}
SQLSelectStatement batchStatement = new SQLSelectStatement();
for (DatabaseField keyField : getReferenceKeyFields()) {
batchStatement.addField(builder.getTable(this.referenceTable).getField(keyField));
}
batchStatement.addField(builder.getTable(this.referenceTable).getField(this.directField));
batchStatement.setWhereClause(batchSelectionCriteria);
batchQuery.setSQLStatement(batchStatement);
this.containerPolicy.addAdditionalFieldsToQuery(batchQuery, getAdditionalFieldsBaseExpression(batchQuery));
batchStatement.normalize(query.getSession(), descriptorToUse, clonedExpressions);
return batchQuery;
}
/**
* INTERNAL:
* Clone and prepare the joined direct query.
* Since direct-collection does not build objects a nest query is not required.
*/
@Override
public ObjectLevelReadQuery prepareNestedJoins(JoinedAttributeManager joinManager, ObjectBuildingQuery baseQuery, AbstractSession session) {
return null;
}
/**
* INTERNAL:
* Return the value of the field from the row or a value holder on the query to obtain the object.
*/
@Override
protected Object valueFromRowInternalWithJoin(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, CacheKey parentCacheKey, AbstractSession executionSession, boolean isTargetProtected) throws DatabaseException {
ContainerPolicy policy = getContainerPolicy();
Object value = policy.containerInstance();
ObjectBuilder objectBuilder = this.descriptor.getObjectBuilder();
// Extract the primary key of the source object, to filter only the joined rows for that object.
Object sourceKey = objectBuilder.extractPrimaryKeyFromRow(row, executionSession);
// If the query was using joining, all of the result rows by primary key will have been computed.
List rows = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
// If no 1-m rows were fetch joined, then get the value normally,
// this can occur with pagination where the last row may not be complete.
if (rows == null) {
return valueFromRowInternal(row, joinManager, sourceQuery, executionSession);
}
int size = rows.size();
if(size > 0) {
// A set of direct values must be maintained to avoid duplicates from multiple 1-m joins.
Set directValues = new HashSet();
ArrayList directValuesList = null;
ArrayList targetRows = null;
boolean shouldAddAll = policy.shouldAddAll();
if(shouldAddAll) {
directValuesList = new ArrayList(size);
targetRows = new ArrayList(size);
}
Converter valueConverter = getValueConverter();
// indicates if collection contains null
boolean containsNull = false;
// For each rows, extract the target row and build the target object and add to the collection.
for (int index = 0; index < size; index++) {
AbstractRecord sourceRow = rows.get(index);
AbstractRecord targetRow = sourceRow;
// The field for many objects may be in the row,
// so build the subpartion of the row through the computed values in the query,
// this also helps the field indexing match.
targetRow = trimRowForJoin(targetRow, joinManager, executionSession);
// Partial object queries must select the primary key of the source and related objects.
// If the target joined rows in null (outerjoin) means an empty collection.
Object directValue = targetRow.get(this.directField);
if (directValue == null) {
if (size == 1) {
// A null direct value means an empty collection returned as nulls from an outerjoin.
return getIndirectionPolicy().valueFromRow(value);
} else {
containsNull = true;
}
}
// Only build/add the target object once, skip duplicates from multiple 1-m joins.
if (!directValues.contains(directValue)) {
directValues.add(directValue);
// Allow for value conversion.
if (valueConverter != null) {
directValue = valueConverter.convertDataValueToObjectValue(directValue, executionSession);
}
if (shouldAddAll) {
directValuesList.add(directValue);
targetRows.add(targetRow);
} else {
policy.addInto(directValue, value, executionSession, targetRow, sourceQuery, parentCacheKey, isTargetProtected);
}
}
}
if (shouldAddAll) {
// if collection contains a single element which is null then return an empty collection
if (!(containsNull && targetRows.size() == 1)) {
policy.addAll(directValuesList, value, executionSession, targetRows, sourceQuery, parentCacheKey, isTargetProtected);
}
} else {
// if collection contains a single element which is null then return an empty collection
if (containsNull && policy.sizeFor(value) == 1) {
policy.clear(value);
}
}
}
return getIndirectionPolicy().valueFromRow(value);
}
/**
* INTERNAL:
* Copy of the attribute of the object.
* This is NOT used for unit of work but for templatizing an object.
*/
@Override
public void buildCopy(Object copy, Object original, CopyGroup group) {
Object attributeValue = getRealCollectionAttributeValueFromObject(original, group.getSession());
attributeValue = getContainerPolicy().cloneFor(attributeValue);
// if value holder is used, then the value holder shared with original substituted for a new ValueHolder.
getIndirectionPolicy().reset(copy);
setRealAttributeValueInObject(copy, attributeValue);
}
/**
* INTERNAL:
* Clone the element, if necessary.
* DirectCollections hold on to objects that do not have Descriptors
* (e.g. int, String). These objects do not need to be cloned, unless they use a converter - they
* are immutable.
*/
@Override
public Object buildElementClone(Object element, Object parent, CacheKey parentCacheKey, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache) {
Object cloneValue = element;
if ((getValueConverter() != null) && getValueConverter().isMutable()) {
cloneValue = getValueConverter().convertDataValueToObjectValue(getValueConverter().convertObjectValueToDataValue(cloneValue, cloningSession), cloningSession);
}
return cloneValue;
}
/**
* INTERNAL:
* Verifies listOrderField's table: it must be reference table.
* Precondition: listOrderField != null.
*/
@Override
protected void buildListOrderField() {
if(this.listOrderField.hasTableName()) {
if(!getReferenceTable().equals(this.listOrderField.getTable())) {
throw DescriptorException.listOrderFieldTableIsWrong(this.getDescriptor(), this, this.listOrderField.getTable(), getReferenceTable());
}
} else {
this.listOrderField.setTable(getReferenceTable());
}
this.listOrderField = getDescriptor().buildField(this.listOrderField, getReferenceTable());
}
/**
* INTERNAL:
* Cascade perform delete through mappings that require the cascade
*/
@Override
public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
//as this mapping type references primitive objects this method does not apply
}
/**
* INTERNAL:
* Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
*/
@Override
public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
// as this mapping type references primitive objects this method does not apply
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
@Override
public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
//as this mapping type references primitive objects this method does not apply
}
/**
* INTERNAL:
* Cascade discover and persist new objects during commit.
*/
@Override
public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors) {
// Direct mappings do not require any cascading.
}
/**
* INTERNAL:
* The mapping clones itself to create deep copy.
*/
@Override
public Object clone() {
DirectCollectionMapping clone = (DirectCollectionMapping)super.clone();
clone.setSourceKeyFields(cloneFields(getSourceKeyFields()));
clone.setReferenceKeyFields(cloneFields(getReferenceKeyFields()));
if(this.changeSetDeleteQuery != null) {
clone.changeSetDeleteQuery = (ModifyQuery)this.changeSetDeleteQuery.clone();
}
// Bug 306075
if(this.changeSetDeleteNullQuery != null) {
clone.changeSetDeleteNullQuery = (ModifyQuery)this.changeSetDeleteNullQuery.clone();
}
if(this.deleteAtIndexQuery != null) {
clone.deleteAtIndexQuery = (ModifyQuery)this.deleteAtIndexQuery.clone();
}
if(this.updateAtIndexQuery != null) {
clone.updateAtIndexQuery = (ModifyQuery)this.updateAtIndexQuery.clone();
}
return clone;
}
/**
* INTERNAL:
* This method is used to calculate the differences between two collections.
*/
@Override
public void compareCollectionsForChange(Object oldCollection, Object newCollection, ChangeRecord changeRecord, AbstractSession session) {
if(this.listOrderField != null) {
compareListsForChange((List)oldCollection, (List)newCollection, changeRecord, session);
return;
}
ContainerPolicy cp = getContainerPolicy();
int numberOfNewNulls = 0;
HashMap originalKeyValues = new HashMap(10);
HashMap cloneKeyValues = new HashMap(10);
if (oldCollection != null) {
Object backUpIter = cp.iteratorFor(oldCollection);
while (cp.hasNext(backUpIter)) {// Make a lookup of the objects
Object secondObject = cp.next(backUpIter, session);
// For CR#2258/CR#2378 handle null values inserted in a collection.
if (secondObject == null) {
numberOfNewNulls--;
} else {
Integer count = (Integer)originalKeyValues.get(secondObject);
if (count == null) {
originalKeyValues.put(secondObject, Integer.valueOf(1));
} else {
originalKeyValues.put(secondObject, Integer.valueOf(count.intValue() + 1));
}
}
}
}
// should a removal occur this is the original count of objects on the database.
// this value is used to determine how many objects to re-insert after the delete as a
// delete will delete all of the objects not just one.
HashMap databaseCount = (HashMap)originalKeyValues.clone();
int databaseNullCount = Math.abs(numberOfNewNulls);
if (newCollection != null) {
Object cloneIter = cp.iteratorFor(newCollection);
/* The following code is used to compare objects in a direct collection.
Because objects in a direct collection are primitives and may be the same object
the following code must count the number of instances in the collection not just the
existence of an object.
*/
while (cp.hasNext(cloneIter)) {//Compare them with the objects from the clone
Object firstObject = cp.next(cloneIter, session);
// For CR#2258/CR#2378 handle null values inserted in a collection.
if (firstObject == null) {
numberOfNewNulls++;
} else {
Integer count = (Integer)originalKeyValues.get(firstObject);
if (count == null) {//the object was not in the backup
Integer cloneCount = (Integer)cloneKeyValues.get(firstObject);
//Add it to the additions hashtable
if (cloneCount == null) {
cloneKeyValues.put(firstObject, Integer.valueOf(1));
} else {
cloneKeyValues.put(firstObject, Integer.valueOf(cloneCount.intValue() + 1));
}
} else if (count.intValue() == 1) {
//There is only one object so remove the whole reference
originalKeyValues.remove(firstObject);
} else {
originalKeyValues.put(firstObject, Integer.valueOf(count.intValue() - 1));
}
}
}
}
if (cloneKeyValues.isEmpty() && originalKeyValues.isEmpty() && (numberOfNewNulls == 0) && (!changeRecord.getOwner().isNew())) {
return;
}
((DirectCollectionChangeRecord)changeRecord).clearChanges();
((DirectCollectionChangeRecord)changeRecord).addAdditionChange(cloneKeyValues, databaseCount);
((DirectCollectionChangeRecord)changeRecord).addRemoveChange(originalKeyValues, databaseCount);
((DirectCollectionChangeRecord)changeRecord).setIsDeferred(false);
((DirectCollectionChangeRecord)changeRecord).setLatestCollection(null);
//For CR#2258, produce a changeRecord which reflects the addition and removal of null values.
if (numberOfNewNulls != 0) {
((DirectCollectionChangeRecord)changeRecord).getCommitAddMap().put(null, Integer.valueOf(databaseNullCount));
if (numberOfNewNulls > 0) {
((DirectCollectionChangeRecord)changeRecord).addAdditionChange(null, Integer.valueOf(numberOfNewNulls));
} else {
numberOfNewNulls *= -1;
((DirectCollectionChangeRecord)changeRecord).addRemoveChange(null, Integer.valueOf(numberOfNewNulls));
}
}
}
/**
* INTERNAL:
* This method is used to calculate the differences between two Lists.
*/
public void compareListsForChange(List oldList, List newList, ChangeRecord changeRecord, AbstractSession session) {
// Maps objects (null included) in newList and oldList to an array of two Sets:
// the first one contains indexes of the object in oldList, the second - in newList.
// Contains only the objects for which the set of indexes in newList and oldList are different;
// only changed indexes appear in the sets (therefore the old index set and new index set don't intersect).
// Examples:
// obj was first (index 0) in oldList; first and second (indexes 0 and 1)in newList: obj -> {{}, {1}};
// obj was not in oldList; first in newList: obj -> {null, {0}};
// obj was first in oldList; not in newList: obj -> {{0}, null};
// obj was first and second in oldList; first in newList: obj -> {{1}, {}};
// Note the difference between null and empty set:
// empty set means there's at least one index (the same in oldList and newList - otherwise it would've been in the set);
// null means there's no indexes.
// That helps during deletion - if we know there is no remaining duplicates for the object to be removed
// we can delete it without checking its index (which allows delete several duplicates in one sql).
// Map entry sets with no new and no old indexes removed.
HashMap changedIndexes = new HashMap(Math.max(oldList.size(), newList.size()));
int nOldSize = 0;
// for each object in oldList insert all its indexes in oldList into the old indexes set corresponding to each object.
if (oldList != null) {
nOldSize = oldList.size();
for(int i=0; i < nOldSize; i++) {
Object obj = oldList.get(i);
Set[] indexes = (Set[])changedIndexes.get(obj);
if (indexes == null) {
// the first index found for the object.
indexes = new Set[]{new HashSet(), null};
changedIndexes.put(obj, indexes);
}
indexes[0].add(i);
}
}
// helper set to store objects for which entries into changedIndexes has been removed:
// if an entry for the object is created again, it will have an empty old indexes set (rather than null)
// to indicate that the object has been on the oldList, too.
HashSet removedFromChangedIndexes = new HashSet();
HashSet dummySet = new HashSet(0);
// for each object in newList, for each its index in newList:
// if the object has the same index in oldList - remove the index from old indexes set;
// if the object doesn't have the same index in oldList - insert the index into new indexes set.
int nNewSize = 0;
if (newList != null) {
nNewSize = newList.size();
for(int i=0; i < nNewSize; i++) {
Object obj = newList.get(i);
Set[] indexes = (Set[])changedIndexes.get(obj);
if (indexes == null) {
// the first index found for the object - or was found and removed before.
if(removedFromChangedIndexes.contains(obj)) {
// the object also exists in oldList
indexes = new Set[]{dummySet, new HashSet()};
} else {
// the object does not exist in oldList
indexes = new Set[]{null, new HashSet()};
}
changedIndexes.put(obj, indexes);
// the object doesn't have this index in oldList - add the index to new indexes set.
indexes[1].add(i);
} else {
if(indexes[0] == null || !indexes[0].contains(i)) {
// the object doesn't have this index in oldList - add the index to new indexes set.
if(indexes[1] == null) {
indexes[1] = new HashSet();
}
indexes[1].add(i);
} else {
// the object has this index in oldList - remove the index from the old indexes set.
indexes[0].remove(i);
if(indexes[0].isEmpty()) {
// no old indexes left for the object.
if(indexes[1] == null || indexes[1].isEmpty()) {
// no new indexes left, too - remove the entry for the object.
changedIndexes.remove(obj);
// store the object in case it has another index on newList
removedFromChangedIndexes.add(obj);
}
}
}
}
}
}
((DirectCollectionChangeRecord)changeRecord).setChangedIndexes(changedIndexes);
((DirectCollectionChangeRecord)changeRecord).setOldSize(nOldSize);
((DirectCollectionChangeRecord)changeRecord).setNewSize(nNewSize);
}
/**
* INTERNAL:
* This method compares the changes between two direct collections. Comparisons are made on equality
* not identity.
*/
@Override
public ChangeRecord compareForChange(Object clone, Object backUp, ObjectChangeSet owner, AbstractSession session) {
Object cloneAttribute = getAttributeValueFromObject(clone);
Object backUpAttribute = null;
if ((cloneAttribute != null) && (!getIndirectionPolicy().objectIsInstantiated(cloneAttribute))) {
return null;
}
Object cloneObjectCollection = getRealCollectionAttributeValueFromObject(clone, session);
Object backUpCollection = null;
if (!owner.isNew()) {
backUpAttribute = getAttributeValueFromObject(backUp);
if ((backUpAttribute == null) && (cloneAttribute == null)) {
return null;
}
backUpCollection = getRealCollectionAttributeValueFromObject(backUp, session);
}
DirectCollectionChangeRecord changeRecord = new DirectCollectionChangeRecord(owner);
changeRecord.setAttribute(getAttributeName());
changeRecord.setMapping(this);
if(this.listOrderField != null) {
changeRecord.setLatestCollection(cloneObjectCollection);
}
compareCollectionsForChange(backUpCollection, cloneObjectCollection, changeRecord, session);
if (changeRecord.hasChanges()) {
changeRecord.setOriginalCollection(backUpCollection);
return changeRecord;
}
return null;
}
/**
* INTERNAL:
* Compare the attributes belonging to this mapping for the objects.
*/
@Override
public boolean compareObjects(Object firstObject, Object secondObject, AbstractSession session) {
Object firstCollection = getRealCollectionAttributeValueFromObject(firstObject, session);
Object secondCollection = getRealCollectionAttributeValueFromObject(secondObject, session);
if(this.listOrderField != null) {
return compareLists((List)firstCollection, (List)secondCollection);
}
ContainerPolicy containerPolicy = getContainerPolicy();
if (containerPolicy.sizeFor(firstCollection) != containerPolicy.sizeFor(secondCollection)) {
return false;
}
HashMap firstCounter = new HashMap();
HashMap secondCounter = new HashMap();
for (Object iter = containerPolicy.iteratorFor(firstCollection);
containerPolicy.hasNext(iter);) {
Object object = containerPolicy.next(iter, session);
if (firstCounter.containsKey(object)) {
int count = ((Integer)firstCounter.get(object)).intValue();
firstCounter.put(object, Integer.valueOf(++count));
} else {
firstCounter.put(object, Integer.valueOf(1));
}
}
for (Object iter = containerPolicy.iteratorFor(secondCollection);
containerPolicy.hasNext(iter);) {
Object object = containerPolicy.next(iter, session);
if (secondCounter.containsKey(object)) {
int count = ((Integer)secondCounter.get(object)).intValue();
secondCounter.put(object, Integer.valueOf(++count));
} else {
secondCounter.put(object, Integer.valueOf(1));
}
}
for (Iterator iterator = firstCounter.keySet().iterator(); iterator.hasNext();) {
Object object = iterator.next();
if (!secondCounter.containsKey(object) || (((Integer)secondCounter.get(object)).intValue() != ((Integer)firstCounter.get(object)).intValue())) {
// containsKey(object) will fail when the objects are arrays.
boolean found = false;
for (Iterator ii = secondCounter.keySet().iterator(); ii.hasNext();) {
Object otherObject = ii.next();
if(object == otherObject) {
found = true;
} else if(object == null || otherObject == null) {
found = false;
} else {
found = Helper.comparePotentialArrays(object, otherObject);
}
if (found) {
iterator.remove();
secondCounter.remove(otherObject);
break;
}
}
if (!found) {
return false;
}
} else {
iterator.remove();
secondCounter.remove(object);
}
}
if (!firstCounter.isEmpty() || !secondCounter.isEmpty()) {
return false;
}
return true;
}
/**
* Compare two lists. For equality the order of the elements should be the same.
* Used only if listOrderField != null
*/
protected boolean compareLists(List firstList, List secondList) {
if (firstList.size() != secondList.size()) {
return false;
}
int size = firstList.size();
for(int i=0; i < size; i++) {
Object firstObject = firstList.get(i);
Object secondObject = secondList.get(i);
if(firstObject != secondObject) {
if(firstObject==null || secondObject==null) {
return false;
} else {
if(!firstObject.equals(secondObject)) {
return false;
}
}
}
}
return true;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this mapping to actual class-based
* settings
* This method is implemented by subclasses as necessary.
* @param classLoader
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader) {
super.convertClassNamesToClasses(classLoader);
// Tell the direct field to convert any class names (type name).
directField.convertClassNamesToClasses(classLoader);
// Convert and any Converter class names.
convertConverterClassNamesToClasses(valueConverter, classLoader);
// Instantiate any custom converter class
if (valueConverterClassName != null) {
Class valueConverterClass;
Converter valueConverter;
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
valueConverterClass = (Class) AccessController.doPrivileged(new PrivilegedClassForName(valueConverterClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(valueConverterClassName, exception.getException());
}
try {
valueConverter = (Converter) AccessController.doPrivileged(new PrivilegedNewInstanceFromClass(valueConverterClass));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(valueConverterClassName, exception.getException());
}
} else {
valueConverterClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(valueConverterClassName, true, classLoader);
valueConverter = (Converter) org.eclipse.persistence.internal.security.PrivilegedAccessHelper.newInstanceFromClass(valueConverterClass);
}
} catch (ClassNotFoundException exc) {
throw ValidationException.classNotFoundWhileConvertingClassNames(valueConverterClassName, exc);
} catch (Exception e) {
// Catches IllegalAccessException and InstantiationException
throw ValidationException.classNotFoundWhileConvertingClassNames(valueConverterClassName, e);
}
setValueConverter(valueConverter);
}
// Check if the attribute classification is set (either directly or through a type conversion converter)
if (attributeClassification == null) {
// Look for an attribute classification name
if (attributeClassificationName != null) {
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
try {
attributeClassification = (Class) AccessController.doPrivileged(new PrivilegedClassForName(attributeClassificationName, true, classLoader));
} catch (PrivilegedActionException pae) {
throw ValidationException.classNotFoundWhileConvertingClassNames(attributeClassificationName, pae.getException());
}
} else {
attributeClassification = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(attributeClassificationName, true, classLoader);
}
} catch (Exception exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(attributeClassificationName, exception);
}
} else {
// Still nothing, default to the type from the direct field.
attributeClassification = getDirectField().getType();
}
}
}
/**
* INTERNAL:
* Extract the source primary key value from the reference direct row.
* Used for batch reading, most following same order and fields as in the mapping.
*/
@Override
protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
int size = this.referenceKeyFields.size();
Object[] key = new Object[size];
ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
for (int index = 0; index < size; index++) {
DatabaseField relationField = this.referenceKeyFields.get(index);
DatabaseField sourceField = this.sourceKeyFields.get(index);
Object value = row.get(relationField);
// Must ensure the classification gets a cache hit.
try {
value = conversionManager.convertObject(value, sourceField.getType());
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
}
key[index] = value;
}
return new CacheId(key);
}
/**
* INTERNAL:
* Extract the primary key value from the source row.
* Used for batch reading, most following same order and fields as in the mapping.
*/
@Override
protected Object extractBatchKeyFromRow(AbstractRecord row, AbstractSession session) {
int size = this.sourceKeyFields.size();
Object[] key = new Object[size];
ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
for (int index = 0; index < size; index++) {
DatabaseField field = this.sourceKeyFields.get(index);
Object value = row.get(field);
// Must ensure the classification to get a cache hit.
try {
value = conversionManager.convertObject(value, field.getType());
} catch (ConversionException exception) {
throw ConversionException.couldNotBeConverted(this, this.descriptor, exception);
}
key[index] = value;
}
return new CacheId(key);
}
/**
* INTERNAL:
* Return the selection criteria used to IN batch fetching.
*/
@Override
protected Expression buildBatchCriteria(ExpressionBuilder builder, ObjectLevelReadQuery query) {
int size = this.referenceKeyFields.size();
Expression table = builder.getTable(this.referenceTable);
if (size > 1) {
// Support composite keys using nested IN.
List fields = new ArrayList(size);
for (DatabaseField referenceKeyField : this.referenceKeyFields) {
fields.add(table.getField(referenceKeyField));
}
return query.getSession().getPlatform().buildBatchCriteriaForComplexId(builder, fields);
} else {
return query.getSession().getPlatform().buildBatchCriteria(builder, table.getField(this.referenceKeyFields.get(0)));
}
}
/**
* INTERNAL:
* Prepare and execute the batch query and store the
* results for each source object in a map keyed by the
* mappings source keys of the source objects.
*/
@Override
protected void executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceDataByKey, AbstractSession session, AbstractRecord translationRow) {
// Execute query and index resulting object sets by key.
List rows = (List)session.executeQuery(query, translationRow);
int size = rows.size();
if (this.containerPolicy.shouldAddAll()) {
if (size > 0) {
Map referenceDataAndRowsByKey = new HashMap();
for (int index = 0; index < size; index++) {
AbstractRecord referenceRow = rows.get(index);
Object referenceValue = referenceRow.get(this.directField);
Object eachReferenceKey = extractKeyFromTargetRow(referenceRow, session);
// Allow for value conversion.
if (this.valueConverter != null) {
referenceValue = this.valueConverter.convertDataValueToObjectValue(referenceValue, query.getSession());
}
List[] valuesAndRows = referenceDataAndRowsByKey.get(eachReferenceKey);
if (valuesAndRows == null) {
valuesAndRows = new List[]{new ArrayList(), new ArrayList()};
referenceDataAndRowsByKey.put(eachReferenceKey, valuesAndRows);
}
valuesAndRows[0].add(referenceValue);
valuesAndRows[1].add(referenceRow);
}
Iterator> iterator = referenceDataAndRowsByKey.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = iterator.next();
Object eachReferenceKey = entry.getKey();
List referenceValues = entry.getValue()[0];
List referenceRows = entry.getValue()[1];
Object container = this.containerPolicy.containerInstance(referenceValues.size());
this.containerPolicy.addAll(referenceValues, container, query.getSession(), referenceRows, (DataReadQuery)query, parentCacheKey, true);
referenceDataByKey.put(eachReferenceKey, container);
}
}
} else {
for (int index = 0; index < size; index++) {
AbstractRecord referenceRow = rows.get(index);
Object referenceValue = referenceRow.get(this.directField);
Object eachReferenceKey = extractKeyFromTargetRow(referenceRow, session);
Object container = referenceDataByKey.get(eachReferenceKey);
if ((container == null) || (container == Helper.NULL_VALUE)) {
container = this.containerPolicy.containerInstance();
referenceDataByKey.put(eachReferenceKey, container);
}
// Allow for value conversion.
if (this.valueConverter != null) {
referenceValue = this.valueConverter.convertDataValueToObjectValue(referenceValue, query.getSession());
}
this.containerPolicy.addInto(referenceValue, container, query.getSession());
}
}
}
/**
* INTERNAL:
* At this point, we realize we don't have indirection;
* so we need to replace the reference object(s) with
* the corresponding object(s) from the remote session.
*
* The reference objects for a DirectCollectionMapping
* are primitives, so they do not need to be replaced.
*/
@Override
public void fixRealObjectReferences(Object object, Map objectInformation, Map processedObjects, ObjectLevelReadQuery query, DistributedSession session) {
// do nothing
}
/**
* PUBLIC:
* Some databases do not properly support all of the base data types. For these databases,
* the base data type must be explicitly specified in the mapping to tell EclipseLink to force
* the instance variable value to that data type.
* @since Java Persistence API 2.0
*/
public Class getAttributeClassification() {
return attributeClassification;
}
/**
* INTERNAL:
* Return the class name of the attribute type.
* This is only used by the MW.
* @since Java Persistence API 2.0
*/
public String getAttributeClassificationName() {
if ((null == attributeClassificationName) && (attributeClassification != null)) {
attributeClassificationName = attributeClassification.getName();
}
return attributeClassificationName;
}
protected ModifyQuery getDeleteQuery() {
if (changeSetDeleteQuery == null) {
changeSetDeleteQuery = new DataModifyQuery();
}
return changeSetDeleteQuery;
}
// Bug 306075
protected ModifyQuery getDeleteNullQuery() {
if (changeSetDeleteNullQuery == null) {
changeSetDeleteNullQuery = new DataModifyQuery();
}
return changeSetDeleteNullQuery;
}
protected ModifyQuery getDeleteAtIndexQuery() {
if (deleteAtIndexQuery == null) {
deleteAtIndexQuery = new DataModifyQuery();
}
return deleteAtIndexQuery;
}
protected ModifyQuery getUpdateAtIndexQuery() {
if (updateAtIndexQuery == null) {
updateAtIndexQuery = new DataModifyQuery();
}
return updateAtIndexQuery;
}
/**
* INTERNAL:
* Returns the set of fields that should be selected to build this mapping's value(s).
* This is used by expressions to determine which fields to include in the select clause for non-object expressions.
*/
@Override
public Vector getSelectFields() {
Vector fields = new NonSynchronizedVector(2);
fields.add(getDirectField());
return fields;
}
/**
* INTERNAL:
* Returns the table(s) that should be selected to build this mapping's value(s).
* This is used by expressions to determine which tables to include in the from clause for non-object expressions.
*/
@Override
public Vector getSelectTables() {
Vector tables = new NonSynchronizedVector(0);
tables.add(getReferenceTable());
return tables;
}
/**
* INTERNAL:
* Return the direct field.
* This is the field in the direct table to store the values.
*/
public DatabaseField getDirectField() {
return directField;
}
/**
* PUBLIC:
* Returns the name of the field name in the reference table.
*/
public String getDirectFieldName() {
if (getDirectField() == null) {
return null;
}
return getDirectField().getQualifiedName();
}
protected DataModifyQuery getInsertQuery() {
return insertQuery;
}
/**
* INTERNAL:
* Returns the join criteria stored in the mapping selection query. This criteria
* is used to read reference objects across the tables from the database.
*/
@Override
public Expression getJoinCriteria(ObjectExpression context, Expression base) {
if (getHistoryPolicy() != null) {
Expression result = super.getJoinCriteria(context, base);
Expression historyCriteria = getHistoryPolicy().additionalHistoryExpression(context, base);
if (result != null) {
return result.and(historyCriteria);
} else if (historyCriteria != null) {
return historyCriteria;
} else {
return null;
}
} else {
return super.getJoinCriteria(context, base);
}
}
/**
* INTERNAL:
* return the object on the client corresponding to the specified object.
* DirectCollections do not have to worry about
* maintaining object identity.
*/
@Override
public Object getObjectCorrespondingTo(Object object, DistributedSession session, Map objectDescriptors, Map processedObjects, ObjectLevelReadQuery query) {
return object;
}
/**
* PUBLIC:
* Return the order by expression.
*/
public List getOrderByExpressions() {
return orderByExpressions;
}
/**
* PUBLIC:
* Allow history support on the reference table.
*/
public HistoryPolicy getHistoryPolicy() {
return historyPolicy;
}
/**
* INTERNAL:
* Get the container policy from the selection query for this mapping.
*/
@Override
protected ContainerPolicy getSelectionQueryContainerPolicy() {
return ((DataReadQuery) getSelectionQuery()).getContainerPolicy();
}
/**
* INTERNAL:
* This cannot be used with direct collection mappings.
*/
@Override
public Class getReferenceClass() {
return null;
}
@Override
public String getReferenceClassName() {
return null;
}
/**
* INTERNAL:
* There is none on direct collection.
*/
@Override
public ClassDescriptor getReferenceDescriptor() {
return null;
}
/**
* INTERNAL:
* Return the reference key field names associated with the mapping.
* These are in-order with the sourceKeyFieldNames.
*/
public Vector getReferenceKeyFieldNames() {
Vector fieldNames = new Vector(getReferenceKeyFields().size());
for (Enumeration fieldsEnum = getReferenceKeyFields().elements();
fieldsEnum.hasMoreElements();) {
fieldNames.addElement(((DatabaseField)fieldsEnum.nextElement()).getQualifiedName());
}
return fieldNames;
}
/**
* INTERNAL:
* Return the reference key fields.
*/
public Vector getReferenceKeyFields() {
return referenceKeyFields;
}
/**
* INTERNAL:
* Return the direct table.
* This is the table to store the values.
*/
public DatabaseTable getReferenceTable() {
return referenceTable;
}
/**
* PUBLIC:
* Returns the name of the reference table
*/
public String getReferenceTableName() {
if (getReferenceTable() == null) {
return null;
}
return getReferenceTable().getName();
}
//This method is added to include table qualifier.
/**
* PUBLIC:
* Returns the qualified name of the reference table.
*/
public String getReferenceTableQualifiedName() {//CR#2407
if (getReferenceTable() == null) {
return null;
}
return getReferenceTable().getQualifiedName();
}
/**
* INTERNAL:
* Return the relationshipPartner mapping for this bi-directional mapping. If the relationshipPartner is null then
* this is a uni-directional mapping.
* DirectCollectionMapping can not be part of a bi-directional mapping
*/
@Override
public DatabaseMapping getRelationshipPartner() {
return null;
}
/**
* PUBLIC:
* Return the source key field names associated with the mapping.
* These are in-order with the referenceKeyFieldNames.
*/
public Vector getSourceKeyFieldNames() {
Vector fieldNames = new Vector(getSourceKeyFields().size());
for (Enumeration fieldsEnum = getSourceKeyFields().elements();
fieldsEnum.hasMoreElements();) {
fieldNames.addElement(((DatabaseField)fieldsEnum.nextElement()).getQualifiedName());
}
return fieldNames;
}
/**
* INTERNAL:
* Return the source key fields.
*/
public Vector getSourceKeyFields() {
return sourceKeyFields;
}
protected boolean hasCustomDeleteQuery() {
return hasCustomDeleteQuery;
}
protected boolean hasCustomInsertQuery() {
return hasCustomInsertQuery;
}
protected boolean hasCustomDeleteAtIndexQuery() {
return hasCustomDeleteAtIndexQuery;
}
protected boolean hasCustomUpdateAtIndexQuery() {
return hasCustomUpdateAtIndexQuery;
}
/**
* INTERNAL:
* Indicates whether the mapping (or at least one of its nested mappings, at any nested depth)
* references an entity.
* To return true the mapping (or nested mapping) should be ForeignReferenceMapping with non-null and non-aggregate reference descriptor.
*/
@Override
public boolean hasNestedIdentityReference() {
return false;
}
/**
* INTERNAL:
* Initialize and validate the mapping properties.
*/
@Override
public void initialize(AbstractSession session) throws DescriptorException {
if (session.hasBroker()) {
if (getInsertQuery().hasSessionName()) {
// substitute session that owns the mapping for the session that owns reference table.
session = session.getBroker().getSessionForName(getInsertQuery().getSessionName());
}
}
if (isKeyForSourceSpecified()) {
initializeSourceKeys(session);
} else {
initializeSourceKeysWithDefaults(session);
}
initializeReferenceTable(session);
initializeReferenceKeys(session);
initializeDirectField(session);
if (getReferenceTable().getName().indexOf(' ') != -1) {
//table names contains a space so needs to be quoted.
String beginQuote = ((DatasourcePlatform)session.getDatasourcePlatform()).getStartDelimiter();
String endQuote = ((DatasourcePlatform)session.getDatasourcePlatform()).getEndDelimiter();
//Ensure this tablename hasn't already been quoted.
if (getReferenceTable().getName().indexOf(beginQuote) == -1) {
getReferenceTable().setName(beginQuote + getReferenceTable().getName() + endQuote);
}
}
if (this.listOrderField != null) {
this.initializeListOrderField(session);
}
getContainerPolicy().initialize(session, this.referenceTable);
// Initialize the value converter sooner since it likely will finish
// configuring field and attribute classifications.
if (getValueConverter() != null) {
getValueConverter().initialize(this, session);
}
if (!hasCustomSelectionQuery()){
initOrRebuildSelectQuery();
getSelectionQuery().setName(getAttributeName());
if (shouldInitializeSelectionCriteria()) {
initializeSelectionCriteria(session);
initializeSelectionStatement(session);
}
}
if (!getSelectionQuery().hasSessionName()) {
getSelectionQuery().setSessionName(session.getName());
}
if (getSelectionQuery().getPartitioningPolicy() == null) {
getSelectionQuery().setPartitioningPolicy(getPartitioningPolicy());
}
getSelectionQuery().setSourceMapping(this);
if ((getValueConverter() != null) && (getSelectionQuery() instanceof DirectReadQuery)) {
((DirectReadQuery)getSelectionQuery()).setValueConverter(getValueConverter());
}
initializeDeleteAllQuery(session);
initializeDeleteQuery(session);
initializeDeleteNullQuery(session); // Bug 306075
initializeInsertQuery(session);
initializeDeleteAtIndexQuery(session);
initializeUpdateAtIndexQuery(session);
if (getHistoryPolicy() != null) {
getHistoryPolicy().initialize(session);
}
super.initialize(session);
}
/**
* INTERNAL:
* Initializes listOrderField.
* Precondition: listOrderField != null.
*/
@Override
protected void initializeListOrderField(AbstractSession session) {
// This method is called twice. The second call (by CollectionMapping.initialize) should be ignored because initialization has been already done.
if(!getContainerPolicy().isOrderedListPolicy() || ((OrderedListContainerPolicy)getContainerPolicy()).getListOrderField() == null) {
super.initializeListOrderField(session);
}
}
/**
* Initialize delete all query. This query is used to delete the collection of objects from the
* reference table.
*/
protected void initializeDeleteAllQuery(AbstractSession session) {
if (!getDeleteAllQuery().hasSessionName()) {
getDeleteAllQuery().setSessionName(session.getName());
}
if (getDeleteAllQuery().getPartitioningPolicy() == null) {
getDeleteAllQuery().setPartitioningPolicy(getPartitioningPolicy());
}
if (hasCustomDeleteAllQuery()) {
return;
}
Expression expression = null;
Expression subExp1;
Expression subExp2;
Expression subExpression;
Expression builder = new ExpressionBuilder();
SQLDeleteStatement statement = new SQLDeleteStatement();
// Construct an expression to delete from the relation table.
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().elementAt(index);
DatabaseField sourceKey = getSourceKeyFields().elementAt(index);
subExp1 = builder.getField(referenceKey);
subExp2 = builder.getParameter(sourceKey);
subExpression = subExp1.equal(subExp2);
if (expression == null) {
expression = subExpression;
} else {
expression = expression.and(subExpression);
}
}
statement.setWhereClause(expression);
statement.setTable(getReferenceTable());
getDeleteAllQuery().setSQLStatement(statement);
}
protected void initializeDeleteQuery(AbstractSession session) {
if (!getDeleteQuery().hasSessionName()) {
getDeleteQuery().setSessionName(session.getName());
}
if (getDeleteQuery().getPartitioningPolicy() == null) {
getDeleteQuery().setPartitioningPolicy(getPartitioningPolicy());
}
if (hasCustomDeleteQuery()) {
return;
}
SQLDeleteStatement statement = new SQLDeleteStatement();
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = createWhereClauseForDeleteQuery(builder);
statement.setWhereClause(expression);
statement.setTable(getReferenceTable());
getDeleteQuery().setSQLStatement(statement);
}
// Bug 306075 - for deleting a null value from a collection
protected void initializeDeleteNullQuery(AbstractSession session) {
if (!getDeleteNullQuery().hasSessionName()) {
getDeleteNullQuery().setSessionName(session.getName());
}
if (getDeleteNullQuery().getPartitioningPolicy() == null) {
getDeleteNullQuery().setPartitioningPolicy(getPartitioningPolicy());
}
SQLDeleteStatement statement = new SQLDeleteStatement();
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = createWhereClauseForDeleteNullQuery(builder);
statement.setWhereClause(expression);
statement.setTable(getReferenceTable());
getDeleteNullQuery().setSQLStatement(statement);
}
protected void initializeDeleteAtIndexQuery(AbstractSession session) {
if (!getDeleteAtIndexQuery().hasSessionName()) {
getDeleteAtIndexQuery().setSessionName(session.getName());
}
if (getDeleteAtIndexQuery().getPartitioningPolicy() == null) {
getDeleteAtIndexQuery().setPartitioningPolicy(getPartitioningPolicy());
}
if (hasCustomDeleteAtIndexQuery()) {
return;
}
SQLDeleteStatement statement = new SQLDeleteStatement();
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = createWhereClauseForDeleteQuery(builder);
expression = expression.and(builder.getField(this.listOrderField).equal(builder.getParameter(this.listOrderField)));
statement.setWhereClause(expression);
statement.setTable(getReferenceTable());
getDeleteAtIndexQuery().setSQLStatement(statement);
}
protected void initializeUpdateAtIndexQuery(AbstractSession session) {
if (!getUpdateAtIndexQuery().hasSessionName()) {
getUpdateAtIndexQuery().setSessionName(session.getName());
}
if (getUpdateAtIndexQuery().getPartitioningPolicy() == null) {
getUpdateAtIndexQuery().setPartitioningPolicy(getPartitioningPolicy());
}
if (hasCustomUpdateAtIndexQuery()) {
return;
}
SQLUpdateStatement statement = new SQLUpdateStatement();
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = createWhereClauseForDeleteQuery(builder);
expression = expression.and(builder.getField(this.listOrderField).equal(builder.getParameter(this.listOrderField)));
statement.setWhereClause(expression);
statement.setTable(getReferenceTable());
AbstractRecord modifyRow = new DatabaseRecord();
modifyRow.add(this.listOrderField, null);
statement.setModifyRow(modifyRow);
getUpdateAtIndexQuery().setSQLStatement(statement);
}
/**
* INTERNAL:
* Indicates whether getListOrderFieldExpression method should create field expression on table expression.
*/
@Override
public boolean shouldUseListOrderFieldTableExpression() {
return true;
}
protected Expression createWhereClauseForDeleteQuery(ExpressionBuilder builder) {
Expression directExp = builder.getField(getDirectField()).equal(builder.getParameter(getDirectField()));
Expression expression = null;
// Construct an expression to delete from the relation table.
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Expression subExp1 = builder.getField(referenceKey);
Expression subExp2 = builder.getParameter(sourceKey);
Expression subExpression = subExp1.equal(subExp2);
expression = subExpression.and(expression);
}
expression = expression.and(directExp);
return expression;
}
// Bug 306075 - for deleting a null value from a collection
protected Expression createWhereClauseForDeleteNullQuery(ExpressionBuilder builder) {
Expression directExp = builder.getField(getDirectField()).isNull();
Expression expression = null;
// Construct an expression to delete from the relation table.
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Expression subExp1 = builder.getField(referenceKey);
Expression subExp2 = builder.getParameter(sourceKey);
Expression subExpression = subExp1.equal(subExp2);
expression = subExpression.and(expression);
}
expression = expression.and(directExp);
return expression;
}
/**
* The field name on the reference table is initialized and cached.
*/
protected void initializeDirectField(AbstractSession session) throws DescriptorException {
if (getDirectField() == null) {
throw DescriptorException.directFieldNameNotSet(this);
}
getDirectField().setTable(getReferenceTable());
getDirectField().setIndex(0);
}
/**
* Initialize insert query. This query is used to insert the collection of objects into the
* reference table.
*/
protected void initializeInsertQuery(AbstractSession session) {
if (!getInsertQuery().hasSessionName()) {
getInsertQuery().setSessionName(session.getName());
}
if (getInsertQuery().getPartitioningPolicy() == null) {
getInsertQuery().setPartitioningPolicy(getPartitioningPolicy());
}
if (hasCustomInsertQuery()) {
return;
}
SQLInsertStatement statement = new SQLInsertStatement();
statement.setTable(getReferenceTable());
AbstractRecord directRow = new DatabaseRecord();
for (Enumeration referenceEnum = getReferenceKeyFields().elements();
referenceEnum.hasMoreElements();) {
directRow.put((DatabaseField)referenceEnum.nextElement(), null);
}
directRow.put(getDirectField(), null);
if(listOrderField != null) {
directRow.put(listOrderField, null);
}
statement.setModifyRow(directRow);
getInsertQuery().setSQLStatement(statement);
getInsertQuery().setModifyRow(directRow);
}
/**
* There is no reference descriptor
*/
@Override
protected void initializeReferenceDescriptor(AbstractSession session) {
// no-op.
}
/**
* The reference keys on the reference table are initialized
*/
protected void initializeReferenceKeys(AbstractSession session) throws DescriptorException {
if (getReferenceKeyFields().size() == 0) {
throw DescriptorException.noReferenceKeyIsSpecified(this);
}
for (Enumeration referenceEnum = getReferenceKeyFields().elements(); referenceEnum.hasMoreElements();) {
DatabaseField field = (DatabaseField)referenceEnum.nextElement();
// Update the field first if the mapping is on a table per tenant entity.
if (getDescriptor().hasTablePerMultitenantPolicy()) {
field.setTable(((TablePerMultitenantPolicy) getDescriptor().getMultitenantPolicy()).getTable(field.getTable()));
}
if (field.hasTableName() && (!(field.getTableName().equals(getReferenceTable().getName())))) {
throw DescriptorException.referenceKeyFieldNotProperlySpecified(field, this);
}
field.setTable(getReferenceTable());
}
}
/**
* Set the table qualifier on the reference table if required
*/
protected void initializeReferenceTable(AbstractSession session) throws DescriptorException {
Platform platform = session.getDatasourcePlatform();
if (getReferenceTable() == null) {
throw DescriptorException.referenceTableNotSpecified(this);
}
if (platform.getTableQualifier().length() > 0) {
if (getReferenceTable().getTableQualifier().length() == 0) {
getReferenceTable().setTableQualifier(platform.getTableQualifier());
}
}
}
protected void initializeSelectionCriteria(AbstractSession session) {
Expression criteria = null;
ExpressionBuilder base = new ExpressionBuilder();
TableExpression table = (TableExpression)base.getTable(getReferenceTable());
Iterator referenceKeys = getReferenceKeyFields().iterator();
Iterator sourceKeys = getSourceKeyFields().iterator();
while (referenceKeys.hasNext()) {
DatabaseField referenceKey = referenceKeys.next();
DatabaseField sourceKey = sourceKeys.next();
Expression expression = table.getField(referenceKey).equal(base.getParameter(sourceKey));
if (criteria == null) {
criteria = expression;
} else {
criteria = expression.and(criteria);
}
}
setSelectionCriteria(criteria);
}
/**
* The selection query is initialized
*/
@Override
protected void initializeSelectionQuery(AbstractSession session) {
// Nothing required.
}
protected void initializeSelectionStatement(AbstractSession session) {
SQLSelectStatement statement = new SQLSelectStatement();
statement.addTable(getReferenceTable());
statement.addField(getDirectField().clone());
statement.setWhereClause(getSelectionCriteria());
statement.setOrderByExpressions(orderByExpressions);
getSelectionQuery().setSQLStatement(statement);
getContainerPolicy().addAdditionalFieldsToQuery(selectionQuery, getAdditionalFieldsBaseExpression(getSelectionQuery()));
statement.normalize(session, null);
}
/**
* The source keys are initialized
*/
protected void initializeSourceKeys(AbstractSession session) {
for (int index = 0; index < getSourceKeyFields().size(); index++) {
DatabaseField field = getDescriptor().buildField(getSourceKeyFields().get(index));
if (usesIndirection()) {
field.setKeepInRow(true);
}
getSourceKeyFields().set(index, field);
}
}
/**
* INTERNAL:
* If a user does not specify the source key then the primary keys of the source table are used.
*/
protected void initializeSourceKeysWithDefaults(AbstractSession session) {
List primaryKeyFields = getDescriptor().getPrimaryKeyFields();
for (int index = 0; index < primaryKeyFields.size(); index++) {
DatabaseField field = primaryKeyFields.get(index);
if (usesIndirection()) {
field.setKeepInRow(true);
}
getSourceKeyFields().addElement(field);
}
}
/**
* INTERNAL:
* Return the base expression to use for adding fields to the query.
* This is the reference table.
*/
@Override
protected Expression getAdditionalFieldsBaseExpression(ReadQuery query) {
if (query.isReadAllQuery()) {
return ((ReadAllQuery)query).getExpressionBuilder();
} else {
return ((DataReadQuery)query).getSQLStatement().getBuilder().getTable(getReferenceTable());
}
}
/**
* INTERNAL:
*/
@Override
public boolean isDirectCollectionMapping() {
return true;
}
/**
* INTERNAL:
*/
@Override
public boolean isElementCollectionMapping() {
return true;
}
/**
* INTERNAL:
* Return if this mapping support joining.
*/
@Override
public boolean isJoiningSupported() {
return true;
}
/**
* INTERNAL:
* Checks if source and target keys are mentioned by the user or not.
*/
protected boolean isKeyForSourceSpecified() {
return !getSourceKeyFields().isEmpty();
}
/**
* INTERNAL:
* Return whether this mapping should be traversed when we are locking
* @return
*/
public boolean isLockableMapping(){
return false;
}
/**
* INTERNAL:
*/
@Override
public boolean isOwned(){
return true;
}
/**
* INTERNAL:
* Iterate on the attribute value.
* The value holder has already been processed.
* PERF: Avoid iteration if not required.
*/
@Override
public void iterateOnRealAttributeValue(DescriptorIterator iterator, Object realAttributeValue) {
if (iterator.shouldIterateOnPrimitives()) {
super.iterateOnRealAttributeValue(iterator, realAttributeValue);
}
}
/**
* INTERNAL:
* Iterate on the specified element.
*/
@Override
public void iterateOnElement(DescriptorIterator iterator, Object element) {
iterator.iteratePrimitiveForMapping(element, this);
}
/**
* INTERNAL:
* Merge changes from the source to the target object.
* Because this is a collection mapping, values are added to or removed from the
* collection based on the changeset
*/
@Override
public void mergeChangesIntoObject(Object target, ChangeRecord changeRecord, Object source, MergeManager mergeManager, AbstractSession targetSession) {
if (this.descriptor.getCachePolicy().isProtectedIsolation()&& !this.isCacheable && !targetSession.isProtectedSession()){
setAttributeValueInObject(target, this.indirectionPolicy.buildIndirectObject(new ValueHolder(null)));
return;
}
ContainerPolicy containerPolicy = getContainerPolicy();
Object valueOfTarget = null;
AbstractSession session = mergeManager.getSession();
DirectCollectionChangeRecord directCollectionChangeRecord = (DirectCollectionChangeRecord) changeRecord;
//Check to see if the target has an instantiated collection
if ((isAttributeValueInstantiated(target)) && (!changeRecord.getOwner().isNew())) {
if (isSynchronizeOnMerge) {
valueOfTarget = getRealCollectionAttributeValueFromObject(target, session);
} else {
valueOfTarget = containerPolicy.cloneFor(getRealCollectionAttributeValueFromObject(target, session));
}
} else {
//if not create an instance of the collection
valueOfTarget = containerPolicy.containerInstance(directCollectionChangeRecord.getAddObjectMap().size());
}
if (!isAttributeValueInstantiated(target)) {
if (mergeManager.shouldMergeChangesIntoDistributedCache()) {
return;
}
for (Object iterator = containerPolicy.iteratorFor(getRealCollectionAttributeValueFromObject(source, session));
containerPolicy.hasNext(iterator);) {
containerPolicy.addInto(containerPolicy.next(iterator, session), valueOfTarget, session);
}
} else {
Object synchronizationTarget = valueOfTarget;
// For indirect containers the delegate must be synchronized on,
// not the wrapper as the clone synchs on the delegate, see bug#5685287.
if (valueOfTarget instanceof IndirectCollection) {
synchronizationTarget = ((IndirectCollection)valueOfTarget).getDelegateObject();
if (((DirectCollectionChangeRecord)changeRecord).orderHasBeenRepaired() && (valueOfTarget instanceof IndirectList)) {
((IndirectList)valueOfTarget).setIsListOrderBrokenInDb(false);
}
}
if (isSynchronizeOnMerge) {
synchronized(synchronizationTarget) {
mergeAddRemoveChanges(valueOfTarget, synchronizationTarget, directCollectionChangeRecord, mergeManager, session);
}
} else {
mergeAddRemoveChanges(valueOfTarget, synchronizationTarget, directCollectionChangeRecord, mergeManager, session);
}
}
setRealAttributeValueInObject(target, valueOfTarget);
}
/**
* INTERNAL:
* Merge changes by adding and removing from the change record to the
* target object, and its delegate object if instance of IndirectCollection.
* It will also reorder the collection if required.
*/
protected void mergeAddRemoveChanges(Object valueOfTarget, Object delegateTarget, DirectCollectionChangeRecord changeRecord, MergeManager mergeManager, AbstractSession session) {
//collect the changes into a vector
HashMap addObjects = changeRecord.getAddObjectMap();
HashMap removeObjects = changeRecord.getRemoveObjectMap();
// Next iterate over the changes and add them to the container
for (Iterator iterator = addObjects.keySet().iterator(); iterator.hasNext();) {
Object object = iterator.next();
int objectCount = ((Integer)addObjects.get(object)).intValue();
for (int i = 0; i < objectCount; ++i) {
if (mergeManager.shouldMergeChangesIntoDistributedCache()) {
//bug#4458089 and 4544532- check if collection contains new item before adding during merge into distributed cache
if (!containerPolicy.contains(object, valueOfTarget, session)) {
containerPolicy.addInto(object, valueOfTarget, session);
}
} else {
containerPolicy.addInto(object, valueOfTarget, session);
}
}
}
for (Iterator iterator = removeObjects.keySet().iterator(); iterator.hasNext();) {
Object object = iterator.next();
int objectCount = ((Integer)removeObjects.get(object)).intValue();
for (int i = 0; i < objectCount; ++i) {
containerPolicy.removeFrom(object, valueOfTarget, session);
}
}
if(this.listOrderField != null && changeRecord.getChangedIndexes() == null) {
this.compareListsForChange((List)changeRecord.getOriginalCollection(), (List)changeRecord.getLatestCollection(), changeRecord, session);
}
if(changeRecord.getChangedIndexes() != null) {
int oldSize = changeRecord.getOldSize();
int newSize = changeRecord.getNewSize();
int delta = newSize - oldSize;
Object newTail[] = null;
if(delta > 0) {
newTail = new Object[delta];
}
Iterator> it = changeRecord.getChangedIndexes().entrySet().iterator();
while(it.hasNext()) {
Map.Entry entry = it.next();
Object value = entry.getKey();
Set[] indexes = entry.getValue();
Set indexesAfter = indexes[1];
if(indexesAfter != null) {
Iterator itIndexesAfter = indexesAfter.iterator();
while(itIndexesAfter.hasNext()) {
int index = itIndexesAfter.next();
if(index < oldSize) {
((List)delegateTarget).set(index, value);
} else {
newTail[index - oldSize] = value;
}
}
}
}
if(delta > 0) {
for(int i=0; i < delta; i++) {
((List)delegateTarget).add(newTail[i]);
}
} else if(delta < 0) {
for(int i=oldSize -1 ; i >= newSize; i--) {
((List)delegateTarget).remove(i);
}
}
}
}
/**
* INTERNAL:
* Merge changes from the source to the target object.
*/
@Override
public void mergeIntoObject(Object target, boolean isTargetUnInitialized, Object source, MergeManager mergeManager, AbstractSession targetSession) {
if (this.descriptor.getCachePolicy().isProtectedIsolation() && !this.isCacheable && !targetSession.isProtectedSession()){
setAttributeValueInObject(target, this.indirectionPolicy.buildIndirectObject(new ValueHolder(null)));
return;
}
if (isTargetUnInitialized) {
// This will happen if the target object was removed from the cache before the commit was attempted
if (mergeManager.shouldMergeWorkingCopyIntoOriginal() && (!isAttributeValueInstantiated(source))) {
setAttributeValueInObject(target, getIndirectionPolicy().getOriginalIndirectionObject(getAttributeValueFromObject(source), targetSession));
return;
}
}
if (!shouldMergeCascadeReference(mergeManager)) {
// This is only going to happen on mergeClone, and we should not attempt to merge the reference
return;
}
if (mergeManager.shouldRefreshRemoteObject() && usesIndirection()) {
mergeRemoteValueHolder(target, source, mergeManager);
return;
}
if (mergeManager.isForRefresh()) {
if (!isAttributeValueInstantiated(target)) {
// This will occur when the clone's value has not been instantiated yet and we do not need
// the refresh that attribute
return;
}
} else if (!isAttributeValueInstantiatedOrChanged(source)) {
// I am merging from a clone into an original. No need to do merge if the attribute was never
// modified
return;
}
ContainerPolicy containerPolicy = getContainerPolicy();
Object valueOfSource = getRealCollectionAttributeValueFromObject(source, mergeManager.getSession());
// trigger instantiation of target attribute
Object valueOfTarget = getRealCollectionAttributeValueFromObject(target, mergeManager.getSession());
Object newContainer = containerPolicy.containerInstance(containerPolicy.sizeFor(valueOfSource));
boolean fireCollectionChangeEvents = false;
boolean firePropertyChangeEvent = false;
ObjectChangeListener listener = null;
if ((this.descriptor.getObjectChangePolicy().isObjectChangeTrackingPolicy()) && (target instanceof ChangeTracker) && (((ChangeTracker)target)._persistence_getPropertyChangeListener() != null)) {
listener = (ObjectChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener();
if(this.listOrderField == null) {
fireCollectionChangeEvents = true;
//Collections may not be indirect list or may have been replaced with user collection.
Object iterator = containerPolicy.iteratorFor(valueOfTarget);
Integer zero = Integer.valueOf(0);//remove does not seem to use index.
while (containerPolicy.hasNext(iterator)) {
// Bug304251: let the containerPolicy build the proper remove CollectionChangeEvent
CollectionChangeEvent event = containerPolicy.createChangeEvent(target, getAttributeName(), valueOfTarget, containerPolicy.next(iterator, mergeManager.getSession()), CollectionChangeEvent.REMOVE, zero, false);
listener.internalPropertyChange(event);
}
if (newContainer instanceof ChangeTracker) {
((ChangeTracker)newContainer)._persistence_setPropertyChangeListener(((ChangeTracker)target)._persistence_getPropertyChangeListener());
}
if (valueOfTarget instanceof ChangeTracker) {
((ChangeTracker)valueOfTarget)._persistence_setPropertyChangeListener(null);//remove listener
}
} else {
firePropertyChangeEvent = true;
}
}
Object originalValueOfTarget = valueOfTarget;
valueOfTarget = newContainer;
int i = 0;
for (Object sourceValuesIterator = containerPolicy.iteratorFor(valueOfSource);
containerPolicy.hasNext(sourceValuesIterator);) {
Object sourceValue = containerPolicy.next(sourceValuesIterator, mergeManager.getSession());
if (fireCollectionChangeEvents) {
// Bug304251: let the containerPolicy build the proper remove CollectionChangeEvent
CollectionChangeEvent event = containerPolicy.createChangeEvent(target, getAttributeName(), valueOfTarget, sourceValue, CollectionChangeEvent.ADD, Integer.valueOf(i), false);
listener.internalPropertyChange(event);
}
containerPolicy.addInto(sourceValue, valueOfTarget, mergeManager.getSession());
i++;
}
if (fireCollectionChangeEvents && (this.descriptor.getObjectChangePolicy().isAttributeChangeTrackingPolicy())) {
// check that there were changes, if not then remove the record.
ObjectChangeSet changeSet = ((AttributeChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener()).getObjectChangeSet();
if (changeSet != null) {
DirectCollectionChangeRecord changeRecord = (DirectCollectionChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (changeRecord != null) {
if (!changeRecord.isDeferred()) {
if (!changeRecord.hasChanges()) {
changeSet.removeChange(getAttributeName());
}
} else {
// Must reset the latest collection.
changeRecord.setLatestCollection(valueOfTarget);
}
}
}
}
if(firePropertyChangeEvent) {
((ObjectChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener()).internalPropertyChange(new PropertyChangeEvent(target, getAttributeName(), originalValueOfTarget, valueOfTarget));
if (valueOfTarget instanceof ChangeTracker) {
((ChangeTracker)valueOfTarget)._persistence_setPropertyChangeListener(((ChangeTracker)target)._persistence_getPropertyChangeListener());
}
if (originalValueOfTarget instanceof ChangeTracker) {
((ChangeTracker)originalValueOfTarget)._persistence_setPropertyChangeListener(null);//remove listener
}
}
// Must re-set variable to allow for set method to re-morph changes if the collection is not being stored directly.
setRealAttributeValueInObject(target, valueOfTarget);
}
/**
* INTERNAL:
* Perform the commit event.
* This is used in the uow to delay data modifications.
*/
@Override
public void performDataModificationEvent(Object[] event, AbstractSession session) throws DatabaseException, DescriptorException {
// Hey I might actually want to use an inner class here... ok array for now.
if (event[0] == Delete) {
session.executeQuery((DataModifyQuery)event[1], (AbstractRecord)event[2]);
if ((getHistoryPolicy() != null) && getHistoryPolicy().shouldHandleWrites()) {
getHistoryPolicy().mappingLogicalDelete((DataModifyQuery)event[1], (AbstractRecord)event[2], session);
}
} else if (event[0] == Insert) {
session.executeQuery((DataModifyQuery)event[1], (AbstractRecord)event[2]);
if ((getHistoryPolicy() != null) && getHistoryPolicy().shouldHandleWrites()) {
getHistoryPolicy().mappingLogicalInsert((DataModifyQuery)event[1], (AbstractRecord)event[2], session);
}
} else if (event[0] == DeleteAll) {
preDelete((DeleteObjectQuery)event[1]);
} else if (event[0] == DeleteAtIndex) {
session.executeQuery((DataModifyQuery)event[1], (AbstractRecord)event[2]);
} else if (event[0] == UpdateAtIndex) {
DataModifyQuery updateAtIndexQuery = (DataModifyQuery)((DataModifyQuery)event[1]).clone();
updateAtIndexQuery.setModifyRow((AbstractRecord)event[3]);
updateAtIndexQuery.setHasModifyRow(true);
updateAtIndexQuery.setIsExecutionClone(true);
session.executeQuery(updateAtIndexQuery, (AbstractRecord)event[2]);
} else {
throw DescriptorException.invalidDataModificationEventCode(event[0], this);
}
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
@Override
public void postCalculateChanges(org.eclipse.persistence.sessions.changesets.ChangeRecord changeRecord, UnitOfWorkImpl uow) {
//no -op for this collection type
}
/**
* INTERNAL:
* Insert the private owned object.
*/
@Override
public void postInsert(WriteObjectQuery query) throws DatabaseException {
Object objects;
AbstractRecord databaseRow = new DatabaseRecord();
if (isReadOnly()) {
return;
}
objects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession());
ContainerPolicy containerPolicy = getContainerPolicy();
if (containerPolicy.isEmpty(objects)) {
return;
}
prepareTranslationRow(query.getTranslationRow(), query.getObject(), query.getDescriptor(), query.getSession());
// Extract primary key and value from the source.
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Object sourceKeyValue = query.getTranslationRow().get(sourceKey);
databaseRow.put(referenceKey, sourceKeyValue);
}
int orderIndex = 0;
// Extract target field and its value. Construct insert statement and execute it
for (Object iter = containerPolicy.iteratorFor(objects); containerPolicy.hasNext(iter);) {
Object wrappedObject = containerPolicy.nextEntry(iter, query.getSession());
Object object = containerPolicy.unwrapIteratorResult(wrappedObject);
if (getValueConverter() != null) {
object = getValueConverter().convertObjectValueToDataValue(object, query.getSession());
}
databaseRow.put(getDirectField(), object);
// In the uow data queries are cached until the end of the commit.
if (query.shouldCascadeOnlyDependentParts()) {
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = databaseRow.clone();
if(listOrderField != null) {
((AbstractRecord)event[2]).put(listOrderField, orderIndex++);
}
query.getSession().getCommitManager().addDataModificationEvent(this, event);
} else {
query.getSession().executeQuery(getInsertQuery(), databaseRow);
if ((getHistoryPolicy() != null) && getHistoryPolicy().shouldHandleWrites()) {
getHistoryPolicy().mappingLogicalInsert(getInsertQuery(), databaseRow, query.getSession());
}
}
containerPolicy.propogatePostInsert(query, wrappedObject);
}
}
/**
* INTERNAL:
* Convert the attribute value to a field value.
* Process any converter if defined.
*/
public Object getFieldValue(Object attributeValue, AbstractSession session) {
if (this.valueConverter != null) {
return this.valueConverter.convertObjectValueToDataValue(attributeValue, session);
}
return attributeValue;
}
/**
* INTERNAL:
* Return source key fields for translation by an AggregateObjectMapping
*/
@Override
public Vector getFieldsForTranslationInAggregate() {
return getSourceKeyFields();
}
/**
* INTERNAL:
* Update private owned part.
*/
@Override
public void postUpdate(WriteObjectQuery writeQuery) throws DatabaseException {
if (isReadOnly()) {
return;
}
if (writeQuery.getObjectChangeSet() != null) {
if(this.listOrderField != null) {
postUpdateWithChangeSetListOrder(writeQuery);
} else {
postUpdateWithChangeSet(writeQuery);
}
return;
}
// If objects are not instantiated that means they are not changed.
if (!isAttributeValueInstantiatedOrChanged(writeQuery.getObject())) {
return;
}
if (writeQuery.getSession().isUnitOfWork()) {
if (compareObjects(writeQuery.getObject(), writeQuery.getBackupClone(), writeQuery.getSession())) {
return;// Nothing has changed, no work required
}
}
DeleteObjectQuery deleteQuery = new DeleteObjectQuery();
deleteQuery.setObject(writeQuery.getObject());
deleteQuery.setSession(writeQuery.getSession());
deleteQuery.setTranslationRow(writeQuery.getTranslationRow());
if (writeQuery.shouldCascadeOnlyDependentParts()) {
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = DeleteAll;
event[1] = deleteQuery;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
} else {
preDelete(deleteQuery);
}
postInsert(writeQuery);
}
/**
* INTERNAL:
* Update private owned part.
*/
protected void postUpdateWithChangeSet(WriteObjectQuery writeQuery) throws DatabaseException {
ObjectChangeSet changeSet = writeQuery.getObjectChangeSet();
DirectCollectionChangeRecord changeRecord = (DirectCollectionChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (changeRecord == null) {
return;
}
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Object sourceKeyValue = writeQuery.getTranslationRow().get(sourceKey);
writeQuery.getTranslationRow().put(referenceKey, sourceKeyValue);
}
for (Iterator iterator = changeRecord.getRemoveObjectMap().keySet().iterator();
iterator.hasNext();) {
Object object = iterator.next();
AbstractRecord thisRow = writeQuery.getTranslationRow().clone();
Object value = getFieldValue(object, writeQuery.getSession());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Delete;
if (value == null) { // Bug 306075 - for deleting a null value from a collection
event[1] = getDeleteNullQuery();
} else {
thisRow.add(getDirectField(), value);
event[1] = getDeleteQuery();
}
event[2] = thisRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
Integer count = (Integer)changeRecord.getCommitAddMap().get(object);
if (count != null) {
for (int counter = count.intValue(); counter > 0; --counter) {
thisRow = writeQuery.getTranslationRow().clone();
thisRow.add(getDirectField(), value);
// Hey I might actually want to use an inner class here... ok array for now.
event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = thisRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
}
}
for (Iterator iterator = changeRecord.getAddObjectMap().keySet().iterator();
iterator.hasNext();) {
Object object = iterator.next();
Integer count = (Integer)changeRecord.getAddObjectMap().get(object);
for (int counter = count.intValue(); counter > 0; --counter) {
AbstractRecord thisRow = writeQuery.getTranslationRow().clone();
Object value = object;
if (getValueConverter() != null) {
value = getValueConverter().convertObjectValueToDataValue(value, writeQuery.getSession());
}
thisRow.add(getDirectField(), value);
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = thisRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
}
}
/**
* INTERNAL:
* Update private owned part.
*/
protected void postUpdateWithChangeSetListOrder(WriteObjectQuery writeQuery) throws DatabaseException {
ObjectChangeSet changeSet = writeQuery.getObjectChangeSet();
DirectCollectionChangeRecord changeRecord = (DirectCollectionChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (changeRecord == null) {
return;
}
for (int index = 0; index < getReferenceKeyFields().size(); index++) {
DatabaseField referenceKey = getReferenceKeyFields().get(index);
DatabaseField sourceKey = getSourceKeyFields().get(index);
Object sourceKeyValue = writeQuery.getTranslationRow().get(sourceKey);
writeQuery.getTranslationRow().put(referenceKey, sourceKeyValue);
}
boolean shouldRepairOrder = false;
if((List)changeRecord.getLatestCollection() instanceof IndirectList) {
shouldRepairOrder = ((IndirectList)changeRecord.getLatestCollection()).isListOrderBrokenInDb();
}
if(shouldRepairOrder) {
// delete all members of collection
DeleteObjectQuery deleteQuery = new DeleteObjectQuery();
deleteQuery.setObject(writeQuery.getObject());
deleteQuery.setSession(writeQuery.getSession());
deleteQuery.setTranslationRow(writeQuery.getTranslationRow());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] eventDeleteAll = new Object[2];
eventDeleteAll[0] = DeleteAll;
eventDeleteAll[1] = deleteQuery;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, eventDeleteAll);
// re-insert them back
for(int i=0; i < ((List)changeRecord.getLatestCollection()).size(); i++) {
Object value = ((List)changeRecord.getLatestCollection()).get(i);
value = getFieldValue(value, writeQuery.getSession());
AbstractRecord insertRow = writeQuery.getTranslationRow().clone();
insertRow.add(getDirectField(), value);
insertRow.add(this.listOrderField, i);
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = insertRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
((IndirectList)changeRecord.getLatestCollection()).setIsListOrderBrokenInDb(false);
changeRecord.setOrderHasBeenRepaired(true);
return;
}
if(changeRecord.getChangedIndexes() == null) {
compareListsForChange((List)changeRecord.getOriginalCollection(), (List)changeRecord.getLatestCollection(), changeRecord, writeQuery.getSession());
}
Iterator> it = changeRecord.getChangedIndexes().entrySet().iterator();
while(it.hasNext()) {
Map.Entry entry = it.next();
Object value = entry.getKey();
if (getValueConverter() != null) {
value = getValueConverter().convertObjectValueToDataValue(value, writeQuery.getSession());
}
Set[] indexes = entry.getValue();
Set indexesBefore = indexes[0];
Set indexesAfter = indexes[1];
if(indexesAfter == null) {
// All copies of the target object deleted - don't need to verify order field contents.
AbstractRecord deleteRow = writeQuery.getTranslationRow().clone();
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Delete;
if (value == null) { // Bug 306075 - for deleting a null value from a collection
event[1] = getDeleteNullQuery();
} else {
deleteRow.add(getDirectField(), value);
event[1] = getDeleteQuery();
}
event[2] = deleteRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
} else if(indexesAfter.isEmpty()) {
// Some copies of the target objects should be deleted, some left in the db
Iterator itBefore = indexesBefore.iterator();
while(itBefore.hasNext()) {
AbstractRecord deleteAtIndexRow = writeQuery.getTranslationRow().clone();
deleteAtIndexRow.add(getDirectField(), value);
deleteAtIndexRow.add(this.listOrderField, itBefore.next());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = DeleteAtIndex;
event[1] = deleteAtIndexQuery;
event[2] = deleteAtIndexRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
} else {
if(indexesBefore == null || indexesBefore.isEmpty()) {
// insert the object for each index in indexesAfter
Iterator itAfter = indexesAfter.iterator();
while(itAfter.hasNext()) {
AbstractRecord insertRow = writeQuery.getTranslationRow().clone();
insertRow.add(getDirectField(), value);
insertRow.add(this.listOrderField, itAfter.next());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = insertRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
} else {
Iterator itBefore = indexesBefore.iterator();
Iterator itAfter = indexesAfter.iterator();
while(itBefore.hasNext() || itAfter.hasNext()) {
if(itBefore.hasNext()) {
if(itAfter.hasNext()) {
// update the object changing index from indexBefore to indexAfter
AbstractRecord updateAtIndexRow = writeQuery.getTranslationRow().clone();
updateAtIndexRow.add(getDirectField(), value);
updateAtIndexRow.add(this.listOrderField, itBefore.next());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[4];
event[0] = UpdateAtIndex;
event[1] = updateAtIndexQuery;
event[2] = updateAtIndexRow;
DatabaseRecord modifyRow = new DatabaseRecord(1);
modifyRow.add(this.listOrderField, itAfter.next());
event[3] = modifyRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
} else {
// delete the object at indexBefore
AbstractRecord deleteAtIndexRow = writeQuery.getTranslationRow().clone();
deleteAtIndexRow.add(getDirectField(), value);
deleteAtIndexRow.add(this.listOrderField, itBefore.next());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = DeleteAtIndex;
event[1] = deleteAtIndexQuery;
event[2] = deleteAtIndexRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
} else {
// itAfter.hasNext() must be true
// insert the object at indexAfter
AbstractRecord insertRow = writeQuery.getTranslationRow().clone();
insertRow.add(getDirectField(), value);
insertRow.add(this.listOrderField, itAfter.next());
// Hey I might actually want to use an inner class here... ok array for now.
Object[] event = new Object[3];
event[0] = Insert;
event[1] = getInsertQuery();
event[2] = insertRow;
writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event);
}
}
}
}
}
}
/**
* INTERNAL:
* Delete private owned part. Which is a collection of objects from the reference table.
*/
@Override
public void preDelete(DeleteObjectQuery query) throws DatabaseException {
if (this.isReadOnly) {
return;
}
if (!this.isCascadeOnDeleteSetOnDatabase) {
prepareTranslationRow(query.getTranslationRow(), query.getObject(), query.getDescriptor(), query.getSession());
query.getSession().executeQuery(this.deleteAllQuery, query.getTranslationRow());
}
if ((this.historyPolicy != null) && this.historyPolicy.shouldHandleWrites()) {
if (this.isCascadeOnDeleteSetOnDatabase) {
prepareTranslationRow(query.getTranslationRow(), query.getObject(), query.getDescriptor(), query.getSession());
}
this.historyPolicy.mappingLogicalDelete(this.deleteAllQuery, query.getTranslationRow(), query.getSession());
}
}
/**
* INTERNAL:
* The translation row may require additional fields than the primary key if the mapping in not on the primary key.
*/
@Override
protected void prepareTranslationRow(AbstractRecord translationRow, Object object, ClassDescriptor descriptor, AbstractSession session) {
// Make sure that each source key field is in the translation row.
for (Enumeration sourceFieldsEnum = getSourceKeyFields().elements();
sourceFieldsEnum.hasMoreElements();) {
DatabaseField sourceKey = (DatabaseField)sourceFieldsEnum.nextElement();
if (!translationRow.containsKey(sourceKey)) {
Object value = descriptor.getObjectBuilder().extractValueFromObjectForField(object, sourceKey, session);
translationRow.put(sourceKey, value);
}
}
}
/**
* INTERNAL:
* Used by DirectMapMapping to rebuild select query.
*/
protected void initOrRebuildSelectQuery() {
this.selectionQuery.setSQLStatement(new SQLSelectStatement());
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
@Override
public void recordPrivateOwnedRemovals(Object object, UnitOfWorkImpl uow) {
}
/**
* INTERNAL:
* Once descriptors are serialized to the remote session. All its mappings and reference descriptors are traversed. Usually
* mappings are initialized and serialized reference descriptors are replaced with local descriptors if they already exist on the
* remote session.
*/
@Override
public void remoteInitialization(DistributedSession session) {
// Remote mappings is initialized here again because while serializing only the uninitialized data is passed
// as the initialized data is not serializable.
if (!isRemotelyInitialized()) {
getAttributeAccessor().initializeAttributes(getDescriptor().getJavaClass());
remotelyInitialized();
}
}
/**
* INTERNAL:
* replace the value holders in the specified reference object(s)
*/
@Override
public Map replaceValueHoldersIn(Object object, RemoteSessionController controller) {
// do nothing, since direct collections do not hold onto other domain objects
return null;
}
/**
* PUBLIC:
* Some databases do not properly support all of the base data types. For these databases,
* the base data type must be explicitly specified in the mapping to tell EclipseLink to force
* the instance variable value to that data type.
* @since Java Persistence API 2.0
* Migrated from AbstractDirectMapping
*/
public void setAttributeClassification(Class attributeClassification) {
this.attributeClassification = attributeClassification;
}
/**
* INTERNAL:
* Set the name of the class for MW usage.
* @since Java Persistence API 2.0
* Migrated from AbstractDirectMapping
*/
public void setAttributeClassificationName(String attributeClassificationName) {
this.attributeClassificationName = attributeClassificationName;
}
protected void setDeleteQuery(ModifyQuery query) {
this.changeSetDeleteQuery = query;
}
/**
* 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 SQL is responsible for doing the deletion required by the mapping,
* such as deletion from join table for M-M.
* Example, 'delete from RESPONS where EMP_ID = #EMP_ID and DESCRIP = #DESCRIP'.
*/
public void setDeleteSQLString(String sqlString) {
DataModifyQuery query = new DataModifyQuery();
query.setSQLString(sqlString);
setCustomDeleteQuery(query);
}
/**
* ADVANCED:
* Configure the mapping to use a container policy.
* The policy manages the access to the collection.
*/
@Override
public void setContainerPolicy(ContainerPolicy containerPolicy) {
this.containerPolicy = containerPolicy;
if (this.selectionQuery.isDataReadQuery()){
((DataReadQuery) getSelectionQuery()).setContainerPolicy(containerPolicy);
}
}
/**
* PUBLIC:
* The default delete query for this mapping can be overridden by specifying the new query.
* This query is responsible for doing the deletion required by the mapping,
* such as deletion from join table for M-M. The query should delete a specific row from the
* DirectCollectionTable bases on the DirectField.
*/
public void setCustomDeleteQuery(ModifyQuery query) {
setDeleteQuery(query);
setHasCustomDeleteQuery(true);
}
/**
* PUBLIC:
* The default delete by index query for this mapping can be overridden by specifying the new query.
* This query used (only in case listOrderField != null) to delete object with particular orderFieldValue.
*/
public void setCustomDeleteAtIndexQuery(ModifyQuery query) {
this.deleteAtIndexQuery = query;
hasCustomDeleteAtIndexQuery = true;
}
/**
* PUBLIC:
* The default insert query for mapping can be overridden by specifying the new query.
* This query inserts the row into the direct table.
*/
public void setCustomInsertQuery(DataModifyQuery query) {
setInsertQuery(query);
setHasCustomInsertQuery(true);
}
/**
* PUBLIC:
* The default delete by index query for this mapping can be overridden by specifying the new query.
* This query used (only in case listOrderField != null) to update orderFieldValue of object with particular orderFieldValue.
*/
public void setCustomUpdateAtIndexQuery(ModifyQuery query) {
this.updateAtIndexQuery = query;
hasCustomUpdateAtIndexQuery = true;
}
/**
* PUBLIC:
* Set the direct field in the reference table.
* This is the field that the primitive data value is stored in.
*/
public void setDirectField(DatabaseField field) {
directField = field;
}
/**
* ADVANCED:
* Set the class type of the field value.
* This can be used if field value differs from the object value,
* has specific typing requirements such as usage of java.sql.Blob or NChar.
* This must be called after the field name has been set.
*/
public void setDirectFieldClassification(Class fieldType) {
getDirectField().setType(fieldType);
}
/**
* ADVANCED:
* Set the class type of the field value.
* This can be used if field value differs from the object value,
* has specific typing requirements such as usage of java.sql.Blob or NChar.
* This must be called after the field name has been set.
*/
public void setDirectFieldClassificationName(String className) {
getDirectField().setTypeName(className);
}
/**
* PUBLIC:
* Set the direct field name in the reference table.
* This is the field that the primitive data value is stored in.
*/
public void setDirectFieldName(String fieldName) {
setDirectField(new DatabaseField(fieldName));
}
protected void setHasCustomDeleteQuery(boolean bool) {
hasCustomDeleteQuery = bool;
}
protected void setHasCustomInsertQuery(boolean bool) {
hasCustomInsertQuery = bool;
}
protected void setInsertQuery(DataModifyQuery insertQuery) {
this.insertQuery = insertQuery;
}
/**
* 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 direct table.
*
Example, 'insert into RESPONS (EMP_ID, RES_DESC) values (#EMP_ID, #RES_DESC)'.
*/
public void setInsertSQLString(String sqlString) {
DataModifyQuery query = new DataModifyQuery();
query.setSQLString(sqlString);
setCustomInsertQuery(query);
}
/**
* INTERNAL:
* This cannot be used with direct collection mappings.
*/
@Override
public void setReferenceClass(Class referenceClass) {
return;
}
@Override
public void setReferenceClassName(String referenceClassName) {
return;
}
/**
* PUBLIC:
* Set the name of the reference key field.
* This is the foreign key field in the direct table referencing the primary key of the source object.
* This method is used if the reference key consists of only a single field.
*/
public void setReferenceKeyFieldName(String fieldName) {
getReferenceKeyFields().addElement(new DatabaseField(fieldName));
}
/**
* INTERNAL:
* Set the reference key field names associated with the mapping.
* These must be in-order with the sourceKeyFieldNames.
*/
public void setReferenceKeyFieldNames(Vector fieldNames) {
Vector fields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(fieldNames.size());
for (Enumeration fieldNamesEnum = fieldNames.elements(); fieldNamesEnum.hasMoreElements();) {
fields.addElement(new DatabaseField((String)fieldNamesEnum.nextElement()));
}
setReferenceKeyFields(fields);
}
/**
* INTERNAL:
* Set the reference fields.
*/
public void setReferenceKeyFields(Vector aVector) {
this.referenceKeyFields = aVector;
}
/**
* INTERNAL:
* Set the reference table.
*/
public void setReferenceTable(DatabaseTable table) {
referenceTable = table;
}
/**
* PUBLIC:
* Sets the selection criteria to be used as a where clause to read
* reference objects. This criteria is automatically generated by the
* TopLink if not explicitly specified by the user.
*/
@Override
public void setSelectionCriteria(Expression anExpression) {
if (getSelectionQuery().isReadAllQuery()){
((ReadAllQuery)getSelectionQuery()).setSelectionCriteria(anExpression);
} else {
getSelectionQuery().getSQLStatement().setWhereClause(anExpression);
}
}
/**
* PUBLIC:
* Set the reference table name.
*/
public void setReferenceTableName(String tableName) {
if (tableName == null) {
setReferenceTable(null);
} else {
setReferenceTable(new DatabaseTable(tableName));
}
}
/**
* INTERNAL:
* Set the container policy on the selection query for this mapping.
*/
@Override
protected void setSelectionQueryContainerPolicy(ContainerPolicy containerPolicy) {
((DataReadQuery) getSelectionQuery()).setContainerPolicy(containerPolicy);
}
/**
* PUBLIC:
* Support history on the reference table.
*/
public void setHistoryPolicy(HistoryPolicy policy) {
this.historyPolicy = policy;
if (policy != null) {
policy.setMapping(this);
}
}
/**
* 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.
*/
@Override
public void setSessionName(String name) {
super.setSessionName(name);
getInsertQuery().setSessionName(name);
}
/**
* INTERNAL:
* Set the source key field names associated with the mapping.
* These must be in-order with the referenceKeyFieldNames.
*/
public void setSourceKeyFieldNames(Vector fieldNames) {
Vector fields = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(fieldNames.size());
for (Enumeration fieldNamesEnum = fieldNames.elements(); fieldNamesEnum.hasMoreElements();) {
fields.addElement(new DatabaseField((String)fieldNamesEnum.nextElement()));
}
setSourceKeyFields(fields);
}
/**
* INTERNAL:
* Set the source fields.
*/
public void setSourceKeyFields(Vector sourceKeyFields) {
this.sourceKeyFields = sourceKeyFields;
}
/**
* 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
*/
@Override
public void collectQueryParameters(Set cacheFields){
for (DatabaseField field : getSourceKeyFields()) {
cacheFields.add(field);
}
}
/**
* INTERNAL:
* Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes
* as apposed to detected changes. If an attribute can not be change tracked it's
* changes can be detected through this process.
*/
@Override
public void calculateDeferredChanges(ChangeRecord changeRecord, AbstractSession session) {
DirectCollectionChangeRecord collectionRecord = (DirectCollectionChangeRecord)changeRecord;
// TODO: Handle events that fired after collection was replaced.
compareCollectionsForChange(collectionRecord.getOriginalCollection(), collectionRecord.getLatestCollection(), collectionRecord, session);
}
/**
* ADVANCED:
* This method is used to have an object add to a collection once the changeSet is applied
* The referenceKey parameter should only be used for direct Maps.
*/
@Override
public void simpleAddToCollectionChangeRecord(Object referenceKey, Object objectToAdd, ObjectChangeSet changeSet, AbstractSession session) {
simpleAddToCollectionChangeRecord(objectToAdd, null, false, changeSet, session, true);
}
protected void simpleAddToCollectionChangeRecord(Object objectToAdd, Integer index, boolean isSet, ObjectChangeSet changeSet, AbstractSession session, boolean isChangeApplied) {
DirectCollectionChangeRecord collectionChangeRecord = (DirectCollectionChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectCollectionChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
changeSet.addChange(collectionChangeRecord);
Object collection = getRealAttributeValueFromObject(changeSet.getUnitOfWorkClone(), session);
if(this.listOrderField != null) {
List originalListCopy = new ArrayList((List)collection);
// collection already contains the added object - to bring it to the original state it should be removed
if(index == null) {
originalListCopy.remove(originalListCopy.size() - 1);
} else {
// intValue() is essential - otherwise invokes remove(Object)
originalListCopy.remove(index.intValue());
}
collectionChangeRecord.setOriginalCollection(originalListCopy);
collectionChangeRecord.setLatestCollection(collection);
} else {
collectionChangeRecord.storeDatabaseCounts(collection, getContainerPolicy(), session);
collectionChangeRecord.setFirstToAddAlreadyInCollection(isChangeApplied);
}
}
if(!collectionChangeRecord.isDeferred() && this.listOrderField == null) {
collectionChangeRecord.addAdditionChange(objectToAdd, Integer.valueOf(1));
}
}
/**
* ADVANCED:
* This method is used to have an object removed from a collection once the changeSet is applied
* The referenceKey parameter should only be used for direct Maps.
*/
@Override
public void simpleRemoveFromCollectionChangeRecord(Object referenceKey, Object objectToRemove, ObjectChangeSet changeSet, AbstractSession session) {
simpleRemoveFromCollectionChangeRecord(objectToRemove, null, false, changeSet, session, true);
}
protected void simpleRemoveFromCollectionChangeRecord(Object objectToRemove, Integer index, boolean isSet, ObjectChangeSet changeSet, AbstractSession session, boolean isChangeApplied) {
DirectCollectionChangeRecord collectionChangeRecord = (DirectCollectionChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectCollectionChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
changeSet.addChange(collectionChangeRecord);
Object collection = getRealAttributeValueFromObject(changeSet.getUnitOfWorkClone(), session);
if(this.listOrderField != null) {
List originalListCopy = new ArrayList((List)collection);
// collection already doesn't contain the removed object - to bring it to the original state it should be added or set back.
// index is not null because IndirectList does remove through indexOf.
if(isSet) {
originalListCopy.set(index, objectToRemove);
} else {
originalListCopy.add(index, objectToRemove);
}
collectionChangeRecord.setOriginalCollection(originalListCopy);
collectionChangeRecord.setLatestCollection(collection);
} else {
collectionChangeRecord.storeDatabaseCounts(collection, getContainerPolicy(), session);
collectionChangeRecord.setFirstToRemoveAlreadyOutCollection(isChangeApplied);
if(isSet) {
collectionChangeRecord.setFirstToAddAlreadyInCollection(isChangeApplied);
}
}
}
if(!collectionChangeRecord.isDeferred() && this.listOrderField == null) {
collectionChangeRecord.addRemoveChange(objectToRemove, Integer.valueOf(1));
}
}
/**
* INTERNAL:
* Either create a new change record or update with the new value. This is used
* by attribute change tracking.
* Specifically in a collection mapping this will be called when the customer
* Set a new collection. In this case we will need to mark the change record
* with the new and the old versions of the collection.
* And mark the ObjectChangeSet with the attribute name then when the changes are calculated
* force a compare on the collections to determine changes.
*/
@Override
public void updateChangeRecord(Object clone, Object newValue, Object oldValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) {
DirectCollectionChangeRecord collectionChangeRecord = (DirectCollectionChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new DirectCollectionChangeRecord(objectChangeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
objectChangeSet.addChange(collectionChangeRecord);
}
collectionChangeRecord.setIsDeferred(true);
objectChangeSet.deferredDetectionRequiredOn(getAttributeName());
if (collectionChangeRecord.getOriginalCollection() == null) {
collectionChangeRecord.recreateOriginalCollection(oldValue, uow);
}
collectionChangeRecord.setLatestCollection(newValue);
}
/**
* INTERNAL:
* Add or removes a new value and its change set to the collection change record based on the event passed in. This is used by
* attribute change tracking.
*/
@Override
public void updateCollectionChangeRecord(CollectionChangeEvent event, ObjectChangeSet changeSet, UnitOfWorkImpl uow) {
if (event != null ) {
//Letting the mapping create and add the ChangeSet to the ChangeRecord rather
// than the policy, since the policy doesn't know how to handle DirectCollectionChangeRecord.
// if ordering is to be supported in the future, check how the method in CollectionMapping is implemented
Object value = event.getNewValue();
if (event.getChangeType() == CollectionChangeEvent.ADD) {
simpleAddToCollectionChangeRecord(value, event.getIndex(), event.isSet(), changeSet, uow, event.isChangeApplied());
} else if (event.getChangeType() == CollectionChangeEvent.REMOVE) {
simpleRemoveFromCollectionChangeRecord(value, event.getIndex(), event.isSet(), changeSet, uow, event.isChangeApplied());
} else {
throw ValidationException.wrongCollectionChangeEventType(event.getChangeType());
}
}
}
/**
* PUBLIC:
* It is illegal to use a Map as the container of a DirectCollectionMapping. Only
* Collection containers are supported for DirectCollectionMappings.
* @see org.eclipse.persistence.mappings.DirectMapMapping
*/
public void useMapClass(Class concreteClass, String methodName) {
throw ValidationException.illegalUseOfMapInDirectCollection(this, concreteClass, methodName);
}
/**
* INTERNAL:
* Return the value of the reference attribute or a value holder.
* Check whether the mapping's attribute should be optimized through batch and joining.
* Overridden to support flashback/historical queries.
*/
@Override
public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, CacheKey cacheKey, AbstractSession session, boolean isTargetProtected, Boolean[] wasCacheUsed) throws DatabaseException {
if (this.descriptor.getCachePolicy().isProtectedIsolation()) {
if (this.isCacheable && isTargetProtected && cacheKey != null) {
//cachekey will be null when isolating to uow
//used cached collection
Object result = null;
Object cached = cacheKey.getObject();
if (cached != null) {
if (wasCacheUsed != null){
wasCacheUsed[0] = Boolean.TRUE;
}
return this.getAttributeValueFromObject(cached);
}
return result;
} else if (!this.isCacheable && !isTargetProtected && cacheKey != null) {
return this.indirectionPolicy.buildIndirectObject(new ValueHolder(null));
}
}
if (row.hasSopObject()) {
return getAttributeValueFromObject(row.getSopObject());
}
if (sourceQuery.isObjectLevelReadQuery() && (((ObjectLevelReadQuery)sourceQuery).isAttributeBatchRead(this.descriptor, getAttributeName())
|| (sourceQuery.isReadAllQuery() && shouldUseBatchReading()))) {
return batchedValueFromRow(row, (ObjectLevelReadQuery)sourceQuery, cacheKey);
}
if (shouldUseValueFromRowWithJoin(joinManager, sourceQuery)) {
return valueFromRowInternalWithJoin(row, joinManager, sourceQuery, cacheKey, session, isTargetProtected);
}
// if the query uses batch reading, return a special value holder
// or retrieve the object from the query property.
ReadQuery targetQuery = getSelectionQuery();
boolean extendingPessimisticLockScope = isExtendingPessimisticLockScope(sourceQuery) && extendPessimisticLockScope == ExtendPessimisticLockScope.TARGET_QUERY;
if ((getHistoryPolicy() != null) || (sourceQuery.getSession().getAsOfClause() != null) || ((sourceQuery.isObjectLevelReadQuery() && ((ObjectLevelReadQuery)sourceQuery).hasAsOfClause()) && (sourceQuery.shouldCascadeAllParts() || (sourceQuery.shouldCascadePrivateParts() && isPrivateOwned()) || (sourceQuery.shouldCascadeByMapping() && this.cascadeRefresh))) || extendingPessimisticLockScope) {
targetQuery = (ReadQuery)targetQuery.clone();
// Code copied roughly from initializeSelectionStatement.
SQLSelectStatement statement = new SQLSelectStatement();
statement.addTable(getReferenceTable());
statement.addField(getDirectField().clone());
if (isDirectMapMapping()) {
statement.addField(((DirectMapMapping)this).getDirectKeyField().clone());
}
statement.setWhereClause((Expression)getSelectionCriteria().clone());
if (sourceQuery.isObjectLevelReadQuery()) {
statement.getBuilder().asOf(((ObjectLevelReadQuery)sourceQuery).getAsOfClause());
}
if (extendingPessimisticLockScope) {
statement.setLockingClause(new ForUpdateClause(sourceQuery.getLockMode()));
}
if (getHistoryPolicy() != null) {
ExpressionBuilder builder = statement.getBuilder();
if (sourceQuery.getSession().getAsOfClause() != null) {
builder.asOf(sourceQuery.getSession().getAsOfClause());
} else if (builder.getAsOfClause() == null) {
builder.asOf(AsOfClause.NO_CLAUSE);
}
Expression temporalExpression = getHistoryPolicy().additionalHistoryExpression(builder, builder);
statement.setWhereClause(statement.getWhereClause().and(temporalExpression));
if (builder.hasAsOfClause()) {
statement.getTables().set(0, getHistoryPolicy().getHistoricalTables().get(0));
}
}
statement.normalize(sourceQuery.getSession(), null);
targetQuery.setSQLStatement(statement);
}
return getIndirectionPolicy().valueFromQuery(targetQuery, row, sourceQuery.getSession());
}
/**
* INTERNAL:
* Checks if object is deleted from the database or not.
*/
@Override
public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException {
// Row is built for translation
if (isReadOnly()) {
return true;
}
AbstractRecord row = getDescriptor().getObjectBuilder().buildRowForTranslation(object, session);
Object value = session.executeQuery(getSelectionQuery(), row);
return getContainerPolicy().isEmpty(value);
}
/**
* INTERNAL:
* DirectCollectionMapping contents should not be considered for addition to the UnitOfWork
* private owned objects list for removal.
*/
@Override
public boolean isCandidateForPrivateOwnedRemoval() {
return false;
}
/**
* INTERNAL
* Return true if this mapping supports cascaded version optimistic locking.
*/
@Override
public boolean isCascadedLockingSupported() {
return true;
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/CollectionMapping.java 0000664 0000000 0000000 00000375701 12216173130 024510 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 02/26/2009-2.0 Guy Pelletier
* - 264001: dot notation for mapped-by and order-by
* 08/23/2010-2.2 Michael O'Brien
* - 323043: application.xml module ordering may cause weaving not to occur causing an NPE.
* warn if expected "_persistence_*_vh" method not found
* instead of throwing NPE during deploy validation.
* 07/19/2011-2.2.1 Guy Pelletier
* - 338812: ManyToMany mapping in aggregate object violate integrity constraint on deletion
* 04/09/2012-2.4 Guy Pelletier
* - 374377: OrderBy with ElementCollection doesn't work
* 14/05/2012-2.4 Guy Pelletier
* - 376603: Provide for table per tenant support for multitenant applications
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.beans.PropertyChangeListener;
import java.util.*;
import org.eclipse.persistence.annotations.OrderCorrectionType;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.changetracking.*;
import org.eclipse.persistence.internal.descriptors.changetracking.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.indirection.*;
import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.sessions.remote.*;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.sessions.remote.*;
import org.eclipse.persistence.sessions.CopyGroup;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.sessions.Project;
/**
*
Purpose: Abstract class for relationship mappings which store collection of objects
*
* @author Sati
* @since TOPLink/Java 1.0
*/
public abstract class CollectionMapping extends ForeignReferenceMapping implements ContainerMapping {
/** Used for delete all in m-m, dc and delete all optimization in 1-m. */
protected transient ModifyQuery deleteAllQuery;
protected transient boolean hasCustomDeleteAllQuery;
protected ContainerPolicy containerPolicy;
protected boolean hasOrderBy;
/** Field holds the order of elements in the list in the db, requires collection of type List, may be not null only in case isListOrderFieldSupported==true */
protected DatabaseField listOrderField;
/** Indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception. */
protected boolean isListOrderFieldSupported;
/** Query used when order of list members is changed. Used only if listOrderField!=null */
protected transient DataModifyQuery changeOrderTargetQuery;
/**
* Specifies what should be done if the list of values read from listOrserField is invalid
* (there should be no nulls, no duplicates, no "holes").
**/
protected OrderCorrectionType orderCorrectionType;
/** Store if the mapping can batch delete reference objects. */
protected Boolean mustDeleteReferenceObjectsOneByOne = null;
/** Flag to indicate if collection needs to be synchronized instead of cloning during merge. */
protected static boolean isSynchronizeOnMerge = Boolean.getBoolean("eclipselink.synchronizeCollectionOnMerge");
/**
* PUBLIC:
* Default constructor.
*/
public CollectionMapping() {
this.selectionQuery = new ReadAllQuery();
this.hasCustomDeleteAllQuery = false;
this.containerPolicy = ContainerPolicy.buildDefaultPolicy();
this.hasOrderBy = false;
this.isListOrderFieldSupported = false;
}
/**
* PUBLIC:
* Provide order support for queryKeyName in ascending order
*/
public void addAscendingOrdering(String queryKeyName) {
this.hasOrderBy = true;
if (queryKeyName == null) {
return;
}
((ReadAllQuery)getSelectionQuery()).addAscendingOrdering(queryKeyName);
}
/**
* PUBLIC:
* Provide order support for queryKeyName in descending order.
*/
public void addDescendingOrdering(String queryKeyName) {
this.hasOrderBy = true;
if (queryKeyName == null) {
return;
}
((ReadAllQuery)getSelectionQuery()).addDescendingOrdering(queryKeyName);
}
/**
* PUBLIC:
* Provide order support for queryKeyName in descending or ascending order.
* Called from the jpa metadata processing of an order by value.
*/
public void addOrderBy(String queryKeyName, boolean isDescending) {
if (isDescending) {
addDescendingOrdering(queryKeyName);
} else {
addAscendingOrdering(queryKeyName);
}
}
/**
* PUBLIC:
* Provide order support for queryKeyName in ascending or descending order.
* Called from the jpa metadata processing of an order by value. The
* aggregate name may be chained through the dot notation.
*/
public void addAggregateOrderBy(String aggregateName, String queryKeyName, boolean isDescending) {
this.hasOrderBy = true;
ReadAllQuery readAllQuery = (ReadAllQuery) getSelectionQuery();
ExpressionBuilder builder = readAllQuery.getExpressionBuilder();
Expression expression = null;
if (aggregateName.contains(".")) {
StringTokenizer st = new StringTokenizer(aggregateName, ".");
while (st.hasMoreTokens()) {
if (expression == null) {
expression = builder.get(st.nextToken());
} else {
expression = expression.get(st.nextToken());
}
}
expression = expression.get(queryKeyName);
} else {
// Single level aggregate
if (aggregateName.equals("")) {
expression = builder.get(queryKeyName);
} else {
expression = builder.get(aggregateName).get(queryKeyName);
}
}
if (isDescending) {
readAllQuery.addOrdering(expression.descending());
} else {
readAllQuery.addOrdering(expression.ascending());
}
}
/**
* INTERNAL:
* Used during building the backup shallow copy to copy
* the vector without re-registering the target objects.
*/
@Override
public Object buildBackupCloneForPartObject(Object attributeValue, Object clone, Object backup, UnitOfWorkImpl unitOfWork) {
// Check for null
if (attributeValue == null) {
return this.containerPolicy.containerInstance(1);
} else {
return this.containerPolicy.cloneFor(attributeValue);
}
}
/**
* INTERNAL:
* Require for cloning, the part must be cloned.
* Ignore the objects, use the attribute value.
*/
@Override
public Object buildCloneForPartObject(Object attributeValue, Object original, CacheKey cacheKey, Object clone, AbstractSession cloningSession, Integer refreshCascade, boolean isExisting, boolean isFromSharedCache) {
ContainerPolicy containerPolicy = this.containerPolicy;
if (attributeValue == null) {
Object container = containerPolicy.containerInstance(1);
if (cloningSession.isUnitOfWork() && (this.getDescriptor().getObjectChangePolicy().isObjectChangeTrackingPolicy()) && ((clone != null) && (((ChangeTracker)clone)._persistence_getPropertyChangeListener() != null)) && (container instanceof CollectionChangeTracker)) {
((CollectionChangeTracker)container).setTrackedAttributeName(this.getAttributeName());
((CollectionChangeTracker)container)._persistence_setPropertyChangeListener(((ChangeTracker)clone)._persistence_getPropertyChangeListener());
}
return container;
}
Object clonedAttributeValue = containerPolicy.containerInstance(containerPolicy.sizeFor(attributeValue));
Object temporaryCollection = null;
if (isSynchronizeOnMerge) {
// I need to synchronize here to prevent the collection from changing while I am cloning it.
// This will occur when I am merging into the cache and I am instantiating a UOW valueHolder at the same time
// I can not synchronize around the clone, as this will cause deadlocks, so I will need to copy the collection then create the clones
// I will use a temporary collection to help speed up the process
synchronized (attributeValue) {
temporaryCollection = containerPolicy.cloneFor(attributeValue);
}
} else {
// Clone is used while merging into cache. It can operate directly without synchronize/clone.
temporaryCollection = attributeValue;
}
for (Object valuesIterator = containerPolicy.iteratorFor(temporaryCollection);containerPolicy.hasNext(valuesIterator);){
containerPolicy.addNextValueFromIteratorInto(valuesIterator, clone, cacheKey, clonedAttributeValue, this, refreshCascade, cloningSession, isExisting, isFromSharedCache);
}
if (cloningSession.isUnitOfWork() && (this.getDescriptor().getObjectChangePolicy().isObjectChangeTrackingPolicy()) && ((clone != null) && (((ChangeTracker)clone)._persistence_getPropertyChangeListener() != null)) && (clonedAttributeValue instanceof CollectionChangeTracker)) {
((CollectionChangeTracker)clonedAttributeValue).setTrackedAttributeName(this.getAttributeName());
((CollectionChangeTracker)clonedAttributeValue)._persistence_setPropertyChangeListener(((ChangeTracker)clone)._persistence_getPropertyChangeListener());
}
if(temporaryCollection instanceof IndirectList) {
((IndirectList)clonedAttributeValue).setIsListOrderBrokenInDb(((IndirectList)temporaryCollection).isListOrderBrokenInDb());
}
return clonedAttributeValue;
}
/**
* INTERNAL:
* Performs a first level clone of the attribute. This generally means on the container will be cloned.
*/
public Object buildContainerClone(Object attributeValue, AbstractSession cloningSession){
Object newContainer = this.containerPolicy.containerInstance(this.containerPolicy.sizeFor(attributeValue));
Object valuesIterator = this.containerPolicy.iteratorFor(attributeValue);
while (this.containerPolicy.hasNext(valuesIterator)) {
Object originalValue = this.containerPolicy.next(valuesIterator, cloningSession);
this.containerPolicy.addInto(originalValue, newContainer, cloningSession);
}
return newContainer;
}
/**
* INTERNAL:
* Copy of the attribute of the object.
* This is NOT used for unit of work but for templatizing an object.
*/
@Override
public void buildCopy(Object copy, Object original, CopyGroup group) {
Object attributeValue = getRealCollectionAttributeValueFromObject(original, group.getSession());
Object valuesIterator = this.containerPolicy.iteratorFor(attributeValue);
attributeValue = this.containerPolicy.containerInstance(this.containerPolicy.sizeFor(attributeValue));
while (this.containerPolicy.hasNext(valuesIterator)) {
Object originalValue = this.containerPolicy.next(valuesIterator, group.getSession());
Object copyValue = originalValue;
Object originalKey = this.containerPolicy.keyFromIterator(valuesIterator);
Object copyKey = originalKey;
if (group.shouldCascadeAllParts() || (group.shouldCascadePrivateParts() && isPrivateOwned()) || group.shouldCascadeTree()) {
copyValue = copyElement(originalValue, group);
copyKey = group.getSession().copyInternal(originalKey, group);
} else {
// Check for backrefs to copies.
copyValue = group.getCopies().get(originalValue);
if (copyValue == null) {
copyValue = originalValue;
}
}
this.containerPolicy.addInto(copyKey, copyValue, attributeValue, group.getSession());
}
// if value holder is used, then the value holder shared with original substituted for a new ValueHolder.
getIndirectionPolicy().reset(copy);
setRealAttributeValueInObject(copy, attributeValue);
}
/**
* INTERNAL:
* Copies member's value
*/
protected Object copyElement(Object original, CopyGroup group) {
return group.getSession().copyInternal(original, group);
}
/**
* INTERNAL:
* Clone the element, if necessary.
*/
public Object buildElementUnitOfWorkClone(Object element, Object parent, Integer refreshCascade, UnitOfWorkImpl unitOfWork, boolean isExisting, boolean isFromSharedCache) {
// optimize registration to knowledge of existence
if (refreshCascade != null ){
switch(refreshCascade){
case ObjectBuildingQuery.CascadeAllParts :
return unitOfWork.mergeClone(element, MergeManager.CASCADE_ALL_PARTS, true);
case ObjectBuildingQuery.CascadePrivateParts :
return unitOfWork.mergeClone(element, MergeManager.CASCADE_PRIVATE_PARTS, true);
case ObjectBuildingQuery.CascadeByMapping :
return unitOfWork.mergeClone(element, MergeManager.CASCADE_BY_MAPPING, true);
default:
return unitOfWork.mergeClone(element, MergeManager.NO_CASCADE, true);
}
}else{
if (isExisting) {
return unitOfWork.registerExistingObject(element, isFromSharedCache);
} else {// not known whether existing or not
return unitOfWork.registerObject(element);
}
}
}
/**
* INTERNAL:
* Clone the element, if necessary.
*/
public Object buildElementClone(Object element, Object parent, CacheKey parentCacheKey, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache) {
if (cloningSession.isUnitOfWork()){
return buildElementUnitOfWorkClone(element, parent, refreshCascade, (UnitOfWorkImpl)cloningSession, isExisting, isFromSharedCache);
}
if (referenceDescriptor.getCachePolicy().isProtectedIsolation()){
return cloningSession.createProtectedInstanceFromCachedData(element, refreshCascade, referenceDescriptor);
}
return element;
}
/**
* INTERNAL:
* This method will access the target relationship and create a list of information to rebuild the relationship.
* This method is used in combination with the CachedValueHolder to store references to PK's to be loaded
* from a cache instead of a query.
*/
@Override
public Object[] buildReferencesPKList(Object entity, Object attribute, AbstractSession session){
Object container = indirectionPolicy.getRealAttributeValueFromObject(entity, attribute);
return containerPolicy.buildReferencesPKList(container, session);
}
/**
* INTERNAL:
* Cascade perform delete through mappings that require the cascade
*/
@Override
public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
if (!this.cascadeRemove) {
return;
}
Object cloneAttribute = getAttributeValueFromObject(object);
if (cloneAttribute == null) {
return;
}
// PERF: If private owned and not instantiated, then avoid instantiating, delete-all will handle deletion.
if ((this.isPrivateOwned) && usesIndirection() && (!mustDeleteReferenceObjectsOneByOne())) {
if (!this.indirectionPolicy.objectIsEasilyInstantiated(cloneAttribute)) {
return;
}
}
ContainerPolicy cp = this.containerPolicy;
Object cloneObjectCollection = null;
cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow);
Object cloneIter = cp.iteratorFor(cloneObjectCollection);
while (cp.hasNext(cloneIter)) {
Object wrappedObject = cp.nextEntry(cloneIter, uow);
Object nextObject = cp.unwrapIteratorResult(wrappedObject);
if ((nextObject != null) && (!visitedObjects.containsKey(nextObject))) {
visitedObjects.put(nextObject, nextObject);
if (this.isCascadeOnDeleteSetOnDatabase && isOneToManyMapping()) {
uow.getCascadeDeleteObjects().add(nextObject);
}
uow.performRemove(nextObject, visitedObjects);
cp.cascadePerformRemoveIfRequired(wrappedObject, uow, visitedObjects);
}
}
}
/**
* INTERNAL:
* Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
*/
@Override
public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
// if the object is not instantiated, do not instantiate or cascade
Object attributeValue = getAttributeValueFromObject(object);
if (attributeValue != null && this.indirectionPolicy.objectIsInstantiated(attributeValue)) {
Object realObjectCollection = getRealCollectionAttributeValueFromObject(object, uow);
ContainerPolicy cp = this.containerPolicy;
for (Object cloneIter = cp.iteratorFor(realObjectCollection); cp.hasNext(cloneIter);) {
Object nextObject = cp.next(cloneIter, uow);
if (nextObject != null && !visitedObjects.containsKey(nextObject)) {
visitedObjects.put(nextObject, nextObject);
// remove the object from the UnitOfWork ChangeSet
uow.performRemovePrivateOwnedObjectFromChangeSet(nextObject, visitedObjects);
}
}
}
}
/**
* INTERNAL:
* Cascade discover and persist new objects during commit.
*/
@Override
public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors) {
Object cloneAttribute = getAttributeValueFromObject(object);
if ((cloneAttribute == null) || (!this.indirectionPolicy.objectIsInstantiated(cloneAttribute))) {
if (cloneAttribute instanceof IndirectCollection) {
IndirectCollection collection = (IndirectCollection)cloneAttribute;
if (collection.hasDeferredChanges()) {
Iterator iterator = collection.getAddedElements().iterator();
boolean cascade = isCascadePersist();
while (iterator.hasNext()) {
Object nextObject = iterator.next();
// remove private owned object from uow list
if (isCandidateForPrivateOwnedRemoval()){
uow.removePrivateOwnedObject(this, nextObject);
}
uow.discoverAndPersistUnregisteredNewObjects(nextObject, cascade, newObjects, unregisteredExistingObjects, visitedObjects, cascadeErrors);
}
}
}
return;
}
ContainerPolicy containerPolicy = this.containerPolicy;
Object cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow);
Object iterator = containerPolicy.iteratorFor(cloneObjectCollection);
boolean cascade = isCascadePersist();
while (containerPolicy.hasNext(iterator)) {
Object wrappedObject = containerPolicy.nextEntry(iterator, uow);
Object nextObject = containerPolicy.unwrapIteratorResult(wrappedObject);
// remove private owned object from uow list
if (isCandidateForPrivateOwnedRemoval()) {
uow.removePrivateOwnedObject(this, nextObject);
}
uow.discoverAndPersistUnregisteredNewObjects(nextObject, cascade, newObjects, unregisteredExistingObjects, visitedObjects, cascadeErrors);
containerPolicy.cascadeDiscoverAndPersistUnregisteredNewObjects(wrappedObject, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors);
}
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
@Override
public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
if (!this.cascadePersist) {
return;
}
Object attributeValue = getAttributeValueFromObject(object);
if ((attributeValue == null)
// Also check if the source is new, then must always cascade.
|| (!this.indirectionPolicy.objectIsInstantiated(attributeValue) && !uow.isCloneNewObject(object))) {
return;
}
ContainerPolicy cp = this.containerPolicy;
Object cloneObjectCollection = null;
cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow);
Object cloneIter = cp.iteratorFor(cloneObjectCollection);
// add private owned objects to uow list if mapping is a candidate and uow should discover new objects and the source object is new.
boolean shouldAddPrivateOwnedObject = isCandidateForPrivateOwnedRemoval() && uow.shouldDiscoverNewObjects() && uow.isCloneNewObject(object);
while (cp.hasNext(cloneIter)) {
Object wrappedObject = cp.nextEntry(cloneIter, uow);
Object nextObject = cp.unwrapIteratorResult(wrappedObject);
if (shouldAddPrivateOwnedObject && nextObject != null) {
uow.addPrivateOwnedObject(this, nextObject);
}
uow.registerNewObjectForPersist(nextObject, visitedObjects);
cp.cascadeRegisterNewIfRequired(wrappedObject, uow, visitedObjects);
}
}
/**
* 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
*/
@Override
public void collectQueryParameters(Set record){
//no-op for mappings that do not support PROTECTED cache isolation
}
/**
* INTERNAL:
* Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes
* as apposed to detected changes. If an attribute can not be change tracked it's
* changes can be detected through this process.
*/
@Override
public void calculateDeferredChanges(ChangeRecord changeRecord, AbstractSession session) {
CollectionChangeRecord collectionRecord = (CollectionChangeRecord)changeRecord;
// TODO: Handle events that fired after collection was replaced.
compareCollectionsForChange(collectionRecord.getOriginalCollection(), collectionRecord.getLatestCollection(), collectionRecord, session);
if(this.isPrivateOwned()) {
postCalculateChanges(collectionRecord, (UnitOfWorkImpl)session);
}
}
/**
* INTERNAL:
* The mapping clones itself to create deep copy.
*/
@Override
public Object clone() {
CollectionMapping clone = (CollectionMapping)super.clone();
clone.setDeleteAllQuery((ModifyQuery)getDeleteAllQuery().clone());
if (this.listOrderField != null) {
clone.listOrderField = this.listOrderField.clone();
}
if(this.changeOrderTargetQuery != null) {
clone.changeOrderTargetQuery = (DataModifyQuery)this.changeOrderTargetQuery.clone();
}
// Clone the container policy.
clone.containerPolicy = (ContainerPolicy) this.containerPolicy.clone();
return clone;
}
/**
* INTERNAL:
* This method is used to calculate the differences between two collections.
*/
public void compareCollectionsForChange(Object oldCollection, Object newCollection, ChangeRecord changeRecord, AbstractSession session) {
this.containerPolicy.compareCollectionsForChange(oldCollection, newCollection, (CollectionChangeRecord) changeRecord, session, getReferenceDescriptor());
}
/**
* INTERNAL:
* This method is used to create a change record from comparing two collections.
*/
@Override
public ChangeRecord compareForChange(Object clone, Object backUp, ObjectChangeSet owner, AbstractSession session) {
Object cloneAttribute = null;
Object backUpAttribute = null;
Object backUpObjectCollection = null;
cloneAttribute = getAttributeValueFromObject(clone);
if ((cloneAttribute != null) && (!this.indirectionPolicy.objectIsInstantiated(cloneAttribute))) {
return null;
}
if (!owner.isNew()) {// if the changeSet is for a new object then we must record all of the attributes
backUpAttribute = getAttributeValueFromObject(backUp);
if ((cloneAttribute == null) && (backUpAttribute == null)) {
return null;
}
backUpObjectCollection = getRealCollectionAttributeValueFromObject(backUp, session);
}
Object cloneObjectCollection = null;
if (cloneAttribute != null) {
cloneObjectCollection = getRealCollectionAttributeValueFromObject(clone, session);
} else {
cloneObjectCollection = this.containerPolicy.containerInstance(1);
}
CollectionChangeRecord changeRecord = new CollectionChangeRecord(owner);
changeRecord.setAttribute(getAttributeName());
changeRecord.setMapping(this);
compareCollectionsForChange(backUpObjectCollection, cloneObjectCollection, changeRecord, session);
if (changeRecord.hasChanges()) {
changeRecord.setOriginalCollection(backUpObjectCollection);
return changeRecord;
}
return null;
}
/**
* INTERNAL:
* Compare the attributes belonging to this mapping for the objects.
*/
@Override
public boolean compareObjects(Object firstObject, Object secondObject, AbstractSession session) {
Object firstObjectCollection = getRealCollectionAttributeValueFromObject(firstObject, session);
Object secondObjectCollection = getRealCollectionAttributeValueFromObject(secondObject, session);
return super.compareObjects(firstObjectCollection, secondObjectCollection, session);
}
/**
* INTERNAL:
* Write the changes defined in the change set for the mapping.
* Mapping added or removed events are raised to allow the mapping to write the changes as required.
*/
public void writeChanges(ObjectChangeSet changeSet, WriteObjectQuery query) throws DatabaseException, OptimisticLockException {
CollectionChangeRecord record = (CollectionChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (record != null) {
for (ObjectChangeSet removedChangeSet : record.getRemoveObjectList().values()) {
objectRemovedDuringUpdate(query, this.containerPolicy.getCloneDataFromChangeSet(removedChangeSet), null);
if (removedChangeSet.getOldKey() != null){
this.containerPolicy.propogatePostUpdate(query, removedChangeSet.getOldKey());
}
}
Map extraData = null;
Object currentObjects = null;
for (ObjectChangeSet addedChangeSet : record.getAddObjectList().values()) {
if (this.listOrderField != null) {
extraData = new HashMap(1);
Integer addedIndexInList = record.getOrderedAddObjectIndices().get(addedChangeSet);
if (addedIndexInList == null) {
if (currentObjects == null) {
currentObjects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession());
}
addedIndexInList = ((List)currentObjects).indexOf(addedChangeSet.getUnitOfWorkClone());
}
extraData.put(this.listOrderField, addedIndexInList);
}
objectAddedDuringUpdate(query, this.containerPolicy.getCloneDataFromChangeSet(addedChangeSet), addedChangeSet, extraData);
if (addedChangeSet.getNewKey() != null){
this.containerPolicy.propogatePostUpdate(query, addedChangeSet.getNewKey());
}
}
if (this.listOrderField != null) {
// This is a hacky check for attribute change tracking, if the backup clone is different, then is using deferred.
List previousList = (List)getRealCollectionAttributeValueFromObject(query.getBackupClone(), query.getSession());;
int previousSize = previousList.size();
if (currentObjects == null) {
currentObjects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession());
}
List currentList = (List)currentObjects;
int currentSize = currentList.size();
boolean shouldRepairOrder = false;
if(currentList instanceof IndirectList) {
shouldRepairOrder = ((IndirectList)currentList).isListOrderBrokenInDb();
}
if(previousList == currentList) {
// previousList is not available
// The same size as previous list,
// at the i-th position holds the index of the i-th original object in the current list (-1 if the object was removed):
// for example: {0, -1, 1, -1, 3} means that:
// previous(0) == current(0);
// previous(1) was removed;
// previous(2) == current(1);
// previous(3) was removed;
// previous(4) == current(3);
// current(1) and current(3) were also on previous list, but with different indexes: they are the ones that should have their index changed.
List currentIndexes = record.getCurrentIndexesOfOriginalObjects(currentList);
for(int i=0; i < currentIndexes.size(); i++) {
int currentIndex = currentIndexes.get(i);
if((currentIndex >= 0) && (currentIndex != i || shouldRepairOrder)) {
objectOrderChangedDuringUpdate(query, currentList.get(currentIndex), currentIndex);
}
}
} else {
for (int i=0; i < previousSize; i++) {
// TODO: should we check for previousObject != null?
Object prevObject = previousList.get(i);
Object currentObject = null;
if(i < currentSize) {
currentObject = currentList.get(i);
}
if(prevObject != currentObject || shouldRepairOrder) {
// object has either been removed or its index in the List has changed
int newIndex = currentList.indexOf(prevObject);
if(newIndex >= 0) {
objectOrderChangedDuringUpdate(query, prevObject, newIndex);
}
}
}
}
if (shouldRepairOrder) {
((IndirectList)currentList).setIsListOrderBrokenInDb(false);
record.setOrderHasBeenRepaired(true);
}
}
}
}
/**
* INTERNAL:
* The memory objects are compared and only the changes are written to the database.
*/
protected void compareObjectsAndWrite(WriteObjectQuery query) throws DatabaseException, OptimisticLockException {
Object currentObjects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession());
Object previousObjects = readPrivateOwnedForObject(query);
if (previousObjects == null) {
previousObjects = getContainerPolicy().containerInstance(1);
}
if (this.listOrderField != null && this.isAggregateCollectionMapping()) {
compareListsAndWrite((List)previousObjects, (List)currentObjects, query);
return;
}
ContainerPolicy cp = this.containerPolicy;
Map previousObjectsByKey = new HashMap(cp.sizeFor(previousObjects)); // Read from db or from backup in uow.
Map currentObjectsByKey = new HashMap(cp.sizeFor(currentObjects)); // Current value of object's attribute (clone in uow).
Map keysOfCurrentObjects = new IdentityHashMap(cp.sizeFor(currentObjects) + 1);
// First index the current objects by their primary key.
for (Object currentObjectsIter = cp.iteratorFor(currentObjects);
cp.hasNext(currentObjectsIter);) {
Object currentObject = cp.next(currentObjectsIter, query.getSession());
try {
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(currentObject, query.getSession());
currentObjectsByKey.put(primaryKey, currentObject);
keysOfCurrentObjects.put(currentObject, primaryKey);
} catch (NullPointerException e) {
// For CR#2646 quietly discard nulls added to a collection mapping.
// This try-catch is essentially a null check on currentObject, for
// ideally the customer should check for these themselves.
if (currentObject != null) {
throw e;
}
}
}
// Next index the previous objects (read from db or from backup in uow)
// and process the difference to current (optimized in same loop).
for (Object previousObjectsIter = cp.iteratorFor(previousObjects);
cp.hasNext(previousObjectsIter);) {
Object wrappedObject = cp.nextEntry(previousObjectsIter, query.getSession());
Map mapKeyFields = containerPolicy.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession());
Object previousObject = containerPolicy.unwrapIteratorResult(wrappedObject);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(previousObject, query.getSession());
previousObjectsByKey.put(primaryKey, previousObject);
// Delete must occur first, in case object with same pk is removed and added,
// (technically should not happen, but same applies to unique constraints)
if (!currentObjectsByKey.containsKey(primaryKey)) {
objectRemovedDuringUpdate(query, wrappedObject, mapKeyFields);
cp.propogatePostUpdate(query, wrappedObject);
}
}
for (Object currentObjectsIter = cp.iteratorFor(currentObjects);
cp.hasNext(currentObjectsIter);) {
Object wrappedObject = cp.nextEntry(currentObjectsIter, query.getSession());
Object currentObject = containerPolicy.unwrapIteratorResult(wrappedObject);
try {
Map mapKeyFields = containerPolicy.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession());
Object primaryKey = keysOfCurrentObjects.get(currentObject);
if (!(previousObjectsByKey.containsKey(primaryKey))) {
objectAddedDuringUpdate(query, currentObject, null, mapKeyFields);
cp.propogatePostUpdate(query, wrappedObject);
} else {
objectUnchangedDuringUpdate(query, currentObject, previousObjectsByKey, primaryKey);
}
} catch (NullPointerException e) {
// For CR#2646 skip currentObject if it is null.
if (currentObject != null) {
throw e;
}
}
}
}
/**
* INTERNAL:
* Old and new lists are compared and only the changes are written to the database.
* Currently there's no support for listOrderField in CollectionMapping in case there's no change sets,
* so this method currently never called (currently only overriding method in AggregateCollectionMapping is called).
* This method should be implemented to support listOrderField functionality without change sets.
*/
protected void compareListsAndWrite(List previousList, List currentList, WriteObjectQuery query) throws DatabaseException, OptimisticLockException {
}
/**
* Compare two objects if their parts are not private owned
*/
@Override
protected boolean compareObjectsWithoutPrivateOwned(Object firstCollection, Object secondCollection, AbstractSession session) {
if(this.listOrderField != null) {
return compareLists((List)firstCollection, (List)secondCollection, session, false);
}
ContainerPolicy cp = this.containerPolicy;
if (cp.sizeFor(firstCollection) != cp.sizeFor(secondCollection)) {
return false;
}
Object firstIter = cp.iteratorFor(firstCollection);
Object secondIter = cp.iteratorFor(secondCollection);
Map keyValues = new HashMap();
if (isMapKeyMapping()) {
while (cp.hasNext(secondIter)) {
Map.Entry secondObject = (Map.Entry)cp.nextEntry(secondIter, session);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject.getValue(), session);
Object key = secondObject.getKey();
keyValues.put(key, primaryKey);
}
while (cp.hasNext(firstIter)) {
Map.Entry firstObject = (Map.Entry)cp.nextEntry(firstIter, session);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject.getValue(), session);
Object key = firstObject.getKey();
if (!primaryKey.equals(keyValues.get(key))) {
return false;
}
}
} else {
while (cp.hasNext(secondIter)) {
Object secondObject = cp.next(secondIter, session);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject, session);
keyValues.put(primaryKey, primaryKey);
}
while (cp.hasNext(firstIter)) {
Object firstObject = cp.next(firstIter, session);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject, session);
if (!keyValues.containsKey(primaryKey)) {
return false;
}
}
}
return true;
}
/**
* Compare two objects if their parts are private owned
*/
@Override
protected boolean compareObjectsWithPrivateOwned(Object firstCollection, Object secondCollection, AbstractSession session) {
if(this.listOrderField != null) {
return compareLists((List)firstCollection, (List)secondCollection, session, true);
}
ContainerPolicy cp = this.containerPolicy;
if (cp.sizeFor(firstCollection) != cp.sizeFor(secondCollection)) {
return false;
}
Object firstIter = cp.iteratorFor(firstCollection);
Object secondIter = cp.iteratorFor(secondCollection);
Map keyValueToObject = new HashMap(cp.sizeFor(firstCollection));
while (cp.hasNext(secondIter)) {
Object secondObject = cp.next(secondIter, session);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject, session);
keyValueToObject.put(primaryKey, secondObject);
}
while (cp.hasNext(firstIter)) {
Object firstObject = cp.next(firstIter, session);
Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject, session);
if (keyValueToObject.containsKey(primaryKey)) {
Object object = keyValueToObject.get(primaryKey);
if (!session.compareObjects(firstObject, object)) {
return false;
}
} else {
return false;
}
}
return true;
}
/**
* Compare two lists. For equality the order of the elements should be the same.
* Used only if listOrderField != null
*/
protected boolean compareLists(List firstList, List secondList, AbstractSession session, boolean withPrivateOwned) {
if (firstList.size() != secondList.size()) {
return false;
}
int size = firstList.size();
for(int i=0; i < size; i++) {
Object firstObject = firstList.get(i);
Object secondObject = secondList.get(i);
if(withPrivateOwned) {
if(!session.compareObjects(firstObject, secondObject)) {
return false;
}
} else {
Object firstKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject, session);
Object secondKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject, session);
if (!firstKey.equals(secondKey)) {
return false;
}
}
}
return true;
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this mapping to actual class-based
* settings
* This method is implemented by subclasses as necessary.
* @param classLoader
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader){
super.convertClassNamesToClasses(classLoader);
containerPolicy.convertClassNamesToClasses(classLoader);
}
/**
* INTERNAL:
* Extract the value from the batch optimized query, this should be supported by most query types.
*/
@Override
public Object extractResultFromBatchQuery(ReadQuery batchQuery, CacheKey parentCacheKey, AbstractRecord sourceRow, AbstractSession session, ObjectLevelReadQuery originalQuery) throws QueryException {
Object result = super.extractResultFromBatchQuery(batchQuery, parentCacheKey, sourceRow, session, originalQuery);
// The source object might not have any target objects.
if (result == null) {
return this.containerPolicy.containerInstance();
} else {
return result;
}
}
/**
* INTERNAL:
* Prepare and execute the batch query and store the
* results for each source object in a map keyed by the
* mappings source keys of the source objects.
*/
@Override
protected void executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map referenceObjectsByKey, AbstractSession session, AbstractRecord translationRow) {
// Execute query and index resulting object sets by key.
ReadAllQuery batchQuery = (ReadAllQuery)query;
ComplexQueryResult complexResult = (ComplexQueryResult)session.executeQuery(batchQuery, translationRow);
Object results = complexResult.getResult();
Iterator rowsIterator = ((List)complexResult.getData()).iterator();
ContainerPolicy queryContainerPolicy = batchQuery.getContainerPolicy();
if (this.containerPolicy.shouldAddAll()) {
// Indexed list mappings require special add that include the row data with the index.
Map referenceObjectsAndRowsByKey = new HashMap();
for (Object objectsIterator = queryContainerPolicy.iteratorFor(results); queryContainerPolicy.hasNext(objectsIterator);) {
Object eachReferenceObject = queryContainerPolicy.next(objectsIterator, session);
AbstractRecord row = rowsIterator.next();
Object eachReferenceKey = extractKeyFromTargetRow(row, session);
List[] objectsAndRows = referenceObjectsAndRowsByKey.get(eachReferenceKey);
if (objectsAndRows == null) {
objectsAndRows = new List[]{new ArrayList(), new ArrayList()};
referenceObjectsAndRowsByKey.put(eachReferenceKey, objectsAndRows);
}
objectsAndRows[0].add(eachReferenceObject);
objectsAndRows[1].add(row);
}
Iterator> iterator = referenceObjectsAndRowsByKey.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = iterator.next();
Object eachReferenceKey = entry.getKey();
List objects = entry.getValue()[0];
List rows = entry.getValue()[1];
Object container = this.containerPolicy.containerInstance(objects.size());
this.containerPolicy.addAll(objects, container, query.getSession(), rows, batchQuery, parentCacheKey, true);
referenceObjectsByKey.put(eachReferenceKey, container);
}
} else {
// Non-indexed list, either normal collection, or a map key.
for (Object objectsIterator = queryContainerPolicy.iteratorFor(results); queryContainerPolicy.hasNext(objectsIterator);) {
Object eachReferenceObject = queryContainerPolicy.next(objectsIterator, session);
AbstractRecord row = rowsIterator.next();
// Handle duplicate rows in the ComplexQueryResult being replaced with null, as a
// result of duplicate filtering being true for constructing the ComplexQueryResult
while (row == null && rowsIterator.hasNext()) {
row = rowsIterator.next();
}
Object eachReferenceKey = extractKeyFromTargetRow(row, session);
Object container = referenceObjectsByKey.get(eachReferenceKey);
if ((container == null) || (container == Helper.NULL_VALUE)) {
container = this.containerPolicy.containerInstance();
referenceObjectsByKey.put(eachReferenceKey, container);
}
this.containerPolicy.addInto(eachReferenceObject, container, session, row, batchQuery, parentCacheKey, true);
}
}
}
/**
* INTERNAL:
* Extract the source primary key value from the target row.
* Used for batch reading, most following same order and fields as in the mapping.
* The method should be overridden by classes that support batch reading.
*/
protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
throw QueryException.batchReadingNotSupported(this, null);
}
/**
* INTERNAL:
* We are not using a remote valueholder
* so we need to replace the reference object(s) with
* the corresponding object(s) from the remote session.
*/
@Override
public void fixRealObjectReferences(Object object, Map objectDescriptors, Map processedObjects, ObjectLevelReadQuery query, DistributedSession session) {
//bug 4147755 getRealAttribute... / setReal
Object attributeValue = getRealAttributeValueFromObject(object, session);
// the object collection could be null, check here to avoid NPE
if (attributeValue == null) {
setAttributeValueInObject(object, null);
return;
}
ObjectLevelReadQuery tempQuery = query;
if (!tempQuery.shouldMaintainCache()) {
if ((!tempQuery.shouldCascadeParts()) || (tempQuery.shouldCascadePrivateParts() && (!isPrivateOwned()))) {
tempQuery = null;
}
}
Object remoteAttributeValue = session.getObjectsCorrespondingToAll(attributeValue, objectDescriptors, processedObjects, tempQuery, this.containerPolicy);
setRealAttributeValueInObject(object, remoteAttributeValue);
}
/**
* INTERNAL:
* Returns the receiver's containerPolicy.
*/
public ContainerPolicy getContainerPolicy() {
return containerPolicy;
}
protected ModifyQuery getDeleteAllQuery() {
if (deleteAllQuery == null) {
deleteAllQuery = new DataModifyQuery();
}
return deleteAllQuery;
}
/**
* INTERNAL:
* Returns the join criteria stored in the mapping selection query. This criteria
* is used to read reference objects across the tables from the database.
*/
@Override
public Expression getJoinCriteria(ObjectExpression context, Expression base) {
Expression selectionCriteria = getSelectionCriteria();
Expression keySelectionCriteria = this.containerPolicy.getKeySelectionCriteria();
if (keySelectionCriteria != null) {
selectionCriteria = selectionCriteria.and(keySelectionCriteria);
}
return context.getBaseExpression().twist(selectionCriteria, base);
}
/**
* INTERNAL:
* return the object on the client corresponding to the specified object.
* CollectionMappings have to worry about
* maintaining object identity.
*/
@Override
public Object getObjectCorrespondingTo(Object object, DistributedSession session, Map objectDescriptors, Map processedObjects, ObjectLevelReadQuery query) {
return session.getObjectsCorrespondingToAll(object, objectDescriptors, processedObjects, query, this.containerPolicy);
}
/**
* INTERNAL:
* Return the ordering query keys.
* Used for Workbench integration.
*/
public List getOrderByQueryKeyExpressions() {
List expressions = new ArrayList ();
if ((getSelectionQuery() != null) && getSelectionQuery().isReadAllQuery()) {
for (Expression orderExpression : ((ReadAllQuery)getSelectionQuery()).getOrderByExpressions()) {
if (orderExpression.isFunctionExpression() && ((FunctionExpression)orderExpression).getBaseExpression().isQueryKeyExpression()) {
expressions.add(orderExpression);
}
}
}
return expressions;
}
/**
* INTERNAL:
* Get the container policy from the selection query for this mapping. This
* method is overridden in DirectCollectionMapping since its selection
* query is a DataReadQuery.
*/
protected ContainerPolicy getSelectionQueryContainerPolicy() {
return ((ReadAllQuery) getSelectionQuery()).getContainerPolicy();
}
/**
* Convenience method.
* Return the value of an attribute, unwrapping value holders if necessary.
* If the value is null, build a new container.
*/
@Override
public Object getRealCollectionAttributeValueFromObject(Object object, AbstractSession session) throws DescriptorException {
Object value = getRealAttributeValueFromObject(object, session);
if (value == null) {
value = this.containerPolicy.containerInstance(1);
}
return value;
}
/**
* PUBLIC:
* Field holds the order of elements in the list in the db, requires collection of type List;
* may be not null only in case isListOrderFieldSupported==true.
*/
public DatabaseField getListOrderField() {
return listOrderField;
}
/**
* INTERNAL:
* Returns list of primary key fields from the reference descriptor.
*/
public List getTargetPrimaryKeyFields() {
return getReferenceDescriptor().getPrimaryKeyFields();
}
/**
* PUBLIC:
* Specifies what should be done if the list of values read from listOrserField is invalid
* (there should be no nulls, no duplicates, no "holes").
*/
public OrderCorrectionType getOrderCorrectionType() {
return this.orderCorrectionType;
}
protected boolean hasCustomDeleteAllQuery() {
return hasCustomDeleteAllQuery;
}
/**
* INTERNAL:
* Return true if ascending or descending ordering has been set on this
* mapping via the @OrderBy annotation.
*/
public boolean hasOrderBy() {
return hasOrderBy;
}
/**
* INTERNAL:
* Initialize the state of mapping.
*/
@Override
public void initialize(AbstractSession session) throws DescriptorException {
super.initialize(session);
setFields(collectFields());
this.containerPolicy.prepare(getSelectionQuery(), session);
// Check that the container policy is correct for the collection type.
if ((!usesIndirection()) && (!getAttributeAccessor().getAttributeClass().isAssignableFrom(this.containerPolicy.getContainerClass()))) {
throw DescriptorException.incorrectCollectionPolicy(this, getAttributeAccessor().getAttributeClass(), this.containerPolicy.getContainerClass());
}
if(listOrderField != null) {
initializeListOrderField(session);
}
}
/**
* INTERNAL:
* Initializes listOrderField.
* Precondition: listOrderField != null.
*/
protected void initializeListOrderField(AbstractSession session) {
if(!List.class.isAssignableFrom(getAttributeAccessor().getAttributeClass())) {
throw DescriptorException.listOrderFieldRequiersList(getDescriptor(), this);
}
boolean isAttributeAssignableFromIndirectList = getAttributeAccessor().getAttributeClass().isAssignableFrom(IndirectList.class);
if(this.orderCorrectionType == null) {
// set default validation mode
if(isAttributeAssignableFromIndirectList) {
this.orderCorrectionType = OrderCorrectionType.READ_WRITE;
} else {
this.orderCorrectionType = OrderCorrectionType.READ;
}
} else if(this.orderCorrectionType == OrderCorrectionType.READ_WRITE) {
//OrderValidationMode.CORRECTION sets container class to IndirectList, make sure the attribute is of compatible type.
if(!isAttributeAssignableFromIndirectList) {
throw DescriptorException.listOrderFieldRequiersIndirectList(getDescriptor(), this);
}
}
ContainerPolicy originalQueryContainerPolicy = getSelectionQueryContainerPolicy();
if(!this.containerPolicy.isOrderedListPolicy()) {
setContainerPolicy(new OrderedListContainerPolicy(this.containerPolicy.getContainerClass()));
// re-prepare replaced container policy as we are initializing
getContainerPolicy().prepare(getSelectionQuery(), session);
}
OrderedListContainerPolicy orderedListContainerPolicy = (OrderedListContainerPolicy)this.containerPolicy;
orderedListContainerPolicy.setListOrderField(this.listOrderField);
orderedListContainerPolicy.setOrderCorrectionType(this.orderCorrectionType);
// If ContainerPolicy's container class is IndirectList, originalQueryContainerPolicy's container class is not (likely Vector)
// and orderCorrectionType doesn't require query to use IndirectList - then query will keep a separate container policy
// that uses its original container class (likely Vector) - this is the same optimization as used in useTransparentList method.
if(this.containerPolicy.getContainerClass().isAssignableFrom(IndirectList.class) &&
!IndirectList.class.isAssignableFrom(originalQueryContainerPolicy.getContainerClass()) &&
this.orderCorrectionType != OrderCorrectionType.READ_WRITE ||
originalQueryContainerPolicy == this.getSelectionQueryContainerPolicy())
{
OrderedListContainerPolicy queryOrderedListContainerPolicy;
if(originalQueryContainerPolicy.getClass().equals(orderedListContainerPolicy.getClass())) {
// original query container policy
queryOrderedListContainerPolicy = (OrderedListContainerPolicy)originalQueryContainerPolicy;
queryOrderedListContainerPolicy.setListOrderField(this.listOrderField);
queryOrderedListContainerPolicy.setOrderCorrectionType(this.orderCorrectionType);
} else {
// clone mapping's container policy
queryOrderedListContainerPolicy = (OrderedListContainerPolicy)orderedListContainerPolicy.clone();
queryOrderedListContainerPolicy.setContainerClass(originalQueryContainerPolicy.getContainerClass());
setSelectionQueryContainerPolicy(queryOrderedListContainerPolicy);
}
}
if(this.listOrderField.getType() == null) {
this.listOrderField.setType(Integer.class);
}
buildListOrderField();
// DirectCollectMap - that uses DataReadQuery - adds listOrderField to selection query in initializeSelectionStatement method.
if (getSelectionQuery().isReadAllQuery()) {
if(shouldUseListOrderFieldTableExpression()) {
initializeListOrderFieldTable(session);
}
}
initializeChangeOrderTargetQuery(session);
}
/**
* INTERNAL:
* Initializes listOrderField's table, does nothing by default.
* Precondition: listOrderField != null.
*/
protected void initializeListOrderFieldTable(AbstractSession session) {
}
/**
* INTERNAL:
* Verifies listOrderField's table, if none found sets the default one.
* Precondition: listOrderField != null.
*/
protected void buildListOrderField() {
if(this.listOrderField.hasTableName()) {
if(!this.getReferenceDescriptor().getDefaultTable().equals(this.listOrderField.getTable())) {
throw DescriptorException.listOrderFieldTableIsWrong(this.getDescriptor(), this, this.listOrderField.getTable(), this.getReferenceDescriptor().getDefaultTable());
}
} else {
this.listOrderField.setTable(this.getReferenceDescriptor().getDefaultTable());
}
this.listOrderField = this.getReferenceDescriptor().buildField(this.listOrderField);
}
/**
* ADVANCED:
* This method should only be called after this mapping's indirection policy has been set
*
* IndirectList and IndirectSet can be configured not to instantiate the list from the
* database when you add and remove from them. IndirectList defaults to this behavior. When
* Set to true, the collection associated with this TransparentIndirection will be setup so as
* not to instantiate for adds and removes. The weakness of this setting for an IndirectSet is
* that when the set is not instantiated, if a duplicate element is added, it will not be
* detected until commit time.
*/
public Boolean shouldUseLazyInstantiationForIndirectCollection() {
if (getIndirectionPolicy() == null){
return null;
}
return getIndirectionPolicy().shouldUseLazyInstantiation();
}
/**
* INTERNAL:
* Indicates whether getListOrderFieldExpression method should create field expression based on table expression.
*/
public boolean shouldUseListOrderFieldTableExpression() {
return false;
}
/**
* INTERNAL:
* Initialize changeOrderTargetQuery.
*/
protected void initializeChangeOrderTargetQuery(AbstractSession session) {
}
/**
* INTERNAL:
* Return whether this mapping is a Collection type.
*/
@Override
public boolean isCollectionMapping() {
return true;
}
/**
* INTERNAL:
* Return if this mapping has a mapped key that uses a OneToOne (object).
*/
public boolean isMapKeyObjectRelationship() {
return this.containerPolicy.isMapKeyObject();
}
/**
* INTERNAL:
* The referenced object is checked if it is instantiated or not,
* also check if it has been changed (as indirect collections avoid instantiation on add/remove.
*/
public boolean isAttributeValueInstantiatedOrChanged(Object object) {
return this.indirectionPolicy.objectIsInstantiatedOrChanged(getAttributeValueFromObject(object));
}
/**
* INTERNAL:
* Iterate on the specified element.
*/
public void iterateOnElement(DescriptorIterator iterator, Object element) {
iterator.iterateReferenceObjectForMapping(element, this);
}
/**
* INTERNAL:
* Iterate on the attribute value.
* The value holder has already been processed.
*/
@Override
public void iterateOnRealAttributeValue(DescriptorIterator iterator, Object realAttributeValue) {
if (realAttributeValue == null) {
return;
}
ContainerPolicy cp = this.containerPolicy;
for (Object iter = cp.iteratorFor(realAttributeValue); cp.hasNext(iter);) {
Object wrappedObject = cp.nextEntry(iter, iterator.getSession());
Object object = cp.unwrapIteratorResult(wrappedObject);
iterateOnElement(iterator, object);
cp.iterateOnMapKey(iterator, wrappedObject);
}
}
/**
* Force instantiation of the load group.
*/
@Override
public void load(final Object object, AttributeItem item, final AbstractSession session, final boolean fromFetchGroup) {
instantiateAttribute(object, session);
if (item.getGroup() != null && (!fromFetchGroup || session.isUnitOfWork()) ){
//if UOW make sure the nested attributes are loaded as the clones will not be instantiated
Object value = getRealAttributeValueFromObject(object, session);
ContainerPolicy cp = this.containerPolicy;
for (Object iterator = cp.iteratorFor(value); cp.hasNext(iterator);) {
Object wrappedObject = cp.nextEntry(iterator, session);
Object nestedObject = cp.unwrapIteratorResult(wrappedObject);
session.load(nestedObject, item.getGroup(nestedObject.getClass()), getReferenceDescriptor(), fromFetchGroup);
}
}
}
/**
* Force instantiation of all indirections.
*/
@Override
public void loadAll(Object object, AbstractSession session, IdentityHashSet loaded) {
instantiateAttribute(object, session);
ClassDescriptor referenceDescriptor = getReferenceDescriptor();
if (referenceDescriptor != null) {
boolean hasInheritance = referenceDescriptor.hasInheritance();
Object value = getRealAttributeValueFromObject(object, session);
ContainerPolicy cp = this.containerPolicy;
for (Object iterator = cp.iteratorFor(value); cp.hasNext(iterator);) {
Object wrappedObject = cp.nextEntry(iterator, session);
Object nestedObject = cp.unwrapIteratorResult(wrappedObject);
if (hasInheritance && !nestedObject.getClass().equals(referenceDescriptor.getJavaClass())){
ClassDescriptor concreteReferenceDescriptor = referenceDescriptor.getInheritancePolicy().getDescriptor(nestedObject.getClass());
concreteReferenceDescriptor.getObjectBuilder().loadAll(nestedObject, session, loaded);
} else {
referenceDescriptor.getObjectBuilder().loadAll(nestedObject, session, loaded);
}
}
}
}
/**
* ADVANCED:
* Return whether the reference objects must be deleted
* one by one, as opposed to with a single DELETE statement.
*/
public boolean mustDeleteReferenceObjectsOneByOne() {
return this.mustDeleteReferenceObjectsOneByOne == null || this.mustDeleteReferenceObjectsOneByOne;
}
/**
* INTERNAL:
* Merge changes from the source to the target object.
* Because this is a collection mapping, values are added to or removed from the
* collection based on the changeset
*/
@Override
public void mergeChangesIntoObject(Object target, ChangeRecord chgRecord, Object source, MergeManager mergeManager, AbstractSession targetSession) {
if (this.descriptor.getCachePolicy().isProtectedIsolation()&& !this.isCacheable && !targetSession.isProtectedSession()){
setAttributeValueInObject(target, this.indirectionPolicy.buildIndirectObject(new ValueHolder(null)));
return;
}
Object valueOfTarget = null;
Object valueOfSource = null;
ContainerPolicy containerPolicy = this.containerPolicy;
CollectionChangeRecord changeRecord = (CollectionChangeRecord) chgRecord;
UnitOfWorkChangeSet uowChangeSet = (UnitOfWorkChangeSet)changeRecord.getOwner().getUOWChangeSet();
// Collect the changes into a vector. Check to see if the target has an instantiated
// collection, if it does then iterate over the changes and merge the collections.
if (isAttributeValueInstantiated(target)) {
// If it is new will need a new collection.
if (changeRecord.getOwner().isNew()) {
valueOfTarget = containerPolicy.containerInstance(changeRecord.getAddObjectList().size());
} else {
if (isSynchronizeOnMerge) {
valueOfTarget = getRealCollectionAttributeValueFromObject(target, mergeManager.getSession());
} else {
// Clone instead of synchronization to avoid possible deadlocks.
valueOfTarget = containerPolicy.cloneFor(getRealCollectionAttributeValueFromObject(target, mergeManager.getSession()));
}
}
containerPolicy.mergeChanges(changeRecord, valueOfTarget, shouldMergeCascadeParts(mergeManager), mergeManager, targetSession, isSynchronizeOnMerge);
} else {
// The valueholder has not been instantiated
if (mergeManager.shouldMergeChangesIntoDistributedCache()) {
return; // do nothing
}
// PERF: Also avoid merge if source has not been instantiated for indirect collection adds.
if (!isAttributeValueInstantiated(source)) {
return;
}
// If I'm not merging on another server then create instance of the collection
valueOfSource = getRealCollectionAttributeValueFromObject(source, mergeManager.getSession());
Object iterator = containerPolicy.iteratorFor(valueOfSource);
valueOfTarget = containerPolicy.containerInstance(containerPolicy.sizeFor(valueOfSource));
while (containerPolicy.hasNext(iterator)) {
// CR#2195 Problem with merging Collection mapping in unit of work and inheritance.
Object objectToMerge = containerPolicy.next(iterator, mergeManager.getSession());
if (shouldMergeCascadeParts(mergeManager) && (valueOfSource != null)) {
ObjectChangeSet changeSet = (ObjectChangeSet)uowChangeSet.getObjectChangeSetForClone(objectToMerge);
mergeManager.mergeChanges(objectToMerge, changeSet, targetSession);
}
// Let the mergemanager get it because I don't have the change for the object.
// CR#2188 Problem with merging Collection mapping in unit of work and transparent indirection.
containerPolicy.addInto(mergeManager.getTargetVersionOfSourceObject(objectToMerge, referenceDescriptor, targetSession), valueOfTarget, mergeManager.getSession());
}
}
if (valueOfTarget == null) {
valueOfTarget = containerPolicy.containerInstance();
}
setRealAttributeValueInObject(target, valueOfTarget);
}
/**
* INTERNAL:
* Merge changes from the source to the target object. This merge is only called when a changeSet for the target
* does not exist or the target is uninitialized
*/
@Override
public void mergeIntoObject(Object target, boolean isTargetUnInitialized, Object source, MergeManager mergeManager, AbstractSession targetSession) {
if (this.descriptor.getCachePolicy().isProtectedIsolation() && !this.isCacheable && !targetSession.isProtectedSession()){
setAttributeValueInObject(target, this.indirectionPolicy.buildIndirectObject(new ValueHolder(null)));
return;
}
if (isTargetUnInitialized) {
// This will happen if the target object was removed from the cache before the commit was attempted
if (mergeManager.shouldMergeWorkingCopyIntoOriginal() && (!isAttributeValueInstantiated(source))) {
setAttributeValueInObject(target, this.indirectionPolicy.getOriginalIndirectionObject(getAttributeValueFromObject(source), targetSession));
return;
}
}
if (!shouldMergeCascadeReference(mergeManager)) {
// This is only going to happen on mergeClone, and we should not attempt to merge the reference
return;
}
if (mergeManager.shouldRefreshRemoteObject() && usesIndirection()) {
mergeRemoteValueHolder(target, source, mergeManager);
return;
}
if (mergeManager.isForRefresh()) {
if (!isAttributeValueInstantiated(target)) {
if(shouldRefreshCascadeParts(mergeManager)){
// We must clone and set the value holder from the source to the target.
// This ensures any cascaded refresh will be applied to the UOW backup valueholder
Object attributeValue = getAttributeValueFromObject(source);
Object clonedAttributeValue = this.indirectionPolicy.cloneAttribute(attributeValue, source, null, target, null, mergeManager.getSession(), false); // building clone from an original not a row.
setAttributeValueInObject(target, clonedAttributeValue);
}
// This will occur when the clone's value has not been instantiated yet and we do not need
// the refresh that attribute
return;
}
} else if (!isAttributeValueInstantiatedOrChanged(source)) {
// I am merging from a clone into an original. No need to do merge if the attribute was never
// modified
return;
}
Object valueOfSource = getRealCollectionAttributeValueFromObject(source, mergeManager.getSession());
// There is a very special case when merging into the shared cache that the original
// has been refreshed and now has non-instantiated indirection objects.
// Force instantiation is not necessary and can cause problem with JTS drivers.
AbstractSession mergeSession = mergeManager.getSession();
Object valueOfTarget = getRealCollectionAttributeValueFromObject(target, mergeSession);
ContainerPolicy containerPolicy = this.containerPolicy;
// BUG#5190470 Must force instantiation of indirection collections.
containerPolicy.sizeFor(valueOfTarget);
boolean fireChangeEvents = false;
ObjectChangeListener listener = null;
Object valueOfSourceCloned = null;
if (!mergeManager.isForRefresh()) {
// EL Bug 338504 - No Need to clone in this case.
valueOfSourceCloned = valueOfSource;
// if we are copying from original to clone then the source will be
// instantiated anyway and we must continue to use the UnitOfWork
// valueholder in the case of transparent indirection
Object newContainer = containerPolicy.containerInstance(containerPolicy.sizeFor(valueOfSourceCloned));
if ((this.descriptor.getObjectChangePolicy().isObjectChangeTrackingPolicy()) && (target instanceof ChangeTracker) && (((ChangeTracker)target)._persistence_getPropertyChangeListener() != null)) {
// Avoid triggering events if we are dealing with the same list.
// We rebuild the new container though since any cascade merge
// activity such as lifecycle methods etc will be captured on
// newly registered objects and not the clones and we need to
// make sure the target has these updates once we are done.
fireChangeEvents = (valueOfSourceCloned != valueOfTarget);
// Collections may not be indirect list or may have been replaced with user collection.
Object iterator = containerPolicy.iteratorFor(valueOfTarget);
listener = (ObjectChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener();
if (fireChangeEvents) {
// Objects removed from the first position in the list, so the index of the removed object is always 0.
// When event is processed the index is used only in listOrderField case, ignored otherwise.
Integer zero = Integer.valueOf(0);
while (containerPolicy.hasNext(iterator)) {
CollectionChangeEvent event = containerPolicy.createChangeEvent(target, getAttributeName(), valueOfTarget, containerPolicy.next(iterator, mergeSession), CollectionChangeEvent.REMOVE, zero, false);
listener.internalPropertyChange(event);
}
}
if (newContainer instanceof ChangeTracker) {
((CollectionChangeTracker)newContainer).setTrackedAttributeName(getAttributeName());
((CollectionChangeTracker)newContainer)._persistence_setPropertyChangeListener(listener);
}
if (valueOfTarget instanceof ChangeTracker) {
((ChangeTracker)valueOfTarget)._persistence_setPropertyChangeListener(null);//remove listener
}
}
valueOfTarget = newContainer;
} else {
if (isSynchronizeOnMerge) {
// EL Bug 338504 - It needs to iterate on object which can possibly
// cause a deadlock scenario while merging changes from original
// to the working copy during rollback of the transaction. So, clone
// the original object instead of synchronizing on it and use cloned
// object to iterate and merge changes to the working copy.
synchronized(valueOfSource) {
valueOfSourceCloned = containerPolicy.cloneFor(valueOfSource);
}
} else {
valueOfSourceCloned = valueOfSource;
}
//bug 3953038 - set a new collection in the object until merge completes, this
// prevents rel-maint. from adding duplicates.
setRealAttributeValueInObject(target, containerPolicy.containerInstance(containerPolicy.sizeFor(valueOfSourceCloned)));
containerPolicy.clear(valueOfTarget);
}
Object sourceIterator = containerPolicy.iteratorFor(valueOfSourceCloned);
// Index of the added object - objects are added to the end of the list.
// When event is processed the index is used only in listOrderField case, ignored otherwise.
int i = 0;
while (containerPolicy.hasNext(sourceIterator)) {
Object wrappedObject = containerPolicy.nextEntry(sourceIterator, mergeManager.getSession());
Object object = containerPolicy.unwrapIteratorResult(wrappedObject);
if (object == null) {
continue;// skip the null
}
if (shouldMergeCascadeParts(mergeManager)) {
Object mergedObject = null;
if ((mergeManager.getSession().isUnitOfWork()) && (((UnitOfWorkImpl)mergeManager.getSession()).getUnitOfWorkChangeSet() != null)) {
// If it is a unit of work, we have to check if I have a change Set for this object
mergedObject = mergeManager.mergeChanges(mergeManager.getObjectToMerge(object, referenceDescriptor, targetSession), (ObjectChangeSet)((UnitOfWorkImpl)mergeManager.getSession()).getUnitOfWorkChangeSet().getObjectChangeSetForClone(object), targetSession);
if (listener != null && !fireChangeEvents && mergedObject != object){
// we are merging a collection into itself that contained detached or new Entities. make sure to remove the
// old change records // bug 302293
this.descriptor.getObjectChangePolicy().updateListenerForSelfMerge(listener, this, object, mergedObject, (UnitOfWorkImpl) mergeManager.getSession());
}
} else {
mergedObject = mergeManager.mergeChanges(mergeManager.getObjectToMerge(object, referenceDescriptor, targetSession), null, targetSession);
}
}
wrappedObject = containerPolicy.createWrappedObjectFromExistingWrappedObject(wrappedObject, source, referenceDescriptor, mergeManager, targetSession);
if (isSynchronizeOnMerge) {
synchronized (valueOfTarget) {
if (fireChangeEvents) {
//Collections may not be indirect list or may have been replaced with user collection.
//bug 304251: let the ContainerPolicy decide what changeevent object to create
CollectionChangeEvent event = containerPolicy.createChangeEvent(target, getAttributeName(), valueOfTarget, wrappedObject, CollectionChangeEvent.ADD, i++, false);
listener.internalPropertyChange(event);
}
containerPolicy.addInto(wrappedObject, valueOfTarget, mergeManager.getSession());
}
} else {
if (fireChangeEvents) {
//Collections may not be indirect list or may have been replaced with user collection.
//bug 304251: let the ContainerPolicy decide what changeevent object to create
CollectionChangeEvent event = containerPolicy.createChangeEvent(target, getAttributeName(), valueOfTarget, wrappedObject, CollectionChangeEvent.ADD, i++, false);
listener.internalPropertyChange(event);
}
containerPolicy.addInto(wrappedObject, valueOfTarget, mergeManager.getSession());
}
}
if (fireChangeEvents && (this.descriptor.getObjectChangePolicy().isAttributeChangeTrackingPolicy())) {
// check that there were changes, if not then remove the record.
ObjectChangeSet changeSet = ((AttributeChangeListener)((ChangeTracker)target)._persistence_getPropertyChangeListener()).getObjectChangeSet();
//Bug4910642 Add NullPointer check
if (changeSet != null) {
CollectionChangeRecord changeRecord = (CollectionChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName());
if (changeRecord != null) {
if (!changeRecord.isDeferred()) {
if (!changeRecord.hasChanges()) {
changeSet.removeChange(getAttributeName());
}
} else {
// Must reset the latest collection.
changeRecord.setLatestCollection(valueOfTarget);
}
}
}
}
// Must re-set variable to allow for set method to re-morph changes if the collection is not being stored directly.
setRealAttributeValueInObject(target, valueOfTarget);
}
/**
* INTERNAL:
* An object was added to the collection during an update, insert it if private.
*/
protected void objectAddedDuringUpdate(ObjectLevelModifyQuery query, Object objectAdded, ObjectChangeSet changeSet, Map extraData) throws DatabaseException, OptimisticLockException {
if (!shouldObjectModifyCascadeToParts(query)) {// Called always for M-M
return;
}
// Only cascade dependents writes in uow.
if (query.shouldCascadeOnlyDependentParts()) {
return;
}
// Insert must not be done for uow or cascaded queries and we must cascade to cascade policy.
// We should distinguish between insert and write (optimization/paraniod).
if (isPrivateOwned()) {
InsertObjectQuery insertQuery = new InsertObjectQuery();
insertQuery.setIsExecutionClone(true);
insertQuery.setObject(containerPolicy.unwrapIteratorResult(objectAdded));
insertQuery.setCascadePolicy(query.getCascadePolicy());
query.getSession().executeQuery(insertQuery);
} else {
// Always write for updates, either private or in uow if calling this method.
UnitOfWorkChangeSet uowChangeSet = null;
if ((changeSet == null) && query.getSession().isUnitOfWork() && (((UnitOfWorkImpl)query.getSession()).getUnitOfWorkChangeSet() != null)) {
uowChangeSet = (UnitOfWorkChangeSet)((UnitOfWorkImpl)query.getSession()).getUnitOfWorkChangeSet();
changeSet = (ObjectChangeSet)uowChangeSet.getObjectChangeSetForClone(query.getObject());
}
WriteObjectQuery writeQuery = new WriteObjectQuery();
writeQuery.setIsExecutionClone(true);
writeQuery.setObject(containerPolicy.unwrapIteratorResult(objectAdded));
writeQuery.setObjectChangeSet(changeSet);
writeQuery.setCascadePolicy(query.getCascadePolicy());
query.getSession().executeQuery(writeQuery);
}
}
protected void objectOrderChangedDuringUpdate(WriteObjectQuery query, Object orderChangedObject, int orderIndex) {
prepareTranslationRow(query.getTranslationRow(), query.getObject(), query.getDescriptor(), query.getSession());
AbstractRecord databaseRow = new DatabaseRecord();
// Extract target field and its value. Construct insert statement and execute it
List targetPrimaryKeyFields = getTargetPrimaryKeyFields();
int size = targetPrimaryKeyFields.size();
for (int index = 0; index < size; index++) {
DatabaseField targetPrimaryKey = targetPrimaryKeyFields.get(index);
Object targetKeyValue = getReferenceDescriptor().getObjectBuilder().extractValueFromObjectForField(orderChangedObject, targetPrimaryKey, query.getSession());
databaseRow.put(targetPrimaryKey, targetKeyValue);
}
databaseRow.put(listOrderField, orderIndex);
query.getSession().executeQuery(changeOrderTargetQuery, databaseRow);
}
/**
* INTERNAL:
* An object was removed to the collection during an update, delete it if private.
*/
protected void objectRemovedDuringUpdate(ObjectLevelModifyQuery query, Object objectDeleted, Map extraData) throws DatabaseException, OptimisticLockException {
if (isPrivateOwned()) {// Must check ownership for uow and cascading.
if (!query.shouldCascadeOnlyDependentParts()) {
containerPolicy.deleteWrappedObject(objectDeleted, query.getSession());
}
}
}
/**
* INTERNAL:
* An object is still in the collection, update it as it may have changed.
*/
protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, Object object) throws DatabaseException, OptimisticLockException {
if (!shouldObjectModifyCascadeToParts(query)) {// Called always for M-M
return;
}
// Only cascade dependents writes in uow.
if (query.shouldCascadeOnlyDependentParts()) {
return;
}
// Always write for updates, either private or in uow if calling this method.
WriteObjectQuery writeQuery = new WriteObjectQuery();
writeQuery.setIsExecutionClone(true);
writeQuery.setObject(object);
writeQuery.setCascadePolicy(query.getCascadePolicy());
query.getSession().executeQuery(writeQuery);
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
@Override
public void postCalculateChanges(org.eclipse.persistence.sessions.changesets.ChangeRecord changeRecord, UnitOfWorkImpl uow) {
// no need for private owned check. This code is only registered for private owned mappings.
// targets are added to and/or removed to/from the source.
CollectionChangeRecord collectionChangeRecord = (CollectionChangeRecord)changeRecord;
Iterator it = collectionChangeRecord.getRemoveObjectList().values().iterator();
while(it.hasNext()) {
ObjectChangeSet ocs = (ObjectChangeSet)it.next();
containerPolicy.postCalculateChanges(ocs, referenceDescriptor, this, uow);
}
}
/**
* INTERNAL:
* Overridden by mappings that require additional processing of the change record after the record has been calculated.
*/
@Override
public void recordPrivateOwnedRemovals(Object object, UnitOfWorkImpl uow) {
// no need for private owned check. This code is only registered for private owned mappings.
// targets are added to and/or removed to/from the source.
if (mustDeleteReferenceObjectsOneByOne()) {
Iterator it = (Iterator) containerPolicy.iteratorFor(getRealAttributeValueFromObject(object, uow));
while (it.hasNext()) {
Object clone = it.next();
containerPolicy.recordPrivateOwnedRemovals(clone, referenceDescriptor, uow);
}
}
}
/**
* INTERNAL:
* Add additional fields
*/
@Override
protected void postPrepareNestedBatchQuery(ReadQuery batchQuery, ObjectLevelReadQuery query) {
super.postPrepareNestedBatchQuery(batchQuery, query);
ReadAllQuery mappingBatchQuery = (ReadAllQuery)batchQuery;
mappingBatchQuery.setShouldIncludeData(true);
this.containerPolicy.addAdditionalFieldsToQuery(mappingBatchQuery, getAdditionalFieldsBaseExpression(mappingBatchQuery));
}
/**
* INTERNAL:
* Return the base expression to use for adding fields to the query.
* Normally this is the query's builder, but may be the join table for m-m.
*/
protected Expression getAdditionalFieldsBaseExpression(ReadQuery query) {
return ((ReadAllQuery)query).getExpressionBuilder();
}
/**
* INTERNAL:
* copies the non primary key information into the row currently used only in ManyToMany
*/
protected void prepareTranslationRow(AbstractRecord translationRow, Object object, ClassDescriptor descriptor, AbstractSession session) {
//Do nothing for the generic Collection Mapping
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to delete the reference objects after the actual object is deleted.
*/
@Override
public void postDelete(DeleteObjectQuery query) throws DatabaseException {
if (this.containerPolicy.propagatesEventsToCollection()){
Object queryObject = query.getObject();
Object values = getAttributeValueFromObject(queryObject);
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, query.getSession());
containerPolicy.propogatePostDelete(query, wrappedObject);
}
}
}
/**
* INTERNAL:
* Ensure the container policy is post initialized
*/
@Override
public void postInitialize(AbstractSession session) {
super.postInitialize(session);
this.containerPolicy.postInitialize(session);
if (this.referenceDescriptor != null && this.mustDeleteReferenceObjectsOneByOne == null) {
this.mustDeleteReferenceObjectsOneByOne = this.referenceDescriptor.hasDependencyOnParts()
|| this.referenceDescriptor.usesOptimisticLocking()
|| (this.referenceDescriptor.hasInheritance() && this.referenceDescriptor.getInheritancePolicy().shouldReadSubclasses())
|| this.referenceDescriptor.hasMultipleTables() || this.containerPolicy.propagatesEventsToCollection()
|| this.referenceDescriptor.hasRelationshipsExceptBackpointer(descriptor);
} else if (this.mustDeleteReferenceObjectsOneByOne == null) {
this.mustDeleteReferenceObjectsOneByOne = false;
}
}
/**
* INTERNAL:
* A subclass should implement this method if it wants different behavior.
* Recurse thru the parts to delete the reference objects after the actual object is deleted.
*/
@Override
public void postInsert(WriteObjectQuery query) throws DatabaseException {
if (this.containerPolicy.propagatesEventsToCollection()){
Object queryObject = query.getObject();
Object values = getAttributeValueFromObject(queryObject);
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, query.getSession());
containerPolicy.propogatePostInsert(query, wrappedObject);
}
}
}
/**
* INTERNAL:
* Propagate preInsert event to container policy if necessary
*/
@Override
public void preInsert(WriteObjectQuery query) throws DatabaseException, OptimisticLockException {
if (this.containerPolicy.propagatesEventsToCollection()){
Object queryObject = query.getObject();
Object values = getAttributeValueFromObject(queryObject);
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, query.getSession());
containerPolicy.propogatePreInsert(query, wrappedObject);
}
}
}
/**
* INTERNAL:
* Propagate preUpdate event to container policy if necessary
*/
@Override
public void preUpdate(WriteObjectQuery query) throws DatabaseException {
if (this.containerPolicy.propagatesEventsToCollection()){
Object queryObject = query.getObject();
Object values = getAttributeValueFromObject(queryObject);
Object iterator = containerPolicy.iteratorFor(values);
while (containerPolicy.hasNext(iterator)){
Object wrappedObject = containerPolicy.nextEntry(iterator, query.getSession());
containerPolicy.propogatePreUpdate(query, wrappedObject);
}
}
}
/**
* INTERNAL:
* An object is still in the collection, update it as it may have changed.
*/
protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, Object object, Map backupclones, Object key) throws DatabaseException, OptimisticLockException {
objectUnchangedDuringUpdate(query, object);
}
/**
* INTERNAL:
* All the privately owned parts are read
*/
protected Object readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery) throws DatabaseException {
if (modifyQuery.getSession().isUnitOfWork()) {
return getRealCollectionAttributeValueFromObject(modifyQuery.getBackupClone(), modifyQuery.getSession());
} else {
// cr 3819
prepareTranslationRow(modifyQuery.getTranslationRow(), modifyQuery.getObject(), modifyQuery.getDescriptor(), modifyQuery.getSession());
return modifyQuery.getSession().executeQuery(getSelectionQuery(), modifyQuery.getTranslationRow());
}
}
/**
* INTERNAL:
* replace the value holders in the specified reference object(s)
*/
@Override
public Map replaceValueHoldersIn(Object object, RemoteSessionController controller) {
return controller.replaceValueHoldersInAll(object, this.containerPolicy);
}
/**
* ADVANCED:
* Configure the mapping to use a container policy.
* The policy manages the access to the collection.
*/
public void setContainerPolicy(ContainerPolicy containerPolicy) {
this.containerPolicy = containerPolicy;
((ReadAllQuery)getSelectionQuery()).setContainerPolicy(containerPolicy);
}
/**
* PUBLIC:
* The default delete all query for mapping can be overridden by specifying the new query.
* This query is responsible for doing the deletion required by the mapping,
* such as deletion of all the rows from join table for M-M, or optimized delete all of target objects for 1-M.
*/
public void setCustomDeleteAllQuery(ModifyQuery query) {
setDeleteAllQuery(query);
setHasCustomDeleteAllQuery(true);
}
protected void setDeleteAllQuery(ModifyQuery query) {
deleteAllQuery = query;
}
/**
* PUBLIC:
* Set the receiver's delete all 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 SQL is responsible for doing the deletion required by the mapping,
* such as deletion of all the rows from join table for M-M, or optimized delete all of target objects for 1-M.
* Example, 'delete from PROJ_EMP where EMP_ID = #EMP_ID'.
*/
public void setDeleteAllSQLString(String sqlString) {
DataModifyQuery query = new DataModifyQuery();
query.setSQLString(sqlString);
setCustomDeleteAllQuery(query);
}
/**
* PUBLIC:
* Set the receiver's delete all 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 call is responsible for doing the deletion required by the mapping,
* such as deletion of all the rows from join table for M-M, or optimized delete all of target objects for 1-M.
* Example, 'new SQLCall("delete from PROJ_EMP where EMP_ID = #EMP_ID")'.
*/
public void setDeleteAllCall(Call call) {
DataModifyQuery query = new DataModifyQuery();
query.setCall(call);
setCustomDeleteAllQuery(query);
}
protected void setHasCustomDeleteAllQuery(boolean bool) {
hasCustomDeleteAllQuery = bool;
}
/**
* INTERNAL:
* Set the container policy on the selection query for this mapping. This
* method is overridden in DirectCollectionMapping since its selection
* query is a DataReadQuery.
*/
protected void setSelectionQueryContainerPolicy(ContainerPolicy containerPolicy) {
((ReadAllQuery) getSelectionQuery()).setContainerPolicy(containerPolicy);
}
/**
* 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.
*/
public void setSessionName(String name) {
getDeleteAllQuery().setSessionName(name);
getSelectionQuery().setSessionName(name);
}
/**
* ADVANCED:
* Calling this method will only affect behavior of mappings using transparent indirection
* This method should only be called after this mapping's indirection policy has been set
*
* IndirectList and IndirectSet can be configured not to instantiate the list from the
* database when you add and remove from them. IndirectList defaults to this behavior. When
* Set to true, the collection associated with this TransparentIndirection will be setup so as
* not to instantiate for adds and removes. The weakness of this setting for an IndirectSet is
* that when the set is not instantiated, if a duplicate element is added, it will not be
* detected until commit time.
*/
public void setUseLazyInstantiationForIndirectCollection(Boolean useLazyInstantiation) {
if (getIndirectionPolicy() != null){
getIndirectionPolicy().setUseLazyInstantiation(useLazyInstantiation);
}
}
/**
* ADVANCED:
* This method is used to have an object add to a collection once the changeSet is applied
* The referenceKey parameter should only be used for direct Maps.
*/
public void simpleAddToCollectionChangeRecord(Object referenceKey, Object changeSetToAdd, ObjectChangeSet changeSet, AbstractSession session) {
CollectionChangeRecord collectionChangeRecord = (CollectionChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new CollectionChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
changeSet.addChange(collectionChangeRecord);
}
this.containerPolicy.recordAddToCollectionInChangeRecord((ObjectChangeSet)changeSetToAdd, collectionChangeRecord);
if (referenceKey != null) {
((ObjectChangeSet)changeSetToAdd).setNewKey(referenceKey);
}
}
/**
* ADVANCED:
* This method is used to have an object removed from a collection once the changeSet is applied
* The referenceKey parameter should only be used for direct Maps.
*/
public void simpleRemoveFromCollectionChangeRecord(Object referenceKey, Object changeSetToRemove, ObjectChangeSet changeSet, AbstractSession session) {
CollectionChangeRecord collectionChangeRecord = (CollectionChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new CollectionChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
changeSet.addChange(collectionChangeRecord);
}
this.containerPolicy.recordRemoveFromCollectionInChangeRecord((ObjectChangeSet)changeSetToRemove, collectionChangeRecord);
if (referenceKey != null) {
((ObjectChangeSet)changeSetToRemove).setOldKey(referenceKey);
}
}
/**
* INTERNAL:
* Either create a new change record or update with the new value. This is used
* by attribute change tracking.
* Specifically in a collection mapping this will be called when the customer
* Set a new collection. In this case we will need to mark the change record
* with the new and the old versions of the collection.
* And mark the ObjectChangeSet with the attribute name then when the changes are calculated
* force a compare on the collections to determine changes.
*/
@Override
public void updateChangeRecord(Object clone, Object newValue, Object oldValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) {
CollectionChangeRecord collectionChangeRecord = (CollectionChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new CollectionChangeRecord(objectChangeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
objectChangeSet.addChange(collectionChangeRecord);
}
// the order is essential - the record should be set to deferred before recreateOriginalCollection is called -
// otherwise will keep altering the change record while adding/removing each element into/from the original collection.
collectionChangeRecord.setIsDeferred(true);
objectChangeSet.deferredDetectionRequiredOn(getAttributeName());
if (collectionChangeRecord.getOriginalCollection() == null) {
collectionChangeRecord.recreateOriginalCollection(oldValue, uow);
}
collectionChangeRecord.setLatestCollection(newValue);
}
/**
* INTERNAL:
* Update a ChangeRecord to replace the ChangeSet for the old entity with the changeSet for the new Entity. This is
* used when an Entity is merged into itself and the Entity reference new or detached entities.
*/
public void updateChangeRecordForSelfMerge(ChangeRecord changeRecord, Object source, Object target, UnitOfWorkChangeSet parentUOWChangeSet, UnitOfWorkImpl unitOfWork){
getContainerPolicy().updateChangeRecordForSelfMerge(changeRecord, source, target, this, parentUOWChangeSet, unitOfWork);
}
/**
* INTERNAL:
* Add or removes a new value and its change set to the collection change record based on the event passed in. This is used by
* attribute change tracking.
*/
public void updateCollectionChangeRecord(CollectionChangeEvent event, ObjectChangeSet changeSet, UnitOfWorkImpl uow) {
if (event !=null && event.getNewValue() != null) {
Object newValue = event.getNewValue();
ClassDescriptor descriptor;
//PERF: Use referenceDescriptor if it does not have inheritance
if (!getReferenceDescriptor().hasInheritance()) {
descriptor = getReferenceDescriptor();
} else {
descriptor = uow.getDescriptor(newValue);
}
newValue = descriptor.getObjectBuilder().unwrapObject(newValue, uow);
ObjectChangeSet changeSetToAdd = descriptor.getObjectBuilder().createObjectChangeSet(newValue, (UnitOfWorkChangeSet)changeSet.getUOWChangeSet(), uow);
CollectionChangeRecord collectionChangeRecord = (CollectionChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName());
if (collectionChangeRecord == null) {
collectionChangeRecord = new CollectionChangeRecord(changeSet);
collectionChangeRecord.setAttribute(getAttributeName());
collectionChangeRecord.setMapping(this);
changeSet.addChange(collectionChangeRecord);
}
if(!collectionChangeRecord.isDeferred()) {
this.containerPolicy.recordUpdateToCollectionInChangeRecord(event, changeSetToAdd, collectionChangeRecord);
}
}
}
/**
* INTERNAL:
* Set the change listener in the collection.
* If the collection is not indirect it must be re-built.
* This is used for resuming or flushing units of work.
*/
@Override
public void setChangeListener(Object clone, PropertyChangeListener listener, UnitOfWorkImpl uow) {
if (this.indirectionPolicy.usesTransparentIndirection() && isAttributeValueInstantiated(clone)) {
Object attributeValue = getRealAttributeValueFromObject(clone, uow);
if (!(attributeValue instanceof CollectionChangeTracker)) {
Object container = attributeValue;
ContainerPolicy containerPolicy = this.containerPolicy;
if (attributeValue == null) {
container = containerPolicy.containerInstance(1);
} else {
container = containerPolicy.containerInstance(containerPolicy.sizeFor(attributeValue));
for (Object iterator = containerPolicy.iteratorFor(attributeValue); containerPolicy.hasNext(iterator);) {
containerPolicy.addInto(containerPolicy.nextEntry(iterator, uow), container, uow);
}
}
setRealAttributeValueInObject(clone, container);
((CollectionChangeTracker)container).setTrackedAttributeName(getAttributeName());
((CollectionChangeTracker)container)._persistence_setPropertyChangeListener(listener);
} else {
((CollectionChangeTracker)attributeValue).setTrackedAttributeName(getAttributeName());
((CollectionChangeTracker)attributeValue)._persistence_setPropertyChangeListener(listener);
}
}
if (this.indirectionPolicy.usesTransparentIndirection()){
((IndirectCollection)getRealAttributeValueFromObject(clone, uow)).clearDeferredChanges();
}
}
/**
* PUBLIC:
* indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception.
*/
public boolean isListOrderFieldSupported() {
return isListOrderFieldSupported;
}
/**
* PUBLIC:
* Field holds the order of elements in the list in the db, requires collection of type List.
* Throws exception if the mapping doesn't support listOrderField.
*/
public void setListOrderField(DatabaseField field) {
if(field != null) {
if(isListOrderFieldSupported) {
this.listOrderField = field;
} else {
throw ValidationException.listOrderFieldNotSupported(this);
}
} else {
this.listOrderField = null;
}
}
/**
* PUBLIC:
* Field holds the order of elements in the list in the db, requires collection of type List.
* Throws exception if the mapping doesn't support listOrderField.
*/
public void setListOrderFieldName(String fieldName) {
setListOrderField(new DatabaseField(fieldName));
}
/**
* ADVANCED::
* Return whether the reference objects must be deleted
* one by one, as opposed to with a single DELETE statement.
* Note: Calling this method disables an optimization of the delete
* behavior
*/
public void setMustDeleteReferenceObjectsOneByOne(Boolean deleteOneByOne) {
this.mustDeleteReferenceObjectsOneByOne = deleteOneByOne;
}
/**
* PUBLIC:
* Specifies what should be done if the list of values read from listOrserField is invalid
* (there should be no nulls, no duplicates, no "holes").
*/
public void setOrderCorrectionType(OrderCorrectionType orderCorrectionType) {
this.orderCorrectionType = orderCorrectionType;
}
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
* Note that if listOrderField is used then setListOrderField method
* should be called before this method.
*
The container class must implement (directly or indirectly) the
* java.util.Collection interface.
*/
public void useCollectionClass(Class concreteClass) {
ContainerPolicy policy = ContainerPolicy.buildPolicyFor(concreteClass, hasOrderBy() || listOrderField != null);
setContainerPolicy(policy);
}
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
*
The container class must implement (directly or indirectly) the
* java.util.SortedSet interface.
*/
public void useSortedSetClass(Class concreteClass, Comparator comparator) {
try {
SortedCollectionContainerPolicy policy = (SortedCollectionContainerPolicy)ContainerPolicy.buildPolicyFor(concreteClass);
policy.setComparator(comparator);
setContainerPolicy(policy);
} catch (ClassCastException e) {
useCollectionClass(concreteClass);
}
}
/**
* INTERNAL:
* Configure the mapping to use an instance of the specified container class name
* to hold the target objects. This method is used by MW.
*
The container class must implement (directly or indirectly) the
* java.util.SortedSet interface.
*/
public void useSortedSetClassName(String className) {
this.useSortedSetClassName(className, null);
}
/**
* INTERNAL:
* Configure the mapping to use an instance of the specified container class name
* to hold the target objects. This method is used by MW.
*
The container class must implement (directly or indirectly) the
* java.util.SortedSet interface.
*/
public void useSortedSetClassName(String className, String comparatorClassName) {
SortedCollectionContainerPolicy policy = new SortedCollectionContainerPolicy(className);
policy.setComparatorClassName(comparatorClassName);
setContainerPolicy(policy);
}
/**
* INTERNAL:
* Used to set the collection class by name.
* This is required when building from metadata to allow the correct class loader to be used.
*/
public void useCollectionClassName(String concreteClassName) {
setContainerPolicy(new CollectionContainerPolicy(concreteClassName));
}
/**
* INTERNAL:
* Used to set the collection class by name.
* This is required when building from metadata to allow the correct class loader to be used.
*/
public void useListClassName(String concreteClassName) {
setContainerPolicy(new ListContainerPolicy(concreteClassName));
}
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects. The key used to index a value in the
* Map is the value returned by a call to the specified
* zero-argument method.
* The method must be implemented by the class (or a superclass) of any
* value to be inserted into the Map.
*
The container class must implement (directly or indirectly) the
* java.util.Map interface.
*
To facilitate resolving the method, the mapping's referenceClass
* must set before calling this method.
*/
public void useMapClass(Class concreteClass, String keyName) {
// the reference class has to be specified before coming here
if (getReferenceClassName() == null) {
throw DescriptorException.referenceClassNotSpecified(this);
}
ContainerPolicy policy = ContainerPolicy.buildPolicyFor(concreteClass);
policy.setKeyName(keyName, getReferenceClassName());
setContainerPolicy(policy);
}
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container
* class to hold the target objects. The key used to index a value in the
* Map is an instance of the composite primary key class.
*
To facilitate resolving the primary key class, the mapping's
* referenceClass must set before calling this method.
*
The container class must implement (directly or indirectly) the
* java.util.Map interface.
*/
public void useMapClass(Class concreteClass) {
useMapClass(concreteClass, null);
}
/**
* INTERNAL:
* Not sure were this is used, MW?
*/
public void useMapClassName(String concreteClassName, String methodName) {
// the reference class has to be specified before coming here
if (getReferenceClassName() == null) {
throw DescriptorException.referenceClassNotSpecified(this);
}
MapContainerPolicy policy = new MapContainerPolicy(concreteClassName);
policy.setKeyName(methodName, getReferenceClass().getName());
setContainerPolicy(policy);
}
/**
* PUBLIC:
* If transparent indirection is used, a special collection will be placed in the source
* object's attribute.
* Fetching of the contents of the collection from the database will be delayed
* until absolutely necessary. (Any message sent to the collection will cause
* the contents to be faulted in from the database.)
* This can result in rather significant performance gains, without having to change
* the source object's attribute from Collection (or List or Vector) to
* ValueHolderInterface.
*/
public void useTransparentCollection() {
setIndirectionPolicy(new TransparentIndirectionPolicy());
useCollectionClass(ClassConstants.IndirectList_Class);
}
/**
* PUBLIC:
* If transparent indirection is used, a special collection will be placed in the source
* object's attribute.
* Fetching of the contents of the collection from the database will be delayed
* until absolutely necessary. (Any message sent to the collection will cause
* the contents to be faulted in from the database.)
* This can result in rather significant performance gains, without having to change
* the source object's attribute from Set to
* ValueHolderInterface.
*/
public void useTransparentSet() {
setIndirectionPolicy(new TransparentIndirectionPolicy());
useCollectionClass(IndirectSet.class);
setSelectionQueryContainerPolicy(ContainerPolicy.buildPolicyFor(HashSet.class));
}
/**
* PUBLIC:
* If transparent indirection is used, a special collection will be placed in the source
* object's attribute.
* Fetching of the contents of the collection from the database will be delayed
* until absolutely necessary. (Any message sent to the collection will cause
* the contents to be faulted in from the database.)
* This can result in rather significant performance gains, without having to change
* the source object's attribute from List to
* ValueHolderInterface.
*/
public void useTransparentList() {
setIndirectionPolicy(new TransparentIndirectionPolicy());
useCollectionClass(ClassConstants.IndirectList_Class);
setSelectionQueryContainerPolicy(ContainerPolicy.buildPolicyFor(Vector.class, hasOrderBy() || listOrderField != null));
}
/**
* PUBLIC:
* If transparent indirection is used, a special map will be placed in the source
* object's attribute.
* Fetching of the contents of the map from the database will be delayed
* until absolutely necessary. (Any message sent to the map will cause
* the contents to be faulted in from the database.)
* This can result in rather significant performance gains, without having to change
* the source object's attribute from Map (or Map or Hashtable) to
* ValueHolderInterface.
* The key used in the Map is the value returned by a call to the zero parameter
* method named methodName. The method should be a zero argument method implemented (or
* inherited) by the value to be inserted into the Map.
*/
public void useTransparentMap(String methodName) {
setIndirectionPolicy(new TransparentIndirectionPolicy());
useMapClass(ClassConstants.IndirectMap_Class, methodName);
ContainerPolicy policy = ContainerPolicy.buildPolicyFor(Hashtable.class);
policy.setKeyName(methodName, getReferenceClass());
setSelectionQueryContainerPolicy(policy);
}
/**
* INTERNAL:
* To validate mappings declaration
*/
@Override
public void validateBeforeInitialization(AbstractSession session) throws DescriptorException {
super.validateBeforeInitialization(session);
this.indirectionPolicy.validateContainerPolicy(session.getIntegrityChecker());
if (getAttributeAccessor() instanceof InstanceVariableAttributeAccessor) {
Class attributeType = ((InstanceVariableAttributeAccessor)getAttributeAccessor()).getAttributeType();
this.indirectionPolicy.validateDeclaredAttributeTypeForCollection(attributeType, session.getIntegrityChecker());
} else if (getAttributeAccessor().isMethodAttributeAccessor()) {
// 323403
Class returnType = ((MethodAttributeAccessor)getAttributeAccessor()).getGetMethodReturnType();
this.indirectionPolicy.validateGetMethodReturnTypeForCollection(returnType, session.getIntegrityChecker());
Class parameterType = ((MethodAttributeAccessor)getAttributeAccessor()).getSetMethodParameterType();
this.indirectionPolicy.validateSetMethodParameterTypeForCollection(parameterType, session.getIntegrityChecker());
}
}
/**
* INTERNAL:
* Checks if object is deleted from the database or not.
*/
@Override
public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException {
// Row is built for translation
if (isReadOnly()) {
return true;
}
if (isPrivateOwned() || isCascadeRemove()) {
Object objects = getRealCollectionAttributeValueFromObject(object, session);
ContainerPolicy containerPolicy = this.containerPolicy;
for (Object iter = containerPolicy.iteratorFor(objects); containerPolicy.hasNext(iter);) {
if (!session.verifyDelete(containerPolicy.next(iter, session))) {
return false;
}
}
}
AbstractRecord row = getDescriptor().getObjectBuilder().buildRowForTranslation(object, session);
//cr 3819 added the line below to fix the translationtable to ensure that it
// contains the required values
prepareTranslationRow(row, object, getDescriptor(), session);
Object value = session.executeQuery(getSelectionQuery(), row);
return this.containerPolicy.isEmpty(value);
}
/**
* INTERNAL:
* Return if this mapping supports change tracking.
*/
@Override
public boolean isChangeTrackingSupported(Project project) {
return this.indirectionPolicy.usesTransparentIndirection();
}
/**
* INTERNAL:
* Directly build a change record without comparison
*/
@Override
public ChangeRecord buildChangeRecord(Object clone, ObjectChangeSet owner, AbstractSession session) {
Object cloneAttribute = null;
cloneAttribute = getAttributeValueFromObject(clone);
if ((cloneAttribute != null) && (!this.indirectionPolicy.objectIsInstantiated(cloneAttribute))) {
return null;
}
// 2612538 - the default size of Map (32) is appropriate
IdentityHashMap cloneKeyValues = new IdentityHashMap();
ContainerPolicy cp = this.containerPolicy;
Object cloneObjectCollection = null;
if (cloneAttribute != null) {
cloneObjectCollection = getRealCollectionAttributeValueFromObject(clone, session);
} else {
cloneObjectCollection = cp.containerInstance(1);
}
Object cloneIter = cp.iteratorFor(cloneObjectCollection);
while (cp.hasNext(cloneIter)) {
Object firstObject = cp.next(cloneIter, session);
if (firstObject != null) {
cloneKeyValues.put(firstObject, firstObject);
}
}
CollectionChangeRecord changeRecord = new CollectionChangeRecord(owner);
changeRecord.setAttribute(getAttributeName());
changeRecord.setMapping(this);
changeRecord.addAdditionChange(cloneKeyValues, cp, (UnitOfWorkChangeSet)owner.getUOWChangeSet(), session);
if (changeRecord.hasChanges()) {
return changeRecord;
}
return null;
}
/**
* INTERNAL:
* This method is used to load a relationship from a list of PKs. This list
* may be available if the relationship has been cached.
*/
@Override
public Object valueFromPKList(Object[] pks, AbstractRecord foreignKeys, AbstractSession session){
ContainerPolicy cp = this.containerPolicy;
return cp.valueFromPKList(pks, foreignKeys, this, session);
}
/**
* INTERNAL:
* Return the value of the field from the row or a value holder on the query to obtain the object.
* To get here the mapping's isJoiningSupported() should return true.
*/
@Override
protected Object valueFromRowInternalWithJoin(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, CacheKey parentCacheKey, AbstractSession executionSession, boolean isTargetProtected) throws DatabaseException {
Object value = this.containerPolicy.containerInstance();
// Extract the primary key of the source object, to filter only the joined rows for that object.
Object sourceKey = this.descriptor.getObjectBuilder().extractPrimaryKeyFromRow(row, executionSession);
// If the query was using joining, all of the result rows by primary key will have been computed.
List rows = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
// If no 1-m rows were fetch joined, then get the value normally,
// this can occur with pagination where the last row may not be complete.
if (rows == null) {
return valueFromRowInternal(row, joinManager, sourceQuery, executionSession);
}
int size = rows.size();
if (size > 0) {
// A nested query must be built to pass to the descriptor that looks like the real query execution would,
// these should be cached on the query during prepare.
ObjectLevelReadQuery nestedQuery = prepareNestedJoinQueryClone(row, rows, joinManager, sourceQuery, executionSession);
// A set of target cache keys must be maintained to avoid duplicates from multiple 1-m joins.
Set targetPrimaryKeys = new HashSet();
ArrayList targetObjects = null;
ArrayList targetRows = null;
boolean shouldAddAll = this.containerPolicy.shouldAddAll();
if (shouldAddAll) {
targetObjects = new ArrayList(size);
targetRows = new ArrayList(size);
}
// For each rows, extract the target row and build the target object and add to the collection.
for (int index = 0; index < size; index++) {
AbstractRecord sourceRow = rows.get(index);
AbstractRecord targetRow = sourceRow;
// The field for many objects may be in the row,
// so build the subpartion of the row through the computed values in the query,
// this also helps the field indexing match.
targetRow = trimRowForJoin(targetRow, joinManager, executionSession);
// Partial object queries must select the primary key of the source and related objects.
// If the target joined rows in null (outerjoin) means an empty collection.
Object targetKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromRow(targetRow, executionSession);
if (targetKey == null) {
// A null primary key means an empty collection returned as nulls from an outerjoin.
return this.indirectionPolicy.valueFromRow(value);
}
// Only build/add the target object once, skip duplicates from multiple 1-m joins.
if (!targetPrimaryKeys.contains(targetKey)) {
nestedQuery.setTranslationRow(targetRow);
targetPrimaryKeys.add(targetKey);
Object targetObject = getReferenceDescriptor().getObjectBuilder().buildObject(nestedQuery, targetRow);
Object targetMapKey = this.containerPolicy.buildKeyFromJoinedRow(targetRow, joinManager, nestedQuery, parentCacheKey, executionSession, isTargetProtected);
nestedQuery.setTranslationRow(null);
if (targetMapKey == null){
if (shouldAddAll) {
targetObjects.add(targetObject);
targetRows.add(targetRow);
} else {
this.containerPolicy.addInto(targetObject, value, executionSession);
}
} else {
this.containerPolicy.addInto(targetMapKey, targetObject, value, executionSession);
}
}
}
if (shouldAddAll) {
this.containerPolicy.addAll(targetObjects, value, executionSession, targetRows, nestedQuery, parentCacheKey, isTargetProtected);
}
}
return this.indirectionPolicy.valueFromRow(value);
}
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/ContainerMapping.java 0000664 0000000 0000000 00000007447 12216173130 024336 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.mappings;
import org.eclipse.persistence.internal.queries.*;
/**
* Interface used by clients to interact
* with the assorted mappings that use ContainerPolicy.
*
* @see org.eclipse.persistence.internal.queries.ContainerPolicy
*
* @author Big Country
* @since TOPLink/Java 4.0
*/
public interface ContainerMapping {
/**
* PUBLIC:
* Return the mapping's container policy.
*/
ContainerPolicy getContainerPolicy();
/**
* PUBLIC:
* Set the mapping's container policy.
*/
void setContainerPolicy(ContainerPolicy containerPolicy);
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
*
The container class must implement (directly or indirectly) the
* java.util.Collection interface.
*/
void useCollectionClass(Class concreteClass);
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
*
The container class must implement (directly or indirectly) the
* java.util.Collection interface.
*/
void useCollectionClassName(String concreteClass);
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects.
*
The container class must implement (directly or indirectly) the
* java.util.List interface.
*/
void useListClassName(String concreteClass);
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects. The key used to index a value in the
* Map is the value returned by a call to the specified
* zero-argument method.
* The method must be implemented by the class (or a superclass) of any
* value to be inserted into the Map.
*
The container class must implement (directly or indirectly) the
* java.util.Map interface.
*
To facilitate resolving the method, the mapping's referenceClass
* must set before calling this method.
*/
void useMapClass(Class concreteClass, String methodName);
/**
* PUBLIC:
* Configure the mapping to use an instance of the specified container class
* to hold the target objects. The key used to index a value in the
* Map is the value returned by a call to the specified
* zero-argument method.
* The method must be implemented by the class (or a superclass) of any
* value to be inserted into the Map.
*
The container class must implement (directly or indirectly) the
* java.util.Map interface.
*
To facilitate resolving the method, the mapping's referenceClass
* must set before calling this method.
*/
void useMapClassName(String concreteClass, String methodName);
}
eclipselink-2.5.1.orig/org/eclipse/persistence/mappings/AggregateObjectMapping.java 0000664 0000000 0000000 00000302314 12216173130 025420 0 ustar /*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 07/19/2011-2.2.1 Guy Pelletier
* - 338812: ManyToMany mapping in aggregate object violate integrity constraint on deletion
* 08/01/2012-2.5 Chris Delahunt
* - 371950: Metadata caching
* 10/25/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 09 Jan 2013-2.5 Gordon Yorke
* - 397772: JPA 2.1 Entity Graph Support
* 02/11/2013-2.5 Guy Pelletier
* - 365931: @JoinColumn(name="FK_DEPT",insertable = false, updatable = true) causes INSERT statement to include this data value that it is associated with
* 06/03/2013-2.5.1 Guy Pelletier
* - 402380: 3 jpa21/advanced tests failed on server with
* "java.lang.NoClassDefFoundError: org/eclipse/persistence/testing/models/jpa21/advanced/enums/Gender"
******************************************************************************/
package org.eclipse.persistence.mappings;
import java.beans.PropertyChangeListener;
import java.util.*;
import java.util.Map.Entry;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.FetchGroupManager;
import org.eclipse.persistence.descriptors.changetracking.AttributeChangeTrackingPolicy;
import org.eclipse.persistence.descriptors.changetracking.DeferredChangeDetectionPolicy;
import org.eclipse.persistence.descriptors.changetracking.ObjectChangeTrackingPolicy;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.queries.ContainerPolicy;
import org.eclipse.persistence.internal.queries.EntityFetchGroup;
import org.eclipse.persistence.internal.queries.JoinedAttributeManager;
import org.eclipse.persistence.internal.queries.MappedKeyMapContainerPolicy;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.internal.descriptors.DescriptorIterator;
import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.expressions.SQLSelectStatement;
import org.eclipse.persistence.logging.SessionLog;
import org.eclipse.persistence.mappings.converters.Converter;
import org.eclipse.persistence.mappings.foundation.AbstractTransformationMapping;
import org.eclipse.persistence.mappings.foundation.MapKeyMapping;
import org.eclipse.persistence.mappings.querykeys.DirectQueryKey;
import org.eclipse.persistence.mappings.querykeys.QueryKey;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.sessions.Project;
/**
*
Purpose:Two objects can be considered to be related by aggregation if there is a strict
* 1:1 relationship between the objects. This means that the target (child or owned) object
* cannot exist without the source (parent) object.
*
* In TopLink, it also means the data for the owned object is stored in the same table as
* the parent.
*
* @author Sati
* @since TOPLink/Java 1.0
*/
public class AggregateObjectMapping extends AggregateMapping implements RelationalMapping, MapKeyMapping, EmbeddableMapping {
/**
* If all the fields in the database row for the aggregate object are NULL,
* then, by default, the mapping will place a null in the appropriate source object
* (as opposed to an aggregate object filled with nulls).
* To change this behavior, set the value of this variable to false. Then the mapping
* will build a new instance of the aggregate object that is filled with nulls
* and place it in the source object.
*/
protected boolean isNullAllowed;
protected DatabaseTable aggregateKeyTable = null;
/** Map the name of a field in the aggregate descriptor to a field in the source table. */
/** 322233 - changed to store the source DatabaseField to hold Case and other colunm info*/
protected Map aggregateToSourceFields;
/**
* Map of nested attributes that need to apply an override name to their
* a nested aggregate mapping's database field. Aggregate to source fields
* map is the existing EclipseLink functionality and works well when all
* embeddable mappings have unique database fields. This map adds specific
* attribute to database field override.
* @see addFieldTranslation()
*/
protected Map nestedFieldTranslations;
/**
* List of many to many mapping overrides to apply at initialize time to
* their cloned aggregate mappings.
*/
protected List overrideManyToManyMappings;
/**
* List of unidirectional one to many mapping overrides to apply at
* initialize time to their cloned aggregate mappings.
*/
protected List overrideUnidirectionalOneToManyMappings;
/**
* List of converters to apply at initialize time to their cloned aggregate mappings.
*/
protected Map converters;
/**
* List of maps id mappings that need to be set to read only at initialize
* time on their cloned aggregate mappings.
*/
protected List mapsIdMappings;
/**
* Default constructor.
*/
public AggregateObjectMapping() {
aggregateToSourceFields = new HashMap(5);
nestedFieldTranslations = new HashMap();
mapsIdMappings = new ArrayList();
overrideManyToManyMappings = new ArrayList();
overrideUnidirectionalOneToManyMappings = new ArrayList();
converters = new HashMap();
isNullAllowed = true;
}
/**
* INTERNAL:
*/
public boolean isRelationalMapping() {
return true;
}
/**
* INTERNAL:
* Used when initializing queries for mappings that use a Map
* Called when the selection query is being initialized to add the fields for the map key to the query
*/
public void addAdditionalFieldsToQuery(ReadQuery selectionQuery, Expression baseExpression){
for (DatabaseField field : getReferenceDescriptor().getAllFields()) {
if (selectionQuery.isObjectLevelReadQuery()) {
((ObjectLevelReadQuery)selectionQuery).addAdditionalField(baseExpression.getField(field));
} else if (selectionQuery.isDataReadQuery()) {
((SQLSelectStatement)((DataReadQuery)selectionQuery).getSQLStatement()).addField(baseExpression.getField(field));
}
}
}
/**
* Add a converter to be applied to a mapping of the aggregate descriptor.
*/
public void addConverter(Converter converter, String attributeName) {
converters.put(attributeName, converter);
}
/**
* INTERNAL:
* Used when initializing queries for mappings that use a Map
* Called when the insert query is being initialized to ensure the fields for the map key are in the insert query
*/
public void addFieldsForMapKey(AbstractRecord joinRow){
for (DatabaseMapping mapping : getReferenceDescriptor().getMappings()) {
if (!mapping.isReadOnly()) {
for (DatabaseField field : mapping.getFields()) {
if (field.isUpdatable()){
joinRow.put(field, null);
}
}
}
}
}
/**
* PUBLIC:
* Add a field name translation that maps from a field name in the
* source table to a field name in the aggregate descriptor.
*/
public void addFieldNameTranslation(String sourceFieldName, String aggregateFieldName) {
// 322233 - changed to store the sourceField instead of sourceFieldName
addFieldTranslation(new DatabaseField(sourceFieldName), aggregateFieldName);
}
/**
* PUBLIC:
* Add a field translation that maps from a field in the
* source table to a field name in the aggregate descriptor.
*/
public void addFieldTranslation(DatabaseField sourceField, String aggregateFieldName) {
//AggregateObjectMapping does not seem to support Aggregates on multiple tables
String unQualifiedAggregateFieldName = aggregateFieldName.substring(aggregateFieldName.lastIndexOf('.') + 1);// -1 is returned for no ".".
getAggregateToSourceFields().put(unQualifiedAggregateFieldName, sourceField);
}
/**
* INTERNAL:
* In JPA users may specify a maps id mapping on a shared embeddable
* descriptor. These mappings need to be set to read-only at initialize
* time, after the reference descriptor is cloned.
*/
public void addMapsIdMapping(DatabaseMapping mapping) {
mapsIdMappings.add(mapping);
}
/**
* INTERNAL:
* Add a nested field translation that maps from a field in the source table
* to a field name in a nested aggregate descriptor. These are handled
* slightly different that regular field translations in that they are
* unique based on the attribute name. It solves the case where multiple
* nested embeddables have mappings to similarly named default columns.
*/
public void addNestedFieldTranslation(String attributeName, DatabaseField sourceField, String aggregateFieldName) {
// Aggregate field name is redundant here as we will look up the field
// through the attribute name. This method signature is to satisfy the
// Embeddable interface. AggregateCollectionMapping uses the aggregate
// field name.
nestedFieldTranslations.put(attributeName, new Object[]{sourceField, aggregateFieldName});
}
/**
* INTERNAL:
* In JPA users may specify overrides to apply to a many to many mapping
* on a shared embeddable descriptor. These settings are applied at
* initialize time, after the reference descriptor is cloned.
*/
public void addOverrideManyToManyMapping(ManyToManyMapping mapping) {
overrideManyToManyMappings.add(mapping);
}
/**
* INTERNAL:
* In JPA users may specify overrides to apply to a unidirectional one to
* many mapping on a shared embeddable descriptor. These settings are
* applied at initialize time, after the reference descriptor is cloned.
*/
public void addOverrideUnidirectionalOneToManyMapping(UnidirectionalOneToManyMapping mapping) {
overrideUnidirectionalOneToManyMappings.add(mapping);
}
/**
* INTERNAL:
* For mappings used as MapKeys in MappedKeyContainerPolicy. Add the target of this mapping to the deleted
* objects list if necessary
*
* This method is used for removal of private owned relationships.
* AggregateObjectMappings are dealt with in their parent delete, so this is a no-op.
*
* @param object
* @param manager
*/
public void addKeyToDeletedObjectsList(Object object, Map deletedObjects){
}
/**
* INTERNAL:
* Return whether all the aggregate fields in the specified
* row are NULL.
*/
protected boolean allAggregateFieldsAreNull(AbstractRecord databaseRow) {
Vector fields = getReferenceFields();
int size = fields.size();
for (int index = 0; index < size; index++) {
DatabaseField field = (DatabaseField)fields.get(index);
Object value = databaseRow.get(field);
if (value != null) {
return false;
}
}
return true;
}
/**
* PUBLIC:
* If all the fields in the database row for the aggregate object are NULL,
* then, by default, the mapping will place a null in the appropriate source object
* (as opposed to an aggregate object filled with nulls). This behavior can be
* explicitly set by calling #allowNull().
* To change this behavior, call #dontAllowNull(). Then the mapping
* will build a new instance of the aggregate object that is filled with nulls
* and place it in the source object.
* In either situation, when writing, the mapping will place a NULL in all the
* fields in the database row for the aggregate object.
*
* Note: Any aggregate that has a relationship mapping automatically does not allow
* null.
*/
public void allowNull() {
setIsNullAllowed(true);
}
/**
* INTERNAL:
* Return whether the query's backup object has an attribute
* value of null.
*/
protected boolean backupAttributeValueIsNull(WriteObjectQuery query) {
if (query.getSession().isUnitOfWork()) {
Object backupAttributeValue = getAttributeValueFromObject(query.getBackupClone());
if (backupAttributeValue == null) {
return true;
}
}
return false;
}
/**
* INTERNAL:
* Build and return an aggregate object from the specified row.
* If a null value is allowed and all the appropriate fields in the row are NULL, return a null.
* If an aggregate is referenced by the target object, return it (maintain identity)
* Otherwise, simply create a new aggregate object and return it.
*/
public Object buildAggregateFromRow(AbstractRecord databaseRow, Object targetObject, CacheKey cacheKey, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, boolean buildShallowOriginal, AbstractSession executionSession, boolean targetIsProtected) throws DatabaseException {
if (databaseRow.hasSopObject()) {
Object sopAggregate = getAttributeValueFromObject(databaseRow.getSopObject());
if ((targetObject != null) && (targetObject != databaseRow.getSopObject())) {
setAttributeValueInObject(targetObject, sopAggregate);
}
return sopAggregate;
}
// check for all NULLs
if (isNullAllowed() && allAggregateFieldsAreNull(databaseRow)) {
return null;
}
// maintain object identity (even if not refreshing) if target object references the aggregate
// if aggregate is not referenced by the target object, construct a new aggregate
Object aggregate = null;
ClassDescriptor descriptor = getReferenceDescriptor();
boolean refreshing = true;
if (targetObject != null){
if (descriptor.hasInheritance()) {
Class newAggregateClass = descriptor.getInheritancePolicy().classFromRow(databaseRow, executionSession);
descriptor = getReferenceDescriptor(newAggregateClass, executionSession);
aggregate = getMatchingAttributeValueFromObject(databaseRow, targetObject, executionSession, descriptor);
if ((aggregate != null) && (aggregate.getClass() != newAggregateClass)) {
// if the class has changed out from underneath us, we cannot preserve object identity
// build a new instance of the *new* class
aggregate = descriptor.getObjectBuilder().buildNewInstance();
refreshing = false;
}
} else {
aggregate = getMatchingAttributeValueFromObject(databaseRow, targetObject, executionSession, descriptor);
}
}
if (aggregate == null) {
aggregate = descriptor.getObjectBuilder().buildNewInstance();
refreshing = false;
}
ObjectBuildingQuery nestedQuery = sourceQuery;
FetchGroup targetFetchGroup = null;
if (sourceQuery.isObjectLevelReadQuery()) {
ObjectLevelReadQuery objectQuery = (ObjectLevelReadQuery)sourceQuery;
ObjectLevelReadQuery nestedObjectQuery = (ObjectLevelReadQuery)nestedQuery;
String attributeName = getAttributeName();
if ((objectQuery.isPartialAttribute(attributeName) || ((joinManager != null) && joinManager.isAttributeJoined(this.descriptor, this)))) {
// A nested query must be built to pass to the descriptor that looks like the real query execution would.
nestedObjectQuery = (ObjectLevelReadQuery)objectQuery.deepClone();
// Must cascade the nested partial/join expression and filter the nested ones.
if (objectQuery.hasPartialAttributeExpressions()) {
nestedObjectQuery.setPartialAttributeExpressions(extractNestedExpressions(objectQuery.getPartialAttributeExpressions(), nestedObjectQuery.getExpressionBuilder(), false));
} else if ( nestedObjectQuery.getJoinedAttributeManager().isToManyJoin()) {
// need the data results to build the child object(s).
List dataResults = new ArrayList();
//setDataResults does processing and calculations (such as DataResultsByPrimaryKey) that we do not want to do on the
//actual data, but it has no other direct set method
nestedObjectQuery.getJoinedAttributeManager().setDataResults(dataResults, executionSession);
//set the dataResults and DataResultsByPrimaryKey directly from the parent
dataResults.addAll(joinManager.getDataResults_());
nestedObjectQuery.getJoinedAttributeManager().getDataResultsByPrimaryKey().putAll(joinManager.getDataResultsByPrimaryKey());
}
nestedObjectQuery.setDescriptor(descriptor);
//need to use the new joinManager which has the proper aggregate descriptor set
joinManager = nestedObjectQuery.getJoinedAttributeManager();
}
if (objectQuery.isAttributeBatchRead(this.descriptor, attributeName)) {
if(nestedObjectQuery == objectQuery) {
// A nested query must be built to pass to the descriptor that looks like the real query execution would.
nestedObjectQuery = (ObjectLevelReadQuery)nestedObjectQuery.clone();
}
// Must carry over properties for batching to work.
nestedObjectQuery.setProperties(objectQuery.getProperties());
// Computed nested batch attribute expressions.
nestedObjectQuery.getBatchFetchPolicy().setAttributeExpressions(extractNestedExpressions(objectQuery.getBatchReadAttributeExpressions(), nestedObjectQuery.getExpressionBuilder(), false));
}
FetchGroup sourceFG = sourceQuery.getExecutionFetchGroup(descriptor);
if (sourceFG != null) {
if(nestedObjectQuery == objectQuery) {
// A nested query must be built to pass to the descriptor that looks like the real query execution would.
nestedObjectQuery = (ObjectLevelReadQuery)nestedObjectQuery.clone();
}
targetFetchGroup = sourceFG.getGroup(getAttributeName());
if(targetFetchGroup != null && sourceQuery.getDescriptor().hasFetchGroupManager()) {
//if the parent object has a fetchgroup manager then aggregates can support a fetchgroup manager
((ObjectLevelReadQuery)nestedObjectQuery).setFetchGroup(targetFetchGroup);
}else{
targetFetchGroup = null;
nestedObjectQuery.setFetchGroup(null);
nestedObjectQuery.setFetchGroupName(null);
}
nestedObjectQuery.setShouldUseDefaultFetchGroup(false);
nestedObjectQuery.prepareFetchGroup();
}
if (descriptor.hasFetchGroupManager()){
descriptor.getFetchGroupManager().unionEntityFetchGroupIntoObject(aggregate, descriptor.getFetchGroupManager().getEntityFetchGroup(targetFetchGroup), executionSession, true);
//merge fetchgroup into aggregate fetchgroup that may have been there from previous read.
}
nestedQuery = nestedObjectQuery;
}
if (buildShallowOriginal) {
descriptor.getObjectBuilder().buildAttributesIntoShallowObject(aggregate, databaseRow, nestedQuery);
} else if (executionSession.isUnitOfWork()) {
descriptor.getObjectBuilder().buildAttributesIntoWorkingCopyClone(aggregate, buildWrapperCacheKeyForAggregate(cacheKey, targetIsProtected), nestedQuery, joinManager, databaseRow, (UnitOfWorkImpl)executionSession, refreshing);
} else {
descriptor.getObjectBuilder().buildAttributesIntoObject(aggregate, buildWrapperCacheKeyForAggregate(cacheKey, targetIsProtected), databaseRow, nestedQuery, joinManager, sourceQuery.getExecutionFetchGroup(descriptor), refreshing, executionSession);
}
if (sourceQuery.shouldMaintainCache() && ! sourceQuery.shouldStoreBypassCache()) {
// Set the fetch group to the domain object, after built.
if ((targetFetchGroup != null) && descriptor.hasFetchGroupManager()) {
EntityFetchGroup entityFetchGroup = (EntityFetchGroup) descriptor.getFetchGroupManager().getEntityFetchGroup(targetFetchGroup).clone();
if (entityFetchGroup !=null){
entityFetchGroup.setRootEntity((FetchGroupTracker) cacheKey.getObject());
entityFetchGroup.setOnEntity(aggregate, executionSession);
}
}
}
return aggregate;
}
/**
* INTERNAL:
* Wrap the aggregate represented by this mapping in a cachekey so it can be processed my
* methods down the stack.
* @param owningCacheKey - the cache key holding the object to extract the aggregate from
* @return
*/
protected CacheKey buildWrapperCacheKeyForAggregate(CacheKey owningCacheKey, boolean targetIsProtected) {
if (!this.descriptor.getCachePolicy().isProtectedIsolation()) {
return owningCacheKey;
}
if (!targetIsProtected || this.isMapKeyMapping || (owningCacheKey == null)) {
return owningCacheKey;
}
CacheKey aggregateKey = owningCacheKey;
Object object = owningCacheKey.getObject();
if (owningCacheKey.getObject() != null) {
Object aggregate = getAttributeValueFromObject(object);
aggregateKey = new CacheKey(null, aggregate, null);
aggregateKey.setProtectedForeignKeys(owningCacheKey.getProtectedForeignKeys());
aggregateKey.setRecord(owningCacheKey.getRecord());
aggregateKey.setIsolated(owningCacheKey.isIsolated());
aggregateKey.setReadTime(owningCacheKey.getReadTime());
}
return aggregateKey;
}
/**
* INTERNAL:
* Write null values for all aggregate fields into the parent row.
*/
protected void writeNullReferenceRow(AbstractRecord record) {
List fields = getReferenceFields();
int size = fields.size();
for (int index = 0; index < size; index++) {
record.put(fields.get(index), null);
}
if (size > 0) {
// EL Bug 319759 - if a field is null, then the update call cache should not be used
record.setNullValueInFields(true);
}
}
/**
* INTERNAL:
* Used to allow object level comparisons.
* In the case of an Aggregate which has no primary key must do an attribute
* by attribute comparison.
*/
public Expression buildObjectJoinExpression(Expression expression, Object value, AbstractSession session) {
Expression attributeByAttributeComparison = null;
Expression join = null;
Object attributeValue = null;
// value need not be unwrapped as it is an aggregate, nor should it
// influence a call to getReferenceDescriptor.
ClassDescriptor referenceDescriptor = getReferenceDescriptor();
if ((value != null) && !referenceDescriptor.getJavaClass().isInstance(value)) {
throw QueryException.incorrectClassForObjectComparison(expression, value, this);
}
Enumeration mappings = referenceDescriptor.getMappings().elements();
for (; mappings.hasMoreElements();) {
DatabaseMapping mapping = (DatabaseMapping)mappings.nextElement();
if (value == null) {
attributeValue = null;
} else {
attributeValue = mapping.getAttributeValueFromObject(value);
}
join = expression.get(mapping.getAttributeName()).equal(attributeValue);
if (attributeByAttributeComparison == null) {
attributeByAttributeComparison = join;
} else {
attributeByAttributeComparison = attributeByAttributeComparison.and(join);
}
}
return attributeByAttributeComparison;
}
/**
* INTERNAL:
* Used to allow object level comparisons.
*/
public Expression buildObjectJoinExpression(Expression expression, Expression argument, AbstractSession session) {
Expression attributeByAttributeComparison = null;
//Enumeration mappingsEnum = getSourceToTargetKeyFields().elements();
Enumeration mappingsEnum = getReferenceDescriptor().getMappings().elements();
for (; mappingsEnum.hasMoreElements();) {
DatabaseMapping mapping = (DatabaseMapping)mappingsEnum.nextElement();
String attributeName = mapping.getAttributeName();
Expression join = expression.get(attributeName).equal(argument.get(attributeName));
if (attributeByAttributeComparison == null) {
attributeByAttributeComparison = join;
} else {
attributeByAttributeComparison = attributeByAttributeComparison.and(join);
}
}
return attributeByAttributeComparison;
}
/**
* INTERNAL:
* Write the aggregate values into the parent row.
*/
protected void writeToRowFromAggregate(AbstractRecord record, Object object, Object attributeValue, AbstractSession session, WriteType writeType) throws DescriptorException {
if (attributeValue == null) {
if (this.isNullAllowed) {
writeNullReferenceRow(record);
} else {
throw DescriptorException.nullForNonNullAggregate(object, this);
}
} else {
if (!session.isClassReadOnly(attributeValue.getClass())) {
getObjectBuilder(attributeValue, session).buildRow(record, attributeValue, session, writeType);
}
}
}
/**
* INTERNAL:
* Write the aggregate values into the parent row for shallow insert.
*/
protected void writeToRowFromAggregateForShallowInsert(AbstractRecord record, Object object, Object attributeValue, AbstractSession session) throws DescriptorException {
if (attributeValue == null) {
if (this.isNullAllowed) {
writeNullReferenceRow(record);
} else {
throw DescriptorException.nullForNonNullAggregate(object, this);
}
} else {
if (!session.isClassReadOnly(attributeValue.getClass())) {
getObjectBuilder(attributeValue, session).buildRowForShallowInsert(record, attributeValue, session);
}
}
}
/**
* INTERNAL:
* Write the aggregate values into the parent row for update after shallow insert.
*/
protected void writeToRowFromAggregateForUpdateAfterShallowInsert(AbstractRecord record, Object object, Object attributeValue, AbstractSession session, DatabaseTable table) throws DescriptorException {
if (attributeValue == null) {
if (!this.isNullAllowed) {
throw DescriptorException.nullForNonNullAggregate(object, this);
}
} else {
if (!session.isClassReadOnly(attributeValue.getClass()) && !isPrimaryKeyMapping()) {
getObjectBuilder(attributeValue, session).buildRowForUpdateAfterShallowInsert(record, attributeValue, session, table);
}
}
}
/**
* INTERNAL:
* Write the aggregate values into the parent row for update before shallow delete.
*/
protected void writeToRowFromAggregateForUpdateBeforeShallowDelete(AbstractRecord record, Object object, Object attributeValue, AbstractSession session, DatabaseTable table) throws DescriptorException {
if (attributeValue == null) {
if (!this.isNullAllowed) {
throw DescriptorException.nullForNonNullAggregate(object, this);
}
} else {
if (!session.isClassReadOnly(attributeValue.getClass()) && !isPrimaryKeyMapping()) {
getObjectBuilder(attributeValue, session).buildRowForUpdateBeforeShallowDelete(record, attributeValue, session, table);
}
}
}
/**
* INTERNAL:
* Build and return a database row built with the values from
* the specified attribute value.
*/
protected void writeToRowFromAggregateWithChangeRecord(AbstractRecord record, ChangeRecord changeRecord, ObjectChangeSet objectChangeSet, AbstractSession session, WriteType writeType) throws DescriptorException {
if (objectChangeSet == null) {
if (this.isNullAllowed) {
writeNullReferenceRow(record);
} else {
Object object = ((ObjectChangeSet)changeRecord.getOwner()).getUnitOfWorkClone();
throw DescriptorException.nullForNonNullAggregate(object, this);
}
} else {
if (!session.isClassReadOnly(objectChangeSet.getClassType(session))) {
getReferenceDescriptor(objectChangeSet.getClassType(session), session).getObjectBuilder().buildRowWithChangeSet(record, objectChangeSet, session, writeType);
}
}
}
/**
* INTERNAL:
* Build and return a database row built with the changed values from
* the specified attribute value.
*/
protected void writeToRowFromAggregateForUpdate(AbstractRecord record, WriteObjectQuery query, Object attributeValue) throws DescriptorException {
if (attributeValue == null) {
if (this.isNullAllowed) {
if (backupAttributeValueIsNull(query)) {
// both attributes are null - no update required
} else {
writeNullReferenceRow(record);
}
} else {
throw DescriptorException.nullForNonNullAggregate(query.getObject(), this);
}
} else if ((query.getBackupClone() != null) && ((getMatchingBackupAttributeValue(query, attributeValue) == null) || !(attributeValue.getClass().equals(getMatchingBackupAttributeValue(query, attributeValue).getClass())))) {
getObjectBuilder(attributeValue, query.getSession()).buildRow(record, attributeValue, query.getSession(), WriteType.UPDATE);
} else {
if (!query.getSession().isClassReadOnly(attributeValue.getClass())) {
WriteObjectQuery clonedQuery = (WriteObjectQuery)query.clone();
clonedQuery.setObject(attributeValue);
if (query.getSession().isUnitOfWork()) {
Object backupAttributeValue = getMatchingBackupAttributeValue(query, attributeValue);
if (backupAttributeValue == null) {
backupAttributeValue = getObjectBuilder(attributeValue, query.getSession()).buildNewInstance();
}
clonedQuery.setBackupClone(backupAttributeValue);
}
getObjectBuilder(attributeValue, query.getSession()).buildRowForUpdate(record, clonedQuery);
}
}
}
/**
* INTERNAL:
* Clone the attribute from the original and assign it to the clone.
*/
@Override
public void buildClone(Object original, CacheKey cacheKey, Object clone, Integer refreshCascade, AbstractSession cloningSession) {
Object attributeValue = getAttributeValueFromObject(original);
Object aggregateClone = buildClonePart(original, clone, cacheKey, attributeValue, refreshCascade, cloningSession);
if (aggregateClone != null && cloningSession.isUnitOfWork()) {
ClassDescriptor descriptor = getReferenceDescriptor(aggregateClone, cloningSession);
descriptor.getObjectChangePolicy().setAggregateChangeListener(clone, aggregateClone, (UnitOfWorkImpl)cloningSession, descriptor, getAttributeName());
}
setAttributeValueInObject(clone, aggregateClone);
}
/**
* INTERNAL:
* Build a clone of the given element in a unitOfWork
* @param element
* @param cloningSession
* @param isExisting
* @return
*/
public Object buildElementClone(Object attributeValue, Object parent, CacheKey parentCacheKey, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache){
Object aggregateClone = buildClonePart(attributeValue, parent, parentCacheKey, refreshCascade, cloningSession, !isExisting);
if (aggregateClone != null && cloningSession.isUnitOfWork()) {
ClassDescriptor descriptor = getReferenceDescriptor(aggregateClone, cloningSession);
descriptor.getObjectChangePolicy().setAggregateChangeListener(parent, aggregateClone, (UnitOfWorkImpl)cloningSession, descriptor, getAttributeName());
}
return aggregateClone;
}
/**
* INTERNAL:
* Set the change listener in the aggregate.
*/
public void setChangeListener(Object clone, PropertyChangeListener listener, UnitOfWorkImpl uow) {
Object attributeValue = getAttributeValueFromObject(clone);
if (attributeValue != null) {
ClassDescriptor descriptor = getReferenceDescriptor(attributeValue, uow);
descriptor.getObjectChangePolicy().setAggregateChangeListener(clone, attributeValue, uow, descriptor, getAttributeName());
}
}
/**
* INTERNAL:
* A combination of readFromRowIntoObject and buildClone.
*
* buildClone assumes the attribute value exists on the original and can
* simply be copied.
*
* readFromRowIntoObject assumes that one is building an original.
*
* Both of the above assumptions are false in this method, and actually
* attempts to do both at the same time.
*
* Extract value from the row and set the attribute to this value in the
* working copy clone.
* In order to bypass the shared cache when in transaction a UnitOfWork must
* be able to populate working copies directly from the row.
*/
public void buildCloneFromRow(AbstractRecord databaseRow, JoinedAttributeManager joinManager, Object clone, CacheKey sharedCacheKey, ObjectBuildingQuery sourceQuery, UnitOfWorkImpl unitOfWork, AbstractSession executionSession) {
// This method is a combination of buildggregateFromRow and
// buildClonePart on the super class.
// none of buildClonePart used, as not an orignal new object, nor
// do we worry about creating heavy clones for aggregate objects.
Object clonedAttributeValue = buildAggregateFromRow(databaseRow, clone, null, joinManager, sourceQuery, false, executionSession, true);
ClassDescriptor descriptor = getReferenceDescriptor(clonedAttributeValue, unitOfWork);
if (clonedAttributeValue != null) {
descriptor.getObjectChangePolicy().setAggregateChangeListener(clone, clonedAttributeValue, unitOfWork, descriptor, getAttributeName());
}
setAttributeValueInObject(clone, clonedAttributeValue);
return;
}
/**
* INTERNAL:
* Builds a shallow original object. Only direct attributes and primary
* keys are populated. In this way the minimum original required for
* instantiating a working copy clone can be built without placing it in
* the shared cache (no concern over cycles).
*/
public void buildShallowOriginalFromRow(AbstractRecord databaseRow, Object original, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, AbstractSession executionSession) {
Object aggregate = buildAggregateFromRow(databaseRow, original, null, joinManager, sourceQuery, true, executionSession, true);// shallow only.
setAttributeValueInObject(original, aggregate);
}
/**
* INTERNAL:
* Certain key mappings favor different types of selection query. Return the appropriate
* type of selectionQuery
* @return
*/
public ReadQuery buildSelectionQueryForDirectCollectionKeyMapping(ContainerPolicy containerPolicy){
ReadAllQuery query = new ReadAllQuery();
query.setReferenceClass(referenceClass);
query.setDescriptor(getReferenceDescriptor());
query.setContainerPolicy(containerPolicy);
return query;
}
/**
* INTERNAL:
* Build and return a "template" database row with all the fields
* set to null.
*/
protected AbstractRecord buildTemplateInsertRow(AbstractSession session) {
AbstractRecord result = getReferenceDescriptor().getObjectBuilder().buildTemplateInsertRow(session);
List processedMappings = (List)getReferenceDescriptor().getMappings().clone();
if (getReferenceDescriptor().hasInheritance()) {
for (ClassDescriptor child : getReferenceDescriptor().getInheritancePolicy().getChildDescriptors()) {
for (DatabaseMapping mapping : child.getMappings()) {
// Only write mappings once.
if (!processedMappings.contains(mapping)) {
mapping.writeInsertFieldsIntoRow(result, session);
processedMappings.add(mapping);
}
}
}
}
return result;
}
/**
* INTERNAL:
* Cascade discover and persist new objects during commit to the map key
*/
public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, boolean getAttributeValueFromObject, Set cascadeErrors){
ObjectBuilder builder = getReferenceDescriptor(object.getClass(), uow).getObjectBuilder();
builder.cascadeDiscoverAndPersistUnregisteredNewObjects(object, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors);
}
/**
* INTERNAL:
* Cascade perform delete through mappings that require the cascade
*/
public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects, boolean getAttributeValueFromObject) {
Object objectReferenced = null;
if (getAttributeValueFromObject){
//objects referenced by this mapping are not registered as they have
// no identity, however mappings from the referenced object may need cascading.
objectReferenced = getAttributeValueFromObject(object);
} else {
objectReferenced = object;
}
if ((objectReferenced == null)) {
return;
}
if (!visitedObjects.containsKey(objectReferenced)) {
visitedObjects.put(objectReferenced, objectReferenced);
ObjectBuilder builder = getReferenceDescriptor(objectReferenced.getClass(), uow).getObjectBuilder();
builder.cascadePerformRemove(objectReferenced, uow, visitedObjects);
}
}
/**
* INTERNAL:
* Cascade perform delete through mappings that require the cascade
*/
public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
cascadePerformRemoveIfRequired(object, uow, visitedObjects, true);
}
/**
* INTERNAL:
* Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
*/
public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
Object attributeValue = getAttributeValueFromObject(object);
if (attributeValue == null) {
return;
}
if (!visitedObjects.containsKey(attributeValue)) {
visitedObjects.put(attributeValue, attributeValue);
ObjectBuilder builder = getReferenceDescriptor(attributeValue, uow).getObjectBuilder();
// cascade perform remove any related objects via ObjectBuilder for an aggregate object
builder.cascadePerformRemovePrivateOwnedObjectFromChangeSet(attributeValue, uow, visitedObjects);
}
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects, boolean getAttributeValueFromObject) {
Object objectReferenced = null;
//aggregate objects are not registered but their mappings should be.
if (getAttributeValueFromObject){
objectReferenced = getAttributeValueFromObject(object);
} else {
objectReferenced = object;
}
if ((objectReferenced == null)) {
return;
}
if (!visitedObjects.containsKey(objectReferenced)) {
visitedObjects.put(objectReferenced, objectReferenced);
ObjectBuilder builder = getReferenceDescriptor(objectReferenced.getClass(), uow).getObjectBuilder();
builder.cascadeRegisterNewForCreate(objectReferenced, uow, visitedObjects);
}
}
/**
* INTERNAL:
* Cascade registerNew for Create through mappings that require the cascade
*/
public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) {
cascadeRegisterNewIfRequired(object, uow, visitedObjects, true);
}
/**
* INTERNAL:
* Clone the aggregate to source field names. AggregateCollectionMapping
* needs each nested embedded mapping to have its own list of aggregate
* to source field names so that it can apply nested override names to
* shared aggregate object mappings.
*/
public Object clone() {
AggregateObjectMapping mappingObject = (AggregateObjectMapping) super.clone();
Map aggregateToSourceFields = new HashMap();
aggregateToSourceFields.putAll(getAggregateToSourceFields());
mappingObject.setAggregateToSourceFields(aggregateToSourceFields);
return mappingObject;
}
/**
* INTERNAL:
* Return the fields handled by the mapping.
*/
@Override
protected Vector collectFields() {
return getReferenceFields();
}
/**
* INTERNAL:
* Aggregate order by all their fields by default.
*/
@Override
public List getOrderByNormalizedExpressions(Expression base) {
List orderBys = new ArrayList(this.fields.size());
for (DatabaseField field : this.fields) {
orderBys.add(base.getField(field));
}
return orderBys;
}
/**
* 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
*/
@Override
public void collectQueryParameters(Set record){
for (DatabaseMapping mapping : getReferenceDescriptor().getMappings()){
if ((mapping.isForeignReferenceMapping() && !mapping.isCacheable()) || (mapping.isAggregateObjectMapping() && mapping.getReferenceDescriptor().hasNoncacheableMappings())){
((ForeignReferenceMapping) mapping).collectQueryParameters(record);
}
}
}
/**
* INTERNAL:
* Convert all the class-name-based settings in this mapping to actual
* class-based settings. This method is used when converting a project that
* has been built with class names to a project with classes.
* @param classLoader
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader) {
super.convertClassNamesToClasses(classLoader);
for (Converter converter : converters.values()) {
// Convert and any Converter class names.
convertConverterClassNamesToClasses(converter, classLoader);
}
}
/**
* INTERNAL
* Called when a DatabaseMapping is used to map the key in a collection. Returns the key.
*/
public Object createMapComponentFromRow(AbstractRecord dbRow, ObjectBuildingQuery query, CacheKey parentCacheKey, AbstractSession session, boolean isTargetProtected){
Object key = buildAggregateFromRow(dbRow, null, parentCacheKey, null, query, false, session, isTargetProtected);
return key;
}
/**
* INTERNAL:
* Creates the Array of simple types used to recreate this map.
*/
public Object createSerializableMapKeyInfo(Object key, AbstractSession session){
return key; // Embeddables have no identity so they are not reduced to PK.
}
/**
* INTERNAL:
* Create an instance of the Key object from the key information extracted from the map.
* This may return the value directly in case of a simple key or will be used as the FK to load a related entity.
*/
public List