| /* |
| * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation from Oracle TopLink |
| package org.eclipse.persistence.testing.tests.isolatedsession; |
| |
| import java.util.*; |
| |
| import java.io.*; |
| |
| import java.math.BigDecimal; |
| |
| import java.sql.Time; |
| |
| import org.eclipse.persistence.indirection.*; |
| import org.eclipse.persistence.sessions.DataRecord; |
| |
| /** |
| * <p><b>Purpose</b>: Represent a employee of an organization. |
| * <p><b>Description</b>: An Employee is a root object in the Employee Demo. |
| * It maintains relationships to all of the other objects in the system. |
| * The employee shows usage of 1-1, 1-m, m-m, aggregate and transformation mappings. |
| * The employee also shows usage of value holder to implement indirection for its relationships |
| * (note, it is strongly suggested to always use value holders for relationships). |
| */ |
| public class IsolatedEmployee implements Serializable { |
| |
| /** Primary key, maped as a direct-to-field, BigDecimal -{@literal >} NUMBER, that makes use of sequence numbers to generate the id. */ |
| public BigDecimal id; |
| |
| /** Direct-to-field mapping, String -{@literal >} VARCHAR. */ |
| public String firstName; |
| |
| /** Direct-to-field mapping, String -{@literal >} VARCHAR. */ |
| public String lastName; |
| |
| /** Object-type mapping, maps "Male" -{@literal >} "M", "Female" -{@literal >} "F". */ |
| public String gender; |
| |
| /** Aggregate-object mapping, stores the object in the employee's table. */ |
| public IsolatedEmploymentPeriod period; |
| |
| /** One-to-one mapping, employee references its address through a foreign key. */ |
| public ValueHolderInterface address; |
| |
| /** One-to-one mapping (same class relationship), employee references its manager through a foreign key. */ |
| public ValueHolderInterface manager; |
| |
| /** One-to-many mapping (same class relationship), inverse relationship to manager, uses manager foreign key in the target. */ |
| public ValueHolderInterface managedEmployees; |
| |
| /** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */ |
| public ValueHolderInterface phoneNumbers; |
| |
| /** Many-to-many mapping, employee references its projects through an intermediate join table. */ |
| public ValueHolderInterface projects; |
| |
| /** Direct-collection mapping, employee stores its collection of plain Strings in an intermediate table. */ |
| public ValueHolderInterface responsibilitiesList; |
| |
| /** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME), |
| this is stored into two different fields in the employee table. */ |
| public Time[] normalHours; |
| |
| /** Direct-to-field mapping, int -{@literal >} NUMBER, salary of the employee in dollars. */ |
| public int salary; |
| public boolean hasChanges = false; |
| |
| /** For performance testing, how many times primary key extracted. */ |
| public static int getIdCallCount = 0; |
| |
| /** |
| * For fields that make use of indirection the constructor should build the value holders. |
| */ |
| public IsolatedEmployee() { |
| this.firstName = ""; |
| this.lastName = ""; |
| this.address = new ValueHolder(); |
| this.manager = new ValueHolder(); |
| this.managedEmployees = new ValueHolder(new Vector()); |
| this.projects = new ValueHolder(new Vector()); |
| this.responsibilitiesList = new ValueHolder(new Vector()); |
| this.phoneNumbers = new ValueHolder(new Vector()); |
| this.normalHours = new Time[2]; |
| Calendar startTime = Calendar.getInstance(); |
| startTime.set(Calendar.MILLISECOND, 0); |
| startTime.set(1970, 0, 1, 9, 0, 0); |
| this.normalHours[0] = new Time(startTime.getTime().getTime()); |
| Calendar endTime = Calendar.getInstance(); |
| endTime.set(Calendar.MILLISECOND, 0); |
| endTime.set(1970, 0, 1, 17, 0, 0); |
| this.normalHours[1] = new Time(endTime.getTime().getTime()); |
| } |
| |
| public boolean hasChanges() { |
| return hasChanges; |
| } |
| |
| public void clearChanges() { |
| hasChanges = false; |
| } |
| |
| public void setChanged() { |
| hasChanges = true; |
| } |
| |
| public static IsolatedEmployee buildEmployeeExample1() { |
| IsolatedEmployee employee = new IsolatedEmployee(); |
| employee.setFirstName("Bob"); |
| employee.setLastName("Smith"); |
| employee.setMale(); |
| employee.setSalary(35000); |
| employee.setPeriod(IsolatedEmploymentPeriod.EmploymentPeriodExample1()); |
| employee.setAddress(IsolatedAddress.AddressExample1()); |
| employee.addResponsibility("Make the coffee."); |
| employee.addResponsibility("Clean the kitchen."); |
| employee.addPhoneNumber(new IsolatedPhoneNumber("Home", "613", "555-9878")); |
| return employee; |
| } |
| |
| public static IsolatedEmployee buildEmployeeExample2() { |
| IsolatedEmployee employee = new IsolatedEmployee(); |
| employee.setFirstName("Andy"); |
| employee.setLastName("McDurmont"); |
| employee.setMale(); |
| employee.setSalary(1500); |
| employee.setPeriod(IsolatedEmploymentPeriod.EmploymentPeriodExample2()); |
| employee.setAddress(IsolatedAddress.AddressExample2()); |
| employee.addResponsibility("Shred reports"); |
| employee.addPhoneNumber(new IsolatedPhoneNumber("Home", "613", "555-9878")); |
| return employee; |
| } |
| |
| /** |
| * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it. |
| */ |
| public void addManagedEmployee(IsolatedEmployee employee) { |
| setChanged(); |
| getManagedEmployees().addElement(employee); |
| employee.setManager(this); |
| } |
| |
| /** |
| * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it. |
| */ |
| public void addPhoneNumber(IsolatedPhoneNumber phoneNumber) { |
| setChanged(); |
| getPhoneNumbers().addElement(phoneNumber); |
| phoneNumber.setOwner(this); |
| } |
| |
| public void addProject(org.eclipse.persistence.testing.models.employee.interfaces.Project project) { |
| setChanged(); |
| getProjects().addElement(project); |
| } |
| |
| public void addResponsibility(String responsibility) { |
| setChanged(); |
| getResponsibilitiesList().addElement(responsibility); |
| } |
| |
| /** |
| * Builds the normalHours Vector. |
| * IMPORTANT: This method builds the value but does not set it. |
| * The mapping will set it using method or direct access |
| * as defined in the descriptor. |
| */ |
| public Time[] buildNormalHours(DataRecord row, org.eclipse.persistence.sessions.Session session) { |
| Time[] hours = new Time[2]; |
| |
| /** This conversion allows for the database type not to match, i.e. may be a Timestamp or String. */ |
| hours[0] = session.getDatasourcePlatform().convertObject(row.get("START_TIME"), Time.class); |
| hours[1] = session.getDatasourcePlatform().convertObject(row.get("END_TIME"), Time.class); |
| return hours; |
| } |
| |
| /** |
| * Builds the table definitions for this class |
| */ |
| public static org.eclipse.persistence.tools.schemaframework.TableDefinition buildIsolatedTableDefinition() { |
| org.eclipse.persistence.tools.schemaframework.TableDefinition tabledefinition = new org.eclipse.persistence.tools.schemaframework.TableDefinition(); |
| |
| // SECTION: TABLE |
| tabledefinition.setName("ISOLATED_EMPLOYEE"); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field.setName("EMP_ID"); |
| field.setTypeName("NUMERIC"); |
| field.setSize(15); |
| field.setShouldAllowNull(false); |
| field.setIsPrimaryKey(true); |
| field.setUnique(false); |
| field.setIsIdentity(true); |
| tabledefinition.addField(field); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field1 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field1.setName("F_NAME"); |
| field1.setTypeName("VARCHAR"); |
| field1.setSize(40); |
| field1.setShouldAllowNull(true); |
| field1.setIsPrimaryKey(false); |
| field1.setUnique(false); |
| field1.setIsIdentity(false); |
| tabledefinition.addField(field1); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field2 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field2.setName("L_NAME"); |
| field2.setTypeName("VARCHAR"); |
| field2.setSize(40); |
| field2.setShouldAllowNull(true); |
| field2.setIsPrimaryKey(false); |
| field2.setUnique(false); |
| field2.setIsIdentity(false); |
| tabledefinition.addField(field2); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field3 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field3.setName("START_DATE"); |
| field3.setTypeName("DATE"); |
| field3.setShouldAllowNull(true); |
| field3.setIsPrimaryKey(false); |
| field3.setUnique(false); |
| field3.setIsIdentity(false); |
| tabledefinition.addField(field3); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field4 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field4.setName("END_DATE"); |
| field4.setTypeName("DATE"); |
| field4.setShouldAllowNull(true); |
| field4.setIsPrimaryKey(false); |
| field4.setUnique(false); |
| field4.setIsIdentity(false); |
| tabledefinition.addField(field4); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field5 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field5.setName("START_TIME"); |
| field5.setTypeName("DATE"); |
| field5.setShouldAllowNull(true); |
| field5.setIsPrimaryKey(false); |
| field5.setUnique(false); |
| field5.setIsIdentity(false); |
| tabledefinition.addField(field5); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field6 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field6.setName("END_TIME"); |
| field6.setTypeName("DATE"); |
| field6.setShouldAllowNull(true); |
| field6.setIsPrimaryKey(false); |
| field6.setUnique(false); |
| field6.setIsIdentity(false); |
| tabledefinition.addField(field6); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field7 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field7.setName("GENDER"); |
| field7.setTypeName("VARCHAR"); |
| field7.setSize(1); |
| field7.setShouldAllowNull(true); |
| field7.setIsPrimaryKey(false); |
| field7.setUnique(false); |
| field7.setIsIdentity(false); |
| tabledefinition.addField(field7); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field8 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field8.setName("ADDR_ID"); |
| field8.setTypeName("NUMERIC"); |
| field8.setSize(15); |
| field8.setShouldAllowNull(true); |
| field8.setIsPrimaryKey(false); |
| field8.setUnique(false); |
| field8.setIsIdentity(false); |
| field8.setForeignKeyFieldName("ISOLATED_ADDRESS.ADDRESS_ID"); |
| tabledefinition.addField(field8); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field9 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field9.setName("MANAGER_ID"); |
| field9.setTypeName("NUMERIC"); |
| field9.setSize(15); |
| field9.setShouldAllowNull(true); |
| field9.setIsPrimaryKey(false); |
| field9.setUnique(false); |
| field9.setIsIdentity(false); |
| field9.setForeignKeyFieldName("ISOLATED_EMPLOYEE.EMP_ID"); |
| tabledefinition.addField(field9); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field10 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field10.setName("VERSION"); |
| field10.setTypeName("NUMERIC"); |
| field10.setSize(15); |
| field10.setShouldAllowNull(true); |
| field10.setIsPrimaryKey(false); |
| field10.setUnique(false); |
| field10.setIsIdentity(false); |
| tabledefinition.addField(field10); |
| return tabledefinition; |
| } |
| |
| /** |
| * TopLink generated method. |
| * <b>WARNING</b>: This code was generated by an automated tool. |
| * Any changes will be lost when the code is re-generated |
| */ |
| public static org.eclipse.persistence.tools.schemaframework.TableDefinition buildISOLATEDRESPONSTable() { |
| org.eclipse.persistence.tools.schemaframework.TableDefinition tabledefinition = new org.eclipse.persistence.tools.schemaframework.TableDefinition(); |
| |
| // SECTION: TABLE |
| tabledefinition.setName("ISOLATED_RESPONS"); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field.setName("EMP_ID"); |
| field.setTypeName("NUMERIC"); |
| field.setSize(15); |
| field.setShouldAllowNull(false); |
| field.setIsPrimaryKey(true); |
| field.setUnique(false); |
| field.setIsIdentity(false); |
| field.setForeignKeyFieldName("EMPLOYEE.EMP_ID"); |
| tabledefinition.addField(field); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field1 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field1.setName("DESCRIP"); |
| field1.setTypeName("VARCHAR"); |
| field1.setSize(200); |
| field1.setShouldAllowNull(false); |
| field1.setIsPrimaryKey(true); |
| field1.setUnique(false); |
| field1.setIsIdentity(false); |
| tabledefinition.addField(field1); |
| return tabledefinition; |
| } |
| |
| /** |
| * TopLink generated method. |
| * <b>WARNING</b>: This code was generated by an automated tool. |
| * Any changes will be lost when the code is re-generated |
| */ |
| public static org.eclipse.persistence.tools.schemaframework.TableDefinition buildISOLATEDSALARYTable() { |
| org.eclipse.persistence.tools.schemaframework.TableDefinition tabledefinition = new org.eclipse.persistence.tools.schemaframework.TableDefinition(); |
| |
| // SECTION: TABLE |
| tabledefinition.setName("ISOLATED_SALARY"); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field.setName("EMP_ID"); |
| field.setTypeName("NUMERIC"); |
| field.setSize(15); |
| field.setShouldAllowNull(false); |
| field.setIsPrimaryKey(true); |
| field.setUnique(false); |
| field.setIsIdentity(false); |
| field.setForeignKeyFieldName("EMPLOYEE.EMP_ID"); |
| tabledefinition.addField(field); |
| |
| // SECTION: FIELD |
| org.eclipse.persistence.tools.schemaframework.FieldDefinition field1 = new org.eclipse.persistence.tools.schemaframework.FieldDefinition(); |
| field1.setName("SALARY"); |
| field1.setTypeName("NUMBER"); |
| field1.setSize(10); |
| field1.setShouldAllowNull(true); |
| field1.setIsPrimaryKey(false); |
| field1.setUnique(false); |
| field1.setIsIdentity(false); |
| tabledefinition.addField(field1); |
| |
| return tabledefinition; |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public IsolatedAddress getAddress() { |
| return (IsolatedAddress)address.getValue(); |
| } |
| |
| /** |
| * Return the last element of the Transformation mapped normalHours. |
| */ |
| public Time getEndTime() { |
| return getNormalHours()[1]; |
| } |
| |
| public String getFirstName() { |
| return firstName; |
| } |
| |
| public String getGender() { |
| return gender; |
| } |
| |
| /** |
| * Used for performance testing. |
| */ |
| public static int getGetIdCallCount() { |
| return getIdCallCount; |
| } |
| |
| /** |
| * Return the persistent identifier of the receiver. |
| */ |
| public BigDecimal getId() { |
| getIdCallCount++; |
| return id; |
| } |
| |
| public String getLastName() { |
| return lastName; |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public Vector getManagedEmployees() { |
| return (Vector)managedEmployees.getValue(); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public IsolatedEmployee getManager() { |
| return (IsolatedEmployee)manager.getValue(); |
| } |
| |
| public Time[] getNormalHours() { |
| return normalHours; |
| } |
| |
| public IsolatedEmploymentPeriod getPeriod() { |
| return period; |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public Vector getPhoneNumbers() { |
| return (Vector)phoneNumbers.getValue(); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public Vector getProjects() { |
| return (Vector)projects.getValue(); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public Vector getResponsibilitiesList() { |
| return (Vector)responsibilitiesList.getValue(); |
| } |
| |
| public int getSalary() { |
| return salary; |
| } |
| |
| /** |
| * Return the first element of the Transformation mapped normalHours. |
| */ |
| public java.sql.Time getStartTime() { |
| return getNormalHours()[0]; |
| } |
| |
| /** |
| * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it. |
| */ |
| public void removeManagedEmployee(IsolatedEmployee employee) { |
| setChanged(); |
| getManagedEmployees().removeElement(employee); |
| employee.setManager(null); |
| } |
| |
| /** |
| * Remove the phone number. |
| * The phone number's owner must not be set to null as it is part of it primary key, |
| * and you can never change the primary key of an existing object. |
| * Only in independent relationships should you null out the back reference. |
| */ |
| public void removePhoneNumber(IsolatedPhoneNumber phoneNumber) { |
| setChanged(); |
| getPhoneNumbers().removeElement(phoneNumber); |
| } |
| |
| public void removeProject(org.eclipse.persistence.testing.models.employee.interfaces.Project project) { |
| setChanged(); |
| getProjects().removeElement(project); |
| } |
| |
| public void removeResponsibility(String responsibility) { |
| setChanged(); |
| getResponsibilitiesList().removeElement(responsibility); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public void setAddress(IsolatedAddress address) { |
| setChanged(); |
| this.address.setValue(address); |
| } |
| |
| /** |
| * Set the last element of the Transformation mapped normalHours. |
| */ |
| public void setEndTime(Time endTime) { |
| setChanged(); |
| getNormalHours()[1] = endTime; |
| } |
| |
| public void setFemale() { |
| setChanged(); |
| setGender("Female"); |
| } |
| |
| public void setFirstName(String firstName) { |
| setChanged(); |
| this.firstName = firstName; |
| } |
| |
| public void setGender(String gender) { |
| setChanged(); |
| this.gender = gender; |
| } |
| |
| /** |
| * For performance testing. |
| */ |
| public static void setGetIdCallCount(int value) { |
| IsolatedEmployee.getIdCallCount = value; |
| } |
| |
| /** |
| * Set the persistent identifier of the receiver. |
| * Note this should never be changed. |
| * Consider making the primary key set methods protected or not having them. |
| * In this demo the setId is required for testing purposes. |
| */ |
| public void setId(BigDecimal id) { |
| setChanged(); |
| this.id = id; |
| } |
| |
| public void setLastName(String lastName) { |
| setChanged(); |
| this.lastName = lastName; |
| } |
| |
| public void setMale() { |
| setChanged(); |
| setGender("Male"); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public void setManagedEmployees(Vector managedEmployees) { |
| setChanged(); |
| this.managedEmployees.setValue(managedEmployees); |
| } |
| |
| /** |
| * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it. |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public void setManager(IsolatedEmployee manager) { |
| setChanged(); |
| this.manager.setValue(manager); |
| } |
| |
| public void setNormalHours(Time[] normalHours) { |
| setChanged(); |
| this.normalHours = normalHours; |
| } |
| |
| public void setPeriod(IsolatedEmploymentPeriod period) { |
| setChanged(); |
| this.period = period; |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public void setPhoneNumbers(Vector phoneNumbers) { |
| setChanged(); |
| this.phoneNumbers.setValue(phoneNumbers); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public void setProjects(Vector projects) { |
| setChanged(); |
| this.projects.setValue(projects); |
| } |
| |
| /** |
| * Notice that the usage of value holders does not effect the public interface or usage of the class. |
| * The get/set methods must however be changed to wrap/unwrap the value holder. |
| */ |
| public void setResponsibilitiesList(Vector responsibilitiesList) { |
| setChanged(); |
| this.responsibilitiesList.setValue(responsibilitiesList); |
| } |
| |
| public void setSalary(int salary) { |
| setChanged(); |
| this.salary = salary; |
| } |
| |
| /** |
| * Set the first element of the Transformation mapped normalHours. |
| */ |
| public void setStartTime(Time startTime) { |
| setChanged(); |
| getNormalHours()[0] = startTime; |
| } |
| |
| /** |
| * Print the first & last name |
| */ |
| public String toString() { |
| StringWriter writer = new StringWriter(); |
| |
| writer.write("IsolatedEmployee: "); |
| writer.write(getFirstName()); |
| writer.write(" "); |
| writer.write(getLastName()); |
| return writer.toString(); |
| } |
| } |