| /* |
| * Copyright (c) 2013, 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: |
| // David McCann - 2.6.0 - July 09, 2013 - Initial Implementation |
| package org.eclipse.persistence.tools.metadata.generation; |
| |
| import static org.eclipse.persistence.platform.database.oracle.plsql.OraclePLSQLTypes.XMLType; |
| |
| import java.sql.Types; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.persistence.internal.core.helper.CoreClassConstants; |
| import org.eclipse.persistence.internal.databaseaccess.DatabasePlatform; |
| import org.eclipse.persistence.internal.helper.ClassConstants; |
| import org.eclipse.persistence.tools.oracleddl.metadata.DatabaseType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.FieldType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.NumericType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLCursorType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ProcedureType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.SizedType; |
| |
| /** |
| * Utility class typically used when constructing JPA/JAXB metadata from a |
| * list of meta-model database types. |
| * |
| */ |
| public class Util { |
| public static final String ARRAY_STR = "ARRAY"; |
| public static final String BIGINT_STR = "BIGINT"; |
| public static final String BINARY_STR = "BINARY"; |
| public static final String BLOB_STR = "BLOB"; |
| public static final String BOOLEAN_STR = "BOOLEAN"; |
| public static final String CHAR_STR = "CHAR"; |
| public static final String CLOB_STR = "CLOB"; |
| public static final String DATE_STR = "DATE"; |
| public static final String DECIMAL_STR = "DECIMAL"; |
| public static final String DOUBLE_STR = "DOUBLE"; |
| public static final String FLOAT_STR = "FLOAT"; |
| public static final String INTEGER_STR = "INTEGER"; |
| public static final String LONG_STR = "LONG"; |
| public static final String LONGRAW_STR = "LONG RAW"; |
| public static final String LONGVARBINARY_STR = "LONGVARBINARY"; |
| public static final String NCHAR_STR = "NCHAR"; |
| public static final String NCLOB_STR = "NCLOB"; |
| public static final String NUMBER_STR = "NUMBER"; |
| public static final String NUMERIC_STR = "NUMERIC"; |
| public static final String NVARCHAR_STR = "NVARCHAR"; |
| public static final String NVARCHAR2_STR = "NVARCHAR2"; |
| public static final String OTHER_STR = "OTHER"; |
| public static final String RAW_STR = "RAW"; |
| public static final String REAL_STR = "REAL"; |
| public static final String ROWID_STR = "ROWID"; |
| public static final String ROWTYPE_STR = "%ROWTYPE"; |
| public static final String SMALLINT_STR = "SMALLINT"; |
| public static final String STRUCT_STR = "STRUCT"; |
| public static final String TIME_STR = "TIME"; |
| public static final String TIMESTAMP_STR = "TIMESTAMP"; |
| public static final String TINYINT_STR = "TINYINT"; |
| public static final String UROWID_STR = "UROWID"; |
| public static final String VARBINARY_STR = "VARBINARY"; |
| public static final String VARCHAR_STR = "VARCHAR"; |
| public static final String VARCHAR2_STR = "VARCHAR2"; |
| public static final String BINARY_INTEGER_STR = "BINARY_INTEGER"; |
| public static final String PLS_INTEGER_STR = "PLS_INTEGER"; |
| public static final String NATURAL_STR = "NATURAL"; |
| public static final String POSITIVE_STR = "POSITIVE"; |
| public static final String SIGNTYPE_STR = "SIGNTYPE"; |
| public static final String BINARY_INTEGER_TYPE_STR = "BinaryInteger"; |
| public static final String PLS_BOOLEAN_TYPE_STR = "PLSQLBoolean"; |
| public static final String PLS_INTEGER_TYPE_STR = "PLSQLInteger"; |
| public static final String NATURAL_TYPE_STR = "Natural"; |
| public static final String POSITIVE_TYPE_STR = "Positive"; |
| public static final String SIGNTYPE_TYPE_STR = "SignType"; |
| |
| public static final String SYS_XMLTYPE_STR = "SYS.XMLTYPE"; |
| public static final String XMLTYPE_STR = "XMLTYPE"; |
| public static final String _TYPE_STR = "_TYPE"; |
| |
| public static final String COMMA = ","; |
| public static final String SINGLE_SPACE = " "; |
| public static final String COMMA_SPACE_STR = COMMA + SINGLE_SPACE; |
| |
| // for CRUD operations |
| public static final String ALL_QUERYNAME = "findAll"; |
| public static final String PK_QUERYNAME = "findByPrimaryKey"; |
| public static final String CREATE_OPERATION_NAME = "create"; |
| public static final String UPDATE_OPERATION_NAME = "update"; |
| public static final String REMOVE_OPERATION_NAME = "delete"; |
| public static final String OPEN_BRACKET = "("; |
| public static final String CLOSE_BRACKET = ")"; |
| public static final String TYPE_STR = "Type"; |
| public static final String SELECT_FROM_STR = "SELECT * FROM "; |
| public static final String WHERE_STR = " WHERE "; |
| public static final String AND_STR = " AND "; |
| public static final String SET_STR = " SET "; |
| public static final String VALUES_STR = " VALUES "; |
| public static final String UPDATE_STR = "UPDATE "; |
| public static final String INSERT_STR = "INSERT INTO "; |
| public static final String DELETE_STR = "DELETE FROM "; |
| public static final String EQUALS_BINDING1_STR = " = ?1"; |
| public static final String EQUALS_BINDING_STR = " = ?"; |
| public static final String QUESTION_STR = "?"; |
| |
| |
| // SQL class names |
| public static final String ARRAY_CLS_STR = "java.sql.Array"; |
| public static final String NCLOB_CLS_STR = "java.sql.NClob"; |
| public static final String OPAQUE_CLS_STR = "java.sql.Struct"; |
| public static final String ROWID_CLS_STR = "java.sql.RowId"; |
| public static final String STRUCT_CLS_STR = "oracle.sql.OPAQUE"; |
| public static final String ORACLE_TIMESTAMP_CLS_STR = "oracle.sql.TIMESTAMP"; |
| |
| // JDK class names |
| static final String ARRAYLIST_CLS_STR = "java.util.ArrayList"; |
| |
| // direction types |
| static final String IN_STR = "IN"; |
| static final String INOUT_STR = "IN_OUT"; |
| static final String OUT_STR = "OUT"; |
| static final String OUT_CURSOR_STR = "OUT_CURSOR"; |
| static final String CURSOR_STR = "CURSOR"; |
| static final String RESULT_STR = "RESULT"; |
| |
| // misc |
| public static final String DOT = "."; |
| public static final String PERCENT = "%"; |
| public static final String UNDERSCORE = "_"; |
| |
| public static final String ITEMS_FLD_STR = "items"; |
| public static final String ITEMS_COL_STR = "ITEMS"; |
| |
| public static final int OPAQUE = 2007; |
| |
| /** |
| * Returns a unqualified entity class name based on a given table or type name. |
| * The returned string will contain an upper case first char, with the |
| * remaining chars in lower case format. |
| */ |
| public static String getUnqualifiedEntityName(String tableName) { |
| String first = tableName.substring(0, 1).toUpperCase(); |
| String rest = tableName.toLowerCase().substring(1); |
| return first.concat(rest); |
| } |
| |
| /** |
| * Returns a entity class name based on a given table or type name. The returned |
| * string will contain an upper case first char, with the remaining chars in |
| * lower case format. The packageName will be prepended to the Entity name |
| * if non-null. |
| */ |
| public static String getEntityName(String tableName, String packageName) { |
| String entityName = getUnqualifiedEntityName(tableName); |
| return packageName == null ? entityName : packageName + DOT + entityName; |
| } |
| |
| /** |
| * Return the JDBC type name for a given type String. |
| */ |
| public static String getJDBCTypeName(String typeName) { |
| // this is inefficient and should be rewritten such that checking is done once only |
| return getJDBCTypeNameFromType(getJDBCTypeFromTypeName(typeName)); |
| } |
| |
| /** |
| * Return the JDBC type (as int) for a given type name. |
| */ |
| public static int getJDBCTypeFromTypeName(String typeName) { |
| if (typeName.equals(NUMERIC_STR)) { |
| return Types.NUMERIC; |
| } |
| if (typeName.equals(VARCHAR_STR) || typeName.equals(VARCHAR2_STR)) { |
| return Types.VARCHAR; |
| } |
| if (typeName.equals(NVARCHAR_STR) || typeName.equals(NVARCHAR2_STR)) { |
| return Types.NVARCHAR; |
| } |
| if (typeName.equals(DATE_STR)) { |
| return Types.DATE; |
| } |
| if (typeName.equals(TIME_STR)) { |
| return Types.TIME; |
| } |
| if (typeName.equals(TIMESTAMP_STR)) { |
| return Types.TIMESTAMP; |
| } |
| if (typeName.equals(DECIMAL_STR)) { |
| return Types.DECIMAL; |
| } |
| if (typeName.equals(INTEGER_STR)) { |
| return Types.INTEGER; |
| } |
| if (typeName.equals(CHAR_STR)) { |
| return Types.CHAR; |
| } |
| if (typeName.equals(NCHAR_STR)) { |
| return Types.NCHAR; |
| } |
| if (typeName.equals(FLOAT_STR)) { |
| return Types.FLOAT; |
| } |
| if (typeName.equals(REAL_STR)) { |
| return Types.REAL; |
| } |
| if (typeName.equals(DOUBLE_STR)) { |
| return Types.DOUBLE; |
| } |
| if (typeName.equals(BINARY_STR)) { |
| return Types.BINARY; |
| } |
| if (typeName.equals(BLOB_STR)) { |
| return Types.BLOB; |
| } |
| if (typeName.equals(CLOB_STR) || |
| typeName.equals(LONG_STR)) { |
| return Types.CLOB; |
| } |
| if (typeName.equals(NCLOB_STR)) { |
| return Types.NCLOB; |
| } |
| if (typeName.equals(RAW_STR) || |
| typeName.equals(LONGRAW_STR)) { |
| return Types.LONGVARBINARY; |
| } |
| if (typeName.equals(ROWID_STR)) { |
| return Types.VARCHAR; |
| } |
| if (typeName.equals(UROWID_STR)) { |
| return Types.VARCHAR; |
| } |
| if (typeName.equals(BIGINT_STR)) { |
| return Types.BIGINT; |
| } |
| if (typeName.equals(STRUCT_STR)) { |
| return Types.STRUCT; |
| } |
| if (typeName.equals(ARRAY_STR)) { |
| return Types.ARRAY; |
| } |
| if (typeName.equals(ROWID_STR)) { |
| return Types.ROWID; |
| } |
| if (typeName.equalsIgnoreCase(XMLTYPE_STR) || |
| typeName.equalsIgnoreCase(SYS_XMLTYPE_STR)) { |
| return Types.VARCHAR; |
| } |
| if (typeName.equals(BOOLEAN_STR) || |
| typeName.equals(INTEGER_STR) || |
| typeName.equals(SMALLINT_STR) || |
| typeName.equals(TINYINT_STR)) { |
| return Types.INTEGER; |
| } |
| return Types.OTHER; |
| } |
| |
| /** |
| * Return the JDBC type name for a given JDBC type code. |
| */ |
| public static String getJDBCTypeNameFromType(int jdbcType) { |
| String typeName = null; |
| switch (jdbcType) { |
| case Types.NUMERIC: |
| typeName = NUMERIC_STR; |
| break; |
| case Types.VARCHAR: |
| typeName = VARCHAR_STR; |
| break; |
| case Types.NVARCHAR: |
| typeName = NVARCHAR_STR; |
| break; |
| case Types.DECIMAL: |
| typeName = DECIMAL_STR; |
| break; |
| case Types.CHAR: |
| typeName = CHAR_STR; |
| break; |
| case Types.NCHAR: |
| typeName = NCHAR_STR; |
| break; |
| case Types.FLOAT: |
| typeName = FLOAT_STR; |
| break; |
| case Types.REAL: |
| typeName = REAL_STR; |
| break; |
| case Types.DOUBLE: |
| typeName = DOUBLE_STR; |
| break; |
| case Types.BINARY: |
| typeName = BINARY_STR; |
| break; |
| case Types.BLOB: |
| typeName = BLOB_STR; |
| break; |
| case Types.CLOB: |
| typeName = CLOB_STR; |
| break; |
| case Types.NCLOB: |
| typeName = NCLOB_STR; |
| break; |
| case Types.VARBINARY : |
| typeName = LONGVARBINARY_STR; |
| break; |
| case Types.LONGVARBINARY: |
| typeName = LONGVARBINARY_STR; |
| break; |
| case Types.DATE: |
| typeName = DATE_STR; |
| break; |
| case Types.TIME: |
| typeName = TIME_STR; |
| break; |
| case Types.TIMESTAMP: |
| typeName = TIMESTAMP_STR; |
| break; |
| case Types.BIGINT: |
| typeName = BIGINT_STR; |
| break; |
| case Types.ARRAY: |
| typeName = ARRAY_STR; |
| break; |
| case Types.STRUCT: |
| typeName = STRUCT_STR; |
| break; |
| case Types.ROWID: |
| typeName = ROWID_STR; |
| break; |
| default: |
| typeName = OTHER_STR; |
| break; |
| } |
| return typeName; |
| } |
| |
| /** |
| * Return the Class name for a given type name using the provided DatabasePlatform. |
| * Object.class.getName() will be returned if the DatabasePlatform returns null. |
| */ |
| public static String getClassNameFromJDBCTypeName(String typeName, DatabasePlatform databasePlatform) { |
| return getClassFromJDBCTypeName(typeName, databasePlatform).getName(); |
| } |
| |
| /** |
| * Return the Class for a given type name using the provided DatabasePlatform. Object.class will |
| * be returned if the DatabasePlatform returns null. |
| */ |
| public static Class<?> getClassFromJDBCTypeName(String typeName, DatabasePlatform databasePlatform) { |
| Class<?> clz = databasePlatform.getClassTypes().get(typeName); |
| if (clz == null) { |
| return CoreClassConstants.OBJECT; |
| } |
| return clz; |
| } |
| |
| /** |
| * Alter the given type name if required. |
| */ |
| protected static String processTypeName(String typeName) { |
| if (!(getJDBCTypeFromTypeName(typeName) == Types.OTHER)) { |
| if (typeName.equals(XMLTYPE_STR)) { |
| typeName = XMLType.name(); |
| } else { |
| // OR Metadata doesn't handle VARCHAR2 |
| if (typeName.equals(VARCHAR2_STR)) { |
| typeName = VARCHAR_STR; |
| } |
| // for BOOLEAN we want to wrap the type in a PLSQLrecord (in ORMetadata.getDatabaseTypeEnum) to |
| // force the appropriate conversion method in PLSQLStoredProcedureCall (declare block, etc) |
| if (!typeName.equals(BOOLEAN_STR)) { |
| typeName = typeName.concat(_TYPE_STR); |
| } |
| } |
| } else { |
| String oPLSQLTypeName = getOraclePLSQLTypeForName(typeName); |
| if (oPLSQLTypeName != null) { |
| typeName = oPLSQLTypeName; |
| } |
| } |
| return typeName; |
| } |
| |
| /** |
| * Returns a Java class name based on a given qualified name. If the name has |
| * a package prepended to it, the the returned string will be in the format |
| * 'packagename.Name', otherwise the format will be 'Name'. For example, given |
| * the name 'test.EMPLOYEE', the method would return the string 'test.Employee'. |
| * |
| */ |
| public static String getGeneratedJavaClassName(String name) { |
| int dotIdx = name.lastIndexOf(DOT); |
| if (dotIdx == -1) { |
| // no package |
| return getGeneratedJavaClassName(name, null); |
| } |
| String packageName = name.substring(0, dotIdx).toLowerCase(); |
| String typeName = name.substring(dotIdx + 1); |
| String first = typeName.substring(0, 1).toUpperCase(); |
| String rest = typeName.toLowerCase().substring(1); |
| return packageName + DOT + first + rest; |
| } |
| |
| /** |
| * Returns a Java class name based on a given name and package. The returned |
| * string will be in the format 'packagename.Name'. For example, given |
| * the name 'EMPLOYEE' and packageName 'TEST', the method would return the |
| * string 'test.Employee'. |
| * |
| */ |
| public static String getGeneratedJavaClassName(String name, String packageName) { |
| String first = name.substring(0, 1).toUpperCase(); |
| String rest = name.toLowerCase().substring(1); |
| return packageName == null || packageName.length() == 0 ? first + rest : packageName.toLowerCase() + DOT + first + rest; |
| } |
| |
| /** |
| * Return a qualified type name for the given DatabaseType. If the type is a |
| * PLSQLType or a PLSQLCursor, and there is a package name available on the |
| * type's parent, a string will be returned in the format 'package.typename'. |
| * Otherwise the type name will be returned. |
| */ |
| public static String getQualifiedTypeName(DatabaseType dbType) { |
| if (dbType.isPLSQLType()) { |
| String packageName = ((PLSQLType) dbType).getParentType().getPackageName(); |
| // for %ROWTYPE we build a record with no package name - need to check for null |
| return packageName != null ? packageName + DOT + dbType.getTypeName() : dbType.getTypeName(); |
| } |
| |
| if (dbType.isPLSQLCursorType()) { |
| // handle cursor |
| PLSQLCursorType cursor = ((PLSQLCursorType) dbType); |
| return cursor.getParentType().getPackageName() + DOT + cursor.getCursorName(); |
| } |
| |
| return dbType.getTypeName(); |
| } |
| |
| /** |
| * Return a qualified compatible type name for the given DatabaseType. If the type is a |
| * PLSQLType, and there is a package name available on the type's parent, a string will |
| * be returned in the format 'package_typename'. Otherwise the type name will be |
| * returned. A compatible type is the JDBC type equivalent of a PL/SQL type. |
| */ |
| public static String getQualifiedCompatibleTypeName(DatabaseType dbType) { |
| String packageName = null; |
| |
| if (dbType.isPLSQLType()) { |
| PLSQLType plsqlType = (PLSQLType) dbType; |
| packageName = plsqlType.getParentType().getPackageName(); |
| } |
| |
| return packageName != null ? packageName + UNDERSCORE + dbType.getTypeName() : dbType.getTypeName(); |
| } |
| |
| |
| /** |
| * Indicates if a given argument type name is considered a PL/SQL scalar |
| * argument, i.e. is one of BOOLEAN, BINARY_INTEGER, PLS_INTEGER, etc. |
| */ |
| public static boolean isArgPLSQLScalar(String argTypeName) { |
| return argTypeName.equals("BOOLEAN") |
| || argTypeName.equals("PLS_INTEGER") |
| || argTypeName.equals("BINARY_INTEGER") |
| || argTypeName.equals("NATURAL") |
| || argTypeName.equals("POSITIVE") |
| || argTypeName.equals("SIGNTYPE"); |
| } |
| |
| /** |
| * Return the Oracle PL/SQL name for a given PL/SQL scalar type. |
| */ |
| public static String getOraclePLSQLTypeForName(String typeName) { |
| if (typeName.equals(BINARY_INTEGER_STR)) |
| return BINARY_INTEGER_TYPE_STR; |
| if (typeName.equals(BOOLEAN_STR)) |
| return PLS_BOOLEAN_TYPE_STR; |
| if (typeName.equals(PLS_INTEGER_STR)) |
| return PLS_INTEGER_TYPE_STR; |
| if (typeName.equals(NATURAL_STR)) |
| return NATURAL_TYPE_STR; |
| if (typeName.equals(POSITIVE_STR)) |
| return POSITIVE_TYPE_STR; |
| if (typeName.equals(SIGNTYPE_STR)) |
| return SIGNTYPE_TYPE_STR; |
| return null; |
| } |
| |
| /** |
| * Return the attribute-type name for a given FieldType. |
| * |
| * For CHAR sized type, java.lang.Character will be returned. |
| * For CHAR non-sized type, java.lang.String will be returned. |
| * For non-CHAR type, the database platform will be used to get the type name. |
| * If the type to be returned is oracle.sql.Timestamp, java.sql.Timestamp will be |
| * returned instead (to handle conversion issue with Oracle11Platform) |
| */ |
| protected static String getAttributeTypeNameForFieldType(FieldType fldType, DatabasePlatform dbPlatform) { |
| String typeName = getJDBCTypeName(fldType.getTypeName()); |
| String attributeType; |
| if (CHAR_STR.equalsIgnoreCase(typeName) && fldType.getEnclosedType().isSizedType()) { |
| SizedType sizedType = (SizedType) fldType.getEnclosedType(); |
| if (sizedType.getSize() == 1) { |
| attributeType = ClassConstants.CHAR.getName(); |
| } else { |
| attributeType = ClassConstants.STRING.getName(); |
| } |
| } else { |
| attributeType = getClassNameFromJDBCTypeName(typeName.toUpperCase(), dbPlatform); |
| } |
| // handle issue with java.sql.Timestamp conversion and Oracle11 platform |
| if (attributeType.contains(ORACLE_TIMESTAMP_CLS_STR)) { |
| attributeType = ClassConstants.TIMESTAMP.getName(); |
| } else if (attributeType.contains(ClassConstants.ABYTE.getName())) { |
| attributeType = ClassConstants.APBYTE.getName(); |
| } |
| return attributeType; |
| } |
| |
| /** |
| * Return the type name to be used for a given database type. The given |
| * DatabaseType's typeName attribute is typically returned, however, in |
| * some cases special handling may be required. For example, in the |
| * case of a NumericType instance, "DECIMAL" should be used for the |
| * type name. |
| */ |
| protected static String getTypeNameForDatabaseType(DatabaseType dataType) { |
| String typeName = dataType.getTypeName(); |
| if (dataType.isNumericType()) { |
| NumericType numericDataType = (NumericType)dataType; |
| if (numericDataType.getScale() > 0) { |
| typeName = DECIMAL_STR; |
| } |
| } |
| return typeName; |
| } |
| |
| /** |
| * Convenience method that detects multiple procedures with the same procedure |
| * name, and updates the overload value on the relevant ProcedureTypes |
| * accordingly. |
| * |
| * The first ProcedureType will have an overload value of 0, the second 1, |
| * and so on. |
| */ |
| protected static void handleOverloading(List<ProcedureType> procedures) { |
| Map<String, List<ProcedureType>> overloadMap = new HashMap<String, List<ProcedureType>>(); |
| for (ProcedureType procedure : procedures) { |
| String procedureName = procedure.getProcedureName(); |
| List<ProcedureType> multipleProcedures = overloadMap.get(procedureName); |
| if (multipleProcedures == null) { |
| multipleProcedures = new ArrayList<ProcedureType>(); |
| overloadMap.put(procedureName, multipleProcedures); |
| } |
| multipleProcedures.add(procedure); |
| } |
| for (List<ProcedureType> procs : overloadMap.values()) { |
| if (procs.size() > 1) { |
| for (int i = 0, len = procs.size(); i < len; i++) { |
| procs.get(i).setOverload(i); |
| } |
| } |
| } |
| |
| } |
| } |
