| /* |
| * 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; |
| |
| //javase imports |
| import java.lang.reflect.Modifier; |
| import java.sql.SQLException; |
| import java.util.List; |
| |
| //EclipseLink imports |
| import dbws.testing.shadowddlgeneration.oldjpub.PublisherException; |
| |
| /** |
| * Instances of the class <code>Type</code> represent user-declared or predefined types in SQL or |
| * PL/SQL that may have fields and methods. Currently, subclasses of <code>Type</code> represent |
| * PL/SQL packages, the top-level PL/SQL scope, Oracle 8 user-defined types (objects, varrays and |
| * nested tables) and the primitive database types. |
| * <br> |
| * This class is analogous to java.lang.Class. |
| */ |
| public abstract class TypeClass { |
| |
| protected Name m_name; |
| protected boolean m_isPrimitive; |
| protected int m_typecode; |
| protected Object m_annotation; |
| protected String m_hint; |
| protected List<String> m_namedTranslations; |
| |
| /** The following methods are adapted from java.lang.Class */ |
| |
| /** |
| * If this Type has a component type, return the Type object that represents the component type; |
| * otherwise returns null. |
| */ |
| public TypeClass getComponentType() throws SQLException, PublisherException { |
| return null; |
| } |
| |
| /** |
| * Returns an array of Field objects reflecting all the fields declared by this Type object. |
| * Returns an array of length 0 if this Type object declares no fields. |
| */ |
| public List<AttributeField> getDeclaredFields(boolean publishedOnly) throws SecurityException, SQLException, |
| PublisherException { |
| /* derived classes that have fields override this */ |
| return null; |
| } |
| |
| /** |
| * Returns an array of Method objects reflecting all the methods declared by this Type object. |
| * Returns an array of length 0 if the Type declares no methods |
| */ |
| public List<ProcedureMethod> getDeclaredMethods() throws SecurityException, SQLException, PublisherException { |
| return null; |
| } |
| |
| /** |
| * Returns an array of Field objects reflecting all the accessible fields of this Type object. |
| * Returns an array of length 0 if this Type object has no accesible fields. |
| */ |
| public List<AttributeField> getFields(boolean publishedOnly) throws SecurityException, SQLException, |
| PublisherException { |
| /* derived classes that have fields override this */ |
| return null; |
| } |
| |
| /** |
| * Returns the modifiers for this type, encoded in an integer. The modifiers currently in use |
| * are: public (always set) final abstract The modifiers are decoded using the methods of |
| * java.lang.reflect.Modifier. If we ever need additional modifiers for C++, we can subclass |
| * Modifier. |
| */ |
| public int getModifiers() throws SQLException { |
| return Modifier.PUBLIC + Modifier.FINAL; |
| } |
| |
| /** |
| * Returns the fully-qualified name of the type represented by this Type object, as a String. |
| */ |
| public String getName() { |
| return m_name.toString(); |
| } |
| |
| /** |
| * Returns the Type representing the supertype of the entity represented by this Type. If no |
| * supertype, returns null |
| */ |
| |
| public TypeClass getSupertype() throws SQLException, PublisherException { |
| return null; |
| } |
| |
| /** |
| * Determines if this Type represents an array type. |
| * <br> |
| */ |
| public boolean isArray() { |
| return false; |
| } |
| |
| /** |
| * Determines if this Type represents an object type. |
| * <br> |
| */ |
| public boolean isObject() { |
| return false; |
| } |
| |
| /** |
| * Determines if this Type represents a primitive type. |
| */ |
| public boolean isPrimitive() { |
| return m_isPrimitive; |
| } |
| |
| /** |
| * Converts the Type to a string, as it would appear in an error message. |
| */ |
| public String toString() { |
| return getName(); |
| } |
| |
| public int hashCode() { |
| return m_name.hashCode(); |
| } |
| |
| public boolean equals(Object obj) { |
| if (obj == null) { |
| return false; |
| } |
| if (obj.getClass() != getClass()) { |
| return false; |
| } |
| |
| return getName().equals(((TypeClass)obj).getName()); |
| } |
| |
| /** |
| * The remaining methods are not adapted from java.lang.Class |
| */ |
| |
| public boolean isPackage() { |
| return false; |
| } |
| |
| public boolean isTable() { |
| return false; |
| } |
| |
| /** |
| * Returns the annotation associated with the Type. The annotation was set by the client of the |
| * Type using setAnnotation(). |
| */ |
| public Object getAnnotation() { |
| return m_annotation; |
| } |
| |
| /** |
| * Sets the annotation associated with the Type. The annotation is an arbitary object chosed by |
| * the client of the Type. |
| */ |
| public void setAnnotation(Object o) { |
| m_annotation = o; |
| } |
| |
| /** |
| * Returns a hint associated with the Type. Usually hints are used for index-by table types. |
| */ |
| public String getHint() { |
| return m_hint; |
| } |
| |
| /** |
| * Sets the hint associated with the Type. Usually hints are used for index-by table types. |
| */ |
| public void setHint(String s) { |
| m_hint = s; |
| } |
| |
| public List<String> getNamedTranslations() { |
| return m_namedTranslations; |
| } |
| |
| public void setNamedTranslations(List<String> v) { |
| m_namedTranslations = v; |
| } |
| |
| /** |
| * Return the typecode for this type. |
| */ |
| public int getTypecode() { |
| return m_typecode; |
| } |
| |
| /** |
| * set the typecode for this type. |
| */ |
| public void setTypecode(int typecode) { |
| m_typecode = typecode; |
| } |
| |
| /** |
| * Return a JDBC typecode for this type. |
| */ |
| public int getJdbcTypecode() { |
| // JDBC shares the same typecode for nested table and varrays |
| if (getTypecode() == OracleTypes.TABLE) { |
| return OracleTypes.ARRAY; |
| } |
| // PL/SQL TABLE is mapped into SQL VARRAT |
| if (getTypecode() == OracleTypes.PLSQL_INDEX_TABLE) { |
| return OracleTypes.ARRAY; |
| } |
| if (getTypecode() == OracleTypes.PLSQL_NESTED_TABLE) { |
| return OracleTypes.ARRAY; |
| } |
| if (getTypecode() == OracleTypes.PLSQL_VARRAY_TABLE) { |
| return OracleTypes.ARRAY; |
| } |
| // PL/SQL RECORD is mapped into SQL OBJECT |
| if (getTypecode() == OracleTypes.PLSQL_RECORD) { |
| return OracleTypes.STRUCT; |
| } |
| return getTypecode(); |
| } |
| |
| public boolean hasMethods() throws SQLException, PublisherException { |
| /* subclasses with methods override this */ |
| return false; |
| } |
| |
| public Name getNameObject() { |
| return m_name; |
| } |
| |
| void setNameObject(Name name) { |
| m_name = name; |
| } |
| |
| protected TypeClass(Name name, int typecode, boolean isPrimitive) { |
| m_name = name; |
| m_typecode = typecode; |
| m_isPrimitive = isPrimitive; |
| } |
| |
| /** |
| * Reports whether this is a PL/SQL type which has user-defined conversion functions to a SQL |
| * type. |
| */ |
| public boolean hasConversion() { |
| return false; |
| } |
| |
| /** |
| * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type. |
| * <br> |
| * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions. |
| */ |
| public String getOutOfConversion() { |
| return null; |
| } |
| |
| /** |
| * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type, qualified |
| * with package name. |
| * <br> |
| * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions. |
| */ |
| public String getOutOfConversionQualified() { |
| return null; |
| } |
| |
| /** |
| * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type, |
| * qualified with package name. |
| * <br> |
| * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions. |
| */ |
| public String getIntoConversion() { |
| return null; |
| } |
| |
| /** |
| * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type, |
| * qualified with package name. |
| * <br> |
| * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions. |
| */ |
| public String getIntoConversionQualified() { |
| return null; |
| } |
| } |