| /* |
| * 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.sql.SQLException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| //EclipseLink imports |
| import dbws.testing.shadowddlgeneration.oldjpub.PublisherException; |
| import dbws.testing.shadowddlgeneration.oldjpub.Util; |
| import dbws.testing.shadowddlgeneration.oldjpub.ViewCache; |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.SCHEMA_IF_NEEDED; |
| import static dbws.testing.shadowddlgeneration.oldjpub.Util.printTypeWithLength; |
| |
| public class SqlType extends TypeClass { |
| |
| // The following type constants are used by the database |
| // to distinguish the various Opaque and SQLJ Object type |
| // flavours |
| |
| public static final int CODE_OPAQUE = 58; |
| public static final int CODE_SQLJTYPE = 108; |
| |
| public static final int SQLJTYPE_SQLDATA = 1; |
| public static final int SQLJTYPE_CUSTOMDATUM = 2; |
| public static final int SQLJTYPE_SERIALIZABLE = 3; |
| public static final int SQLJTYPE_ORADATA = 5; |
| public static final int SQLJTYPE_BOTH = 6; |
| public static final int SQLJTYPE_BOTH8I = 7; |
| |
| // The following type constants are internal to JDBC |
| public static final int ORACLE_TYPES_NCHAR = -72054; |
| public static final int ORACLE_TYPES_NCLOB = -72055; |
| public static final int ORACLE_TYPES_BOOLEAN = -72056; |
| public static final int ORACLE_TYPES_TBD = -72057; |
| |
| protected String m_version; |
| protected SqlReflector m_reflector; // null for predefined types |
| protected ViewCache m_viewCache; |
| protected SqlType m_parentType; |
| protected boolean m_isReused; |
| |
| public SqlName getSqlName() { |
| return (SqlName)m_name; |
| } |
| |
| public boolean isRef() { |
| return getTypecode() == OracleTypes.REF; |
| } |
| |
| public boolean isCollection() { |
| return (getTypecode() == OracleTypes.ARRAY || getTypecode() == OracleTypes.TABLE || isPlsqlTable()); |
| } |
| |
| public boolean isPlsqlTable() { |
| return (getTypecode() == OracleTypes.PLSQL_INDEX_TABLE |
| || getTypecode() == OracleTypes.PLSQL_NESTED_TABLE || getTypecode() == OracleTypes.PLSQL_VARRAY_TABLE); |
| } |
| |
| public boolean isPlsqlRecord() { |
| return (getTypecode() == OracleTypes.PLSQL_RECORD); |
| } |
| |
| public boolean isOpaque() { |
| return getTypecode() == OracleTypes.OPAQUE; |
| } |
| |
| public boolean isJavaStruct() { |
| return getTypecode() == OracleTypes.JAVA_STRUCT; |
| } |
| |
| public boolean isSqlStatement() { |
| return false; |
| } |
| |
| public int getSqljKind() { |
| return 0; |
| } |
| |
| public boolean isStruct() { |
| return getTypecode() == OracleTypes.STRUCT; |
| } |
| |
| /** |
| * Returns the version string of a SqlType. |
| * |
| * * @return the version string of the type. |
| */ |
| public String getVersion() { |
| return m_version; |
| } |
| |
| /** |
| * Set the version string of a declared type. |
| * |
| * * @param version the version string of the type |
| */ |
| public void setVersion(String version) { |
| m_version = version; |
| } |
| |
| /** |
| * Get the attribute hashtable associated with a SqlType. The attributes in the hashtable were |
| * registered via addAttribute(). |
| */ |
| @SuppressWarnings("unchecked") |
| public Map<String, String> getAttributes() { |
| return (Map<String, String>)getAnnotation(); |
| } |
| |
| /** |
| * Add an attribute to the collection of attributes of a SqlType. JPub only adds attributes |
| * mentioned in the input file. |
| */ |
| public void addAttribute(String sqlField, String javaField) { |
| // TODO: check for duplicate Java field names! |
| String dbField = m_viewCache.dbifyName(sqlField); |
| if (javaField == null) { |
| javaField = sqlField; |
| } |
| @SuppressWarnings("unchecked") |
| Map<String, String> h = (Map<String, String>)getAnnotation(); |
| List<String> v = getNamedTranslations(); |
| if (h == null) { |
| h = new HashMap<String, String>(); |
| setAnnotation(h); |
| } |
| if (v == null) { |
| v = new ArrayList<String>(); |
| setNamedTranslations(v); |
| } |
| Object old = h.put(dbField, javaField); |
| v.add(sqlField); |
| if (old != null) { |
| throw new IllegalArgumentException("Redeclaration of field " + dbField + " in " + this |
| + "!"); |
| } |
| } |
| |
| /** |
| * SqlType CONSTRUCTORS |
| */ |
| /** |
| * This constructor is used for user-defined and REF types. It may not be called more than once |
| * for the same non-null sqlName. |
| */ |
| protected SqlType(SqlName sqlName, int typecode, boolean generateMe, SqlType parentType, |
| SqlReflector reflector) { |
| this(sqlName, typecode, generateMe, false, parentType, reflector); |
| m_isReused = false; |
| } |
| |
| SqlType(SqlName sqlName, int typecode, boolean generateMe, boolean isPrimitive, |
| SqlType parentType, SqlReflector reflector) { |
| super(sqlName, typecode, isPrimitive); |
| m_isReused = false; |
| m_reflector = reflector; |
| if (m_reflector != null) { |
| m_viewCache = m_reflector.getViewCache(); |
| } |
| if (sqlName != null) { // For SqlRefType, sqlName==null |
| if (m_reflector != null) { |
| m_reflector.addType(sqlName, this, generateMe); |
| } |
| } |
| m_parentType = parentType; |
| } |
| |
| /** |
| * This constructor is used for predefined SQL types. It may not be called more than once for |
| * the same name. |
| */ |
| public SqlType(String name, int typecode) { |
| super(new SqlName(null, name, true, false, true, null, null, null, null/* reflector */), |
| typecode, true); |
| } |
| |
| /** |
| * This constructor is used for predefined PL/SQL to SQL type mapping. |
| */ |
| SqlType(SqlName name, int typecode) { |
| super(name, typecode, true); |
| } |
| |
| // Determine whether "this" type depends on "t" |
| // For instance, if "t" is a field of "this", |
| // or the element type of "this" |
| private List<SqlType> m_dependTypes = null; |
| |
| boolean dependsOn(SqlType t) { |
| if (m_dependTypes == null) { |
| m_dependTypes = new ArrayList<SqlType>(); |
| if (isPlsqlRecord() || this instanceof DefaultArgsHolderType) { |
| try { |
| List<AttributeField> fields = getDeclaredFields(true); |
| for (int i = 0; i < fields.size(); i++) { |
| SqlType st = (SqlType)fields.get(i).getType(); |
| if (st.isPlsqlRecord() || st.isPlsqlTable()) { |
| m_dependTypes.add(st); |
| } |
| } |
| } |
| catch (Exception e) { |
| System.err.println(e.getMessage()); |
| } |
| } |
| else if (this instanceof PlsqlTableType) { // to fend off PlsqlIndexTableType |
| try { |
| SqlType st = (SqlType)((PlsqlTableType)this).getComponentType(); |
| if (st.isPlsqlRecord() || st.isPlsqlTable()) { |
| m_dependTypes.add(st); |
| } |
| } |
| catch (Exception e) { |
| System.err.println(e.getMessage()); |
| } |
| } |
| } |
| if (m_dependTypes.contains(t)) { |
| return true; |
| } |
| for (int i = 0; i < m_dependTypes.size(); i++) { |
| if (m_dependTypes.get(i).dependsOn(t)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean hasConversion() { |
| // For SqlRefType, getSqlName()==null |
| if (getSqlName() == null) { |
| return false; |
| } |
| return getSqlName().hasConversion(); |
| } |
| |
| /** |
| * Reports the SQL type into which the PL/SQL can be converted. Returns null if not a PL/SQL |
| * type or if it doed not have a user-defined conversion. |
| */ |
| public String getTargetTypeName() { |
| return getSqlName().getTargetTypeName(); |
| } |
| |
| public String getTargetTypeName(int schemaNames) { |
| return getSqlName().getFullTargetTypeName(schemaNames); |
| } |
| |
| public String getTypeName() { |
| return getSqlName().getTypeName(); |
| } |
| |
| /** |
| * 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. |
| */ |
| //static Hashtable m_convFuns = new Hashtable(); |
| |
| @Override |
| public String getOutOfConversion() { |
| // For SqlRefType, getSqlName()==null |
| if (getSqlName() == null) { |
| return null; |
| } |
| return getSqlName().getOutOfConversion(); |
| } |
| |
| /** |
| * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type. |
| * <br> |
| * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions. |
| */ |
| @Override |
| public String getIntoConversion() { |
| // For SqlRefType, getSqlName()==null |
| if (getSqlName() == null) { |
| return null; |
| } |
| return getSqlName().getIntoConversion(); |
| } |
| |
| // Return the conversion function name |
| // prefixed with package name, |
| // if the conversion function is a generated one |
| @Override |
| public String getOutOfConversionQualified() { |
| // For SqlRefType, getSqlName()==null |
| if (getSqlName() == null) { |
| return null; |
| } |
| return getSqlName().getOutOfConversionQualified(); |
| } |
| |
| // Return the conversion function name |
| // prefixed with package name, |
| // if the conversion function is a generated one |
| @Override |
| public String getIntoConversionQualified() { |
| // For SqlRefType, getSqlName()==null |
| if (getSqlName() == null) { |
| return null; |
| } |
| return getSqlName().getIntoConversionQualified(); |
| } |
| |
| // SQL declaration of the generated SQL types |
| public String getSqlTypeDecl() throws SQLException, PublisherException { |
| String sqlTypeDecl = ""; |
| if (isPlsqlRecord() && !getSqlName().isReused()) { |
| sqlTypeDecl += "CREATE OR REPLACE TYPE " + getTargetTypeName() + " AS OBJECT (\n"; |
| List<AttributeField> fields = this.getFields(true); |
| for (int i = 0; i < fields.size(); i++) { |
| if (i != 0) { |
| sqlTypeDecl += ",\n"; |
| } |
| sqlTypeDecl += " " + Util.unreserveSql(fields.get(i).getName()) + " "; |
| sqlTypeDecl += fields.get(i).printTypeWithLength(SCHEMA_IF_NEEDED); |
| } |
| sqlTypeDecl += "\n);"; |
| } |
| else if (isPlsqlTable() && !getSqlName().isReused()) { |
| PlsqlTableType plType = (PlsqlTableType)this; |
| SqlType eleType = (SqlType)plType.getComponentType(); |
| sqlTypeDecl += "CREATE OR REPLACE TYPE " + getTargetTypeName(); |
| sqlTypeDecl += " AS TABLE OF "; |
| sqlTypeDecl += printTypeWithLength(eleType.getTargetTypeName(SCHEMA_IF_NEEDED), plType |
| .getElemTypeLength(), plType.getElemTypePrecision(), plType.getElemTypeScale()); |
| sqlTypeDecl += ";"; |
| } |
| else if ((this instanceof DefaultArgsHolderType) && !getSqlName().isReused()) { |
| DefaultArgsHolderType holder = (DefaultArgsHolderType)this; |
| sqlTypeDecl += "CREATE OR REPLACE TYPE " + getTypeName() + " AS OBJECT (\n"; |
| AttributeField vfield = holder.getFields(false).get(0); |
| sqlTypeDecl += " " + vfield.getName() + " "; |
| sqlTypeDecl += vfield.printTypeWithLength(); |
| sqlTypeDecl += "\n);"; |
| } |
| return sqlTypeDecl; |
| } |
| |
| // Drop the generated SQL type |
| public String getSqlTypeDrop() throws SQLException, PublisherException { |
| //return getSqlName().isReused() ? "" : "DROP TYPE " + getTargetTypeName() + " FORCE; \n" |
| // + "show errors\n"; |
| return "DROP TYPE " + getTargetTypeName() + " FORCE;"; |
| } |
| |
| // PL/SQL package declaration for conversion functions |
| // between SQL and PL/SQL |
| public String getConversionFunDecl() throws PublisherException, SQLException { |
| if (!hasConversion()) { |
| return ""; |
| } |
| String sqlConvPkgDecl = ""; |
| |
| // If this type is a ROWTYPE, then redefine it as a normal PL/SQL record |
| if (getSqlName().isRowType()) { |
| sqlConvPkgDecl += "\t-- Redefine a PL/SQL RECORD type originally defined via CURSOR%ROWTYPE" |
| + "\n"; |
| sqlConvPkgDecl += "\tTYPE " + getTypeName() + " IS RECORD (\n"; |
| List<AttributeField> fields = this.getFields(true); |
| for (int i = 0; i < fields.size(); i++) { |
| if (i != 0) { |
| sqlConvPkgDecl += ",\n"; |
| } |
| sqlConvPkgDecl += "\t\t" + fields.get(i).getName() + " " |
| + fields.get(i).printTypeWithLength(); |
| } |
| sqlConvPkgDecl += ");"; |
| } |
| |
| // PL/SQL to SQL |
| sqlConvPkgDecl += "\t-- Declare the conversion functions the PL/SQL type " + getTypeName() |
| + "\n" + "\tFUNCTION " + getOutOfConversion() + "(aPlsqlItem " + getTypeName() + ")\n" |
| + " \tRETURN " + getTargetTypeName() + ";\n"; |
| |
| // SQL to PL/SQL |
| sqlConvPkgDecl += "\tFUNCTION " + getIntoConversion() + "(aSqlItem " + getTargetTypeName() |
| + ")\n" + "\tRETURN " + getTypeName() + ";"; |
| return sqlConvPkgDecl; |
| } |
| |
| // PL/SQL package body for conversion functions between SQL and PL/SQL |
| public String getConversionPL2SQLFunBody() throws SQLException, PublisherException { |
| if (!hasConversion()) { |
| return ""; |
| } |
| // PL/SQL to SQL |
| String sqlConvPkgBody = "\tFUNCTION " + getOutOfConversion() + "(aPlsqlItem " |
| + getTypeName() + ")\n " + "\tRETURN " + getTargetTypeName() + " IS \n" + "\taSqlItem " |
| + getTargetTypeName() + "; \n" + "\tBEGIN \n" |
| + getOutOfConvStmts("\t\t", "aPlsqlItem", "aSqlItem") + "\t\tRETURN aSqlItem;\n" |
| + "\tEND " + getOutOfConversion() + ";\n"; |
| return sqlConvPkgBody; |
| } |
| |
| // PL/SQL package body for conversion functions between SQL and PL/SQL |
| public String getConversionSQL2PLFunBody() throws SQLException, PublisherException { |
| if (!hasConversion()) { |
| return ""; |
| } |
| // SQL to PL/SQL |
| String sqlConvPkgBody = "\tFUNCTION " + getIntoConversion() + "(aSqlItem " |
| + getTargetTypeName() + ") \n" + "\tRETURN " + getTypeName() + " IS \n" |
| + "\taPlsqlItem " + getTypeName() + "; \n" + "\tBEGIN \n" |
| + getIntoConvStmts("\t\t", "aSqlItem", "aPlsqlItem") + "\t\tRETURN aPlsqlItem;\n" |
| + "\tEND " + getIntoConversion() + ";\n"; |
| return sqlConvPkgBody; |
| } |
| |
| // both conversion functions |
| public String getBothConversions() throws SQLException, PublisherException { |
| return getConversionSQL2PLFunBody() + getConversionPL2SQLFunBody(); |
| } |
| |
| // Return assignment statements from SQL objects to PL/SQL records |
| public String getIntoConvStmts(String formatPrefix, String maybeSql, String maybePlsql) |
| throws SQLException, PublisherException { |
| if (!isPlsqlRecord() && !isPlsqlTable()) { |
| return formatPrefix + maybePlsql + "." + getName() + " := " + maybeSql + getName() |
| + ";\n"; |
| } |
| String stmts = ""; |
| if (isPlsqlRecord()) { |
| List<AttributeField> fields = getFields(true); |
| for (int i = 0; i < java.lang.reflect.Array.getLength(fields); i++) { |
| AttributeField af = fields.get(i); |
| stmts += formatPrefix |
| + maybePlsql |
| + "." |
| + af.getName() |
| + " := " |
| + ((af.getType().hasConversion() && af.getType() |
| .getIntoConversion() != null) ? af.getType().getIntoConversion() |
| + "(" + maybeSql + "." + Util.unreserveSql(af.getName()) + ");\n" |
| : maybeSql + "." + Util.unreserveSql(af.getName()) + ";\n"); |
| } |
| } |
| else { // if (isPlsqlTable()) |
| TypeClass compType = ((PlsqlTableType)this).getComponentType(); |
| if (getTypecode() == OracleTypes.PLSQL_NESTED_TABLE |
| || getTypecode() == OracleTypes.PLSQL_VARRAY_TABLE) { |
| stmts += formatPrefix + maybePlsql + " := " + getTypeName() + "();\n"; |
| stmts += formatPrefix + maybePlsql + ".EXTEND" + "(" + maybeSql + ".COUNT);\n"; |
| } |
| stmts += formatPrefix |
| + "IF " |
| + maybeSql |
| + ".COUNT>0 THEN\n" |
| + formatPrefix |
| + "FOR I IN 1.." |
| + maybeSql |
| + ".COUNT LOOP\n" |
| + formatPrefix |
| + "\t" |
| + maybePlsql |
| + "(I)" |
| + " := " |
| + ((compType.hasConversion() && compType.getIntoConversion() != null) ? compType |
| .getIntoConversion() |
| + "(" + maybeSql + "(I)" + ");\n" : maybeSql + "(I);\n") + formatPrefix |
| + "END LOOP; \n" + formatPrefix + "END IF;\n"; |
| } |
| return stmts; |
| } |
| |
| // Return assignment statements from PL/SQL records to SQL objects |
| public String getOutOfConvStmts(String formatPrefix, String maybePlsql, String maybeSql) |
| throws SQLException, PublisherException { |
| if (!isPlsqlRecord() && !isPlsqlTable()) { |
| return formatPrefix + maybeSql + " := " + maybePlsql + ";\n"; |
| } |
| String stmts = ""; |
| if (isPlsqlRecord()) { |
| List<AttributeField> fields = getFields(true); |
| stmts += formatPrefix + maybeSql + " := " + getTargetTypeName() + "(NULL"; |
| for (int i = 1; i < fields.size(); i++) { |
| stmts += ", NULL"; |
| } |
| stmts += ");\n"; |
| |
| for (int i = 0; i < fields.size(); i++) { |
| AttributeField af = fields.get(i); |
| stmts += formatPrefix |
| + maybeSql |
| + "." |
| + Util.unreserveSql(af.getName()) |
| + " := " |
| + ((af.getType().hasConversion() && af.getType() |
| .getOutOfConversion() != null) ? af.getType().getOutOfConversion() |
| + "(" + maybePlsql + "." + af.getName() + ");\n" : maybePlsql + "." |
| + af.getName() + ";\n"); |
| } |
| } |
| else { // if (isPlsqlTable()) |
| TypeClass compType = ((PlsqlTableType)this).getComponentType(); |
| stmts += formatPrefix |
| + maybeSql |
| + " := " |
| + getTargetTypeName() |
| + "();\n" |
| + formatPrefix |
| + maybeSql |
| + ".EXTEND(" |
| + maybePlsql |
| + ".COUNT);\n" |
| + formatPrefix |
| + "IF " |
| + maybePlsql |
| + ".COUNT>0 THEN\n" |
| + formatPrefix |
| + "FOR I IN " |
| + maybePlsql |
| + ".FIRST.." |
| + maybePlsql |
| + ".LAST LOOP\n" |
| + formatPrefix |
| + "\t" |
| + maybeSql |
| + "(I + 1 - " |
| + maybePlsql |
| + ".FIRST)" |
| + " := " |
| + ((compType.hasConversion() || compType.getOutOfConversion() != null) ? compType |
| .getOutOfConversion() |
| + "(" + maybePlsql + "(I)" + ");\n" : maybePlsql + "(I);\n") + formatPrefix |
| + "END LOOP; \n" + formatPrefix + "END IF; \n"; |
| } |
| return stmts; |
| } |
| } |
