Attachment #176709 for bug #317197




package org.eclipse.persistence.testing.framework.wdf.customizer;

import org.eclipse.persistence.config.DescriptorCustomizer;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.mappings.ManyToManyMapping;
import org.eclipse.persistence.mappings.OneToOneMapping;
import org.eclipse.persistence.platform.database.DatabasePlatform;
import org.eclipse.persistence.platform.database.MySQLPlatform;
import org.eclipse.persistence.platform.database.OraclePlatform;

public class AdjustArrayTypeCustomizer implements DescriptorCustomizer {

	private static final String VARCHAR = "VARCHAR";
	private static final String BINARY = "BINARY";
	private static Class<? extends DatabasePlatform> databasePlatformClass;

	public static void setDatabasePlatformClass(
			Class<? extends DatabasePlatform> databasePlatformClass) {
		AdjustArrayTypeCustomizer.databasePlatformClass = databasePlatformClass;
	}

	@Override
	public void customize(ClassDescriptor descriptor) throws Exception {

		Iterable<DatabaseMapping> mappings = descriptor.getMappings();
		for (DatabaseMapping mapping : mappings) {
			if (mapping.isDirectToFieldMapping()) {
				adjustDatabaseField(mapping.getField());
			}
			if (mapping.isOneToOneMapping()) {
				OneToOneMapping oneToOneMapping = (OneToOneMapping) mapping;
				for (DatabaseField field : oneToOneMapping
						.getForeignKeyFields()) {
					adjustDatabaseField(field);
				}
			} else if (mapping.isManyToManyMapping()) {
				ManyToManyMapping manyToManyMapping = (ManyToManyMapping) mapping;
				for (DatabaseField field : manyToManyMapping
						.getSourceRelationKeyFields()) {
					adjustDatabaseField(field);
				}
				for (DatabaseField field : manyToManyMapping
						.getTargetRelationKeyFields()) {
					adjustDatabaseField(field);
				}
			}
		}
	}

	private void adjustDatabaseField(DatabaseField field) {
		String columnDefintion = field.getColumnDefinition();
		if (columnDefintion != null) {
			if (columnDefintion.startsWith(BINARY)) {
				adjustBinaryType(field, columnDefintion);
			} else if (columnDefintion.startsWith(VARCHAR)) {
				adjustVarcharType(field, columnDefintion);
			}

		}
	}

	private void adjustBinaryType(DatabaseField field, String columnDefintion) {
		final String newDefinition;
		if (OraclePlatform.class.isAssignableFrom(databasePlatformClass)) {
			newDefinition = columnDefintion.replace(BINARY, "RAW");
		} else if (MySQLPlatform.class.isAssignableFrom(databasePlatformClass)) {
			newDefinition = columnDefintion.replace(BINARY, "binary");
		} else if (databasePlatformClass.getName().endsWith("MaxDBPlatform")) {
			newDefinition = columnDefintion.replace(BINARY, "CHAR") + " BYTE";
		} else {
			return;
		}
		field.setColumnDefinition(newDefinition);
	}

	private void adjustVarcharType(DatabaseField field, String columnDefintion) {
		final String newDefinition;
		if (OraclePlatform.class.isAssignableFrom(databasePlatformClass)) {
			newDefinition = columnDefintion.replace(VARCHAR, "VARCHAR2");
		} else if (databasePlatformClass.getName().endsWith("MaxDBPlatform")) {
			newDefinition = columnDefintion + " UNICODE";
		} else {
			return;
		}
		field.setColumnDefinition(newDefinition);
	}

}





