### Eclipse Workspace Patch 1.0 #P org.eclipse.jpt.jpa.core diff --git META-INF/MANIFEST.MF META-INF/MANIFEST.MF index da72c36..8099ce8 100644 --- META-INF/MANIFEST.MF +++ META-INF/MANIFEST.MF @@ -65,6 +65,7 @@ org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.binary;x-internal:=true, org.eclipse.jpt.jpa.core.internal.jpa2.resource.java.source;x-internal:=true, org.eclipse.jpt.jpa.core.internal.jpa2_1;x-internal:=true, + org.eclipse.jpt.jpa.core.internal.jpa2_1.context, org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java;x-internal:=true, org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm;x-internal:=true, org.eclipse.jpt.jpa.core.internal.jpa2_1.resource.java;x-internal:=true, diff --git model/src/org/eclipse/jpt/jpa/core/resource/orm/XmlStoredProcedureParameter.java model/src/org/eclipse/jpt/jpa/core/resource/orm/XmlStoredProcedureParameter.java index be716cf..7c34127 100644 --- model/src/org/eclipse/jpt/jpa/core/resource/orm/XmlStoredProcedureParameter.java +++ model/src/org/eclipse/jpt/jpa/core/resource/orm/XmlStoredProcedureParameter.java @@ -10,15 +10,11 @@ package org.eclipse.jpt.jpa.core.resource.orm; import org.eclipse.emf.common.notify.Notification; - import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EStructuralFeature; - import org.eclipse.emf.ecore.impl.ENotificationImpl; - import org.eclipse.jpt.common.core.internal.utility.translators.SimpleTranslator; import org.eclipse.jpt.common.core.resource.xml.EBaseObjectImpl; - import org.eclipse.jpt.jpa.core.resource.orm.v2_1.JPA2_1; import org.eclipse.jpt.jpa.core.resource.orm.v2_1.OrmV2_1Package; import org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1; @@ -64,14 +60,10 @@ protected String description = DESCRIPTION_EDEFAULT; /** - * The default value of the '{@link #getMode() Mode}' attribute. - * - * - * @see #getMode() - * @generated - * @ordered + * changed this to null and removed the generated flag so emf won't generate over it + * we don't want a default for enums, just null if the tag does not exist */ - protected static final ParameterMode_2_1 MODE_EDEFAULT = ParameterMode_2_1.IN; + protected static final ParameterMode_2_1 MODE_EDEFAULT = null; /** * The cached value of the '{@link #getMode() Mode}' attribute. diff --git src/org/eclipse/jpt/jpa/core/context/QueryContainer.java src/org/eclipse/jpt/jpa/core/context/QueryContainer.java index 49afa31..9c79dff 100644 --- src/org/eclipse/jpt/jpa/core/context/QueryContainer.java +++ src/org/eclipse/jpt/jpa/core/context/QueryContainer.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008, 2012 Oracle. All rights reserved. + * Copyright (c) 2008, 2013 Oracle. All rights reserved. * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0, which accompanies this distribution * and is available at http://www.eclipse.org/legal/epl-v10.html. @@ -10,9 +10,10 @@ package org.eclipse.jpt.jpa.core.context; import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; /** - * Container for named queries and/or named native queries. + * Container for named queries and/or named native queries and/or named stored procedure queries. * Used by entities and the orm.xml * entity-mappings element. *

@@ -22,7 +23,7 @@ * pioneering adopters on the understanding that any code that uses this API * will almost certainly be broken (repeatedly) as the API evolves. * - * @version 2.2 + * @version 3.3 * @since 2.2 */ public interface QueryContainer @@ -115,4 +116,45 @@ */ void moveNamedNativeQuery(int targetIndex, int sourceIndex); + + // ********** named stored procedure queries ********** + + /** + * Return the container's named stored procedure queries. + */ + ListIterable getNamedStoredProcedureQueries(); + + String NAMED_STORED_PROCEDURE_QUERIES_LIST = "namedStoredProcedureQueries"; //$NON-NLS-1$ + + /** + * Return the number of named stored procedure queries. + */ + int getNamedStoredProcedureQueriesSize(); + + /** + * Add a new named stored procedure query to the container and return it. + */ + NamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(); + + /** + * Add a new named stored procedure query to the container at the specified index + * and return it. + */ + NamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index); + + /** + * Remove from the container the named stored procedure query at the specified index. + */ + void removeNamedStoredProcedureQuery(int index); + + /** + * Remove the specified named stored procedure query from the container. + */ + void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedStoredProcedureQuery); + + /** + * Move a named stored procedure query as specified. + */ + void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex); + } diff --git src/org/eclipse/jpt/jpa/core/internal/AbstractJpaNode.java src/org/eclipse/jpt/jpa/core/internal/AbstractJpaNode.java index fb2fab7..174f910 100644 --- src/org/eclipse/jpt/jpa/core/internal/AbstractJpaNode.java +++ src/org/eclipse/jpt/jpa/core/internal/AbstractJpaNode.java @@ -158,6 +158,7 @@ protected JpaFactory2_0 getJpaFactory2_0() { return (JpaFactory2_0) this.getJpaFactory(); } + /** * Call {@link #isJpa2_1Compatible()} before calling this method. */ diff --git src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java index aeb46d6..589ead1 100644 --- src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java +++ src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java @@ -23,6 +23,10 @@ import org.eclipse.jpt.jpa.core.context.java.JavaNamedQuery; import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer; import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; import org.eclipse.jpt.jpa.core.resource.java.NamedNativeQueryAnnotation; import org.eclipse.jpt.jpa.core.resource.java.NamedQueryAnnotation; import org.eclipse.wst.validation.internal.provisional.core.IMessage; @@ -33,12 +37,13 @@ */ public class GenericJavaQueryContainer extends AbstractJavaJpaContextNode - implements JavaQueryContainer + implements JavaQueryContainer, JavaQueryContainer2_1 { protected final Owner owner; protected final ContextListContainer namedQueryContainer; protected final ContextListContainer namedNativeQueryContainer; + protected final ContextListContainer namedStoredProcedureQueryContainer; public GenericJavaQueryContainer(JpaContextNode parent, Owner owner) { @@ -46,6 +51,7 @@ this.owner = owner; this.namedQueryContainer = this.buildNamedQueryContainer(); this.namedNativeQueryContainer = this.buildNamedNativeQueryContainer(); + this.namedStoredProcedureQueryContainer = this.buildNamedStoredProcedureQueryContainer(); } @@ -56,6 +62,7 @@ super.synchronizeWithResourceModel(); this.syncNamedQueries(); this.syncNamedNativeQueries(); + this.syncNamedStoredProcedureQueries(); } @Override @@ -63,6 +70,7 @@ super.update(); this.updateNodes(this.getNamedQueries()); this.updateNodes(this.getNamedNativeQueries()); + this.updateNodes(this.getNamedStoredProcedureQueries()); } @@ -242,6 +250,91 @@ } } + // ********** named stored procedure queries ********** + + public ListIterable getNamedStoredProcedureQueries() { + return this.namedStoredProcedureQueryContainer.getContextElements(); + } + + public int getNamedStoredProcedureQueriesSize() { + return this.namedStoredProcedureQueryContainer.getContextElementsSize(); + } + + public JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery() { + return this.addNamedStoredProcedureQuery(this.getNamedNativeQueriesSize()); + } + + public JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index) { + NamedStoredProcedureQuery2_1Annotation annotation = this.addNamedStoredProcedureQueryAnnotation(index); + return this.namedStoredProcedureQueryContainer.addContextElement(index, annotation); + } + + protected NamedStoredProcedureQuery2_1Annotation addNamedStoredProcedureQueryAnnotation(int index) { + return (NamedStoredProcedureQuery2_1Annotation) this.owner.getResourceAnnotatedElement().addAnnotation(index, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME); + } + + public void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedStoredProcedureQuery) { + this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOfContextElement((JavaNamedStoredProcedureQuery2_1) namedStoredProcedureQuery)); + } + + public void removeNamedStoredProcedureQuery(int index) { + this.owner.getResourceAnnotatedElement().removeAnnotation(index, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME); + this.namedStoredProcedureQueryContainer.removeContextElement(index); + } + + public void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex) { + this.owner.getResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME); + this.namedStoredProcedureQueryContainer.moveContextElement(targetIndex, sourceIndex); + } + + protected JavaNamedStoredProcedureQuery2_1 buildNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) { + return this.isJpa2_1Compatible() ? + this.getJpaFactory2_1().buildJavaNamedStoredProcedureQuery2_1(this, namedStoredProcedureQueryAnnotation) : + null; + } + + protected void syncNamedStoredProcedureQueries() { + this.namedStoredProcedureQueryContainer.synchronizeWithResourceModel(); + } + + protected ListIterable getNamedStoredProcedureQueryAnnotations() { + return new SubListIterableWrapper(this.getNestableNamedStoredProcedureQueryAnnotations_()); + } + + protected ListIterable getNestableNamedStoredProcedureQueryAnnotations_() { + return this.owner.getResourceAnnotatedElement().getAnnotations(NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME); + } + + protected ContextListContainer buildNamedStoredProcedureQueryContainer() { + NamedStoredProcedureQueryContainer container = new NamedStoredProcedureQueryContainer(); + container.initialize(); + return container; + } + + /** + * named query container + */ + protected class NamedStoredProcedureQueryContainer + extends ContextListContainer + { + @Override + protected String getContextElementsPropertyName() { + return NAMED_STORED_PROCEDURE_QUERIES_LIST; + } + @Override + protected JavaNamedStoredProcedureQuery2_1 buildContextElement(NamedStoredProcedureQuery2_1Annotation resourceElement) { + return GenericJavaQueryContainer.this.buildNamedStoredProcedureQuery(resourceElement); + } + @Override + protected ListIterable getResourceElements() { + return GenericJavaQueryContainer.this.getNamedStoredProcedureQueryAnnotations(); + } + @Override + protected NamedStoredProcedureQuery2_1Annotation getResourceElement(JavaNamedStoredProcedureQuery2_1 contextElement) { + return contextElement.getQueryAnnotation(); + } + } + // ********** validation ********** diff --git src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java index eacb2b7..321e049 100644 --- src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java +++ src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java @@ -21,9 +21,13 @@ import org.eclipse.jpt.jpa.core.context.orm.OrmNamedQuery; import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer; import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1; import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory; import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedNativeQuery; import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedQuery; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; import org.eclipse.jpt.jpa.core.resource.orm.XmlQueryContainer; import org.eclipse.wst.validation.internal.provisional.core.IMessage; import org.eclipse.wst.validation.internal.provisional.core.IReporter; @@ -33,12 +37,13 @@ */ public class GenericOrmQueryContainer extends AbstractOrmXmlContextNode - implements OrmQueryContainer + implements OrmQueryContainer, OrmQueryContainer2_1 { protected final XmlQueryContainer xmlQueryContainer; protected final ContextListContainer namedQueryContainer; protected final ContextListContainer namedNativeQueryContainer; + protected final ContextListContainer namedStoredProcedureQueryContainer; public GenericOrmQueryContainer(JpaContextNode parent, XmlQueryContainer xmlQueryContainer) { @@ -46,6 +51,7 @@ this.xmlQueryContainer = xmlQueryContainer; this.namedQueryContainer = this.buildNamedQueryContainer(); this.namedNativeQueryContainer = this.buildNamedNativeQueryContainer(); + this.namedStoredProcedureQueryContainer = this.buildNamedStoredProcedureQueryContainer(); } @@ -56,6 +62,7 @@ super.synchronizeWithResourceModel(); this.syncNamedQueries(); this.syncNamedNativeQueries(); + this.syncNamedStoredProcedureQueries(); } @Override @@ -63,6 +70,7 @@ super.update(); this.updateNodes(this.getNamedQueries()); this.updateNodes(this.getNamedNativeQueries()); + this.updateNodes(this.getNamedStoredProcedureQueries()); } @@ -70,7 +78,10 @@ @SuppressWarnings("unchecked") public Iterable getQueries() { - return IterableTools.concatenate(this.getNamedQueries(), this.getNamedNativeQueries()); + return IterableTools.concatenate( + this.getNamedQueries(), + this.getNamedNativeQueries(), + this.getNamedStoredProcedureQueries()); } @@ -239,6 +250,91 @@ } + // ********** named stored procedure queries ********** + + public ListIterable getNamedStoredProcedureQueries() { + return this.namedStoredProcedureQueryContainer.getContextElements(); + } + + public int getNamedStoredProcedureQueriesSize() { + return this.namedStoredProcedureQueryContainer.getContextElementsSize(); + } + + public OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery() { + return this.addNamedStoredProcedureQuery(this.getNamedStoredProcedureQueriesSize()); + } + + public OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index) { + XmlNamedStoredProcedureQuery xmlQuery = this.buildXmlNamedStoredProcedureQuery(); + OrmNamedStoredProcedureQuery2_1 query = this.namedStoredProcedureQueryContainer.addContextElement(index, xmlQuery); + this.xmlQueryContainer.getNamedStoredProcedureQueries().add(index, xmlQuery); + return query; + } + + protected XmlNamedStoredProcedureQuery buildXmlNamedStoredProcedureQuery() { + return OrmFactory.eINSTANCE.createXmlNamedStoredProcedureQuery(); + } + + public void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedQuery) { + this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOfContextElement((OrmNamedStoredProcedureQuery2_1) namedQuery)); + } + + public void removeNamedStoredProcedureQuery(int index) { + this.namedStoredProcedureQueryContainer.removeContextElement(index); + this.xmlQueryContainer.getNamedStoredProcedureQueries().remove(index); + } + + public void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex) { + this.namedStoredProcedureQueryContainer.moveContextElement(targetIndex, sourceIndex); + this.xmlQueryContainer.getNamedStoredProcedureQueries().move(targetIndex, sourceIndex); + } + + protected OrmNamedStoredProcedureQuery2_1 buildNamedStoredProcedureQuery(XmlNamedStoredProcedureQuery xmlNamedQuery) { + return this.isOrmXml2_1Compatible() ? + this.getContextNodeFactory2_1().buildOrmNamedStoredProcedureQuery2_1(this, xmlNamedQuery) : + null; + } + + protected void syncNamedStoredProcedureQueries() { + this.namedStoredProcedureQueryContainer.synchronizeWithResourceModel(); + } + + protected ListIterable getXmlNamedStoredProcedureQueries() { + // clone to reduce chance of concurrency problems + return IterableTools.cloneLive(this.xmlQueryContainer.getNamedStoredProcedureQueries()); + } + + protected ContextListContainer buildNamedStoredProcedureQueryContainer() { + NamedStoredProcedureQueryContainer container = new NamedStoredProcedureQueryContainer(); + container.initialize(); + return container; + } + + /** + * named query container + */ + protected class NamedStoredProcedureQueryContainer + extends ContextListContainer + { + @Override + protected String getContextElementsPropertyName() { + return NAMED_STORED_PROCEDURE_QUERIES_LIST; + } + @Override + protected OrmNamedStoredProcedureQuery2_1 buildContextElement(XmlNamedStoredProcedureQuery resourceElement) { + return GenericOrmQueryContainer.this.buildNamedStoredProcedureQuery(resourceElement); + } + @Override + protected ListIterable getResourceElements() { + return GenericOrmQueryContainer.this.getXmlNamedStoredProcedureQueries(); + } + @Override + protected XmlNamedStoredProcedureQuery getResourceElement(OrmNamedStoredProcedureQuery2_1 contextElement) { + return contextElement.getXmlQuery(); + } + } + + // ********** validation ********** /** diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/GenericJpaFactory2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/GenericJpaFactory2_1.java index 7662d29..c1d3c00 100644 --- src/org/eclipse/jpt/jpa/core/internal/jpa2_1/GenericJpaFactory2_1.java +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/GenericJpaFactory2_1.java @@ -7,30 +7,50 @@ * Contributors: * Oracle - initial API and implementation ******************************************************************************/ -package org.eclipse.jpt.jpa.core.internal.jpa2_1; +package org.eclipse.jpt.jpa.core.internal.jpa2_1; import org.eclipse.jpt.common.core.resource.java.JavaResourceType; import org.eclipse.jpt.jpa.core.context.JpaContextNode; +import org.eclipse.jpt.jpa.core.context.java.JavaQuery; import org.eclipse.jpt.jpa.core.internal.jpa2.GenericJpaFactory2_0; import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1; import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1; import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1; - - -/** - * Central class that allows extenders to easily replace implementations of - * various Dali interfaces. - */ -public class GenericJpaFactory2_1 - extends GenericJpaFactory2_0 - implements JpaFactory2_1 -{ - - public GenericJpaFactory2_1() { - super(); +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; + + +/** + * Central class that allows extenders to easily replace implementations of + * various Dali interfaces. + */ +public class GenericJpaFactory2_1 + extends GenericJpaFactory2_0 + implements JpaFactory2_1 +{ + + public GenericJpaFactory2_1() { + super(); + } + + public JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1( + JavaQuery parent, + StoredProcedureParameter2_1Annotation parameterAnnotation) { + return new GenericJavaStoredProcedureParameter2_1(parent, parameterAnnotation); + } + + public JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1( + JavaQueryContainer2_1 parent, + NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) { + return new GenericJavaNamedStoredProcedureQuery2_1(parent, namedStoredProcedureQueryAnnotation); } public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) { return new GenericJavaConverterType(parent, jrt); - } -} + } +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/NamedStoredProcedureQuery2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/NamedStoredProcedureQuery2_1.java new file mode 100644 index 0000000..e24d472 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/NamedStoredProcedureQuery2_1.java @@ -0,0 +1,169 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context; + +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.Query; + +/** + * named stored procedure query + *

+ * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public interface NamedStoredProcedureQuery2_1 + extends Query +{ + + // ********** procedure name ********** + + String getProcedureName(); + String PROCEDURE_NAME_PROPERTY = "procedureName"; //$NON-NLS-1$ + + void setProcedureName(String procedureName); + + + // ********** parameters ********** + + /** + * Return the query's parameters. + */ + ListIterable getParameters(); + String PARAMETERS_LIST = "parameters"; //$NON-NLS-1$ + + /** + * Return the number of parameters in the query. + */ + int getParametersSize(); + + /** + * Add a parameter to the query and return the object representing it. + */ + StoredProcedureParameter2_1 addParameter(); + + /** + * Add a parameter to the index and return the object representing it. + */ + StoredProcedureParameter2_1 addParameter(int index); + + /** + * Remove the parameter from the query. + */ + void removeParameter(StoredProcedureParameter2_1 parameter); + + /** + * Remove the parameter at the index from the query. + */ + void removeParameter(int index); + + /** + * Move the hint from the source index to the target index. + */ + void moveParameter(int targetIndex, int sourceIndex); + + /** + * Return the parameter at the index. + */ + StoredProcedureParameter2_1 getParameter(int index); + + // ********** result classes ********** + + /** + * Return the query's result classes. + */ + ListIterable getResultClasses(); + String RESULT_CLASSES_LIST = "resultClasses"; //$NON-NLS-1$ + + /** + * Return the number of result classes in the query. + */ + int getResultClassesSize(); + + /** + * Return the result class at the index. + */ + String getResultClass(int index); + + /** + * Add the result class to the query. + */ + void addResultClass(String resultClass); + + /** + * Add the result class to the index. + */ + void addResultClass(int index, String resultClass); + + /** + * Remove the result class from the query's list of result classes. + */ + void removeResultClass(String resultClass); + + /** + * Remove the result class at the index. + */ + void removeResultClass(int index); + + /** + * Move the result class from the source index to the target index. + */ + void moveResultClass(int targetIndex, int sourceIndex); + + + // ********** result set mappings ********** + + /** + * Return the query's result set mappings. + */ + ListIterable getResultSetMappings(); + String RESULT_SET_MAPPINGS_LIST = "resultSetMappings"; //$NON-NLS-1$ + + /** + * Return the number of result set mappings in the query. + */ + int getResultSetMappingsSize(); + + /** + * Return the result class at the index. + */ + String getResultSetMapping(int index); + + + /** + * Add the result set mapping to the query. + */ + void addResultSetMapping(String resultClass); + + /** + * Add the result set mapping to the index. + */ + void addResultSetMapping(int index, String resultClass); + + /** + * Remove the result set mapping from the query's list of result set mappings. + */ + void removeResultSetMapping(String resultClass); + + /** + * Remove the result set mapping at the index. + */ + void removeResultSetMapping(int index); + + /** + * Move the result set mapping from the source index to the target index. + */ + void moveResultSetMapping(int targetIndex, int sourceIndex); +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/StoredProcedureParameter2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/StoredProcedureParameter2_1.java new file mode 100644 index 0000000..2c6aa98 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/StoredProcedureParameter2_1.java @@ -0,0 +1,82 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context; + +import org.eclipse.jpt.jpa.core.context.JpaContextNode; +import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1; + +/** + * stored procedure parameter + *

+ * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public interface StoredProcedureParameter2_1 + extends JpaContextNode +{ + + // ********* name ********** + String getName(); + String NAME_PROPERTY = "name"; //$NON-NLS-1$ + + void setName(String name); + + + // *********** mode ************* + + /** + * Return the specified mode if present, + * otherwise return the default lock mode. + */ + ParameterMode2_1 getMode(); + ParameterMode2_1 getSpecifiedMode(); + void setSpecifiedMode(ParameterMode2_1 mode); + String SPECIFIED_MODE_PROPERTY = "specifiedParameterMode"; //$NON-NLS-1$ + ParameterMode2_1 getDefaultMode(); + String DEFAULT_MODE_PROPERTY = "defaultParameterMode"; //$NON-NLS-1$ + + + // ********** type *********** + + String getTypeName(); + String TYPE_NAME_PROPERTY = "typeName"; //$NON-NLS-1$ + + void setTypeName(String type); + + /** + * If the type name is specified, this will return it fully qualified. If not + * specified, then it will return null + */ + String getFullyQualifiedTypeName(); + String FULLY_QUALIFIED_TYPE_NAME_PROPERTY = "fullyQualifiedTypeName"; //$NON-NLS-1$ + + /** + * Return the character to be used for browsing or + * creating the type {@link org.eclipse.jdt.core.IType IType}. + * @see org.eclipse.jdt.core.IType#getFullyQualifiedName(char) + */ + char getTypeEnclosingTypeSeparator(); + + + // ********** validation *********** + + /** + * Return whether this stored procedure parameter is equivalent + * to the specified stored procedure parameter. + */ + boolean isEquivalentTo(StoredProcedureParameter2_1 parameter); + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java new file mode 100644 index 0000000..e010221 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java @@ -0,0 +1,340 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java; + +import java.util.ArrayList; +import java.util.Vector; +import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.common.utility.internal.collection.ListTools; +import org.eclipse.jpt.common.utility.internal.iterable.IterableTools; +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.Query; +import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer; +import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaQuery; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; + +/** + * orm.xml named stored procedure query + */ +public class GenericJavaNamedStoredProcedureQuery2_1 + extends AbstractJavaQuery + implements JavaNamedStoredProcedureQuery2_1 +{ + protected String procedureName; + + protected final ContextListContainer parameterContainer; + + protected final Vector resultClasses = new Vector(); + + protected final Vector resultSetMappings = new Vector(); + + + public GenericJavaNamedStoredProcedureQuery2_1(JavaQueryContainer2_1 parent, NamedStoredProcedureQuery2_1Annotation queryAnnotation) { + super(parent, queryAnnotation); + this.procedureName = queryAnnotation.getProcedureName(); + this.parameterContainer = this.buildParameterContainer(); + this.initializeResultClasses(); + this.initializeResultSetMappings(); + } + + + // ********** synchronize/update ********** + + @Override + public void synchronizeWithResourceModel() { + super.synchronizeWithResourceModel(); + this.setProcedureName_(this.queryAnnotation.getProcedureName()); + this.syncParameters(); + this.syncResultClasses(); + this.syncResultSetMappings(); + } + + @Override + public void update() { + super.update(); + this.updateNodes(this.getParameters()); + } + + + // ********* procedure name ******** + + public String getProcedureName() { + return this.procedureName; + } + + public void setProcedureName(String procedureName) { + this.queryAnnotation.setProcedureName(procedureName); + this.setProcedureName_(procedureName); + } + + protected void setProcedureName_(String procedureName) { + String old = this.procedureName; + this.procedureName = procedureName; + this.firePropertyChanged(PROCEDURE_NAME_PROPERTY, old, procedureName); + } + + // ************ parameters *********** + + public ListIterable getParameters() { + return this.parameterContainer.getContextElements(); + } + + public int getParametersSize() { + return this.parameterContainer.getContextElementsSize(); + } + + public JavaStoredProcedureParameter2_1 addParameter() { + return this.addParameter(this.getParametersSize()); + } + + public JavaStoredProcedureParameter2_1 addParameter(int index) { + StoredProcedureParameter2_1Annotation annotation = this.queryAnnotation.addParameter(index); + return this.parameterContainer.addContextElement(index, annotation); + } + + public void removeParameter(StoredProcedureParameter2_1 parameter) { + this.removeParameter(this.parameterContainer.indexOfContextElement((JavaStoredProcedureParameter2_1) parameter)); + } + + public void removeParameter(int index) { + this.queryAnnotation.removeParameter(index); + this.parameterContainer.removeContextElement(index); + } + + public void moveParameter(int targetIndex, int sourceIndex) { + this.queryAnnotation.moveParameter(targetIndex, sourceIndex); + this.parameterContainer.moveContextElement(targetIndex, sourceIndex); + } + + public JavaStoredProcedureParameter2_1 getParameter(int index) { + return this.parameterContainer.get(index); + } + + protected JavaStoredProcedureParameter2_1 buildParameter(StoredProcedureParameter2_1Annotation parameterAnnotation) { + return this.isJpa2_1Compatible() ? + this.getJpaFactory2_1().buildJavaStoredProcedureParameter2_1(this, parameterAnnotation) : + null; + } + + protected void syncParameters() { + this.parameterContainer.synchronizeWithResourceModel(); + } + + protected ListIterable getParameterAnnotations() { + return this.queryAnnotation.getParameters(); + } + + protected ContextListContainer buildParameterContainer() { + ParameterContainer container = new ParameterContainer(); + container.initialize(); + return container; + } + + /** + * stored procedure parameter container + */ + protected class ParameterContainer + extends ContextListContainer + { + @Override + protected String getContextElementsPropertyName() { + return PARAMETERS_LIST; + } + @Override + protected JavaStoredProcedureParameter2_1 buildContextElement(StoredProcedureParameter2_1Annotation resourceElement) { + return GenericJavaNamedStoredProcedureQuery2_1.this.buildParameter(resourceElement); + } + @Override + protected ListIterable getResourceElements() { + return GenericJavaNamedStoredProcedureQuery2_1.this.getParameterAnnotations(); + } + @Override + protected StoredProcedureParameter2_1Annotation getResourceElement(JavaStoredProcedureParameter2_1 contextElement) { + return contextElement.getStoredProcedureParameter2_1Annotation(); + } + } + + + // *********** result classes ********** + + public ListIterable getResultClasses() { + return IterableTools.cloneLive(this.resultClasses); + } + + public int getResultClassesSize() { + return this.resultClasses.size(); + } + + public String getResultClass(int index) { + return this.resultClasses.get(index); + } + + public void addResultClass(String resultClass) { + this.addResultClass(this.resultClasses.size(), resultClass); + } + + public void addResultClass(int index, String resultClass) { + this.queryAnnotation.addResultClass(index, resultClass); + this.addItemToList(index, resultClass, this.resultClasses, RESULT_CLASSES_LIST); + } + + public void removeResultClass(String resultClass) { + this.removeResultClass(this.resultClasses.indexOf(resultClass)); + } + + public void removeResultClass(int index) { + this.queryAnnotation.removeResultClass(index); + this.removeItemFromList(index, this.resultClasses, RESULT_CLASSES_LIST); + } + + public void moveResultClass(int targetIndex, int sourceIndex) { + this.queryAnnotation.moveResultClass(targetIndex, sourceIndex); + this.moveItemInList(targetIndex, sourceIndex, this.resultClasses, RESULT_CLASSES_LIST); + } + + protected void initializeResultClasses() { + for (String resultClass : this.getResourceResultClasses()) { + this.resultClasses.add(resultClass); + } + } + + protected void syncResultClasses() { + this.synchronizeList(this.getResourceResultClasses(), this.resultClasses, RESULT_CLASSES_LIST); + } + + protected Iterable getResourceResultClasses() { + return this.queryAnnotation.getResultClasses(); + } + + + // *********** result set mappings ********* + + public ListIterable getResultSetMappings() { + return IterableTools.cloneLive(this.resultSetMappings); + } + + public int getResultSetMappingsSize() { + return this.resultSetMappings.size(); + } + + public String getResultSetMapping(int index) { + return this.resultSetMappings.get(index); + } + + public void addResultSetMapping(String resultSetMapping) { + this.addResultSetMapping(this.resultSetMappings.size(), resultSetMapping); + } + + public void addResultSetMapping(int index, String resultSetMapping) { + this.queryAnnotation.addResultSetMapping(index, resultSetMapping); + this.addItemToList(index, resultSetMapping, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + } + + public void removeResultSetMapping(String resultSetMapping) { + this.removeResultSetMapping(this.resultSetMappings.indexOf(resultSetMapping)); + } + + public void removeResultSetMapping(int index) { + this.queryAnnotation.removeResultSetMapping(index); + this.removeItemFromList(index, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + } + + public void moveResultSetMapping(int targetIndex, int sourceIndex) { + this.queryAnnotation.moveResultSetMapping(targetIndex, sourceIndex); + this.moveItemInList(targetIndex, sourceIndex, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + } + + protected void initializeResultSetMappings() { + for (String resultSetMapping : this.getResourceResultSetMappings()) { + this.resultSetMappings.add(resultSetMapping); + } + } + + protected void syncResultSetMappings() { + this.synchronizeList(this.getResourceResultSetMappings(), this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + } + + protected Iterable getResourceResultSetMappings() { + return this.queryAnnotation.getResultSetMappings(); + } + + @Override + public void toString(StringBuilder sb) { + sb.append(this.resultClasses); + sb.append(this.resultSetMappings); + } + + + // ********** metadata conversion ********* + + public void convertTo(OrmQueryContainer queryContainer) { + ((OrmQueryContainer2_1) queryContainer).addNamedStoredProcedureQuery().convertFrom(this); + } + + public void delete() { + this.getParent().removeNamedStoredProcedureQuery(this); + } + + + // ********** validation ********** + + @Override + protected boolean isEquivalentTo(Query other) { + return super.isEquivalentTo(other) + && this.isEquivalentTo((NamedStoredProcedureQuery2_1) other); + } + + protected boolean isEquivalentTo(NamedStoredProcedureQuery2_1 other) { + return ObjectTools.equals(this.procedureName, other.getProcedureName()) && + this.parametersAreEquivalentTo(other) && + this.valuesAreEquivalent(other, this.getResultClasses(), other.getResultClasses()) && + this.valuesAreEquivalent(other, this.getResultSetMappings(), other.getResultSetMappings()); + } + + protected boolean valuesAreEquivalent(NamedStoredProcedureQuery2_1 other, ListIterable list1, ListIterable list2) { + ArrayList stringList1 = ListTools.list(list1); + ArrayList stringList2 = ListTools.list(list2); + if (stringList1.size() != stringList2.size()) { + return false; + } + for (int i = 0; i < stringList1.size(); i++) { + if ( !ObjectTools.equals(stringList1.get(i), stringList2.get(i))) { + return false; + } + } + return true; + } + + protected boolean parametersAreEquivalentTo(NamedStoredProcedureQuery2_1 other) { + // get fixed lists of the stored procedure parameters + ArrayList parameter1 = ListTools.list(this.getParameters()); + ArrayList parameter2 = ListTools.list(other.getParameters()); + if (parameter1.size() != parameter2.size()) { + return false; + } + for (int i = 0; i < parameter1.size(); i++) { + if ( ! parameter1.get(i).isEquivalentTo(parameter2.get(i))) { + return false; + } + } + return true; + } + + // ********** misc ********** + + public Class getType() { + return NamedStoredProcedureQuery2_1.class; + } + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaStoredProcedureParameter2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaStoredProcedureParameter2_1.java new file mode 100644 index 0000000..a3d92f1 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaStoredProcedureParameter2_1.java @@ -0,0 +1,189 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java; + +import org.eclipse.jpt.common.core.utility.TextRange; +import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.jpa.core.context.java.JavaQuery; +import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; + +/** + * Java stored procedure parameter + */ +public class GenericJavaStoredProcedureParameter2_1 + extends AbstractJavaJpaContextNode + implements JavaStoredProcedureParameter2_1 +{ + protected final StoredProcedureParameter2_1Annotation parameterAnnotation; + + protected String name; + + protected ParameterMode2_1 specifiedMode; + protected ParameterMode2_1 defaultMode; + + protected String typeName; + protected String fullyQualifiedTypeName; + + + public GenericJavaStoredProcedureParameter2_1(JavaQuery parent, StoredProcedureParameter2_1Annotation parameterAnnotation) { + super(parent); + this.parameterAnnotation = parameterAnnotation; + this.name = parameterAnnotation.getName(); + this.specifiedMode = this.buildSpecifiedMode(); + this.typeName = parameterAnnotation.getTypeName(); + } + + + // ********** synchronize/update ********** + + @Override + public void synchronizeWithResourceModel() { + super.synchronizeWithResourceModel(); + this.setName_(this.parameterAnnotation.getName()); + this.setSpecifiedMode_(this.buildSpecifiedMode()); + this.setTypeName_(this.parameterAnnotation.getTypeName()); + } + + @Override + public void update() { + super.update(); + this.setDefaultMode(this.buildDefaultMode()); + this.setFullyQualifiedTypeName(this.buildFullyQualifiedTypeName()); + } + + // ********* name ************** + + public String getName() { + return this.name; + } + + public void setName(String name) { + this.parameterAnnotation.setName(name); + this.setName_(name); + } + + protected void setName_(String name) { + String old = this.name; + this.name = name; + this.firePropertyChanged(NAME_PROPERTY, old, name); + } + + + // ********** mode ********** + + public ParameterMode2_1 getMode() { + return (this.specifiedMode != null) ? this.specifiedMode : this.defaultMode; + } + + public ParameterMode2_1 getSpecifiedMode() { + return this.specifiedMode; + } + + public void setSpecifiedMode(ParameterMode2_1 mode) { + ((StoredProcedureParameter2_1Annotation) this.parameterAnnotation).setMode(ParameterMode2_1.toJavaResourceModel(mode)); + this.setSpecifiedMode_(mode); + } + + protected void setSpecifiedMode_(ParameterMode2_1 mode) { + ParameterMode2_1 old = this.specifiedMode; + this.specifiedMode = mode; + this.firePropertyChanged(SPECIFIED_MODE_PROPERTY, old, mode); + } + + protected ParameterMode2_1 buildSpecifiedMode() { + return this.isJpa2_1Compatible() ? + ParameterMode2_1.fromJavaResourceModel(((StoredProcedureParameter2_1Annotation) this.parameterAnnotation).getMode()) : + null; + } + + public ParameterMode2_1 getDefaultMode() { + return this.defaultMode; + } + + protected void setDefaultMode(ParameterMode2_1 mode) { + ParameterMode2_1 old = this.defaultMode; + this.defaultMode = mode; + this.firePropertyChanged(DEFAULT_MODE_PROPERTY, old, mode); + } + + protected ParameterMode2_1 buildDefaultMode() { + return this.isJpa2_1Compatible() ? ParameterMode2_1.IN : null; + } + + + // ********** type ********** + + public String getTypeName() { + return this.typeName; + } + + public void setTypeName(String typeName) { + this.parameterAnnotation.setTypeName(typeName); + this.setTypeName_(typeName); + } + + protected void setTypeName_(String typeName) { + String old = this.typeName; + this.typeName = typeName; + this.firePropertyChanged(TYPE_NAME_PROPERTY, old, typeName); + } + + public String getFullyQualifiedTypeName() { + return this.fullyQualifiedTypeName; + } + + protected void setFullyQualifiedTypeName(String typeName) { + String old = this.fullyQualifiedTypeName; + this.fullyQualifiedTypeName = typeName; + this.firePropertyChanged(FULLY_QUALIFIED_TYPE_NAME_PROPERTY, old, typeName); + } + + protected String buildFullyQualifiedTypeName() { + return this.parameterAnnotation.getFullyQualifiedTypeName(); + } + + public char getTypeEnclosingTypeSeparator() { + return '.'; + } + + + // ********** validation ********** + + public TextRange getValidationTextRange() { + TextRange textRange = this.parameterAnnotation.getTextRange(); + return (textRange != null) ? textRange : this.getQuery().getValidationTextRange(); + } + + public boolean isEquivalentTo(StoredProcedureParameter2_1 parameter) { + return ObjectTools.equals(this.name, parameter.getName()) && + ObjectTools.equals(this.specifiedMode, parameter.getMode()) && + ObjectTools.equals(this.typeName, parameter.getTypeName()) ; + } + + + // ********** misc ********** + + @Override + public JavaQuery getParent() { + return (JavaQuery) super.getParent(); + } + + protected JavaQuery getQuery() { + return this.getParent(); + } + + public StoredProcedureParameter2_1Annotation getStoredProcedureParameter2_1Annotation() { + return this.parameterAnnotation; + } + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaNamedStoredProcedureQuery2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaNamedStoredProcedureQuery2_1.java new file mode 100644 index 0000000..ed0d6ce --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaNamedStoredProcedureQuery2_1.java @@ -0,0 +1,41 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java; + +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.java.JavaQuery; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; + +/** + * Java named stored procedure query + *

+ * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public interface JavaNamedStoredProcedureQuery2_1 + extends NamedStoredProcedureQuery2_1, JavaQuery +{ + NamedStoredProcedureQuery2_1Annotation getQueryAnnotation(); + + // *********** parameters ************ + + ListIterable getParameters(); + + JavaStoredProcedureParameter2_1 addParameter(); + + JavaStoredProcedureParameter2_1 addParameter(int index); +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaQueryContainer2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaQueryContainer2_1.java new file mode 100644 index 0000000..d744a1a --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaQueryContainer2_1.java @@ -0,0 +1,38 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java; + +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.java.JavaQueryContainer; + +/** + * Java query container for JPA 2.1 + *

+ * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public interface JavaQueryContainer2_1 + extends JavaQueryContainer +{ + // ********** named stored procedure queries ********** + + ListIterable getNamedStoredProcedureQueries(); + + JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(); + + JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index); + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaStoredProcedureParameter2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaStoredProcedureParameter2_1.java new file mode 100644 index 0000000..fc99d52 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/JavaStoredProcedureParameter2_1.java @@ -0,0 +1,31 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java; + +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; + +/** + * Java stored procedure parameter + *

+ * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public interface JavaStoredProcedureParameter2_1 + extends StoredProcedureParameter2_1 +{ + StoredProcedureParameter2_1Annotation getStoredProcedureParameter2_1Annotation(); +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java new file mode 100644 index 0000000..92cbc71 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java @@ -0,0 +1,353 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm; + +import java.util.ArrayList; +import java.util.Vector; +import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.common.utility.internal.collection.ListTools; +import org.eclipse.jpt.common.utility.internal.iterable.IterableTools; +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.JpaContextNode; +import org.eclipse.jpt.jpa.core.context.Query; +import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmQuery; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; + +public class GenericOrmNamedStoredProcedureQuery2_1 + extends AbstractOrmQuery + implements OrmNamedStoredProcedureQuery2_1 +{ + protected String procedureName; + + protected final ContextListContainer parameterContainer; + + protected final Vector resultClasses = new Vector(); + + protected final Vector resultSetMappings = new Vector(); + + + public GenericOrmNamedStoredProcedureQuery2_1(JpaContextNode parent, XmlNamedStoredProcedureQuery xmlNamedStoredProcedureQuery) { + super(parent, xmlNamedStoredProcedureQuery); + this.procedureName = this.xmlQuery.getProcedureName(); + this.parameterContainer = this.buildParameterContainer(); + this.initializeResultClasses(); + this.initializeResultSetMappings(); + } + + + // ********** synchronize/update ********** + + @Override + public void synchronizeWithResourceModel() { + super.synchronizeWithResourceModel(); + this.setProcedureName_(this.xmlQuery.getProcedureName()); + this.syncParameters(); + this.syncResultClasses(); + this.syncResultSetMappings(); + } + + @Override + public void update() { + super.update(); + this.updateNodes(this.getParameters()); + } + + +// ********* procedure name ******** + +public String getProcedureName() { + return this.procedureName; +} + +public void setProcedureName(String procedureName) { + this.xmlQuery.setProcedureName(procedureName); + this.setProcedureName_(procedureName); +} + +protected void setProcedureName_(String procedureName) { + String old = this.procedureName; + this.procedureName = procedureName; + this.firePropertyChanged(PROCEDURE_NAME_PROPERTY, old, procedureName); +} + +// ********** parameters ********** + +public ListIterable getParameters() { + return this.parameterContainer.getContextElements(); +} + +public int getParametersSize() { + return this.parameterContainer.getContextElementsSize(); +} + +public OrmStoredProcedureParameter2_1 addParameter() { + return this.addParameter(this.getParametersSize()); +} + +public OrmStoredProcedureParameter2_1 addParameter(int index) { + XmlStoredProcedureParameter xmlParameter = this.buildXmlStoredProcedureParameter(); + OrmStoredProcedureParameter2_1 parameter = this.parameterContainer.addContextElement(index, xmlParameter); + this.xmlQuery.getParameters().add(index, xmlParameter); + return parameter; +} + +protected XmlStoredProcedureParameter buildXmlStoredProcedureParameter() { + return OrmFactory.eINSTANCE.createXmlStoredProcedureParameter(); +} + +public void removeParameter(StoredProcedureParameter2_1 parameter) { + this.removeParameter(this.parameterContainer.indexOfContextElement((OrmStoredProcedureParameter2_1) parameter)); +} + +public void removeParameter(int index) { + this.parameterContainer.removeContextElement(index); + this.xmlQuery.getParameters().remove(index); +} + +public void moveParameter(int targetIndex, int sourceIndex) { + this.parameterContainer.moveContextElement(targetIndex, sourceIndex); + this.xmlQuery.getParameters().move(targetIndex, sourceIndex); +} + +public OrmStoredProcedureParameter2_1 getParameter(int index) { + return this.parameterContainer.get(index); +} + +protected OrmStoredProcedureParameter2_1 buildParameter(XmlStoredProcedureParameter xmlParameter) { + return this.isOrmXml2_1Compatible() ? + this.getContextNodeFactory2_1().buildOrmStoredProcedureParameter(this, xmlParameter) : + null; +} + +protected void syncParameters() { + this.parameterContainer.synchronizeWithResourceModel(); +} + +protected ListIterable getXmlParameters() { + // clone to reduce chance of concurrency problems + return IterableTools.cloneLive(this.xmlQuery.getParameters()); +} + +protected ContextListContainer buildParameterContainer() { + ParameterContainer container = new ParameterContainer(); + container.initialize(); + return container; +} + +/** + * query hint container + */ +protected class ParameterContainer + extends ContextListContainer +{ + @Override + protected String getContextElementsPropertyName() { + return PARAMETERS_LIST; + } + @Override + protected OrmStoredProcedureParameter2_1 buildContextElement(XmlStoredProcedureParameter resourceElement) { + return GenericOrmNamedStoredProcedureQuery2_1.this.buildParameter(resourceElement); + } + @Override + protected ListIterable getResourceElements() { + return GenericOrmNamedStoredProcedureQuery2_1.this.getXmlParameters(); + } + @Override + protected XmlStoredProcedureParameter getResourceElement(OrmStoredProcedureParameter2_1 contextElement) { + return contextElement.getXmlStoredProcedureParameter(); + } +} + + +// *********** result classes ********** + +public ListIterable getResultClasses() { + return IterableTools.cloneLive(this.resultClasses); +} + +public int getResultClassesSize() { + return this.resultClasses.size(); +} + +public String getResultClass(int index) { + return this.resultClasses.get(index); +} + +public void addResultClass(String resultClass) { + this.addResultClass(this.resultClasses.size(), resultClass); +} + +public void addResultClass(int index, String resultClass) { + this.addItemToList(index, resultClass, this.resultClasses, RESULT_CLASSES_LIST); + this.xmlQuery.getResultClasses().add(index, resultClass); +} + +public void removeResultClass(String resultClass) { + this.removeResultClass(this.resultClasses.indexOf(resultClass)); +} + +public void removeResultClass(int index) { + this.removeItemFromList(index, this.resultClasses, RESULT_CLASSES_LIST); + this.xmlQuery.getResultClasses().remove(index); +} + +public void moveResultClass(int targetIndex, int sourceIndex) { + this.moveItemInList(targetIndex, sourceIndex, this.resultClasses, RESULT_CLASSES_LIST); + this.xmlQuery.getResultClasses().move(targetIndex, sourceIndex); +} + +protected void initializeResultClasses() { + for (String resultClass : this.getResourceResultClasses()) { + this.resultClasses.add(resultClass); + } +} + +protected void syncResultClasses() { + this.synchronizeList(this.getResourceResultClasses(), this.resultClasses, RESULT_CLASSES_LIST); +} + +protected Iterable getResourceResultClasses() { + return this.xmlQuery.getResultClasses(); +} + + +// *********** result set mappings ********* + +public ListIterable getResultSetMappings() { + return IterableTools.cloneLive(this.resultSetMappings); +} + +public int getResultSetMappingsSize() { + return this.resultSetMappings.size(); +} + +public String getResultSetMapping(int index) { + return this.resultSetMappings.get(index); +} + +public void addResultSetMapping(String resultSetMapping) { + this.addResultSetMapping(this.resultSetMappings.size(), resultSetMapping); +} + +public void addResultSetMapping(int index, String resultSetMapping) { + this.addItemToList(index, resultSetMapping, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + this.xmlQuery.getResultSetMappings().add(index, resultSetMapping); +} + +public void removeResultSetMapping(String resultSetMapping) { + this.removeResultSetMapping(this.resultSetMappings.indexOf(resultSetMapping)); +} + +public void removeResultSetMapping(int index) { + this.removeItemFromList(index, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + this.xmlQuery.getResultSetMappings().remove(index); +} + +public void moveResultSetMapping(int targetIndex, int sourceIndex) { + this.moveItemInList(targetIndex, sourceIndex, this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); + this.xmlQuery.getResultSetMappings().move(targetIndex, sourceIndex); +} + +protected void initializeResultSetMappings() { + for (String resultSetMapping : this.getResourceResultSetMappings()) { + this.resultSetMappings.add(resultSetMapping); + } +} + +protected void syncResultSetMappings() { + this.synchronizeList(this.getResourceResultSetMappings(), this.resultSetMappings, RESULT_SET_MAPPINGS_LIST); +} + +protected Iterable getResourceResultSetMappings() { + return this.xmlQuery.getResultSetMappings(); +} + +@Override +public void toString(StringBuilder sb) { + sb.append(this.resultClasses); + sb.append(this.resultSetMappings); +} + + +// ********** metadata conversion ********* + +public void convertFrom(JavaNamedStoredProcedureQuery2_1 javaQuery) { + super.convertFrom(javaQuery); + this.setName(javaQuery.getName()); + this.setProcedureName(javaQuery.getProcedureName()); + for (JavaStoredProcedureParameter2_1 javaParameter : javaQuery.getParameters()) { + this.addParameter().convertFrom(javaParameter); + } + for (String resultClass : javaQuery.getResultClasses()) { + this.addResultClass(resultClass); + } + for (String resultSetMapping : javaQuery.getResultSetMappings()) { + this.addResultSetMapping(resultSetMapping); + } +} + + +// ********** validation ********** + +@Override +protected boolean isEquivalentTo(Query other) { + return super.isEquivalentTo(other) + && this.isEquivalentTo((NamedStoredProcedureQuery2_1) other); +} + +protected boolean isEquivalentTo(NamedStoredProcedureQuery2_1 other) { + return ObjectTools.equals(this.procedureName, other.getProcedureName()) && + this.parametersAreEquivalentTo(other) && + this.valuesAreEquivalent(other, this.getResultClasses(), other.getResultClasses()) && + this.valuesAreEquivalent(other, this.getResultSetMappings(), other.getResultSetMappings()); +} + +protected boolean valuesAreEquivalent(NamedStoredProcedureQuery2_1 other, ListIterable list1, ListIterable list2) { + ArrayList stringList1 = ListTools.list(list1); + ArrayList stringList2 = ListTools.list(list2); + if (stringList1.size() != stringList2.size()) { + return false; + } + for (int i = 0; i < stringList1.size(); i++) { + if ( !ObjectTools.equals(stringList1.get(i), stringList2.get(i))) { + return false; + } + } + return true; +} + +protected boolean parametersAreEquivalentTo(NamedStoredProcedureQuery2_1 other) { + // get fixed lists of the stored procedure parameters + ArrayList parameter1 = ListTools.list(this.getParameters()); + ArrayList parameter2 = ListTools.list(other.getParameters()); + if (parameter1.size() != parameter2.size()) { + return false; + } + for (int i = 0; i < parameter1.size(); i++) { + if ( ! parameter1.get(i).isEquivalentTo(parameter2.get(i))) { + return false; + } + } + return true; +} + +// ********** misc ********** + +public Class getType() { + return NamedStoredProcedureQuery2_1.class; +} + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmStoredProcedureParameter2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmStoredProcedureParameter2_1.java new file mode 100644 index 0000000..612ec18 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmStoredProcedureParameter2_1.java @@ -0,0 +1,201 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm; + +import org.eclipse.jpt.common.core.utility.TextRange; +import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.jpa.core.context.orm.OrmQuery; +import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; + +public class GenericOrmStoredProcedureParameter2_1 + extends AbstractOrmXmlContextNode + implements OrmStoredProcedureParameter2_1 +{ + + protected final XmlStoredProcedureParameter xmlStoredProcedureParameter; + + protected String name; + + protected ParameterMode2_1 specifiedMode; + protected ParameterMode2_1 defaultMode; + + protected String typeName; + protected String fullyQualifiedTypeName; + + + public GenericOrmStoredProcedureParameter2_1( + OrmQuery parent, + XmlStoredProcedureParameter xmlStoredProcedureParameter) { + super(parent); + this.xmlStoredProcedureParameter = xmlStoredProcedureParameter; + this.name = xmlStoredProcedureParameter.getName(); + this.specifiedMode = this.buildSpecifiedMode(); + this.typeName = xmlStoredProcedureParameter.getClassName(); + } + + + // ********** synchronize/update ********** + + @Override + public void synchronizeWithResourceModel() { + super.synchronizeWithResourceModel(); + this.setName_(this.xmlStoredProcedureParameter.getName()); + this.setSpecifiedMode_(this.buildSpecifiedMode()); + this.setTypeName_(this.xmlStoredProcedureParameter.getClassName()); + } + + @Override + public void update() { + super.update(); + this.setDefaultMode(this.buildDefaultMode()); + this.setFullyQualifiedTypeName(this.buildFullyQualifiedTypeName()); + } + + // ********** name ********** + + public String getName() { + return this.name; + } + + public void setName(String name) { + this.setName_(name); + this.xmlStoredProcedureParameter.setName(name); + } + + protected void setName_(String name) { + String old = this.name; + this.name = name; + this.firePropertyChanged(NAME_PROPERTY, old, name); + } + + + // ********** mode ********** + + public ParameterMode2_1 getMode() { + return (this.specifiedMode != null) ? this.specifiedMode : this.defaultMode; + } + + public ParameterMode2_1 getSpecifiedMode() { + return this.specifiedMode; + } + + public void setSpecifiedMode(ParameterMode2_1 mode) { + this.xmlStoredProcedureParameter.setMode(ParameterMode2_1.toOrmResourceModel(mode)); + this.setSpecifiedMode_(mode); + } + + public void setSpecifiedMode_(ParameterMode2_1 mode) { + ParameterMode2_1 old = this.specifiedMode; + this.specifiedMode = mode; + this.firePropertyChanged(SPECIFIED_MODE_PROPERTY, old, mode); + } + + protected ParameterMode2_1 buildSpecifiedMode() { + return this.isJpa2_1Compatible() ? + ParameterMode2_1.fromOrmResourceModel(this.xmlStoredProcedureParameter.getMode()) : + null; + } + + public ParameterMode2_1 getDefaultMode() { + return this.defaultMode; + } + + protected void setDefaultMode(ParameterMode2_1 mode) { + ParameterMode2_1 old = this.defaultMode; + this.defaultMode = mode; + this.firePropertyChanged(DEFAULT_MODE_PROPERTY, old, mode); + } + + protected ParameterMode2_1 buildDefaultMode() { + return this.isJpa2_1Compatible() ? ParameterMode2_1.IN : null; + } + + + // ********** type ********** + + public String getTypeName() { + return this.typeName; + } + + public void setTypeName(String typeName) { + this.xmlStoredProcedureParameter.setClassName(typeName); + this.setTypeName_(typeName); + } + + protected void setTypeName_(String typeName) { + String old = this.typeName; + this.typeName = typeName; + this.firePropertyChanged(TYPE_NAME_PROPERTY, old, typeName); + } + + public String getFullyQualifiedTypeName() { + return this.fullyQualifiedTypeName; + } + + protected void setFullyQualifiedTypeName(String typeName) { + String old = this.fullyQualifiedTypeName; + this.fullyQualifiedTypeName = typeName; + this.firePropertyChanged(FULLY_QUALIFIED_TYPE_NAME_PROPERTY, old, typeName); + } + + protected String buildFullyQualifiedTypeName() { + return this.getMappingFileRoot().qualify(this.typeName); + } + + public char getTypeEnclosingTypeSeparator() { + return '$'; + } + + // ********** metadata conversion ********** + + public void convertFrom(JavaStoredProcedureParameter2_1 javaParameter) { + this.setName(javaParameter.getName()); + this.setSpecifiedMode(javaParameter.getMode()); + this.setTypeName(javaParameter.getTypeName()); + } + + // ********** validation ********** + + public TextRange getValidationTextRange() { + TextRange textRange = this.xmlStoredProcedureParameter.getValidationTextRange(); + return (textRange != null) ? textRange : this.getQuery().getValidationTextRange(); + } + + public boolean isEquivalentTo(StoredProcedureParameter2_1 parameter) { + return ObjectTools.equals(this.name, parameter.getName()) && + ObjectTools.equals(this.specifiedMode, parameter.getSpecifiedMode()) && + ObjectTools.equals(this.typeName, parameter.getTypeName()); + } + + // ********** misc ********** + + @Override + public OrmQuery getParent() { + return (OrmQuery) super.getParent(); + } + + protected OrmQuery getQuery() { + return this.getParent(); + } + + public XmlStoredProcedureParameter getXmlStoredProcedureParameter() { + return this.xmlStoredProcedureParameter; + } + + @Override + public void toString(StringBuilder sb) { + sb.append(this.name); + sb.append(this.typeName); + } +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmXml2_1ContextNodeFactory.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmXml2_1ContextNodeFactory.java index 08e285d..8b6d159 100644 --- src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmXml2_1ContextNodeFactory.java +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmXml2_1ContextNodeFactory.java @@ -14,6 +14,8 @@ import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmConverterType2_1; import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmXml2_1ContextNodeFactory; import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; public class GenericOrmXml2_1ContextNodeFactory extends GenericOrmXml2_0ContextNodeFactory @@ -23,4 +25,16 @@ public OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter) { return new GenericOrmConverterType(parent, xmlConverter); } + + public OrmNamedStoredProcedureQuery2_1 buildOrmNamedStoredProcedureQuery2_1( + OrmQueryContainer2_1 parent, + XmlNamedStoredProcedureQuery xmlNamedStoredProcedureQuery) { + return new GenericOrmNamedStoredProcedureQuery2_1(parent, xmlNamedStoredProcedureQuery); + } + + public OrmStoredProcedureParameter2_1 buildOrmStoredProcedureParameter( + OrmNamedStoredProcedureQuery2_1 parent, + XmlStoredProcedureParameter xmlParameter) { + return new GenericOrmStoredProcedureParameter2_1(parent, xmlParameter); + } } diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmNamedStoredProcedureQuery2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmNamedStoredProcedureQuery2_1.java new file mode 100644 index 0000000..6324233 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmNamedStoredProcedureQuery2_1.java @@ -0,0 +1,39 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm; + +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.orm.OrmQuery; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; + +public interface OrmNamedStoredProcedureQuery2_1 + extends OrmQuery, NamedStoredProcedureQuery2_1 +{ + XmlNamedStoredProcedureQuery getXmlQuery(); + + // *********** parameters ************ + + ListIterable getParameters(); + + OrmStoredProcedureParameter2_1 addParameter(); + + OrmStoredProcedureParameter2_1 addParameter(int index); + + // ********** metadata conversion ********* + + /** + * Build up a mapping file query from + * the given Java query + */ + void convertFrom(JavaNamedStoredProcedureQuery2_1 javaQuery); + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmQueryContainer2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmQueryContainer2_1.java new file mode 100644 index 0000000..90cff38 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmQueryContainer2_1.java @@ -0,0 +1,26 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm; + +import org.eclipse.jpt.common.utility.iterable.ListIterable; +import org.eclipse.jpt.jpa.core.context.orm.OrmQueryContainer; + +public interface OrmQueryContainer2_1 + extends OrmQueryContainer +{ + // ********** named stored procedure queries ********** + + ListIterable getNamedStoredProcedureQueries(); + + OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(); + + OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery(int index); + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmStoredProcedureParameter2_1.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmStoredProcedureParameter2_1.java new file mode 100644 index 0000000..febe7a7 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/OrmStoredProcedureParameter2_1.java @@ -0,0 +1,28 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm; + +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; + +public interface OrmStoredProcedureParameter2_1 + extends StoredProcedureParameter2_1 +{ + XmlStoredProcedureParameter getXmlStoredProcedureParameter(); + + // ****** metadata conversion **** + /** + * Build up a mapping file stored procedure parameter + * from the given Java stored procedure parameter + */ + void convertFrom(JavaStoredProcedureParameter2_1 javaStoredProcedureParameter); + +} diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/binary/BinaryStoredProcedureParameter2_1Annotation.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/binary/BinaryStoredProcedureParameter2_1Annotation.java index 244ff1c..05e61c6 100644 --- src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/binary/BinaryStoredProcedureParameter2_1Annotation.java +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/binary/BinaryStoredProcedureParameter2_1Annotation.java @@ -14,7 +14,7 @@ import org.eclipse.jpt.common.core.resource.java.JavaResourceNode; import org.eclipse.jpt.common.core.utility.TextRange; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1; -import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; /** @@ -25,7 +25,7 @@ implements StoredProcedureParameter2_1Annotation { private String name; - private ParameterMode2_1 mode; + private ParameterMode_2_1 mode; private String type; @@ -89,22 +89,22 @@ } // ***** mode - public ParameterMode2_1 getMode() { + public ParameterMode_2_1 getMode() { return this.mode; } - public void setMode(ParameterMode2_1 mode) { + public void setMode(ParameterMode_2_1 mode) { throw new UnsupportedOperationException(); } - private void setMode_(ParameterMode2_1 mode) { - ParameterMode2_1 old = this.mode; + private void setMode_(ParameterMode_2_1 mode) { + ParameterMode_2_1 old = this.mode; this.mode = mode; this.firePropertyChanged(MODE_PROPERTY, old, mode); } - private ParameterMode2_1 buildMode() { - return ParameterMode2_1.fromJavaAnnotationValue(this.getJdtMemberValue(this.getModeElementName())); + private ParameterMode_2_1 buildMode() { + return ParameterMode_2_1.fromJavaAnnotationValue(this.getJdtMemberValue(this.getModeElementName())); } public TextRange getModeTextRange() { @@ -112,11 +112,11 @@ } // ***** type - public String getType() { + public String getTypeName() { return this.type; } - public void setType(String type) { + public void setTypeName(String type) { throw new UnsupportedOperationException(); } diff --git src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/source/SourceStoredProcedureParameter2_1Annotation.java src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/source/SourceStoredProcedureParameter2_1Annotation.java index c610e32..46b550c 100644 --- src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/source/SourceStoredProcedureParameter2_1Annotation.java +++ src/org/eclipse/jpt/jpa/core/internal/jpa2_1/resource/java/source/SourceStoredProcedureParameter2_1Annotation.java @@ -26,7 +26,7 @@ import org.eclipse.jpt.common.core.utility.jdt.ExpressionConverter; import org.eclipse.jpt.common.core.utility.jdt.IndexedDeclarationAnnotationAdapter; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1; -import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; /** @@ -43,7 +43,7 @@ private DeclarationAnnotationElementAdapter modeDeclarationAdapter; private AnnotationElementAdapter modeAdapter; - private ParameterMode2_1 mode; + private ParameterMode_2_1 mode; private TextRange modeTextRange; private DeclarationAnnotationElementAdapter typeDeclarationAdapter; @@ -166,25 +166,25 @@ } // ***** mode - public ParameterMode2_1 getMode() { + public ParameterMode_2_1 getMode() { return this.mode; } - public void setMode(ParameterMode2_1 mode) { + public void setMode(ParameterMode_2_1 mode) { if (this.attributeValueHasChanged(this.mode, mode)) { this.mode = mode; - this.modeAdapter.setValue(ParameterMode2_1.toJavaAnnotationValue(mode)); + this.modeAdapter.setValue(ParameterMode_2_1.toJavaAnnotationValue(mode)); } } - private void syncMode(ParameterMode2_1 astValue) { - ParameterMode2_1 old = this.mode; + private void syncMode(ParameterMode_2_1 astValue) { + ParameterMode_2_1 old = this.mode; this.mode = astValue; this.firePropertyChanged(MODE_PROPERTY, old, astValue); } - private ParameterMode2_1 buildMode(Annotation astAnnotation) { - return ParameterMode2_1.fromJavaAnnotationValue(this.modeAdapter.getValue(astAnnotation)); + private ParameterMode_2_1 buildMode(Annotation astAnnotation) { + return ParameterMode_2_1.fromJavaAnnotationValue(this.modeAdapter.getValue(astAnnotation)); } public TextRange getModeTextRange() { @@ -204,11 +204,11 @@ } // ***** type - public String getType() { + public String getTypeName() { return this.type; } - public void setType(String type) { + public void setTypeName(String type) { if (this.attributeValueHasChanged(this.type, type)) { this.type = type; this.fqTypeNameStale = true; diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/JpaFactory2_1.java src/org/eclipse/jpt/jpa/core/jpa2_1/JpaFactory2_1.java index 71001de..9085256 100644 --- src/org/eclipse/jpt/jpa/core/jpa2_1/JpaFactory2_1.java +++ src/org/eclipse/jpt/jpa/core/jpa2_1/JpaFactory2_1.java @@ -11,8 +11,14 @@ import org.eclipse.jpt.common.core.resource.java.JavaResourceType; import org.eclipse.jpt.jpa.core.context.JpaContextNode; +import org.eclipse.jpt.jpa.core.context.java.JavaQuery; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1; import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0; import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; /** * JPA 2.1 factory @@ -25,10 +31,19 @@ * * @version 3.3 * @since 3.3 - */ -public interface JpaFactory2_1 - extends JpaFactory2_0 + */ +public interface JpaFactory2_1 + extends JpaFactory2_0 { - + // ********** Java Context Model ********** + JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt); -} + + JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1( + JavaQuery parent, + StoredProcedureParameter2_1Annotation parameterAnnotation); + + JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1( + JavaQueryContainer2_1 parent, + NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation); +} diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/ParameterMode2_1.java src/org/eclipse/jpt/jpa/core/jpa2_1/ParameterMode2_1.java new file mode 100644 index 0000000..afd74e1 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/jpa2_1/ParameterMode2_1.java @@ -0,0 +1,106 @@ +/******************************************************************************* +* Copyright (c) 2013 Oracle. All rights reserved. +* This program and the accompanying materials are made available under the +* terms of the Eclipse Public License v1.0, which accompanies this distribution +* and is available at http://www.eclipse.org/legal/epl-v10.html. +* +* Contributors: +* Oracle - initial API and implementation +*******************************************************************************/ +package org.eclipse.jpt.jpa.core.jpa2_1; + + +/** + * parameter mode + * + * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public enum ParameterMode2_1 +{ + IN( + org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.IN, + org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.IN + ), + INOUT( + org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.INOUT, + org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.INOUT + ), + OUT( + org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.OUT, + org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.OUT + ), + REF_CURSOR( + org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1.REF_CURSOR, + org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1.REF_CURSOR + ); + + + private org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode; + private org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode; + + ParameterMode2_1( + org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode, + org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) { + if (javaParameterMode == null) { + throw new NullPointerException(); + } + if (ormParameterMode == null) { + throw new NullPointerException(); + } + this.javaParameterMode = javaParameterMode; + this.ormParameterMode = ormParameterMode; + } + + public org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 getJavaParameterMode() { + return this.javaParameterMode; + } + + public org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 getOrmParameterMode() { + return this.ormParameterMode; + } + + + // ********** static methods ********** + + public static ParameterMode2_1 fromJavaResourceModel(org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode) { + return (javaParameterMode == null) ? null : fromJavaResourceModel_(javaParameterMode); + } + + private static ParameterMode2_1 fromJavaResourceModel_(org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 javaParameterMode) { + for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) { + if (parameterMode.getJavaParameterMode() == javaParameterMode) { + return parameterMode; + } + } + return null; + } + + public static org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1 toJavaResourceModel(ParameterMode2_1 parameterMode) { + return (parameterMode == null) ? null : parameterMode.getJavaParameterMode(); + } + + + public static ParameterMode2_1 fromOrmResourceModel(org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) { + return (ormParameterMode == null) ? null : fromOrmResourceModel_(ormParameterMode); + } + + private static ParameterMode2_1 fromOrmResourceModel_(org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 ormParameterMode) { + for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) { + if (parameterMode.getOrmParameterMode() == ormParameterMode) { + return parameterMode; + } + } + return null; + } + + public static org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1 toOrmResourceModel(ParameterMode2_1 parameterMode) { + return (parameterMode == null) ? null : parameterMode.getOrmParameterMode(); + } +} diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/context/orm/OrmXml2_1ContextNodeFactory.java src/org/eclipse/jpt/jpa/core/jpa2_1/context/orm/OrmXml2_1ContextNodeFactory.java index 45d8a98..74a0e5b 100644 --- src/org/eclipse/jpt/jpa/core/jpa2_1/context/orm/OrmXml2_1ContextNodeFactory.java +++ src/org/eclipse/jpt/jpa/core/jpa2_1/context/orm/OrmXml2_1ContextNodeFactory.java @@ -11,6 +11,11 @@ import org.eclipse.jpt.jpa.core.context.orm.OrmXmlContextNodeFactory; import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; /** * JPA 2.1 orm.xml context node factory @@ -28,4 +33,12 @@ extends OrmXmlContextNodeFactory { OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter); + + OrmNamedStoredProcedureQuery2_1 buildOrmNamedStoredProcedureQuery2_1( + OrmQueryContainer2_1 parent, + XmlNamedStoredProcedureQuery xmlNamedQuery); + + OrmStoredProcedureParameter2_1 buildOrmStoredProcedureParameter( + OrmNamedStoredProcedureQuery2_1 parent, + XmlStoredProcedureParameter xmlParameter); } diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/NamedStoredProcedureQuery2_1Annotation.java src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/NamedStoredProcedureQuery2_1Annotation.java index 23d5317..227303c 100644 --- src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/NamedStoredProcedureQuery2_1Annotation.java +++ src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/NamedStoredProcedureQuery2_1Annotation.java @@ -116,6 +116,11 @@ /** * Corresponds to the 'resultClasses' element of the NamedStoredProcedureQuery annotation. */ + void addResultClass(int index, String resultClass); + + /** + * Corresponds to the 'resultClasses' element of the NamedStoredProcedureQuery annotation. + */ void moveResultClass(int targetIndex, int sourceIndex); /** @@ -156,6 +161,11 @@ /** * Corresponds to the 'resultSetMappings' element of the NamedStoredProcedureQuery annotation. */ + void addResultSetMapping(int index, String resultSetMapping); + + /** + * Corresponds to the 'resultSetMappings' element of the NamedStoredProcedureQuery annotation. + */ void moveResultSetMapping(int targetIndex, int sourceIndex); /** diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/ParameterMode2_1.java src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/ParameterMode2_1.java deleted file mode 100644 index 8e4dc8c..0000000 --- src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/ParameterMode2_1.java +++ /dev/null @@ -1,67 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2013 Oracle. All rights reserved. - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0, which accompanies this distribution - * and is available at http://www.eclipse.org/legal/epl-v10.html. - * - * Contributors: - * Oracle - initial API and implementation - ******************************************************************************/ -package org.eclipse.jpt.jpa.core.jpa2_1.resource.java; - - -/** - * Corresponds to the JPA 2.1 enum - * javax.persistence.ParameterMode - *

- * Provisional API: This interface is part of an interim API that is still - * under development and expected to change significantly before reaching - * stability. It is available at this early stage to solicit feedback from - * pioneering adopters on the understanding that any code that uses this API - * will almost certainly be broken (repeatedly) as the API evolves. - * - * @version 3.3 - * @since 3.3 - */ -public enum ParameterMode2_1 -{ - - IN(JPA2_1.PARAMETER_MODE__IN), - INOUT(JPA2_1.PARAMETER_MODE__INOUT), - OUT(JPA2_1.PARAMETER_MODE__OUT), - REF_CURSOR(JPA2_1.PARAMETER_MODE__REF_CURSOR); - - - private String javaAnnotationValue; - - ParameterMode2_1(String javaAnnotationValue) { - if (javaAnnotationValue == null) { - throw new NullPointerException(); - } - this.javaAnnotationValue = javaAnnotationValue; - } - - public String getJavaAnnotationValue() { - return this.javaAnnotationValue; - } - - - // ********** static methods ********** - - public static ParameterMode2_1 fromJavaAnnotationValue(Object javaAnnotationValue) { - return (javaAnnotationValue == null) ? null : fromJavaAnnotationValue_(javaAnnotationValue); - } - - private static ParameterMode2_1 fromJavaAnnotationValue_(Object javaAnnotationValue) { - for (ParameterMode2_1 parameterMode : ParameterMode2_1.values()) { - if (parameterMode.getJavaAnnotationValue().equals(javaAnnotationValue)) { - return parameterMode; - } - } - return null; - } - - public static String toJavaAnnotationValue(ParameterMode2_1 parameterMode) { - return (parameterMode == null) ? null : parameterMode.getJavaAnnotationValue(); - } -} diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/ParameterMode_2_1.java src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/ParameterMode_2_1.java new file mode 100644 index 0000000..5f27dd8 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/ParameterMode_2_1.java @@ -0,0 +1,67 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.jpa2_1.resource.java; + + +/** + * Corresponds to the JPA 2.1 enum + * javax.persistence.ParameterMode + *

+ * Provisional API: This interface is part of an interim API that is still + * under development and expected to change significantly before reaching + * stability. It is available at this early stage to solicit feedback from + * pioneering adopters on the understanding that any code that uses this API + * will almost certainly be broken (repeatedly) as the API evolves. + * + * @version 3.3 + * @since 3.3 + */ +public enum ParameterMode_2_1 +{ + + IN(JPA2_1.PARAMETER_MODE__IN), + INOUT(JPA2_1.PARAMETER_MODE__INOUT), + OUT(JPA2_1.PARAMETER_MODE__OUT), + REF_CURSOR(JPA2_1.PARAMETER_MODE__REF_CURSOR); + + + private String javaAnnotationValue; + + ParameterMode_2_1(String javaAnnotationValue) { + if (javaAnnotationValue == null) { + throw new NullPointerException(); + } + this.javaAnnotationValue = javaAnnotationValue; + } + + public String getJavaAnnotationValue() { + return this.javaAnnotationValue; + } + + + // ********** static methods ********** + + public static ParameterMode_2_1 fromJavaAnnotationValue(Object javaAnnotationValue) { + return (javaAnnotationValue == null) ? null : fromJavaAnnotationValue_(javaAnnotationValue); + } + + private static ParameterMode_2_1 fromJavaAnnotationValue_(Object javaAnnotationValue) { + for (ParameterMode_2_1 parameterMode : ParameterMode_2_1.values()) { + if (parameterMode.getJavaAnnotationValue().equals(javaAnnotationValue)) { + return parameterMode; + } + } + return null; + } + + public static String toJavaAnnotationValue(ParameterMode_2_1 parameterMode) { + return (parameterMode == null) ? null : parameterMode.getJavaAnnotationValue(); + } +} diff --git src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/StoredProcedureParameter2_1Annotation.java src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/StoredProcedureParameter2_1Annotation.java index 1f0a943..9e0ba2a 100644 --- src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/StoredProcedureParameter2_1Annotation.java +++ src/org/eclipse/jpt/jpa/core/jpa2_1/resource/java/StoredProcedureParameter2_1Annotation.java @@ -56,14 +56,14 @@ * Corresponds to the 'mode' element of the StoredProcedureParameter annotation. * Return null if the element does not exist in the annotation */ - ParameterMode2_1 getMode(); + ParameterMode_2_1 getMode(); String MODE_PROPERTY = "mode"; //$NON-NLS-1$ /** * Corresponds to the 'mode' element of the StoredProcedureParameter annotation. * Setting to null will remove the element. */ - void setMode(ParameterMode2_1 mode); + void setMode(ParameterMode_2_1 mode); /** * Return the {@link TextRange} for the 'mode' element. If the element @@ -77,14 +77,14 @@ * Corresponds to the 'type' element of the StoredProcedureParameter annotation. * Return null if the element does not exist in the annotation */ - String getType(); + String getTypeName(); String TYPE_PROPERTY = "type"; //$NON-NLS-1$ /** * Corresponds to the 'type' element of the StoredProcedureParameter annotation. * Setting to null will remove the element. */ - void setType(String type); + void setTypeName(String type); /** * Return the {@link TextRange} for the 'type' element. If the element #P org.eclipse.jpt.jpa.eclipselink.core diff --git src/org/eclipse/jpt/jpa/eclipselink/core/internal/EclipseLink2_5JpaFactory.java src/org/eclipse/jpt/jpa/eclipselink/core/internal/EclipseLink2_5JpaFactory.java index 42fe680..f61c3f6 100644 --- src/org/eclipse/jpt/jpa/eclipselink/core/internal/EclipseLink2_5JpaFactory.java +++ src/org/eclipse/jpt/jpa/eclipselink/core/internal/EclipseLink2_5JpaFactory.java @@ -11,9 +11,17 @@ import org.eclipse.jpt.common.core.resource.java.JavaResourceType; import org.eclipse.jpt.jpa.core.context.JpaContextNode; +import org.eclipse.jpt.jpa.core.context.java.JavaQuery; import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaConverterType; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.GenericJavaStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.java.JavaStoredProcedureParameter2_1; import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1; import org.eclipse.jpt.jpa.core.jpa2_1.context.java.JavaConverterType2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; /** * EclipseLink 2.5 factory @@ -29,4 +37,17 @@ public JavaConverterType2_1 buildJavaConverterType(JpaContextNode parent, JavaResourceType jrt) { return new GenericJavaConverterType(parent, jrt); } + + public JavaStoredProcedureParameter2_1 buildJavaStoredProcedureParameter2_1( + JavaQuery parent, + StoredProcedureParameter2_1Annotation parameterAnnotation) { + return new GenericJavaStoredProcedureParameter2_1(parent, parameterAnnotation); + } + + public JavaNamedStoredProcedureQuery2_1 buildJavaNamedStoredProcedureQuery2_1( + JavaQueryContainer2_1 parent, + NamedStoredProcedureQuery2_1Annotation namedStoredProcedureQueryAnnotation) { + return new GenericJavaNamedStoredProcedureQuery2_1(parent, namedStoredProcedureQueryAnnotation); + } + } diff --git src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmXml2_5ContextNodeFactory.java src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmXml2_5ContextNodeFactory.java index d5d0669..aec6916 100644 --- src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmXml2_5ContextNodeFactory.java +++ src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmXml2_5ContextNodeFactory.java @@ -10,10 +10,17 @@ package org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm; import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmConverterType; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.GenericOrmStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1; import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.EntityMappings2_1; import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmConverterType2_1; import org.eclipse.jpt.jpa.core.jpa2_1.context.orm.OrmXml2_1ContextNodeFactory; import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; public class EclipseLinkOrmXml2_5ContextNodeFactory extends EclipseLinkOrmXml2_4ContextNodeFactory @@ -22,4 +29,16 @@ public OrmConverterType2_1 buildOrmConverter(EntityMappings2_1 parent, XmlConverter xmlConverter) { return new GenericOrmConverterType(parent, xmlConverter); } + + public OrmNamedStoredProcedureQuery2_1 buildOrmNamedStoredProcedureQuery2_1( + OrmQueryContainer2_1 parent, + XmlNamedStoredProcedureQuery xmlNamedStoredProcedureQuery) { + return new GenericOrmNamedStoredProcedureQuery2_1(parent, xmlNamedStoredProcedureQuery); + } + + public OrmStoredProcedureParameter2_1 buildOrmStoredProcedureParameter( + OrmNamedStoredProcedureQuery2_1 parent, + XmlStoredProcedureParameter xmlParameter) { + return new GenericOrmStoredProcedureParameter2_1(parent, xmlParameter); + } } #P org.eclipse.jpt.jpa.core.tests diff --git src/org/eclipse/jpt/jpa/core/tests/internal/context/JptJpaCoreContextModelTests.java src/org/eclipse/jpt/jpa/core/tests/internal/context/JptJpaCoreContextModelTests.java index 8a22329..1cfce1b 100644 --- src/org/eclipse/jpt/jpa/core/tests/internal/context/JptJpaCoreContextModelTests.java +++ src/org/eclipse/jpt/jpa/core/tests/internal/context/JptJpaCoreContextModelTests.java @@ -20,6 +20,8 @@ import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.orm.Generic2_0OrmContextModelTests; import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.persistence.Generic2_0PersistenceContextModelTests; import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.JpaProject2_1Tests; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.java.Generic2_1JavaContextModelTests; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.orm.Generic2_1OrmContextModelTests; import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.persistence.JptJpa2_1ContextPersistenceModelTests; /** @@ -43,6 +45,8 @@ suite.addTest(Generic2_0OrmContextModelTests.suite()); suite.addTest(Generic2_0PersistenceContextModelTests.suite()); suite.addTest(JptJpa2_1ContextPersistenceModelTests.suite()); + suite.addTest(Generic2_1JavaContextModelTests.suite()); + suite.addTest(Generic2_1OrmContextModelTests.suite()); } else { suite.addTest(TestSuite.warning(JptJpaCoreTests.buildMissingJarErrorMessage())); } diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java index 2f80cfe..8a10b9e 100644 --- src/org/eclipse/jpt/jpa/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java @@ -38,7 +38,7 @@ return suite; } - private Generic2_0JavaContextModelTests() { + protected Generic2_0JavaContextModelTests() { super(); throw new UnsupportedOperationException(); } diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/Generic2_1ContextModelTestCase.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/Generic2_1ContextModelTestCase.java index cdf2c1d..064436c 100644 --- src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/Generic2_1ContextModelTestCase.java +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/Generic2_1ContextModelTestCase.java @@ -13,7 +13,8 @@ import org.eclipse.jpt.jpa.core.jpa2_1.JpaProject2_1; import org.eclipse.jpt.jpa.core.tests.internal.context.ContextModelTestCase; -public abstract class Generic2_1ContextModelTestCase extends ContextModelTestCase +public abstract class Generic2_1ContextModelTestCase + extends ContextModelTestCase { protected Generic2_1ContextModelTestCase(String name) { super(name); diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/Generic2_1JavaContextModelTests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/Generic2_1JavaContextModelTests.java new file mode 100644 index 0000000..cc33558 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/Generic2_1JavaContextModelTests.java @@ -0,0 +1,30 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.java; + +import junit.framework.Test; +import junit.framework.TestSuite; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.java.Generic2_0JavaContextModelTests; + +public class Generic2_1JavaContextModelTests + extends Generic2_0JavaContextModelTests +{ + public static Test suite() { + TestSuite suite = new TestSuite(Generic2_1JavaContextModelTests.class.getPackage().getName()); + suite.addTestSuite(GenericJavaNamedStoredProcedureQuery2_1Tests.class); + suite.addTestSuite(GenericJavaStoredProcedureParameter2_1Tests.class); + return suite; + } + + private Generic2_1JavaContextModelTests() { + super(); + throw new UnsupportedOperationException(); + } +} diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1Tests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1Tests.java new file mode 100644 index 0000000..8a740ea --- /dev/null +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1Tests.java @@ -0,0 +1,867 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.java; + +import java.util.Iterator; +import java.util.ListIterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.AstNodeType; +import org.eclipse.jpt.common.core.resource.java.JavaResourceType; +import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; +import org.eclipse.jpt.jpa.core.context.Entity; +import org.eclipse.jpt.jpa.core.context.QueryHint; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.NamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase; + +public class GenericJavaNamedStoredProcedureQuery2_1Tests + extends Generic2_1ContextModelTestCase +{ + public GenericJavaNamedStoredProcedureQuery2_1Tests(String name) { + super(name); + } + + + private static final String QUERY_NAME = "QUERY_NAME"; + private static final String PROCEDURE_NAME = "MY_PROCEDURE"; + + private ICompilationUnit createTestEntityWithNamedStoredProcedureQuery() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return IteratorTools.iterator(JPA.ENTITY, JPA2_1.NAMED_STORED_PROCEDURE_QUERY); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@NamedStoredProcedureQuery(name=\"" + QUERY_NAME + "\", procedureName=\"" + PROCEDURE_NAME + "\")"); + } + }); + } + + + // ********** name *********** + + public void testUpdateName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + assertEquals(QUERY_NAME, procedureQueryAnnotation.getName()); + assertEquals(QUERY_NAME, procedureQuery.getName()); + + //set name to null in the resource model + procedureQueryAnnotation.setName(null); + getJpaProject().synchronizeContextModel(); + assertNull(procedureQueryAnnotation.getName()); + assertNull(procedureQuery.getName()); + + //set name in the resource model, verify context model updated + procedureQueryAnnotation.setName("foo"); + getJpaProject().synchronizeContextModel(); + assertEquals("foo", procedureQueryAnnotation.getName()); + assertEquals("foo", procedureQuery.getName()); + } + + public void testModifyName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + assertEquals(QUERY_NAME, procedureQueryAnnotation.getName()); + assertEquals(QUERY_NAME, procedureQuery.getName()); + + //set name to null in the context model + procedureQuery.setName(null); + assertNull(procedureQueryAnnotation.getName()); + assertNull(procedureQuery.getName()); + + //set name in the context model, verify resource model updated + procedureQuery.setName("foo"); + assertEquals("foo", procedureQueryAnnotation.getName()); + assertEquals("foo", procedureQuery.getName()); + } + + // ********** procedure name *********** + + public void testUpdateProcedureName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + assertEquals(PROCEDURE_NAME, procedureQueryAnnotation.getProcedureName()); + assertEquals(PROCEDURE_NAME, procedureQuery.getProcedureName()); + + //set procedure name to null in the resource model + procedureQueryAnnotation.setProcedureName(null); + getJpaProject().synchronizeContextModel(); + assertNull(procedureQueryAnnotation.getProcedureName()); + assertNull(procedureQuery.getProcedureName()); + + //set procedure name in the resource model, verify context model updated + procedureQueryAnnotation.setProcedureName("foo"); + getJpaProject().synchronizeContextModel(); + assertEquals("foo", procedureQueryAnnotation.getProcedureName()); + assertEquals("foo", procedureQuery.getProcedureName()); + } + + public void testModifyProcedureName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + assertEquals(PROCEDURE_NAME, procedureQueryAnnotation.getProcedureName()); + assertEquals(PROCEDURE_NAME, procedureQuery.getProcedureName()); + + //set procedure name to null in the context model + procedureQuery.setProcedureName(null); + assertNull(procedureQueryAnnotation.getProcedureName()); + assertNull(procedureQuery.getProcedureName()); + + //set procedure name in the context model, verify resource model updated + procedureQuery.setProcedureName("foo"); + assertEquals("foo", procedureQueryAnnotation.getProcedureName()); + assertEquals("foo", procedureQuery.getProcedureName()); + } + + + // ******** parameters ********** + + public void testAddParameter() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + StoredProcedureParameter2_1 parameter1 = procedureQuery.addParameter(0); + parameter1.setName("FOO"); + + assertEquals("FOO", procedureQueryAnnotation.parameterAt(0).getName()); + + StoredProcedureParameter2_1 parameter2 = procedureQuery.addParameter(0); + parameter2.setName("BAR"); + + assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName()); + assertEquals("FOO", procedureQueryAnnotation.parameterAt(1).getName()); + + StoredProcedureParameter2_1 parameter3 = procedureQuery.addParameter(1); + parameter3.setName("BAZ"); + + assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName()); + assertEquals("BAZ", procedureQueryAnnotation.parameterAt(1).getName()); + assertEquals("FOO", procedureQueryAnnotation.parameterAt(2).getName()); + + ListIterator parameters = procedureQuery.getParameters().iterator(); + assertEquals(parameter2, parameters.next()); + assertEquals(parameter3, parameters.next()); + assertEquals(parameter1, parameters.next()); + + parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + } + + public void testRemoveParameter() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addParameter(0).setName("FOO"); + procedureQuery.addParameter(1).setName("BAR"); + procedureQuery.addParameter(2).setName("BAZ"); + + assertEquals(3, procedureQueryAnnotation.getParametersSize()); + + procedureQuery.removeParameter(0); + assertEquals(2, procedureQueryAnnotation.getParametersSize()); + assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName()); + assertEquals("BAZ", procedureQueryAnnotation.parameterAt(1).getName()); + + procedureQuery.removeParameter(0); + assertEquals(1, procedureQueryAnnotation.getParametersSize()); + assertEquals("BAZ", procedureQueryAnnotation.parameterAt(0).getName()); + + procedureQuery.removeParameter(0); + assertEquals(0, procedureQueryAnnotation.getParametersSize()); + } + + public void testMoveParameter() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addParameter(0).setName("FOO"); + procedureQuery.addParameter(1).setName("BAR"); + procedureQuery.addParameter(2).setName("BAZ"); + + assertEquals(3, procedureQueryAnnotation.getParametersSize()); + + + procedureQuery.moveParameter(2, 0); + ListIterator parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + + assertEquals("BAR", procedureQueryAnnotation.parameterAt(0).getName()); + assertEquals("BAZ", procedureQueryAnnotation.parameterAt(1).getName()); + assertEquals("FOO", procedureQueryAnnotation.parameterAt(2).getName()); + + + procedureQuery.moveParameter(0, 1); + parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("BAR", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + + assertEquals("BAZ", procedureQueryAnnotation.parameterAt(0).getName()); + assertEquals("BAR", procedureQueryAnnotation.parameterAt(1).getName()); + assertEquals("FOO", procedureQueryAnnotation.parameterAt(2).getName()); + } + + public void testUpdateParameters() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQueryAnnotation.addParameter(0).setName("FOO"); + procedureQueryAnnotation.addParameter(1).setName("BAR"); + procedureQueryAnnotation.addParameter(2).setName("BAZ"); + getJpaProject().synchronizeContextModel(); + + ListIterator parameters = procedureQuery.getParameters().iterator(); + assertEquals("FOO", parameters.next().getName()); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryAnnotation.moveParameter(2, 0); + getJpaProject().synchronizeContextModel(); + parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryAnnotation.moveParameter(0, 1); + getJpaProject().synchronizeContextModel(); + parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("BAR", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryAnnotation.removeParameter(1); + getJpaProject().synchronizeContextModel(); + parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryAnnotation.removeParameter(1); + getJpaProject().synchronizeContextModel(); + parameters = procedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryAnnotation.removeParameter(0); + getJpaProject().synchronizeContextModel(); + assertFalse(procedureQuery.getParameters().iterator().hasNext()); + } + + public void testParametersSize() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + assertEquals(0, procedureQuery.getParametersSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQueryAnnotation.addParameter(0); + getJpaProject().synchronizeContextModel(); + assertEquals(1, procedureQuery.getParametersSize()); + + procedureQueryAnnotation.addParameter(0); + getJpaProject().synchronizeContextModel(); + assertEquals(2, procedureQuery.getParametersSize()); + + procedureQueryAnnotation.removeParameter(0); + procedureQueryAnnotation.removeParameter(0); + getJpaProject().synchronizeContextModel(); + assertEquals(0, procedureQuery.getParametersSize()); + } + + // ********** result classes ********** + + public void testAddResultClass() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultClass("Employee"); + assertEquals("Employee", procedureQueryAnnotation.resultClassAt(0)); + + procedureQuery.addResultClass("Address"); + assertEquals("Employee", procedureQueryAnnotation.resultClassAt(0)); + assertEquals("Address", procedureQueryAnnotation.resultClassAt(1)); + + procedureQuery.addResultClass(1, "Project"); + assertEquals("Employee", procedureQueryAnnotation.resultClassAt(0)); + assertEquals("Project", procedureQueryAnnotation.resultClassAt(1)); + assertEquals("Address", procedureQueryAnnotation.resultClassAt(2)); + + ListIterator resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Employee", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + } + + public void testRemoveResultClass() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultClass("Employee"); + procedureQuery.addResultClass("Address"); + procedureQuery.addResultClass("Project"); + + assertEquals(3, procedureQueryAnnotation.getResultClassesSize()); + + procedureQuery.removeResultClass(0); + assertEquals(2, procedureQueryAnnotation.getResultClassesSize()); + assertEquals("Address", procedureQueryAnnotation.resultClassAt(0)); + assertEquals("Project", procedureQueryAnnotation.resultClassAt(1)); + + procedureQuery.removeResultClass("Project"); + assertEquals(1, procedureQueryAnnotation.getResultClassesSize()); + assertEquals("Address", procedureQueryAnnotation.resultClassAt(0)); + + procedureQuery.removeResultClass(0); + assertEquals(0, procedureQueryAnnotation.getResultClassesSize()); + } + + public void testMoveResultClass() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultClass("Employee"); + procedureQuery.addResultClass("Address"); + procedureQuery.addResultClass("Project"); + + assertEquals(3, procedureQueryAnnotation.getResultClassesSize()); + + procedureQuery.moveResultClass(2, 0); + ListIterator resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Address", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + + assertEquals("Address", procedureQueryAnnotation.resultClassAt(0)); + assertEquals("Project", procedureQueryAnnotation.resultClassAt(1)); + assertEquals("Employee", procedureQueryAnnotation.resultClassAt(2)); + + procedureQuery.moveResultClass(0, 1); + resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + + assertEquals("Project", procedureQueryAnnotation.resultClassAt(0)); + assertEquals("Address", procedureQueryAnnotation.resultClassAt(1)); + assertEquals("Employee", procedureQueryAnnotation.resultClassAt(2)); + } + + public void testUpdateResultClass() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultClass("Employee"); + procedureQuery.addResultClass("Address"); + procedureQuery.addResultClass("Project"); + getJpaProject().synchronizeContextModel(); + + ListIterator resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Employee", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryAnnotation.moveResultClass(2, 0); + getJpaProject().synchronizeContextModel(); + resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Address", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryAnnotation.moveResultClass(0, 1); + getJpaProject().synchronizeContextModel(); + resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryAnnotation.removeResultClass(1); + getJpaProject().synchronizeContextModel(); + resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryAnnotation.removeResultClass(1); + getJpaProject().synchronizeContextModel(); + resultClasses = procedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryAnnotation.removeResultClass(0); + getJpaProject().synchronizeContextModel(); + assertFalse(procedureQuery.getResultClasses().iterator().hasNext()); + } + + public void testResultClassesSize() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + assertEquals(0, procedureQuery.getResultClassesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQueryAnnotation.addResultClass("Employee"); + getJpaProject().synchronizeContextModel(); + assertEquals(1, procedureQuery.getResultClassesSize()); + + procedureQueryAnnotation.addResultClass(0, "Address"); + getJpaProject().synchronizeContextModel(); + assertEquals(2, procedureQuery.getResultClassesSize()); + + procedureQueryAnnotation.removeResultClass(0); + procedureQueryAnnotation.removeResultClass(0); + getJpaProject().synchronizeContextModel(); + assertEquals(0, procedureQuery.getResultClassesSize()); + } + + // ********** result set mappings ********** + + public void testAddResultSetMapping() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultSetMapping("Employee"); + assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(0)); + + procedureQuery.addResultSetMapping("Address"); + assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(0)); + assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(1)); + + procedureQuery.addResultSetMapping(1, "Project"); + assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(0)); + assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(1)); + assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(2)); + + ListIterator resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Employee", resultSetMapping.next()); + assertEquals("Project", resultSetMapping.next()); + assertEquals("Address", resultSetMapping.next()); + } + + public void testRemoveResultSetMapping() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultSetMapping("Employee"); + procedureQuery.addResultSetMapping("Address"); + procedureQuery.addResultSetMapping("Project"); + + assertEquals(3, procedureQueryAnnotation.getResultSetMappingsSize()); + + procedureQuery.removeResultSetMapping(0); + assertEquals(2, procedureQueryAnnotation.getResultSetMappingsSize()); + assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(0)); + assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(1)); + + procedureQuery.removeResultSetMapping("Project"); + assertEquals(1, procedureQueryAnnotation.getResultSetMappingsSize()); + assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(0)); + + procedureQuery.removeResultSetMapping(0); + assertEquals(0, procedureQueryAnnotation.getResultSetMappingsSize()); + } + + public void testMoveResultSetMapping() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultSetMapping("Employee"); + procedureQuery.addResultSetMapping("Address"); + procedureQuery.addResultSetMapping("Project"); + + assertEquals(3, procedureQueryAnnotation.getResultSetMappingsSize()); + + procedureQuery.moveResultSetMapping(2, 0); + ListIterator resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Address", resultSetMapping.next()); + assertEquals("Project", resultSetMapping.next()); + assertEquals("Employee", resultSetMapping.next()); + + assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(0)); + assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(1)); + assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(2)); + + procedureQuery.moveResultSetMapping(0, 1); + resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMapping.next()); + assertEquals("Address", resultSetMapping.next()); + assertEquals("Employee", resultSetMapping.next()); + + assertEquals("Project", procedureQueryAnnotation.resultSetMappingAt(0)); + assertEquals("Address", procedureQueryAnnotation.resultSetMappingAt(1)); + assertEquals("Employee", procedureQueryAnnotation.resultSetMappingAt(2)); + } + + public void testUpdateResultSetMapping() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addResultSetMapping("Employee"); + procedureQuery.addResultSetMapping("Address"); + procedureQuery.addResultSetMapping("Project"); + getJpaProject().synchronizeContextModel(); + + ListIterator resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Employee", resultSetMapping.next()); + assertEquals("Address", resultSetMapping.next()); + assertEquals("Project", resultSetMapping.next()); + assertFalse(resultSetMapping.hasNext()); + + procedureQueryAnnotation.moveResultSetMapping(2, 0); + getJpaProject().synchronizeContextModel(); + resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Address", resultSetMapping.next()); + assertEquals("Project", resultSetMapping.next()); + assertEquals("Employee", resultSetMapping.next()); + assertFalse(resultSetMapping.hasNext()); + + procedureQueryAnnotation.moveResultSetMapping(0, 1); + getJpaProject().synchronizeContextModel(); + resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMapping.next()); + assertEquals("Address", resultSetMapping.next()); + assertEquals("Employee", resultSetMapping.next()); + assertFalse(resultSetMapping.hasNext()); + + procedureQueryAnnotation.removeResultSetMapping(1); + getJpaProject().synchronizeContextModel(); + resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMapping.next()); + assertEquals("Employee", resultSetMapping.next()); + assertFalse(resultSetMapping.hasNext()); + + procedureQueryAnnotation.removeResultSetMapping(1); + getJpaProject().synchronizeContextModel(); + resultSetMapping = procedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMapping.next()); + assertFalse(resultSetMapping.hasNext()); + + procedureQueryAnnotation.removeResultSetMapping(0); + getJpaProject().synchronizeContextModel(); + assertFalse(procedureQuery.getResultSetMappings().iterator().hasNext()); + } + + public void testResultSetMappingsSize() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + assertEquals(0, procedureQuery.getResultSetMappingsSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQueryAnnotation.addResultSetMapping("Employee"); + getJpaProject().synchronizeContextModel(); + assertEquals(1, procedureQuery.getResultSetMappingsSize()); + + procedureQueryAnnotation.addResultSetMapping(0, "Address"); + getJpaProject().synchronizeContextModel(); + assertEquals(2, procedureQuery.getResultSetMappingsSize()); + + procedureQueryAnnotation.removeResultSetMapping(0); + procedureQueryAnnotation.removeResultSetMapping(0); + getJpaProject().synchronizeContextModel(); + assertEquals(0, procedureQuery.getResultSetMappingsSize()); + } + + // ************ hints ************ + + public void testAddHint() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + QueryHint queryHint = procedureQuery.addHint(0); + queryHint.setName("FOO"); + + assertEquals("FOO", procedureQueryAnnotation.hintAt(0).getName()); + + QueryHint queryHint2 = procedureQuery.addHint(0); + queryHint2.setName("BAR"); + + assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName()); + assertEquals("FOO", procedureQueryAnnotation.hintAt(1).getName()); + + QueryHint queryHint3 = procedureQuery.addHint(1); + queryHint3.setName("BAZ"); + + assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName()); + assertEquals("BAZ", procedureQueryAnnotation.hintAt(1).getName()); + assertEquals("FOO", procedureQueryAnnotation.hintAt(2).getName()); + + ListIterator hints = procedureQuery.getHints().iterator(); + assertEquals(queryHint2, hints.next()); + assertEquals(queryHint3, hints.next()); + assertEquals(queryHint, hints.next()); + + hints = procedureQuery.getHints().iterator(); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + } + + public void testRemoveHint() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addHint(0).setName("FOO"); + procedureQuery.addHint(1).setName("BAR"); + procedureQuery.addHint(2).setName("BAZ"); + + assertEquals(3, procedureQueryAnnotation.getHintsSize()); + + procedureQuery.removeHint(0); + assertEquals(2, procedureQueryAnnotation.getHintsSize()); + assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName()); + assertEquals("BAZ", procedureQueryAnnotation.hintAt(1).getName()); + + procedureQuery.removeHint(0); + assertEquals(1, procedureQueryAnnotation.getHintsSize()); + assertEquals("BAZ", procedureQueryAnnotation.hintAt(0).getName()); + + procedureQuery.removeHint(0); + assertEquals(0, procedureQueryAnnotation.getHintsSize()); + } + + public void testMoveHint() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQuery.addHint(0).setName("FOO"); + procedureQuery.addHint(1).setName("BAR"); + procedureQuery.addHint(2).setName("BAZ"); + + assertEquals(3, procedureQueryAnnotation.getHintsSize()); + + procedureQuery.moveHint(2, 0); + ListIterator hints = procedureQuery.getHints().iterator(); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + + assertEquals("BAR", procedureQueryAnnotation.hintAt(0).getName()); + assertEquals("BAZ", procedureQueryAnnotation.hintAt(1).getName()); + assertEquals("FOO", procedureQueryAnnotation.hintAt(2).getName()); + + + procedureQuery.moveHint(0, 1); + hints = procedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertEquals("BAR", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + + assertEquals("BAZ", procedureQueryAnnotation.hintAt(0).getName()); + assertEquals("BAR", procedureQueryAnnotation.hintAt(1).getName()); + assertEquals("FOO", procedureQueryAnnotation.hintAt(2).getName()); + } + + public void testUpdateHints() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQueryAnnotation.addHint(0).setName("FOO"); + procedureQueryAnnotation.addHint(1).setName("BAR"); + procedureQueryAnnotation.addHint(2).setName("BAZ"); + getJpaProject().synchronizeContextModel(); + + ListIterator hints = procedureQuery.getHints().iterator(); + assertEquals("FOO", hints.next().getName()); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryAnnotation.moveHint(2, 0); + getJpaProject().synchronizeContextModel(); + hints = procedureQuery.getHints().iterator(); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryAnnotation.moveHint(0, 1); + getJpaProject().synchronizeContextModel(); + hints = procedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertEquals("BAR", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryAnnotation.removeHint(1); + getJpaProject().synchronizeContextModel(); + hints = procedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryAnnotation.removeHint(1); + getJpaProject().synchronizeContextModel(); + hints = procedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryAnnotation.removeHint(0); + getJpaProject().synchronizeContextModel(); + assertFalse(procedureQuery.getHints().iterator().hasNext()); + } + + public void testHintsSize() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + Entity entity = getJavaEntity(); + NamedStoredProcedureQuery2_1 procedureQuery = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next(); + assertEquals(0, procedureQuery.getHintsSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation procedureQueryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + + procedureQueryAnnotation.addHint(0); + getJpaProject().synchronizeContextModel(); + assertEquals(1, procedureQuery.getHintsSize()); + + procedureQueryAnnotation.addHint(0); + getJpaProject().synchronizeContextModel(); + assertEquals(2, procedureQuery.getHintsSize()); + + procedureQueryAnnotation.removeHint(0); + procedureQueryAnnotation.removeHint(0); + getJpaProject().synchronizeContextModel(); + assertEquals(0, procedureQuery.getHintsSize()); + } + +} diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/GenericJavaStoredProcedureParameter2_1Tests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/GenericJavaStoredProcedureParameter2_1Tests.java new file mode 100644 index 0000000..f5c974d --- /dev/null +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/java/GenericJavaStoredProcedureParameter2_1Tests.java @@ -0,0 +1,217 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.java; + +import java.util.Iterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.AstNodeType; +import org.eclipse.jpt.common.core.resource.java.JavaResourceType; +import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; +import org.eclipse.jpt.jpa.core.context.Entity; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.StoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase; + +public class GenericJavaStoredProcedureParameter2_1Tests + extends Generic2_1ContextModelTestCase +{ + public GenericJavaStoredProcedureParameter2_1Tests(String name) { + super(name); + } + + + private static final String QUERY_NAME = "QUERY_NAME"; + + private ICompilationUnit createTestEntityWithNamedStoredProcedureQuery() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return IteratorTools.iterator(JPA.ENTITY, JPA2_1.NAMED_STORED_PROCEDURE_QUERY, JPA2_1.NAMED_STORED_PROCEDURE_PARAMETER); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@NamedStoredProcedureQuery(name=\"" + QUERY_NAME + "\", parameters=@StoredProcedureParameter())"); + } + }); + } + + // ************ name *********** + + public void testUpdateName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next(); + + assertNull(parameterAnnotation.getName()); + assertNull(parameter.getName()); + + //set name in the resource model, verify context model updated + parameterAnnotation.setName("foo"); + getJpaProject().synchronizeContextModel(); + assertEquals("foo", parameterAnnotation.getName()); + assertEquals("foo", parameter.getName()); + + //set name to null in the resource model + parameterAnnotation.setName(null); + getJpaProject().synchronizeContextModel(); + assertNull(parameter.getName()); + } + + public void testModifyName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next(); + + assertNull(parameterAnnotation.getName()); + assertNull(parameter.getName()); + + //set name in the context model, verify resource model updated + parameter.setName("foo"); + assertEquals("foo", parameterAnnotation.getName()); + assertEquals("foo", parameter.getName()); + + //set name to null in the context model + parameter.setName(null); + assertNull(parameterAnnotation.getName()); + assertNull(parameter.getName()); + } + + // ************ mode ********** + + public void testUpdateMode() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next(); + + assertNull(parameterAnnotation.getMode()); + assertNull(parameter.getSpecifiedMode()); + assertEquals(ParameterMode2_1.IN, parameter.getMode()); + + //set mode in the resource model, verify context model updated + parameterAnnotation.setMode(ParameterMode_2_1.IN); + getJpaProject().synchronizeContextModel(); + assertEquals(ParameterMode_2_1.IN, parameterAnnotation.getMode()); + assertEquals(ParameterMode2_1.IN, parameter.getMode()); + + //set name to null in the resource model + parameterAnnotation.setMode(null); + getJpaProject().synchronizeContextModel(); + assertNull(parameterAnnotation.getMode()); + assertNull(parameter.getSpecifiedMode()); + assertEquals(ParameterMode2_1.IN, parameter.getMode()); + + } + + public void testModifyMode() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next(); + + assertNull(parameterAnnotation.getMode()); + assertNull(parameter.getSpecifiedMode()); + assertEquals(ParameterMode2_1.IN, parameter.getMode()); + + //set mode in the context model, verify resource model updated + parameter.setSpecifiedMode(ParameterMode2_1.INOUT); + assertEquals(ParameterMode_2_1.INOUT, parameterAnnotation.getMode()); + assertEquals(ParameterMode2_1.INOUT, parameter.getMode()); + + //set mode to null in the context model + parameter.setSpecifiedMode(null); + assertNull(parameterAnnotation.getMode()); + assertNull(parameter.getSpecifiedMode()); + assertEquals(ParameterMode2_1.IN, parameter.getMode()); + + } + + // ************ type name ********** + + public void testUpdateTypeName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next(); + + assertNull(parameterAnnotation.getTypeName()); + assertNull(parameter.getTypeName()); + + //set type in the resource model, verify context model updated + parameterAnnotation.setTypeName("Foo"); + getJpaProject().synchronizeContextModel(); + assertEquals("Foo", parameterAnnotation.getTypeName()); + assertEquals("Foo", parameter.getTypeName()); + + //set type to null in the resource model + parameterAnnotation.setTypeName(null); + getJpaProject().synchronizeContextModel(); + assertNull(parameter.getTypeName()); + } + + public void testModifyTypeName() throws Exception { + createTestEntityWithNamedStoredProcedureQuery(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + Entity entity = getJavaEntity(); + StoredProcedureParameter2_1 parameter = entity.getQueryContainer().getNamedStoredProcedureQueries().iterator().next().getParameters().iterator().next(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, AstNodeType.TYPE); + NamedStoredProcedureQuery2_1Annotation queryAnnotation = ((NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, NamedStoredProcedureQuery2_1Annotation.ANNOTATION_NAME)); + StoredProcedureParameter2_1Annotation parameterAnnotation = queryAnnotation.getParameters().iterator().next(); + + assertNull(parameterAnnotation.getTypeName()); + assertNull(parameter.getTypeName()); + + //set type in the context model, verify resource model updated + parameter.setTypeName("Foo"); + assertEquals("Foo", parameterAnnotation.getTypeName()); + assertEquals("Foo", parameter.getTypeName()); + + //set type to null in the context model + parameter.setTypeName(null); + assertNull(parameterAnnotation.getTypeName()); + assertNull(parameter.getTypeName()); + } + +} diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/Generic2_1OrmContextModelTests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/Generic2_1OrmContextModelTests.java new file mode 100644 index 0000000..e2ee06a --- /dev/null +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/Generic2_1OrmContextModelTests.java @@ -0,0 +1,33 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.orm; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class Generic2_1OrmContextModelTests extends TestCase +{ + + public static Test suite() { + TestSuite suite = new TestSuite(Generic2_1OrmContextModelTests.class.getPackage().getName()); + + suite.addTestSuite(GenericOrmNamedStoredProcedureQuery2_1Tests.class); + suite.addTestSuite(GenericOrmStoredProcedureParameter2_1Tests.class); + + return suite; + } + + private Generic2_1OrmContextModelTests() { + super(); + throw new UnsupportedOperationException(); + } + +} diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1Tests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1Tests.java new file mode 100644 index 0000000..131e5da --- /dev/null +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1Tests.java @@ -0,0 +1,712 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.orm; + +import java.util.ListIterator; +import org.eclipse.jpt.jpa.core.MappingKeys; +import org.eclipse.jpt.jpa.core.context.orm.OrmEntity; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType; +import org.eclipse.jpt.jpa.core.context.orm.OrmQueryHint; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmNamedStoredProcedureQuery2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory; +import org.eclipse.jpt.jpa.core.resource.orm.XmlEntityMappings; +import org.eclipse.jpt.jpa.core.resource.orm.XmlNamedStoredProcedureQuery; +import org.eclipse.jpt.jpa.core.resource.persistence.PersistenceFactory; +import org.eclipse.jpt.jpa.core.resource.persistence.XmlMappingFileRef; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase; + +public class GenericOrmNamedStoredProcedureQuery2_1Tests + extends Generic2_1ContextModelTestCase +{ + public GenericOrmNamedStoredProcedureQuery2_1Tests(String name) { + super(name); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef(); + mappingFileRef.setFileName(XmlEntityMappings.DEFAULT_RUNTIME_PATH_NAME); + getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef); + getPersistenceXmlResource().save(null); + } + + // *********** name ********* + + public void testUpdateName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + assertNull(ormProcedureQuery.getName()); + assertNull(procedureQueryResource.getName()); + + //set name in the resource model, verify context model updated + procedureQueryResource.setName("foo"); + assertEquals("foo", ormProcedureQuery.getName()); + assertEquals("foo", procedureQueryResource.getName()); + + //set name to null in the resource model + procedureQueryResource.setName(null); + assertNull(ormProcedureQuery.getName()); + assertNull(procedureQueryResource.getName()); + } + + public void testModifyName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + assertNull(ormProcedureQuery.getName()); + assertNull(procedureQueryResource.getName()); + + //set name in the context model, verify resource model updated + ormProcedureQuery.setName("foo"); + assertEquals("foo", ormProcedureQuery.getName()); + assertEquals("foo", procedureQueryResource.getName()); + + //set new name in the context model, verify resource model updated + ormProcedureQuery.setName("newFoo"); + assertEquals("newFoo", ormProcedureQuery.getName()); + assertEquals("newFoo", procedureQueryResource.getName()); + + //set name to null in the context model + ormProcedureQuery.setName(null); + assertNull(ormProcedureQuery.getName()); + assertNull(procedureQueryResource.getName()); + } + + // ********** procedure name *********** + + public void testUpdateProcedureName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + assertNull(ormProcedureQuery.getProcedureName()); + assertNull(procedureQueryResource.getProcedureName()); + + //set procedure name in the resource model, verify context model updated + procedureQueryResource.setProcedureName("foo"); + assertEquals("foo", ormProcedureQuery.getProcedureName()); + assertEquals("foo", procedureQueryResource.getProcedureName()); + + //set procedure name to null in the resource model + procedureQueryResource.setProcedureName(null); + assertNull(ormProcedureQuery.getProcedureName()); + assertNull(procedureQueryResource.getProcedureName()); + } + + public void testModifyProcedureName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + assertNull(ormProcedureQuery.getProcedureName()); + assertNull(procedureQueryResource.getName()); + + //set procedure name in the context model, verify resource model updated + ormProcedureQuery.setProcedureName("foo"); + assertEquals("foo", ormProcedureQuery.getProcedureName()); + assertEquals("foo", procedureQueryResource.getProcedureName()); + + //set new procedure name in the context model, verify resource model updated + ormProcedureQuery.setProcedureName("newFoo"); + assertEquals("newFoo", ormProcedureQuery.getProcedureName()); + assertEquals("newFoo", procedureQueryResource.getProcedureName()); + + //set procedure name to null in the context model + ormProcedureQuery.setProcedureName(null); + assertNull(ormProcedureQuery.getProcedureName()); + assertNull(procedureQueryResource.getProcedureName()); + } + + + // ************ parameters ************ + + public void testAddParameter() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + OrmStoredProcedureParameter2_1 parameter1 = ormProcedureQuery.addParameter(0); + parameter1.setName("FOO"); + + assertEquals("FOO", procedureQueryResource.getParameters().get(0).getName()); + + OrmStoredProcedureParameter2_1 parameter2 = ormProcedureQuery.addParameter(0); + parameter2.setName("BAR"); + + assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName()); + assertEquals("FOO", procedureQueryResource.getParameters().get(1).getName()); + + OrmStoredProcedureParameter2_1 parameter3 = ormProcedureQuery.addParameter(1); + parameter3.setName("BAZ"); + + assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName()); + assertEquals("BAZ", procedureQueryResource.getParameters().get(1).getName()); + assertEquals("FOO", procedureQueryResource.getParameters().get(2).getName()); + + ListIterator parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals(parameter2, parameters.next()); + assertEquals(parameter3, parameters.next()); + assertEquals(parameter1, parameters.next()); + + parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + } + + public void testRemoveParameter() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addParameter(0).setName("FOO"); + ormProcedureQuery.addParameter(1).setName("BAR"); + ormProcedureQuery.addParameter(2).setName("BAZ"); + + assertEquals(3, procedureQueryResource.getParameters().size()); + + ormProcedureQuery.removeParameter(0); + assertEquals(2, procedureQueryResource.getParameters().size()); + assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName()); + assertEquals("BAZ", procedureQueryResource.getParameters().get(1).getName()); + + ormProcedureQuery.removeParameter(0); + assertEquals(1, procedureQueryResource.getParameters().size()); + assertEquals("BAZ", procedureQueryResource.getParameters().get(0).getName()); + + ormProcedureQuery.removeParameter(0); + assertEquals(0, procedureQueryResource.getParameters().size()); + } + + public void testMoveParameter() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addParameter(0).setName("FOO"); + ormProcedureQuery.addParameter(1).setName("BAR"); + ormProcedureQuery.addParameter(2).setName("BAZ"); + + assertEquals(3, procedureQueryResource.getParameters().size()); + + ormProcedureQuery.moveParameter(2, 0); + ListIterator parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + + assertEquals("BAR", procedureQueryResource.getParameters().get(0).getName()); + assertEquals("BAZ", procedureQueryResource.getParameters().get(1).getName()); + assertEquals("FOO", procedureQueryResource.getParameters().get(2).getName()); + + + ormProcedureQuery.moveParameter(0, 1); + parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("BAR", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + + assertEquals("BAZ", procedureQueryResource.getParameters().get(0).getName()); + assertEquals("BAR", procedureQueryResource.getParameters().get(1).getName()); + assertEquals("FOO", procedureQueryResource.getParameters().get(2).getName()); + } + + public void testUpdateParameters() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + procedureQueryResource.getParameters().add(OrmFactory.eINSTANCE.createXmlStoredProcedureParameter()); + procedureQueryResource.getParameters().add(OrmFactory.eINSTANCE.createXmlStoredProcedureParameter()); + procedureQueryResource.getParameters().add(OrmFactory.eINSTANCE.createXmlStoredProcedureParameter()); + + procedureQueryResource.getParameters().get(0).setName("FOO"); + procedureQueryResource.getParameters().get(1).setName("BAR"); + procedureQueryResource.getParameters().get(2).setName("BAZ"); + + ListIterator parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("FOO", parameters.next().getName()); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryResource.getParameters().move(2, 0); + parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAR", parameters.next().getName()); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryResource.getParameters().move(0, 1); + parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("BAR", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryResource.getParameters().remove(1); + parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertEquals("FOO", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryResource.getParameters().remove(1); + parameters = ormProcedureQuery.getParameters().iterator(); + assertEquals("BAZ", parameters.next().getName()); + assertFalse(parameters.hasNext()); + + procedureQueryResource.getParameters().remove(0); + assertFalse(ormProcedureQuery.getParameters().iterator().hasNext()); + } + + + // ************ result classes ******** + + public void testAddResultClass() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addResultClass("Employee"); + assertEquals("Employee", procedureQueryResource.getResultClasses().get(0)); + + ormProcedureQuery.addResultClass("Address"); + assertEquals("Employee", procedureQueryResource.getResultClasses().get(0)); + assertEquals("Address", procedureQueryResource.getResultClasses().get(1)); + + ormProcedureQuery.addResultClass(1, "Project"); + + assertEquals("Employee", procedureQueryResource.getResultClasses().get(0)); + assertEquals("Project", procedureQueryResource.getResultClasses().get(1)); + assertEquals("Address", procedureQueryResource.getResultClasses().get(2)); + + ListIterator resultSetClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Employee", resultSetClasses.next()); + assertEquals("Project", resultSetClasses.next()); + assertEquals("Address", resultSetClasses.next()); + } + + public void testRemoveResultClass() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addResultClass("Employee"); + ormProcedureQuery.addResultClass("Address"); + ormProcedureQuery.addResultClass("Project"); + + assertEquals(3, procedureQueryResource.getResultClasses().size()); + + ormProcedureQuery.removeResultClass(0); + assertEquals(2, procedureQueryResource.getResultClasses().size()); + assertEquals("Address", procedureQueryResource.getResultClasses().get(0)); + assertEquals("Project", procedureQueryResource.getResultClasses().get(1)); + + ormProcedureQuery.removeResultClass("Project"); + assertEquals(1, procedureQueryResource.getResultClasses().size()); + assertEquals("Address", procedureQueryResource.getResultClasses().get(0)); + + ormProcedureQuery.removeResultClass(0); + assertEquals(0, procedureQueryResource.getResultClasses().size()); + } + + public void testMoveResultClass() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addResultClass("Employee"); + ormProcedureQuery.addResultClass("Address"); + ormProcedureQuery.addResultClass("Project"); + + assertEquals(3, procedureQueryResource.getResultClasses().size()); + + ormProcedureQuery.moveResultClass(2, 0); + ListIterator resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Address", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + + assertEquals("Address", procedureQueryResource.getResultClasses().get(0)); + assertEquals("Project", procedureQueryResource.getResultClasses().get(1)); + assertEquals("Employee", procedureQueryResource.getResultClasses().get(2)); + + ormProcedureQuery.moveResultClass(0, 1); + resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + + assertEquals("Project", procedureQueryResource.getResultClasses().get(0)); + assertEquals("Address", procedureQueryResource.getResultClasses().get(1)); + assertEquals("Employee", procedureQueryResource.getResultClasses().get(2)); + } + + public void testUpdateResultClasses() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + procedureQueryResource.getResultClasses().add("Employee"); + procedureQueryResource.getResultClasses().add("Address"); + procedureQueryResource.getResultClasses().add("Project"); + + ListIterator resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Employee", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryResource.getResultClasses().move(2, 0); + resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Address", resultClasses.next()); + assertEquals("Project", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryResource.getResultClasses().move(0, 1); + resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertEquals("Address", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryResource.getResultClasses().remove(1); + resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertEquals("Employee", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryResource.getResultClasses().remove(1); + resultClasses = ormProcedureQuery.getResultClasses().iterator(); + assertEquals("Project", resultClasses.next()); + assertFalse(resultClasses.hasNext()); + + procedureQueryResource.getResultClasses().remove(0); + assertFalse(ormProcedureQuery.getResultClasses().iterator().hasNext()); + } + + + // ************ result set mappings ******** + + public void testAddResultSetMapping() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addResultSetMapping("Employee"); + assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(0)); + + ormProcedureQuery.addResultSetMapping("Address"); + assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(0)); + assertEquals("Address", procedureQueryResource.getResultSetMappings().get(1)); + + ormProcedureQuery.addResultSetMapping(1, "Project"); + + assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(0)); + assertEquals("Project", procedureQueryResource.getResultSetMappings().get(1)); + assertEquals("Address", procedureQueryResource.getResultSetMappings().get(2)); + + ListIterator resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Employee", resultSetMappings.next()); + assertEquals("Project", resultSetMappings.next()); + assertEquals("Address", resultSetMappings.next()); + } + + public void testRemoveResultSetMapping() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addResultSetMapping("Employee"); + ormProcedureQuery.addResultSetMapping("Address"); + ormProcedureQuery.addResultSetMapping("Project"); + + assertEquals(3, procedureQueryResource.getResultSetMappings().size()); + + ormProcedureQuery.removeResultSetMapping(0); + assertEquals(2, procedureQueryResource.getResultSetMappings().size()); + assertEquals("Address", procedureQueryResource.getResultSetMappings().get(0)); + assertEquals("Project", procedureQueryResource.getResultSetMappings().get(1)); + + ormProcedureQuery.removeResultSetMapping("Project"); + assertEquals(1, procedureQueryResource.getResultSetMappings().size()); + assertEquals("Address", procedureQueryResource.getResultSetMappings().get(0)); + + ormProcedureQuery.removeResultSetMapping(0); + assertEquals(0, procedureQueryResource.getResultSetMappings().size()); + } + + public void testMoveResultSetMapping() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addResultSetMapping("Employee"); + ormProcedureQuery.addResultSetMapping("Address"); + ormProcedureQuery.addResultSetMapping("Project"); + + assertEquals(3, procedureQueryResource.getResultSetMappings().size()); + + ormProcedureQuery.moveResultSetMapping(2, 0); + ListIterator resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Address", resultSetMappings.next()); + assertEquals("Project", resultSetMappings.next()); + assertEquals("Employee", resultSetMappings.next()); + + assertEquals("Address", procedureQueryResource.getResultSetMappings().get(0)); + assertEquals("Project", procedureQueryResource.getResultSetMappings().get(1)); + assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(2)); + + ormProcedureQuery.moveResultSetMapping(0, 1); + resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMappings.next()); + assertEquals("Address", resultSetMappings.next()); + assertEquals("Employee", resultSetMappings.next()); + + assertEquals("Project", procedureQueryResource.getResultSetMappings().get(0)); + assertEquals("Address", procedureQueryResource.getResultSetMappings().get(1)); + assertEquals("Employee", procedureQueryResource.getResultSetMappings().get(2)); + } + + public void testUpdateResultSetMappings() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + procedureQueryResource.getResultSetMappings().add("Employee"); + procedureQueryResource.getResultSetMappings().add("Address"); + procedureQueryResource.getResultSetMappings().add("Project"); + + ListIterator resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Employee", resultSetMappings.next()); + assertEquals("Address", resultSetMappings.next()); + assertEquals("Project", resultSetMappings.next()); + assertFalse(resultSetMappings.hasNext()); + + procedureQueryResource.getResultSetMappings().move(2, 0); + resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Address", resultSetMappings.next()); + assertEquals("Project", resultSetMappings.next()); + assertEquals("Employee", resultSetMappings.next()); + assertFalse(resultSetMappings.hasNext()); + + procedureQueryResource.getResultSetMappings().move(0, 1); + resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMappings.next()); + assertEquals("Address", resultSetMappings.next()); + assertEquals("Employee", resultSetMappings.next()); + assertFalse(resultSetMappings.hasNext()); + + procedureQueryResource.getResultSetMappings().remove(1); + resultSetMappings = ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMappings.next()); + assertEquals("Employee", resultSetMappings.next()); + assertFalse(resultSetMappings.hasNext()); + + procedureQueryResource.getResultSetMappings().remove(1); + resultSetMappings= ormProcedureQuery.getResultSetMappings().iterator(); + assertEquals("Project", resultSetMappings.next()); + assertFalse(resultSetMappings.hasNext()); + + procedureQueryResource.getResultSetMappings().remove(0); + assertFalse(ormProcedureQuery.getResultSetMappings().iterator().hasNext()); + } + + + // ************ hints ********** + + public void testAddHint() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + OrmQueryHint queryHint = ormProcedureQuery.addHint(0); + queryHint.setName("FOO"); + + assertEquals("FOO", procedureQueryResource.getHints().get(0).getName()); + + OrmQueryHint queryHint2 = ormProcedureQuery.addHint(0); + queryHint2.setName("BAR"); + + assertEquals("BAR", procedureQueryResource.getHints().get(0).getName()); + assertEquals("FOO", procedureQueryResource.getHints().get(1).getName()); + + OrmQueryHint queryHint3 = ormProcedureQuery.addHint(1); + queryHint3.setName("BAZ"); + + assertEquals("BAR", procedureQueryResource.getHints().get(0).getName()); + assertEquals("BAZ", procedureQueryResource.getHints().get(1).getName()); + assertEquals("FOO", procedureQueryResource.getHints().get(2).getName()); + + ListIterator queryHints = ormProcedureQuery.getHints().iterator(); + assertEquals(queryHint2, queryHints.next()); + assertEquals(queryHint3, queryHints.next()); + assertEquals(queryHint, queryHints.next()); + + queryHints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAR", queryHints.next().getName()); + assertEquals("BAZ", queryHints.next().getName()); + assertEquals("FOO", queryHints.next().getName()); + } + + public void testRemoveHint() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addHint(0).setName("FOO"); + ormProcedureQuery.addHint(1).setName("BAR"); + ormProcedureQuery.addHint(2).setName("BAZ"); + + assertEquals(3, procedureQueryResource.getHints().size()); + + ormProcedureQuery.removeHint(0); + assertEquals(2, procedureQueryResource.getHints().size()); + assertEquals("BAR", procedureQueryResource.getHints().get(0).getName()); + assertEquals("BAZ", procedureQueryResource.getHints().get(1).getName()); + + ormProcedureQuery.removeHint(0); + assertEquals(1, procedureQueryResource.getHints().size()); + assertEquals("BAZ", procedureQueryResource.getHints().get(0).getName()); + + ormProcedureQuery.removeHint(0); + assertEquals(0, procedureQueryResource.getHints().size()); + } + + public void testMoveHint() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + ormProcedureQuery.addHint(0).setName("FOO"); + ormProcedureQuery.addHint(1).setName("BAR"); + ormProcedureQuery.addHint(2).setName("BAZ"); + + assertEquals(3, procedureQueryResource.getHints().size()); + + + ormProcedureQuery.moveHint(2, 0); + ListIterator hints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + + assertEquals("BAR", procedureQueryResource.getHints().get(0).getName()); + assertEquals("BAZ", procedureQueryResource.getHints().get(1).getName()); + assertEquals("FOO", procedureQueryResource.getHints().get(2).getName()); + + + ormProcedureQuery.moveHint(0, 1); + hints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertEquals("BAR", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + + assertEquals("BAZ", procedureQueryResource.getHints().get(0).getName()); + assertEquals("BAR", procedureQueryResource.getHints().get(1).getName()); + assertEquals("FOO", procedureQueryResource.getHints().get(2).getName()); + } + + public void testUpdateHints() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmNamedStoredProcedureQuery2_1 ormProcedureQuery = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0); + + XmlNamedStoredProcedureQuery procedureQueryResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0); + + procedureQueryResource.getHints().add(OrmFactory.eINSTANCE.createXmlQueryHint()); + procedureQueryResource.getHints().add(OrmFactory.eINSTANCE.createXmlQueryHint()); + procedureQueryResource.getHints().add(OrmFactory.eINSTANCE.createXmlQueryHint()); + + procedureQueryResource.getHints().get(0).setName("FOO"); + procedureQueryResource.getHints().get(1).setName("BAR"); + procedureQueryResource.getHints().get(2).setName("BAZ"); + + ListIterator hints = ormProcedureQuery.getHints().iterator(); + assertEquals("FOO", hints.next().getName()); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryResource.getHints().move(2, 0); + hints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAR", hints.next().getName()); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryResource.getHints().move(0, 1); + hints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertEquals("BAR", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryResource.getHints().remove(1); + hints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertEquals("FOO", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryResource.getHints().remove(1); + hints = ormProcedureQuery.getHints().iterator(); + assertEquals("BAZ", hints.next().getName()); + assertFalse(hints.hasNext()); + + procedureQueryResource.getHints().remove(0); + assertFalse(ormProcedureQuery.getHints().iterator().hasNext()); + } + +} diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/GenericOrmStoredProcedureParameter2_1Tests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/GenericOrmStoredProcedureParameter2_1Tests.java new file mode 100644 index 0000000..b3f67e8 --- /dev/null +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/context/orm/GenericOrmStoredProcedureParameter2_1Tests.java @@ -0,0 +1,197 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.orm; + +import org.eclipse.jpt.jpa.core.MappingKeys; +import org.eclipse.jpt.jpa.core.context.orm.OrmEntity; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmQueryContainer2_1; +import org.eclipse.jpt.jpa.core.internal.jpa2_1.context.orm.OrmStoredProcedureParameter2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.resource.orm.XmlEntityMappings; +import org.eclipse.jpt.jpa.core.resource.orm.XmlStoredProcedureParameter; +import org.eclipse.jpt.jpa.core.resource.orm.v2_1.ParameterMode_2_1; +import org.eclipse.jpt.jpa.core.resource.persistence.PersistenceFactory; +import org.eclipse.jpt.jpa.core.resource.persistence.XmlMappingFileRef; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2_1.context.Generic2_1ContextModelTestCase; + +public class GenericOrmStoredProcedureParameter2_1Tests + extends Generic2_1ContextModelTestCase +{ + public GenericOrmStoredProcedureParameter2_1Tests(String name) { + super(name); + } + + + @Override + protected void setUp() throws Exception { + super.setUp(); + XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef(); + mappingFileRef.setFileName(XmlEntityMappings.DEFAULT_RUNTIME_PATH_NAME); + getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef); + getPersistenceXmlResource().save(null); + } + + // ******* name *********** + + public void testUpdateName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0); + + XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0); + + assertNull(ormParameter.getName()); + assertNull(parameterResource.getName()); + + //set name in the resource model, verify context model updated + parameterResource.setName("foo"); + assertEquals("foo", ormParameter.getName()); + assertEquals("foo", parameterResource.getName()); + + //set name to null in the resource model + parameterResource.setName(null); + assertNull(ormParameter.getName()); + assertNull(parameterResource.getName()); + } + + public void testModifyName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0); + + XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0); + + assertNull(ormParameter.getName()); + assertNull(parameterResource.getName()); + + //set name in the context model, verify resource model updated + ormParameter.setName("foo"); + assertEquals("foo", ormParameter.getName()); + assertEquals("foo", parameterResource.getName()); + + //set new name in the context model, verify resource model updated + ormParameter.setName("newFoo"); + assertEquals("newFoo", ormParameter.getName()); + assertEquals("newFoo", parameterResource.getName()); + + //set name to null in the context model + ormParameter.setName(null); + assertNull(ormParameter.getName()); + assertNull(parameterResource.getName()); + } + + // ********* mode ********* + + public void testUpdateMode() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0); + + XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0); + + assertNull(ormParameter.getSpecifiedMode()); + // test default mode + assertEquals(ParameterMode2_1.IN, ormParameter.getMode()); + assertNull(parameterResource.getMode()); + + //set mode in the resource model, verify context model updated + parameterResource.setMode(ParameterMode_2_1.INOUT); + assertEquals(ParameterMode2_1.INOUT, ormParameter.getMode()); + assertEquals(ParameterMode_2_1.INOUT, parameterResource.getMode()); + + //set mode to null in the resource model + parameterResource.setMode(null); + assertNull(ormParameter.getSpecifiedMode()); + // test default mode + assertEquals(ParameterMode2_1.IN, ormParameter.getMode()); + assertNull(parameterResource.getMode()); + } + + public void testModifyMode() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0); + + XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0); + + assertNull(ormParameter.getSpecifiedMode()); + // test default mode + assertEquals(ParameterMode2_1.IN, ormParameter.getMode()); + assertNull(parameterResource.getMode()); + + //set mode in the context model, verify resource model updated + ormParameter.setSpecifiedMode(ParameterMode2_1.INOUT); + assertEquals(ParameterMode2_1.INOUT, ormParameter.getMode()); + assertEquals(ParameterMode_2_1.INOUT, parameterResource.getMode()); + + //set new mode in the context model, verify resource model updated + ormParameter.setSpecifiedMode(ParameterMode2_1.OUT); + assertEquals(ParameterMode2_1.OUT, ormParameter.getMode()); + assertEquals(ParameterMode_2_1.OUT, parameterResource.getMode()); + + + //set mode to null in the context model + ormParameter.setSpecifiedMode(null); + assertNull(ormParameter.getSpecifiedMode()); + // test default mode + assertEquals(ParameterMode2_1.IN, ormParameter.getMode()); + assertNull(parameterResource.getMode()); + } + + // *********** type name ********* + + public void testUpdateTypeName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0); + + XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0); + + assertNull(ormParameter.getTypeName()); + assertNull(parameterResource.getClassName()); + + //set type name in the resource model, verify context model updated + parameterResource.setClassName("MyType"); + assertEquals("MyType", ormParameter.getTypeName()); + assertEquals("MyType", parameterResource.getClassName()); + + //set type name to null in the resource model + parameterResource.setClassName(null); + assertNull(ormParameter.getTypeName()); + assertNull(parameterResource.getClassName()); + } + + public void testModifyTypeName() throws Exception { + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo"); + OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping(); + OrmStoredProcedureParameter2_1 ormParameter = ((OrmQueryContainer2_1) ormEntity.getQueryContainer()).addNamedStoredProcedureQuery(0).addParameter(0); + + XmlStoredProcedureParameter parameterResource = getXmlEntityMappings().getEntities().get(0).getNamedStoredProcedureQueries().get(0).getParameters().get(0); + + assertNull(ormParameter.getTypeName()); + assertNull(parameterResource.getClassName()); + + //set type name in the resource model, verify context model updated + parameterResource.setClassName("MyType"); + assertEquals("MyType", ormParameter.getTypeName()); + assertEquals("MyType", parameterResource.getClassName()); + + //set type name in the resource model, verify context model updated + parameterResource.setClassName("MyNewType"); + assertEquals("MyNewType", ormParameter.getTypeName()); + assertEquals("MyNewType", parameterResource.getClassName()); + + //set type name to null in the resource model + parameterResource.setClassName(null); + assertNull(ormParameter.getTypeName()); + assertNull(parameterResource.getClassName()); + } +} diff --git src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/resource/java/StoredProcedureParameter2_1AnnotationTests.java src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/resource/java/StoredProcedureParameter2_1AnnotationTests.java index 33bb3ca..1600a90 100644 --- src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/resource/java/StoredProcedureParameter2_1AnnotationTests.java +++ src/org/eclipse/jpt/jpa/core/tests/internal/jpa2_1/resource/java/StoredProcedureParameter2_1AnnotationTests.java @@ -15,7 +15,7 @@ import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.JPA2_1; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.NamedStoredProcedureQuery2_1Annotation; -import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode2_1; +import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.ParameterMode_2_1; import org.eclipse.jpt.jpa.core.jpa2_1.resource.java.StoredProcedureParameter2_1Annotation; @SuppressWarnings("nls") @@ -85,7 +85,7 @@ NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY); StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0); - assertEquals(ParameterMode2_1.IN, parameter.getMode()); + assertEquals(ParameterMode_2_1.IN, parameter.getMode()); } public void testSetMode() throws Exception { @@ -94,10 +94,10 @@ NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY); StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0); - assertEquals(ParameterMode2_1.IN, parameter.getMode()); + assertEquals(ParameterMode_2_1.IN, parameter.getMode()); - parameter.setMode(ParameterMode2_1.INOUT); - assertEquals(ParameterMode2_1.INOUT, parameter.getMode()); + parameter.setMode(ParameterMode_2_1.INOUT); + assertEquals(ParameterMode_2_1.INOUT, parameter.getMode()); assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = INOUT, type = MyType.class)", cu); parameter.setMode(null); @@ -114,7 +114,7 @@ NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY); StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0); - assertEquals("MyType", parameter.getType()); + assertEquals("MyType", parameter.getTypeName()); } public void testSetType() throws Exception { @@ -124,14 +124,14 @@ NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY); StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0); - assertEquals("MyType", parameter.getType()); + assertEquals("MyType", parameter.getTypeName()); - parameter.setType("Foo"); - assertEquals("Foo", parameter.getType()); + parameter.setTypeName("Foo"); + assertEquals("Foo", parameter.getTypeName()); assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = Foo.class", cu); - parameter.setType(null); - assertNull(parameter.getType()); + parameter.setTypeName(null); + assertNull(parameter.getTypeName()); assertSourceDoesNotContain("type", cu); assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN", cu); } @@ -143,10 +143,10 @@ NamedStoredProcedureQuery2_1Annotation namedQuery = (NamedStoredProcedureQuery2_1Annotation) resourceType.getAnnotation(0, JPA2_1.NAMED_STORED_PROCEDURE_QUERY); StoredProcedureParameter2_1Annotation parameter = namedQuery.parameterAt(0); - assertNotNull(parameter.getType()); + assertNotNull(parameter.getTypeName()); assertEquals("MyType", parameter.getFullyQualifiedTypeName()); - parameter.setType(TYPE_NAME); + parameter.setTypeName(TYPE_NAME); assertEquals(FULLY_QUALIFIED_TYPE_NAME, parameter.getFullyQualifiedTypeName()); assertSourceContains("@StoredProcedureParameter(name = \"MyParameter\", mode = ParameterMode.IN, type = " + TYPE_NAME + ".class)", cu);