| /* |
| * 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: |
| // Mike Norman: Jan 2012 - Initial implementation |
| package org.eclipse.persistence.tools.dbws.oracle; |
| |
| import static org.eclipse.persistence.internal.helper.Helper.NL; |
| import static org.eclipse.persistence.tools.dbws.Util.COMMA; |
| import static org.eclipse.persistence.tools.dbws.Util.FLOAT_STR; |
| import static org.eclipse.persistence.tools.dbws.Util.INTEGER_STR; |
| import static org.eclipse.persistence.tools.dbws.Util.NUMERIC_STR; |
| import static org.eclipse.persistence.tools.dbws.Util.OTHER_STR; |
| import static org.eclipse.persistence.tools.dbws.Util.PERCENT; |
| import static org.eclipse.persistence.tools.dbws.Util.SEMICOLON; |
| import static org.eclipse.persistence.tools.dbws.Util.SINGLE_SPACE; |
| import static org.eclipse.persistence.tools.dbws.Util.UNDERSCORE; |
| import static org.eclipse.persistence.tools.dbws.Util.getJDBCTypeFromTypeName; |
| import static org.eclipse.persistence.tools.dbws.Util.getJDBCTypeNameFromType; |
| |
| //javase imports |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Stack; |
| |
| //EclipseLink imports |
| import org.eclipse.persistence.tools.oracleddl.metadata.CharType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.CompositeDatabaseTypeWithEnclosedType; |
| 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.PLSQLCollectionType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLPackageType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLRecordType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PrecisionType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ROWTYPEType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.RawType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum; |
| import org.eclipse.persistence.tools.oracleddl.metadata.SizedType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.TYPEType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.TableType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.VarChar2Type; |
| import org.eclipse.persistence.tools.oracleddl.metadata.VarCharType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.visit.BaseDatabaseTypeVisitor; |
| |
| public class ShadowDDLGenerator { |
| |
| static final String ROWTYPE_PREFIX = "_ROWTYPE_SQL"; |
| |
| protected PLSQLPackageType plsqlPackageType; |
| protected Map<String, Integer> rowTYPETypeCounts; |
| protected Map<CompositeDatabaseTypeWithEnclosedType, DDLWrapper> createDDLs = |
| new HashMap<CompositeDatabaseTypeWithEnclosedType, DDLWrapper>(); |
| protected Map<CompositeDatabaseTypeWithEnclosedType, DDLWrapper> dropDDLs = |
| new HashMap<CompositeDatabaseTypeWithEnclosedType, DDLWrapper>(); |
| |
| public ShadowDDLGenerator(PLSQLPackageType plsqlPackageType) { |
| this.plsqlPackageType = plsqlPackageType; |
| //count all the %ROWTYPE's and assign unique number |
| CountROWTYPETypesVisitor countVisitor = new CountROWTYPETypesVisitor(); |
| plsqlPackageType.accept(countVisitor); |
| rowTYPETypeCounts = countVisitor.getRowTYPETypeCounts(); |
| // visit all the PLSQLType's |
| DDLWrapperGeneratorVisitor generatorVisitor = new DDLWrapperGeneratorVisitor(); |
| plsqlPackageType.accept(generatorVisitor); |
| } |
| |
| public String getCreateDDLFor(CompositeDatabaseTypeWithEnclosedType dType) { |
| return createDDLs.get(dType).ddl; |
| } |
| public List<String> getAllCreateDDLs() { |
| List<String> allDDLs = new ArrayList<String>(); |
| for (Map.Entry<CompositeDatabaseTypeWithEnclosedType, DDLWrapper> me : createDDLs.entrySet()) { |
| allDDLs.add(me.getValue().ddl); |
| } |
| return allDDLs; |
| } |
| |
| public String getDropDDLFor(CompositeDatabaseTypeWithEnclosedType dType) { |
| return dropDDLs.get(dType).ddl; |
| } |
| public List<String> getAllDropDDLs() { |
| List<String> allDDLs = new ArrayList<String>(); |
| for (Map.Entry<CompositeDatabaseTypeWithEnclosedType, DDLWrapper> me : dropDDLs.entrySet()) { |
| allDDLs.add(me.getValue().ddl); |
| } |
| return allDDLs; |
| } |
| |
| protected String getShadowROWTYPETypeName(ROWTYPEType rowTYPEType) { |
| return rowTYPEType.getTypeName().replace(PERCENT, UNDERSCORE); |
| } |
| |
| static class CountROWTYPETypesVisitor extends BaseDatabaseTypeVisitor { |
| Map<String, Integer> rowTYPETypeCounts = new HashMap<String, Integer>(); |
| int initialRowTYPETypeCount = 0; |
| @Override |
| public void beginVisit(ROWTYPEType rowTYPEType) { |
| Integer rowTYPETypeCount = rowTYPETypeCounts.get(rowTYPEType.getTypeName()); |
| if (rowTYPETypeCount == null) { |
| rowTYPETypeCounts.put(rowTYPEType.getTypeName(), initialRowTYPETypeCount++); |
| } |
| } |
| public Map<String, Integer> getRowTYPETypeCounts() { |
| return rowTYPETypeCounts; |
| } |
| } |
| |
| class DDLWrapperGeneratorVisitor extends BaseDatabaseTypeVisitor { |
| static final String COR_TYPE = "CREATE OR REPLACE TYPE "; |
| static final String DROP_TYPE = "DROP TYPE "; |
| static final String FORCE = " FORCE"; |
| static final String LBRACKET = "("; |
| static final String RBRACKET = ")"; |
| static final String SPACES = " "; |
| static final String AS_OBJECT = " AS OBJECT ("; |
| static final String AS_TABLE_OF = " AS TABLE OF "; |
| static final String END_OBJECT = "\n);"; |
| static final String NUMBER_STR = "NUMBER"; |
| static final String ROWID_STR = "VARCHAR2(256)"; |
| static final String NUMBER_DEFAULTSIZE = "38"; |
| static final String FLOAT_DEFAULTSIZE = "63"; |
| static final String DOUBLE_DEFAULTSIZE = "126"; |
| static final String LONG_DEFAULTSIZE = "32760"; |
| protected Stack<PLSQLRecordType> recordTypes = new Stack<PLSQLRecordType>(); |
| protected Stack<ROWTYPEType> rowTYPETypes = new Stack<ROWTYPEType>(); |
| @Override |
| public void beginVisit(PLSQLRecordType recordType) { |
| if (recordTypes.isEmpty()) { |
| recordTypes.push(recordType); |
| } |
| else if (!recordTypes.peek().equals(recordType)) { |
| recordTypes.push(recordType); |
| } |
| DDLWrapper ddlWrapper = createDDLs.get(recordType); |
| if (ddlWrapper == null) { |
| ddlWrapper = new DDLWrapper(); |
| ddlWrapper.ddl = COR_TYPE + recordType.getParentType().getPackageName() + UNDERSCORE + |
| recordType.getTypeName().toUpperCase() + AS_OBJECT; |
| createDDLs.put(recordType, ddlWrapper); |
| } |
| } |
| @Override |
| public void endVisit(PLSQLRecordType recordType) { |
| recordTypes.pop(); |
| DDLWrapper ddlWrapper = createDDLs.get(recordType); |
| if (ddlWrapper != null && !ddlWrapper.finished) { |
| ddlWrapper.ddl += END_OBJECT; |
| ddlWrapper.finished = true; |
| } |
| ddlWrapper = dropDDLs.get(recordType); |
| if (ddlWrapper == null) { |
| ddlWrapper = new DDLWrapper(); |
| ddlWrapper.ddl = DROP_TYPE + recordType.getParentType().getPackageName() + UNDERSCORE + |
| recordType.getTypeName().toUpperCase() + FORCE + SEMICOLON; |
| ddlWrapper.finished = true; |
| dropDDLs.put(recordType, ddlWrapper); |
| } |
| } |
| @Override |
| public void beginVisit(FieldType fieldType) { |
| //skip fields from ObjectType's |
| if (!recordTypes.isEmpty()) { |
| PLSQLRecordType currentRecordType = recordTypes.peek(); |
| if (currentRecordType != null) { |
| DDLWrapper ddlWrapper = createDDLs.get(currentRecordType); |
| if (!ddlWrapper.finished) { |
| String fieldName = fieldType.getFieldName(); |
| for (int i = 0, len = currentRecordType.getFields().size(); i < len; i++) { |
| FieldType f = currentRecordType.getFields().get(i); |
| if (fieldName.equals(f.getFieldName())) { |
| ddlWrapper.ddl += SPACES + fieldName + SINGLE_SPACE; |
| DatabaseType fieldDataType = f.getEnclosedType(); |
| String fieldShadowName = null; |
| if (fieldDataType.isPLSQLType()) { |
| fieldShadowName = ((PLSQLType)fieldDataType).getParentType(). |
| getPackageName() + UNDERSCORE + fieldDataType. |
| getTypeName().toUpperCase(); |
| } else if (fieldDataType.isTYPEType()) { |
| fieldShadowName = getShadowTypeName(fieldDataType); |
| TYPEType tType = (TYPEType) fieldDataType; |
| if (tType.getEnclosedType().isFieldType()) { |
| FieldType fType = (FieldType) tType.getEnclosedType(); |
| if (fType.getEnclosedType().isPrecisionType()) { |
| PrecisionType pType = (PrecisionType) fType.getEnclosedType(); |
| long precision = pType.getPrecision(); |
| if (precision != pType.getDefaultPrecision()) { |
| long scale = pType.getScale(); |
| if (scale != 0) { |
| fieldShadowName = fieldShadowName + LBRACKET + precision + COMMA + scale + RBRACKET; |
| } else { |
| fieldShadowName = fieldShadowName + LBRACKET + precision + RBRACKET; |
| } |
| } |
| } else if (fType.getEnclosedType().isSizedType()) { |
| SizedType sType = (SizedType) fType.getEnclosedType(); |
| fieldShadowName = fieldShadowName + LBRACKET + sType.getSize() + RBRACKET; |
| } |
| } |
| } else { |
| fieldShadowName = getShadowTypeName(fieldDataType); |
| } |
| ddlWrapper.ddl += fieldShadowName; |
| if (i < len -1) { |
| ddlWrapper.ddl += COMMA + NL; |
| } |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| @Override |
| public void beginVisit(PLSQLCollectionType collectionType) { |
| DDLWrapper ddlWrapper = createDDLs.get(collectionType); |
| if (ddlWrapper == null) { |
| ddlWrapper = new DDLWrapper(); |
| } |
| if (!ddlWrapper.finished) { |
| String shadowNestedTypeName = null; |
| DatabaseType nestedType = collectionType.getEnclosedType(); |
| if (nestedType.isNumericType()) { |
| NumericType nDataType = (NumericType)nestedType; |
| if (nDataType.isNumberSynonym()) { |
| shadowNestedTypeName = NUMBER_STR; |
| } |
| else { |
| shadowNestedTypeName = NUMERIC_STR; |
| } |
| PrecisionType pDataType = (PrecisionType)nestedType; |
| long defaultPrecision = pDataType.getDefaultPrecision(); |
| long precision = pDataType.getPrecision(); |
| long scale = pDataType.getScale(); |
| if (precision != defaultPrecision) { |
| shadowNestedTypeName += LBRACKET + precision; |
| if (scale != 0) { |
| shadowNestedTypeName += COMMA + SINGLE_SPACE + scale; |
| } |
| shadowNestedTypeName += RBRACKET; |
| } |
| } |
| else { |
| shadowNestedTypeName = getShadowTypeName(nestedType); |
| } |
| ddlWrapper.ddl = COR_TYPE + collectionType.getParentType().getPackageName() + |
| UNDERSCORE + collectionType.getTypeName().toUpperCase() + AS_TABLE_OF + |
| shadowNestedTypeName + SEMICOLON; |
| ddlWrapper.finished = true; |
| createDDLs.put(collectionType, ddlWrapper); |
| } |
| } |
| @Override |
| public void endVisit(PLSQLCollectionType collectionType) { |
| DDLWrapper ddlWrapper = new DDLWrapper(); |
| ddlWrapper.ddl = DROP_TYPE + collectionType.getParentType().getPackageName() + UNDERSCORE + |
| collectionType.getTypeName().toUpperCase() + FORCE + SEMICOLON; |
| ddlWrapper.finished = true; |
| dropDDLs.put(collectionType, ddlWrapper); |
| } |
| @Override |
| public void beginVisit(ROWTYPEType rowTYPEType) { |
| if (rowTYPETypes.isEmpty()) { |
| rowTYPETypes.push(rowTYPEType); |
| } |
| else if (!rowTYPETypes.peek().equals(rowTYPEType)) { |
| rowTYPETypes.push(rowTYPEType); |
| } |
| DDLWrapper ddlWrapper = createDDLs.get(rowTYPEType); |
| if (ddlWrapper == null) { |
| ddlWrapper = new DDLWrapper(); |
| ddlWrapper.ddl = COR_TYPE + getShadowROWTYPETypeName(rowTYPEType) + AS_OBJECT; |
| //manually 'crawl' thru %ROWTYPE to TableType to columns and build up type fields |
| DatabaseType enclosedType = rowTYPEType.getEnclosedType(); |
| if (enclosedType.isTableType()) { |
| TableType tableType = (TableType)enclosedType; |
| ddlWrapper.ddl += NL; |
| for (int i = 0, len = tableType.getColumns().size(); i < len; i++) { |
| FieldType f = tableType.getColumns().get(i); |
| ddlWrapper.ddl += SPACES + f.getFieldName() + SINGLE_SPACE; |
| DatabaseType fieldDataType = f.getEnclosedType(); |
| String fieldShadowName = getShadowTypeName(fieldDataType); |
| ddlWrapper.ddl += fieldShadowName; |
| if (i < len -1) { |
| ddlWrapper.ddl += COMMA + NL; |
| } |
| } |
| createDDLs.put(rowTYPEType, ddlWrapper); |
| } |
| /* |
| else { |
| //Huh? a %ROWTYPE that points to something other than a TableType? |
| //ignore for now |
| } |
| */ |
| } |
| } |
| @Override |
| public void endVisit(ROWTYPEType rowTYPEType) { |
| rowTYPETypes.pop(); |
| DDLWrapper ddlWrapper = createDDLs.get(rowTYPEType); |
| if (ddlWrapper != null && !ddlWrapper.finished) { |
| ddlWrapper.ddl += END_OBJECT; |
| ddlWrapper.finished = true; |
| } |
| ddlWrapper = dropDDLs.get(rowTYPEType); |
| if (ddlWrapper == null) { |
| ddlWrapper = new DDLWrapper(); |
| ddlWrapper.ddl = DROP_TYPE + getShadowROWTYPETypeName(rowTYPEType) + FORCE + SEMICOLON; |
| ddlWrapper.finished = true; |
| dropDDLs.put(rowTYPEType, ddlWrapper); |
| } |
| } |
| |
| protected String getShadowTypeName(DatabaseType dataType ) { |
| String shadowTypeName = null; |
| if (dataType == ScalarDatabaseTypeEnum.INTEGER_TYPE || |
| dataType == ScalarDatabaseTypeEnum.SMALLINT_TYPE) { |
| shadowTypeName = NUMBER_STR + LBRACKET + NUMBER_DEFAULTSIZE + RBRACKET; |
| } |
| else if (dataType == ScalarDatabaseTypeEnum.BINARY_INTEGER_TYPE || |
| dataType == ScalarDatabaseTypeEnum.BOOLEAN_TYPE || |
| dataType == ScalarDatabaseTypeEnum.NATURAL_TYPE || |
| dataType == ScalarDatabaseTypeEnum.PLS_INTEGER_TYPE || |
| dataType == ScalarDatabaseTypeEnum.POSITIVE_TYPE || |
| dataType == ScalarDatabaseTypeEnum.SIGN_TYPE || |
| dataType == ScalarDatabaseTypeEnum.SIMPLE_INTEGER_TYPE) { |
| shadowTypeName = INTEGER_STR; |
| } |
| else if (dataType == ScalarDatabaseTypeEnum.ROWID_TYPE) { |
| shadowTypeName = ROWID_STR; |
| } |
| else if (dataType == ScalarDatabaseTypeEnum.SIMPLE_DOUBLE_TYPE) { |
| shadowTypeName = ScalarDatabaseTypeEnum.BINARY_DOUBLE_TYPE.getTypeName(); |
| } |
| else if (dataType == ScalarDatabaseTypeEnum.SIMPLE_FLOAT_TYPE) { |
| shadowTypeName = ScalarDatabaseTypeEnum.BINARY_FLOAT_TYPE.getTypeName(); |
| } |
| else if (dataType.isPrecisionType()) { |
| PrecisionType pDataType = (PrecisionType)dataType; |
| long defaultPrecision = pDataType.getDefaultPrecision(); |
| String defaultPrecisionStr = NUMBER_DEFAULTSIZE; |
| if (dataType.isNumericType() || dataType.isDecimalType()) { |
| shadowTypeName = NUMBER_STR; |
| } |
| else { |
| shadowTypeName = FLOAT_STR; |
| defaultPrecisionStr = FLOAT_DEFAULTSIZE; |
| if (dataType.isFloatType() || dataType.isDoubleType()) { |
| defaultPrecisionStr = DOUBLE_DEFAULTSIZE; |
| } |
| } |
| if (!(dataType.isNumericType() && ((NumericType)dataType).isNumberSynonym())) { |
| long precision = pDataType.getPrecision(); |
| long scale = pDataType.getScale(); |
| if (precision != defaultPrecision) { |
| shadowTypeName += LBRACKET + precision; |
| if (scale != 0) { |
| shadowTypeName += COMMA + SINGLE_SPACE + scale; |
| } |
| } |
| else { |
| shadowTypeName += LBRACKET + defaultPrecisionStr; |
| } |
| shadowTypeName += RBRACKET; |
| } |
| } |
| else if (dataType.isVarCharType()) { |
| shadowTypeName = VarChar2Type.TYPENAME; |
| VarCharType vcharType = (VarCharType)dataType; |
| long defaultSize = vcharType.getDefaultSize(); |
| long size = vcharType.getSize(); |
| String sizeStr = Long.toString(size); |
| if (dataType.isLongType()) { |
| shadowTypeName = VarChar2Type.TYPENAME; |
| if (size == defaultSize) { |
| sizeStr = LONG_DEFAULTSIZE; |
| } |
| } |
| shadowTypeName += LBRACKET + sizeStr + RBRACKET; |
| } |
| else if (dataType.isCharType()) { |
| shadowTypeName = CharType.TYPENAME; |
| long size = ((CharType)dataType).getSize(); |
| shadowTypeName += LBRACKET + size + RBRACKET; |
| } |
| else if (dataType.isSizedType()) { |
| shadowTypeName = dataType.getTypeName(); |
| SizedType sDataType = (SizedType)dataType; |
| long defaultSize = sDataType.getDefaultSize(); |
| String sizeStr = null; |
| long size = sDataType.getSize(); |
| if (dataType.isLongType()) { |
| shadowTypeName = VarChar2Type.TYPENAME; |
| if (size == defaultSize) { |
| sizeStr = LONG_DEFAULTSIZE; |
| } |
| else { |
| sizeStr = Long.toString(size); |
| } |
| shadowTypeName += LBRACKET + sizeStr + RBRACKET; |
| } |
| else if (dataType.isLongRawType()) { |
| shadowTypeName = RawType.TYPENAME; |
| if (size == defaultSize) { |
| sizeStr = LONG_DEFAULTSIZE; |
| } |
| else { |
| sizeStr = Long.toString(size); |
| } |
| shadowTypeName += LBRACKET + sizeStr + RBRACKET; |
| } |
| else if (size != defaultSize) { |
| shadowTypeName += LBRACKET + size + RBRACKET; |
| } |
| } |
| else if (dataType.isPLSQLType()) { |
| shadowTypeName = ((PLSQLType)dataType).getParentType().getPackageName() + |
| UNDERSCORE + dataType.getTypeName(); |
| } |
| else { |
| String typeName = dataType.getTypeName(); |
| int typ = getJDBCTypeFromTypeName(typeName); |
| shadowTypeName = getJDBCTypeNameFromType(typ); |
| if (OTHER_STR.equals(shadowTypeName)) { |
| shadowTypeName = typeName; |
| } |
| } |
| return shadowTypeName; |
| } |
| } |
| static class DDLWrapper { |
| String ddl; |
| boolean finished = false; |
| @Override |
| public String toString() { |
| return ddl; |
| } |
| } |
| } |