import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.platform.database.DatabasePlatform;
import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
import org.eclipse.persistence.testing.framework.wdf.server.Notification;
import org.eclipse.persistence.testing.framework.wdf.server.ServerTestRunner;
import org.junit.Assert;

        String databasePlatformClassName = testProperties.get(PersistenceUnitProperties.TARGET_DATABASE); 
        

		if (databasePlatformClassName != null) {
			databasePlatformClass = (Class<? extends DatabasePlatform>) Class.forName(databasePlatformClassName);
			AdjustArrayTypeCustomizer.setDatabasePlatformClass(databasePlatformClass);
		} else {
			databasePlatformClass = null; // FIXME
		}        

        String testBugzillaRun = (String) testProperties.get(TEST_BUGZILLA_RUN);
        if ("all".equals(testBugzillaRun)) {

Lines 48-53 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/models/wdf/jpa1/employee/Employee.java (-3 / +8 lines)
48	import javax.persistence.Transient;	48	import javax.persistence.Transient;
49	import javax.persistence.UniqueConstraint;	49	import javax.persistence.UniqueConstraint;
50		50
		51	import org.eclipse.persistence.annotations.Customizer;
		52	import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
		53
51	@Cacheable(true)	54	@Cacheable(true)
52	@Entity	55	@Entity
53	@Table(name = "TMP_EMP", uniqueConstraints = @UniqueConstraint(columnNames = { "ID", "DEPARTMENT" }))	56	@Table(name = "TMP_EMP", uniqueConstraints = @UniqueConstraint(columnNames = { "ID", "DEPARTMENT" }))
Lines 55-60 Link Here
55	@NamedNativeQueries( {	58	@NamedNativeQueries( {
56	@NamedNativeQuery(name = "Employee.schlonz", query = "select \"TMP_EMP\".* from \"TMP_EMP\"", resultClass = Employee.class),	59	@NamedNativeQuery(name = "Employee.schlonz", query = "select \"TMP_EMP\".* from \"TMP_EMP\"", resultClass = Employee.class),
57	@NamedNativeQuery(name = "Employee.schlonzHint", query = "select \"TMP_EMP\".* from \"TMP_EMP\"", resultClass = Employee.class) })	60	@NamedNativeQuery(name = "Employee.schlonzHint", query = "select \"TMP_EMP\".* from \"TMP_EMP\"", resultClass = Employee.class) })
		61	@Customizer(AdjustArrayTypeCustomizer.class)
58	public class Employee implements Serializable {	62	public class Employee implements Serializable {
59		63
60	private static final long serialVersionUID = 1L;	64	private static final long serialVersionUID = 1L;
Lines 152-158 Link Here
152	// <join-column name="PROFILE_GUID"/>	156	// <join-column name="PROFILE_GUID"/>
153	// </attribute>	157	// </attribute>
154	@OneToOne	158	@OneToOne
155	@JoinColumn(name = "PROFILE_GUID")	159	@JoinColumn(name = "PROFILE_GUID", columnDefinition=TravelProfile.BINARY_16_COLUMN)
156	protected TravelProfile travelProfile;	160	protected TravelProfile travelProfile;
157		161
158	// <attribute name="hobbies">	162	// <attribute name="hobbies">
Lines 186-193 Link Here
186	@JoinTable(name = "TMP_EMP_CREDIT", joinColumns = { @JoinColumn(name = "CLIENT_ID") }, inverseJoinColumns = { @JoinColumn(name = "CREDIT_ID") })	190	@JoinTable(name = "TMP_EMP_CREDIT", joinColumns = { @JoinColumn(name = "CLIENT_ID") }, inverseJoinColumns = { @JoinColumn(name = "CREDIT_ID") })
187	protected Set<CreditCardAccount> creditCardAccounts;	191	protected Set<CreditCardAccount> creditCardAccounts;
188		192
189	@OneToOne	193	// @OneToOne
190	@JoinColumn(name = "AUTOMOBILE")	194	// @JoinColumn(name = "AUTOMOBILE")
		195	@Transient // EclipseLink has issue with cyclic FKs FIXME: file bug and add id here
191	protected MotorVehicle automobile;	196	protected MotorVehicle automobile;
192		197
193	@ManyToOne	198	@ManyToOne

Lines 26-36 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/models/wdf/jpa1/employee/Item_Byte.java (-1 / +5 lines)
26	import javax.persistence.OneToMany;	26	import javax.persistence.OneToMany;
27	import javax.persistence.Table;	27	import javax.persistence.Table;
28		28
		29	import org.eclipse.persistence.annotations.Customizer;
		30	import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
		31
29	@Entity	32	@Entity
30	@Table(name = "BYTE_ITEM")	33	@Table(name = "BYTE_ITEM")
		34	@Customizer(AdjustArrayTypeCustomizer.class)
31	public class Item_Byte implements Serializable {	35	public class Item_Byte implements Serializable {
32	@Id	36	@Id
33	@Column(name = "ITEM_ID")	37	@Column(name = "ITEM_ID", columnDefinition=TravelProfile.BINARY_16_COLUMN)
34	private byte[] itemId;	38	private byte[] itemId;
35	private String namespace;	39	private String namespace;
36	private String text;	40	private String text;

Lines 22-31 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/models/wdf/jpa1/employee/TravelProfile.java (+7 lines)
22	import javax.persistence.ManyToMany;	22	import javax.persistence.ManyToMany;
23	import javax.persistence.Table;	23	import javax.persistence.Table;
24		24
		25	import org.eclipse.persistence.annotations.Customizer;
		26	import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
		27
25	@Entity	28	@Entity
26	@Table(name = "TMP_PROFILE")	29	@Table(name = "TMP_PROFILE")
		30	@Customizer(AdjustArrayTypeCustomizer.class)
27	public class TravelProfile {	31	public class TravelProfile {
28		32
		33	static final String BINARY_16_COLUMN = "BINARY(16)";
		34
29	/**	35	/**
30	* @param guid	36	* @param guid
31	* The guid to set.	37	* The guid to set.
Lines 85-90 Link Here
85	* @return Returns the guid.	91	* @return Returns the guid.
86	*/	92	*/
87	@Id	93	@Id
		94	@Column(length = 16, columnDefinition=BINARY_16_COLUMN)
88	public byte[] getGuid() {	95	public byte[] getGuid() {
89	return guid;	96	return guid;
90	}	97	}




import javax.persistence.TableGenerator;
import javax.persistence.Version;

import org.eclipse.persistence.annotations.Customizer;
import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;

@Cacheable(value = true)
@Entity
@Table(name = "TMP_VEHICLE")
@EntityListeners( { VehicleListener.class })
@DiscriminatorColumn(name = "DTYPE", discriminatorType = DiscriminatorType.INTEGER)
@DiscriminatorValue("-1")
@Customizer(AdjustArrayTypeCustomizer.class)
public class Vehicle implements Serializable {

    private static final long serialVersionUID = 1L;

    int version;

    @ManyToMany
    @JoinTable(name = "TMP_VEHICLE_PROFILE", joinColumns = { @JoinColumn(name = "VEHICLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "PROFILE_ID", columnDefinition=TravelProfile.BINARY_16_COLUMN) })
    private Set<TravelProfile> profiles;

    public void setId(Short id) {




import javax.persistence.Transient;
import javax.persistence.Version;

import org.eclipse.persistence.annotations.Customizer;
import org.eclipse.persistence.annotations.Mutable;
import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;

/*
 * This entity class contains all supported <i>basic </i> data types.


@Entity
@Table(name = "TMP_BASIC_TYPES_FA")
@Customizer(AdjustArrayTypeCustomizer.class)
public class BasicTypesFieldAccess {

    @Transient


    // arrays
    @Basic
	@Column(name = "PBA_BINARY", length = 8, columnDefinition = "BINARY(8)")
    @Mutable
    protected byte[] primitiveByteArray2Binary; // BINARY


    protected byte[] primitiveByteArray2Blob; // BLOB

    @Basic
	@Column(name = "WBA_BINARY", length = 8, columnDefinition = "BINARY(8)")
    @Mutable
    protected Byte[] wrapperByteArray2Binary; // BINARY


    protected Byte[] wrapperByteArray2Blob; // BLOB

    @Basic
	@Column(name = "PCA_VARCHAR", columnDefinition = "VARCHAR(255)")
    @Mutable
    protected char[] primitiveCharArray2Varchar; // VARCHAR


    protected char[] primitiveCharArray2Clob; // CLOB

    @Basic
	@Column(name = "WCA_VARCHAR", columnDefinition = "VARCHAR(255)")
    @Mutable
    protected Character[] wrapperCharacterArray2Varchar; // VARCHAR






import org.eclipse.persistence.platform.database.MySQLPlatform;
import org.eclipse.persistence.platform.database.OraclePlatform;
import org.eclipse.persistence.platform.database.SQLServerPlatform;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.Skip;
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;

public class TestSequence extends JPA1Base {

    @Test
    @Skip(databaseNames = "org.eclipse.persistence.platform.database.MySQLPlatform", databases=SQLServerPlatform.class)
    public void testPersist() {
        JPAEnvironment env = getEnvironment();
        EntityManager em = env.getEntityManager();

    }

    @Test
    @Skip(databases = {MySQLPlatform.class, SQLServerPlatform.class})
    public void testPersistFlock() {
        JPAEnvironment env = getEnvironment();
        EntityManager em = env.getEntityManager();

    }

    @Test
    @Skip(databases = {MySQLPlatform.class, SQLServerPlatform.class})
    @ToBeInvestigated(databases = OraclePlatform.class)
    // adjust test
    public void testAllocSize() {

Lines 20-30 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/tests/wdf/jpa1/JPA1Base.java (-2 / +2 lines)
20	public abstract class JPA1Base extends AbstractBaseTest {	20	public abstract class JPA1Base extends AbstractBaseTest {
21		21
22	private static final String[] CLEARABLE_TABLE_NAMES = { "TMP_EMP_CREDIT", "TMP_CREDIT_ACC", "TMP_BROKER_ACC",	22	private static final String[] CLEARABLE_TABLE_NAMES = { "TMP_EMP_CREDIT", "TMP_CREDIT_ACC", "TMP_BROKER_ACC",
23	"TMP_SAVE_ACC", "TMP_MARGIN_ACC", "TMP_CHECK_ACC", "TMP_EMP_PROJECT", "TMP_DEP", "TMP_REVIEW_DETAILS",	23	"TMP_SAVE_ACC", "TMP_MARGIN_ACC", "TMP_CHECK_ACC", "TMP_EMP_PROJECT", "TMP_REVIEW_DETAILS",
24	"TMP_EMP_REVIEW", "TMP_BASIC_TYPES_FA", "TMP_TEMPORAL_FA", "TMP_BASIC_TYPES_PA", "TMP_NODE", "TMP_EMBEDD_FA",	24	"TMP_EMP_REVIEW", "TMP_BASIC_TYPES_FA", "TMP_TEMPORAL_FA", "TMP_BASIC_TYPES_PA", "TMP_NODE", "TMP_EMBEDD_FA",
25	"TMP_EMBEDD_PA", "TMP_ISLAND", "TMP_EMP_PATENT", "TMP_PROJECT_DETAILS", "TMP_PROFILE", "TMP_CASC_NODE",	25	"TMP_EMBEDD_PA", "TMP_ISLAND", "TMP_EMP_PATENT", "TMP_PROJECT_DETAILS", "TMP_PROFILE", "TMP_CASC_NODE",
26	"TMP_COURSE_EMP", "TMP_COURSE", "TMP_REVIEW", "TMP_PATENT", "TMP_CASC_NODE_DESC", "TMP_EMP_HOBBY", "TMP_HOBBY",	26	"TMP_COURSE_EMP", "TMP_COURSE", "TMP_REVIEW", "TMP_PATENT", "TMP_CASC_NODE_DESC", "TMP_EMP_HOBBY", "TMP_HOBBY",
27	"TMP_EMP_BICYCLE", "TMP_VEHICLE", "TMP_EMP", "TMP_OFFICE_CUBICLE", "TMP_OFFICE", "TMP_ALLRELATIONS", "TMP_CUBICLE",	27	"TMP_EMP_BICYCLE", "TMP_VEHICLE", "TMP_EMP", "TMP_DEP", "TMP_OFFICE_CUBICLE", "TMP_OFFICE", "TMP_ALLRELATIONS", "TMP_CUBICLE",
28	"TMP_ALLRELATIONS_LIST", "TMP_ALLRELATIONS_SET", "TMP_ALLRELATIONS_COLLECTION", "TMP_ALLRELATIONS_MAPID",	28	"TMP_ALLRELATIONS_LIST", "TMP_ALLRELATIONS_SET", "TMP_ALLRELATIONS_COLLECTION", "TMP_ALLRELATIONS_MAPID",
29	"TMP_ALLRELATIONS_MAPFIELD", "TMP_TASK", "TMP_PROJECT", "TMP_CITY", "TMP_CITY_TMP_COP", "TMP_CITY_TMP_CRIMINAL",	29	"TMP_ALLRELATIONS_MAPFIELD", "TMP_TASK", "TMP_PROJECT", "TMP_CITY", "TMP_CITY_TMP_COP", "TMP_CITY_TMP_CRIMINAL",
30	"TMP_COP", "TMP_COP_TMP_CRIMINAL", "TMP_COP_TMP_INFORMER", "TMP_CRIMINAL", "TMP_CRIMINAL_TMP_CRIMINAL",	30	"TMP_COP", "TMP_COP_TMP_CRIMINAL", "TMP_COP_TMP_INFORMER", "TMP_CRIMINAL", "TMP_CRIMINAL_TMP_CRIMINAL",





import javax.persistence.TemporalType;

import org.eclipse.persistence.platform.database.OraclePlatform;
import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
import org.eclipse.persistence.testing.framework.wdf.Issue;
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
import org.junit.Test;


    }
    
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testInBinary() {
        byte[] byteArr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
        byte[] byteArr2 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };




import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.eclipse.persistence.platform.database.OraclePlatform;
import org.eclipse.persistence.testing.framework.wdf.Issue;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Bicycle;


    // @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL })
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testQueryWithBuiltinAbs() throws Exception {
        EntityManager em = getEnvironment().getEntityManager();
        try {


    // @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL })
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testQueryWithMemberOf() throws Exception {
        EntityManager em = getEnvironment().getEntityManager();
        try {

Lines 13-18 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestGroupByOrderByHaving.java (+8 lines)
13		13
14	package org.eclipse.persistence.testing.tests.wdf.jpa1.query;	14	package org.eclipse.persistence.testing.tests.wdf.jpa1.query;
15		15
		16	import org.eclipse.persistence.testing.framework.wdf.Skip;
16	import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;	17	import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
17	import org.junit.Test;	18	import org.junit.Test;
18		19
Lines 139-144 Link Here
139	}	140	}
140		141
141	@Test	142	@Test
		143	@Skip(databaseNames="org.eclipse.persistence.platform.database.MaxDBPlatform")
		144	/*
		145	* On MaxDB, the query maps to
		146	* "SELECT t0.ID, t0.COOL, t0.NAME, t0.TYPE, t0.CITY_ENUM, t0.CITY_TESLA_INT, t0.CITY_TESLA_BLOB FROM TMP_CITY t0 WHERE EXISTS (SELECT 1 FROM TMP_COP t2, TMP_COP t1 WHERE (t2.ID = t1.PARTNER_ID) GROUP BY t1.ID HAVING (t2.ID = 5))"
		147	* . The query is invalid (as expected) and should fail on the database as
		148	* t2.ID is no grouping column and must not be used in HAVING.
		149	*/
142	public void testSubQueryGroupBy3() {	150	public void testSubQueryGroupBy3() {
143	/* 21 */assertInvalidQuery("select _city from City _city where exists(select max(c.id) from Cop c group by c.id having c.partner.id = 5)");	151	/* 21 */assertInvalidQuery("select _city from City _city where exists(select max(c.id) from Cop c group by c.id having c.partner.id = 5)");
144	}	152	}




import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.eclipse.persistence.platform.database.OraclePlatform;
import org.eclipse.persistence.testing.framework.wdf.Issue;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department;


    @SuppressWarnings("unchecked")
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testJoinFetchProjects() throws SQLException {
        init();
        EntityManager em = getEnvironment().getEntityManager();

    }

    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testDistinctJoinFetchHobbiesWithMultipleSelectItems() throws SQLException {
        init();
        EntityManager em = getEnvironment().getEntityManager();




import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.eclipse.persistence.platform.database.SQLServerPlatform;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.Skip;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Cubicle;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee;

        }
    }

    @Skip(databases=SQLServerPlatform.class)
    @Test
    public void testColumnResult() throws SQLException {
        init();

        }
    }

    @Skip(databases=SQLServerPlatform.class)
    @Test
    public void testFieldResult() throws SQLException {
        init();

        }
    }

    @Skip(databases=SQLServerPlatform.class)
    @Test
    public void testFieldByField() throws SQLException {
        clearAllTables();




import javax.persistence.Query;
import javax.persistence.TemporalType;

import org.eclipse.persistence.platform.database.OraclePlatform;
import org.eclipse.persistence.testing.framework.wdf.Issue;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesFieldAccess;
import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedEnum;


    // arrays
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testPrimitiveByteArray2Binary() {
        final byte[] UNCHANGED = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
        Validator validator = new Validator() {

    }

    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testPrimitiveCharArray2Varchar() {
        final char[] UNCHANGED = new char[] { 'U', 'N', 'C', 'H', 'A', 'N', 'G', 'E', 'D' };
        Validator validator = new Validator() {

    }

    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testWrapperByteArray2Binary() {
        final Byte[] UNCHANGED = new Byte[] { Byte.valueOf((byte) 0), Byte.valueOf((byte) 1), Byte.valueOf((byte) 2),
                Byte.valueOf((byte) 3), Byte.valueOf((byte) 4), Byte.valueOf((byte) 5), Byte.valueOf((byte) 6),


    @SuppressWarnings("boxing")
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testWrapperCharArray2Varchar() {
        final Character[] UNCHANGED = new Character[] { 'U', 'N', 'C', 'H', 'A', 'N', 'G', 'E', 'D' };
        Validator validator = new Validator() {




import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
import org.eclipse.persistence.testing.framework.wdf.Issue;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesFieldAccess;

        }
    }

    private void validateType(String subList, Class<?> type) {
    private void validateType(String subList, Class type) {
        JPAEnvironment env = getEnvironment();
        EntityManager em = env.getEntityManager();
        try {


    // arrays
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testCountPrimitiveByteArray2Binary() {
        validateCount("primitiveByteArray2Binary");
    }

    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testCountPrimitiveCharArray2Varchar() {
        validateCount("primitiveCharArray2Varchar");
    }

    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testCountWrapperByteArray2Binary() {
        validateCount("wrapperByteArray2Binary");
    }

    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testCountWrapperCharArray2Varchar() {
        validateCount("wrapperCharacterArray2Varchar");
    }


    // immutable reference types
    @Test
    @Bugzilla(bugid=320120, databaseNames="org.eclipse.persistence.platform.database.MaxDBPlatform")
    public void testSumBigDecimal() {
        validateSum("bigDecimal", BigDecimal.class);
    }


    // arrays
    @Test
    @Issue(issueid=13, databases=OraclePlatform.class)
    public void testMaxPrimitiveByteArray2Binary() {
        validateMax("primitiveByteArray2Binary", byte[].class);
    }

Lines 20-25 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestSetFunctions.java (+2 lines)
20	import javax.persistence.EntityManager;	20	import javax.persistence.EntityManager;
21	import javax.persistence.Query;	21	import javax.persistence.Query;
22		22
		23	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
23	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;	24	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
24	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee;	25	import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee;
25	import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;	26	import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;
Lines 66-71 Link Here
66	}	67	}
67		68
68	@Test	69	@Test
		70	@Bugzilla(bugid=320120, databaseNames="org.eclipse.persistence.platform.database.MaxDBPlatform")
69	public void testSum() {	71	public void testSum() {
70	JPAEnvironment env = getEnvironment();	72	JPAEnvironment env = getEnvironment();
71	EntityManager em = env.getEntityManager();	73	EntityManager em = env.getEntityManager();




import javax.persistence.Query;
import javax.sql.DataSource;

import org.eclipse.persistence.platform.database.SQLServerPlatform;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.Skip;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department;
import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesPropertyAccess;
import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;

    }

    @Test
    @Skip(databases=SQLServerPlatform.class)
    public void testNativeFieldsExecuteOnlyOutsideTransactionSmall() {
        final JPAEnvironment environment = getEnvironment();
        final EntityManager myEm = environment.getEntityManager();

Lines 28-34 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/tests/wdf/jpa1/simple/TestBasicFieldTypes.java (-1 / +2 lines)
28		28
29	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;	29	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
30	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;	30	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
31	import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;	31	import org.eclipse.persistence.testing.framework.wdf.Skip;
32	import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesFieldAccess;	32	import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesFieldAccess;
33	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedEnum;	33	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedEnum;
34	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedSerializable;	34	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedSerializable;
Lines 856-861 Link Here
856	}	856	}
857		857
858	@Test	858	@Test
		859	@Skip(databaseNames = "org.eclipse.persistence.platform.database.MaxDBPlatform")
859	public void testPrimitiveByteArray2Longvarbinary() {	860	public void testPrimitiveByteArray2Longvarbinary() {
860	final byte[] UNCHANGED = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };	861	final byte[] UNCHANGED = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
861	MutableValidator validator = new MutableValidator() {	862	MutableValidator validator = new MutableValidator() {

Lines 28-34 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/tests/wdf/jpa1/simple/TestBasicPropertyTypes.java (-1 / +2 lines)
28		28
29	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;	29	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
30	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;	30	import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
31	import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;	31	import org.eclipse.persistence.testing.framework.wdf.Skip;
32	import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesPropertyAccess;	32	import org.eclipse.persistence.testing.models.wdf.jpa1.types.BasicTypesPropertyAccess;
33	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedEnum;	33	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedEnum;
34	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedSerializable;	34	import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedSerializable;
Lines 856-861 Link Here
856	}	856	}
857		857
858	@Test	858	@Test
		859	@Skip(databaseNames = "org.eclipse.persistence.platform.database.MaxDBPlatform")
859	public void testPrimitiveByteArray2Longvarbinary() {	860	public void testPrimitiveByteArray2Longvarbinary() {
860	final byte[] UNCHANGED = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };	861	final byte[] UNCHANGED = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
861	MutableValidator validator = new MutableValidator() {	862	MutableValidator validator = new MutableValidator() {

Return to bug 317197

Line 0 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/framework/wdf/customizer/AdjustArrayTypeCustomizer.java (+90 lines)
		1	package org.eclipse.persistence.testing.framework.wdf.customizer;
		2
		3	import org.eclipse.persistence.config.DescriptorCustomizer;
		4	import org.eclipse.persistence.descriptors.ClassDescriptor;
		5	import org.eclipse.persistence.internal.helper.DatabaseField;
		6	import org.eclipse.persistence.mappings.DatabaseMapping;
		7	import org.eclipse.persistence.mappings.ManyToManyMapping;
		8	import org.eclipse.persistence.mappings.OneToOneMapping;
		9	import org.eclipse.persistence.platform.database.DatabasePlatform;
		10	import org.eclipse.persistence.platform.database.MySQLPlatform;
		11	import org.eclipse.persistence.platform.database.OraclePlatform;
		12
		13	public class AdjustArrayTypeCustomizer implements DescriptorCustomizer {
		14
		15	private static final String VARCHAR = "VARCHAR";
		16	private static final String BINARY = "BINARY";
		17	private static Class<? extends DatabasePlatform> databasePlatformClass;
		18
		19	public static void setDatabasePlatformClass(
		20	Class<? extends DatabasePlatform> databasePlatformClass) {
		21	AdjustArrayTypeCustomizer.databasePlatformClass = databasePlatformClass;
		22	}
		23
		24	@Override
		25	public void customize(ClassDescriptor descriptor) throws Exception {
		26
		27	Iterable<DatabaseMapping> mappings = descriptor.getMappings();
		28	for (DatabaseMapping mapping : mappings) {
		29	if (mapping.isDirectToFieldMapping()) {
		30	adjustDatabaseField(mapping.getField());
		31	}
		32	if (mapping.isOneToOneMapping()) {
		33	OneToOneMapping oneToOneMapping = (OneToOneMapping) mapping;
		34	for (DatabaseField field : oneToOneMapping
		35	.getForeignKeyFields()) {
		36	adjustDatabaseField(field);
		37	}
		38	} else if (mapping.isManyToManyMapping()) {
		39	ManyToManyMapping manyToManyMapping = (ManyToManyMapping) mapping;
		40	for (DatabaseField field : manyToManyMapping
		41	.getSourceRelationKeyFields()) {
		42	adjustDatabaseField(field);
		43	}
		44	for (DatabaseField field : manyToManyMapping
		45	.getTargetRelationKeyFields()) {
		46	adjustDatabaseField(field);
		47	}
		48	}
		49	}
		50	}
		51
		52	private void adjustDatabaseField(DatabaseField field) {
		53	String columnDefintion = field.getColumnDefinition();
		54	if (columnDefintion != null) {
		55	if (columnDefintion.startsWith(BINARY)) {
		56	adjustBinaryType(field, columnDefintion);
		57	} else if (columnDefintion.startsWith(VARCHAR)) {
		58	adjustVarcharType(field, columnDefintion);
		59	}
		60
		61	}
		62	}
		63
		64	private void adjustBinaryType(DatabaseField field, String columnDefintion) {
65	final String newDefinition;
66	if (OraclePlatform.class.isAssignableFrom(databasePlatformClass)) {
67	newDefinition = columnDefintion.replace(BINARY, "RAW");
68	} else if (MySQLPlatform.class.isAssignableFrom(databasePlatformClass)) {
69	newDefinition = columnDefintion.replace(BINARY, "binary");
70	} else if (databasePlatformClass.getName().endsWith("MaxDBPlatform")) {
71	newDefinition = columnDefintion.replace(BINARY, "CHAR") + " BYTE";
72	} else {
73	return;
74	}
75	field.setColumnDefinition(newDefinition);
76	}
77
78	private void adjustVarcharType(DatabaseField field, String columnDefintion) {
79	final String newDefinition;
80	if (OraclePlatform.class.isAssignableFrom(databasePlatformClass)) {
81	newDefinition = columnDefintion.replace(VARCHAR, "VARCHAR2");
82	} else if (databasePlatformClass.getName().endsWith("MaxDBPlatform")) {
83	newDefinition = columnDefintion + " UNICODE";
84	} else {
85	return;
86	}
87	field.setColumnDefinition(newDefinition);
88	}
89
90	}

Lines 26-31 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/framework/wdf/SkipBugzillaTestRunner.java (-5 / +7 lines)
26		26
27	import org.eclipse.persistence.config.PersistenceUnitProperties;	27	import org.eclipse.persistence.config.PersistenceUnitProperties;
28	import org.eclipse.persistence.platform.database.DatabasePlatform;	28	import org.eclipse.persistence.platform.database.DatabasePlatform;
		29	import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
29	import org.eclipse.persistence.testing.framework.wdf.server.Notification;	30	import org.eclipse.persistence.testing.framework.wdf.server.Notification;
30	import org.eclipse.persistence.testing.framework.wdf.server.ServerTestRunner;	31	import org.eclipse.persistence.testing.framework.wdf.server.ServerTestRunner;
31	import org.junit.Assert;	32	import org.junit.Assert;
Lines 112-122 Link Here
112	String databasePlatformClassName = testProperties.get(PersistenceUnitProperties.TARGET_DATABASE);	113	String databasePlatformClassName = testProperties.get(PersistenceUnitProperties.TARGET_DATABASE);
113		114
114		115
115	if (databasePlatformClassName != null) {	116	if (databasePlatformClassName != null) {
116	databasePlatformClass = (Class<? extends DatabasePlatform>) Class.forName(databasePlatformClassName);	117	databasePlatformClass = (Class<? extends DatabasePlatform>) Class.forName(databasePlatformClassName);
117	} else {	118	AdjustArrayTypeCustomizer.setDatabasePlatformClass(databasePlatformClass);
118	databasePlatformClass = null; // FIXME	119	} else {
119	}	120	databasePlatformClass = null; // FIXME
		121	}
120		122
121	String testBugzillaRun = (String) testProperties.get(TEST_BUGZILLA_RUN);	123	String testBugzillaRun = (String) testProperties.get(TEST_BUGZILLA_RUN);
122	if ("all".equals(testBugzillaRun)) {	124	if ("all".equals(testBugzillaRun)) {

Lines 34-45 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/models/wdf/jpa1/employee/Vehicle.java (-1 / +5 lines)
34	import javax.persistence.TableGenerator;	34	import javax.persistence.TableGenerator;
35	import javax.persistence.Version;	35	import javax.persistence.Version;
36		36
		37	import org.eclipse.persistence.annotations.Customizer;
		38	import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
		39
37	@Cacheable(value = true)	40	@Cacheable(value = true)
38	@Entity	41	@Entity
39	@Table(name = "TMP_VEHICLE")	42	@Table(name = "TMP_VEHICLE")
40	@EntityListeners( { VehicleListener.class })	43	@EntityListeners( { VehicleListener.class })
41	@DiscriminatorColumn(name = "DTYPE", discriminatorType = DiscriminatorType.INTEGER)	44	@DiscriminatorColumn(name = "DTYPE", discriminatorType = DiscriminatorType.INTEGER)
42	@DiscriminatorValue("-1")	45	@DiscriminatorValue("-1")
		46	@Customizer(AdjustArrayTypeCustomizer.class)
43	public class Vehicle implements Serializable {	47	public class Vehicle implements Serializable {
44		48
45	private static final long serialVersionUID = 1L;	49	private static final long serialVersionUID = 1L;
Lines 59-65 Link Here
59	int version;	63	int version;
60		64
61	@ManyToMany	65	@ManyToMany
62	@JoinTable(name = "TMP_VEHICLE_PROFILE", joinColumns = { @JoinColumn(name = "VEHICLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "PROFILE_ID") })	66	@JoinTable(name = "TMP_VEHICLE_PROFILE", joinColumns = { @JoinColumn(name = "VEHICLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "PROFILE_ID", columnDefinition=TravelProfile.BINARY_16_COLUMN) })
63	private Set<TravelProfile> profiles;	67	private Set<TravelProfile> profiles;
64		68
65	public void setId(Short id) {	69	public void setId(Short id) {

Lines 19-27 Link Here

(-)jpa/eclipselink.jpa.wdf.test/src/org/eclipse/persistence/testing/tests/wdf/jpa1/query/TestConditionalExpressions.java (-3 lines)
19		19
20	import javax.persistence.TemporalType;	20	import javax.persistence.TemporalType;
21		21
22	import org.eclipse.persistence.platform.database.OraclePlatform;
23	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;	22	import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
24	import org.eclipse.persistence.testing.framework.wdf.Issue;
25	import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;	23	import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
26	import org.junit.Test;	24	import org.junit.Test;
27		25
Lines 605-611 Link Here
605	}	603	}
606		604
607	@Test	605	@Test
608	@Issue(issueid=13, databases=OraclePlatform.class)
609	public void testInBinary() {	606	public void testInBinary() {
610	byte[] byteArr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };	607	byte[] byteArr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
611	byte[] byteArr2 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };	608	byte[] byteArr2 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };