| /* |
| * 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 - from Proof-of-concept, become production code |
| package dbws.testing.shadowddlgeneration.oldjpub; |
| |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.ALL_ARGUMENTS; |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.OBJECT_NAME; |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.OVERLOAD; |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.OWNER; |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.PACKAGE_NAME; |
| |
| //javase imports |
| import java.sql.SQLException; |
| import java.util.Iterator; |
| |
| /** |
| * Describe PL/SQL table type, including index-by tables |
| */ |
| public class PlsqlTableType extends SqlCollectionType { |
| |
| protected ElemInfo m_elemInfo; |
| |
| public PlsqlTableType(SqlName sqlName, int typeCode, ElemInfo elemInfo, SqlType elemType, |
| int[] details, boolean generateMe, SqlType parentType, SqlReflector reflector) { |
| super(sqlName, typeCode, generateMe, parentType, reflector); |
| m_elemInfo = elemInfo; |
| m_elementType = elemType; |
| m_elemTypeLength = details[DETAILS_TYPE_LENGTH]; |
| m_elemTypePrecision = details[DETAILS_TYPE_PRECISION]; |
| m_elemTypeScale = details[DETAILS_TYPE_SCALE]; |
| } |
| |
| @Override |
| protected ElemInfo getElemInfo() { |
| return m_elemInfo; |
| } |
| |
| public static ElemInfo getElemInfo(String _schema, String _typeName, String packageName, |
| String methodName, String methodNo, ViewCache viewCache) throws SQLException { |
| |
| String schema = Util.getSchema(_schema, _typeName); |
| String typeName = Util.getType(_schema, _typeName); |
| if (typeName.indexOf('.') >= 0) { |
| typeName = typeName.substring(typeName.indexOf('.') + 1); |
| } |
| |
| Iterator<ViewRow> iter; |
| if (packageName != null && packageName.length() > 0) { |
| iter = viewCache.getRows(ALL_ARGUMENTS, new String[0], new String[]{OWNER, PACKAGE_NAME, |
| OBJECT_NAME, OVERLOAD}, new Object[]{schema, packageName, methodName, methodNo}, |
| // new String[0]); |
| new String[]{"SEQUENCE"}); |
| } |
| else { // For toplevel publishing |
| iter = viewCache.getRows(ALL_ARGUMENTS, new String[0], new String[]{OWNER}, new Object[]{schema}, |
| new String[0]); |
| } |
| PlsqlElemHelper[] info = PlsqlElemHelper.getPlsqlElemHelper(iter); |
| |
| // element type is either right before or after the table type |
| int i0 = 0; |
| int i1 = -1; |
| for (i0 = 1; i0 < info.length - 1; i0++) { |
| if (schema != null && schema.equals(info[i0].typeOwner) && typeName != null |
| && typeName.equals(info[i0].typeSubname)) { |
| if (info[i0 - 1].sequence == (info[i0].sequence + 1) |
| && info[i0 - 1].dataLevel == (info[i0].dataLevel + 1) |
| && info[i0 - 1].objectName.equals(info[i0].objectName) |
| && (info[i0 - 1].overload == info[i0].overload || (info[i0 - 1].overload != null && info[i0 - 1].overload |
| .equals(info[i0].overload)))) { |
| i1 = i0 - 1; |
| break; |
| } |
| else if (info[i0 + 1].sequence == (info[i0].sequence + 1) |
| && info[i0 + 1].dataLevel == (info[i0].dataLevel + 1) |
| && info[i0 + 1].objectName.equals(info[i0].objectName) |
| && (info[i0 - 1].overload == info[i0].overload || (info[i0 - 1].overload != null && info[i0 - 1].overload |
| .equals(info[i0].overload)))) { |
| i1 = i0 + 1; |
| break; |
| } |
| } |
| } |
| if (i1 == -1) { |
| i0 = 0; |
| if (schema != null && schema.equals(info[i0].typeOwner) && typeName != null |
| && typeName.equals(info[i0].typeSubname)) { |
| i1 = 1; |
| } |
| i0 = info.length - 1; |
| if (schema != null && schema.equals(info[i0].typeOwner) && typeName != null |
| && typeName.equals(info[i0].typeSubname)) { |
| i1 = i0 - 1; |
| } |
| } |
| |
| if (i1 >= info.length || i1 < 0) { |
| throw new java.sql.SQLException("Error reflecting element type for collection type " |
| + typeName); |
| } |
| |
| PlsqlElemInfo peti = new PlsqlElemInfo(info[i1]); |
| return peti; |
| } |
| |
| @Override |
| public TypeClass getComponentType() { |
| return m_elementType; |
| } |
| |
| public static final int NUMBER_OF_DETAILS = 3; |
| public static final int DETAILS_TYPE_LENGTH = 0; |
| public static final int DETAILS_TYPE_PRECISION = 1; |
| public static final int DETAILS_TYPE_SCALE = 2; |
| |
| public static TypeClass getComponentType(ElemInfo elemInfo, SqlReflector reflector, SqlType parentType, |
| int[] details) throws SQLException, PublisherException { |
| SqlType result = null; |
| try { |
| PlsqlElemInfo info = null; |
| info = (PlsqlElemInfo)elemInfo; |
| String elemTypeName = info.elemTypeName; |
| String elemSchemaName = info.elemTypeOwner; |
| String elemTypeMod = info.elemTypeMod; |
| String elemPackageName = info.elemTypePackageName; |
| String elemMethodName = info.elemTypeMethodName; |
| String elemMethodNo = info.elemTypeMethodNo; |
| int elemTypeSequence = info.elemTypeSequence; |
| details[0] = info.elemTypeLength; |
| details[1] = info.elemTypePrecision; |
| details[2] = info.elemTypeScale; |
| |
| result = reflector.addPlsqlDBType(elemSchemaName, elemTypeName, null, elemTypeMod, |
| false, elemPackageName, elemMethodName, elemMethodNo, elemTypeSequence, parentType); // this |
| } |
| catch (SQLException e) { |
| System.err.println(e.getMessage()); |
| if (result == null) { |
| result = SqlReflector.UNKNOWN_TYPE; |
| } |
| } |
| return result; |
| } |
| |
| /* |
| * Figure out the index type for PL/SQL INDEXBY TABLE |
| */ |
| private static String getIndexType(SqlName sqlName, ViewCache viewCache) throws SQLException { |
| return "NUMBER"; |
| } |
| |
| /** |
| * Create a PL/SQL table type. If -plsqlindexbytable is set and whenever possible, the method |
| * will return predefined scalar index-by table types, which will be mapped into Java arrays. |
| * |
| * @return either a newly defined PL/SQL Table type or a predefined scalar PL/SQL index-by table |
| * type |
| */ |
| |
| public static SqlType newInstance(SqlName sqlName, int typeCode, ElemInfo elemInfo, |
| SqlType elemType, int[] details, boolean generateMe, SqlType parentType, |
| boolean isGrandparent, SqlReflector reflector) throws SQLException, PublisherException { |
| /** |
| * Identify toplevel scalar PL/SQL indexby table, to be mapped to predefined PL/SQL indexby |
| * table type. Under the following situations, predefined scalar index-by table types cannot |
| * be used: - in pre 10.2 compatible mode - when the PL/SQL table is used as a field of a |
| * record (isGrandparent) |
| */ |
| if (parentType != null |
| && (!isGrandparent && parentType != null && parentType instanceof SqlPackageType) |
| && typeCode == OracleTypes.PLSQL_INDEX_TABLE) { |
| @SuppressWarnings("unused") |
| String indexType = getIndexType(sqlName, reflector.getViewCache()); |
| /* |
| * if ("NUMBER".equals(indexType)) { Map map = new JavaMap(elemType, reflector); SqlType |
| * plsqlTableType = map.getPlsqlTableType(elemType); if (plsqlTableType != null) { |
| * return plsqlTableType; } } |
| */ |
| } |
| // mapped to user-defined SQL table type |
| return new PlsqlTableType(sqlName, typeCode, elemInfo, elemType, details, generateMe, |
| parentType, reflector); |
| } |
| } |
