/*
 * 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.ALL_COLL_TYPES;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.ALL_OBJECTS;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.ALL_TYPES;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.ALL_TYPE_ATTRS;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.ATTR_NAME;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.ATTR_TYPE_NAME;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.DEFAULT_VARCHAR_LEN;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.ELEM_TYPE_NAME;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.IS_COLLECTION;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.IS_PACKAGE;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.IS_TOPLEVEL;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.IS_TYPE;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.MAX_IDENTIFIER_LENGTH;
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;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.TOPLEVEL;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.TYPE_NAME;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.getDefaultTypeLen;

//javase imports
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

/*
 * SQL Type Reflection Facility
 */
public class SqlReflector {

    public static final String CHAR_CS = "CHAR_CS";
    public static final String NCHAR_CS = "NCHAR_CS";
    public static final String ROWTYPE = "ROWTYPE";
    public static final String ROWTYPE_PL = ROWTYPE + "_PL";
    public static final String ROWTYPE_SQL = ROWTYPE + "_SQL";
    private static final int MAGIC_NUMBER = 0;

    public static final SqlType BFILE_TYPE = new SqlType("BFILE", OracleTypes.BFILE);
    public static final SqlType BINARY_INTEGER_TYPE =
    // new SqlType("BINARY_INTEGER", OracleTypes.INTEGER);
    new SqlType(new SqlName("BINARY_INTEGER", "INTEGER"), OracleTypes.INTEGER);
    public static final SqlType BLOB_TYPE = new SqlType("BLOB", OracleTypes.BLOB);
    // public static final SqlType BOOLEAN_TYPE =
    // new SqlType("BOOLEAN", SqlType.OracleTypes_BOOLEAN);
    public static final SqlType CHAR_TYPE = new SqlType("CHAR", OracleTypes.CHAR);
    public static final SqlType CLOB_TYPE = new SqlType("CLOB", OracleTypes.CLOB);
    public static final SqlType DATE_TYPE = new SqlType("DATE", OracleTypes.DATE);
    public static final SqlType NCHAR_TYPE = new SqlType("NCHAR", SqlType.ORACLE_TYPES_NCHAR);
    public static final SqlType NCLOB_TYPE = new SqlType("NCLOB", SqlType.ORACLE_TYPES_NCLOB);
    /*
     * public static final SqlType TIME_TYPE = new SqlType("TIME", OracleTypes.TIME); public static
     * final SqlType TIME_WTZ_TYPE = new SqlType("TIME WITH TIME ZONE", OracleTypes.TIME); public
     * static final SqlType TIMETZ_TYPE = // alternate spelling new SqlType("TIME WITH TZ",
     * OracleTypes.TIME);
     */
    public static final SqlType TIMESTAMP_TYPE = new SqlType("TIMESTAMP", OracleTypes.TIMESTAMP);
    public static final SqlType TIMESTAMP_WTZ_TYPE =
        new SqlType("TIMESTAMP WITH TZ", -101 ); // ==OracleTypes.TIMESTAMPTZ
    public static final SqlType TIMESTAMPTZ_TYPE = // alternate spelling
        new SqlType("TIMESTAMP WITH TIME ZONE", -101 ); // ==OracleTypes.TIMESTAMPTZ
    public static final SqlType TIMESTAMPTZ_TYPE0 = // alternate spelling
        new SqlType("TIMESTAMPTZ", -101 ); // ==OracleTypes.TIMESTAMPTZ
    public static final SqlType TIMESTAMP_WLTZ_TYPE =
        new SqlType("TIMESTAMP WITH LOCAL TZ", -102 ); // ==OracleTypes.TIMESTAMPLTZ
    public static final SqlType TIMESTAMPLTZ_TYPE = // alternate spelling
    new SqlType("TIMESTAMP WITH LOCAL TIME ZONE", -102 ); // ==OracleTypes.TIMESTAMPLTZ
    public static final SqlType TIMESTAMPLTZ_TYPE0 = // alternate spelling
    new SqlType("TIMESTAMPLTZ", -102 ); // ==OracleTypes.TIMESTAMPLTZ
    public static final SqlType DECIMAL_TYPE = new SqlType("DECIMAL", OracleTypes.DECIMAL);
    public static final SqlType DOUBLE_PRECISION_TYPE = new SqlType("DOUBLE PRECISION",
        OracleTypes.DOUBLE);
    public static final SqlType FLOAT_TYPE = new SqlType("FLOAT", OracleTypes.FLOAT);
    public static final SqlType FLOAT38TYPE = new SqlType("FLOAT38", OracleTypes.NUMBER);
    // TBD: Using the two types, 101 (OracleTypes.BDOUBLE),
    // 100 (OracleType.BFLOAT), results in <unsupported type>,
    // e.g., for the command
    // jpub -u scott/tiger -sql=sys.xmltype:XMLType
    public static final SqlType BINARY_DOUBLE_TYPE = new SqlType("BINARY_DOUBLE", 101); // OracleTypes.BDOUBLE
    public static final SqlType BINARY_FLOAT_TYPE = new SqlType("BINARY_FLOAT", 100); // OracleTypes.BFLOAT
    // Note: not referencing OracleTypes.BDOULBE and BFLOAT is
    // to avoid incompatible with pre-10i JDBC drivers
    public static final SqlType INTEGER_TYPE = new SqlType("INTEGER", OracleTypes.INTEGER);
    public static final SqlType INT_TYPE = new SqlType("INT", OracleTypes.INTEGER);
    public static final SqlType LONG_TYPE =
    // new SqlType("LONG", OracleTypes.LONGVARBINARY);
    new SqlType(new SqlName("LONG", "VARCHAR2"), OracleTypes.VARCHAR);
    public static final SqlType LONG_RAW_TYPE =
    // new SqlType("LONG RAW", OracleTypes.RAW);
    new SqlType(new SqlName("LONG RAW", "RAW"), OracleTypes.RAW);
    public static final SqlType NUMBER_TYPE = new SqlType("NUMBER", OracleTypes.NUMBER);
    public static final SqlType NUMERIC_TYPE = new SqlType("NUMERIC", OracleTypes.NUMERIC);
    public static final SqlType NVARCHAR2_TYPE = new SqlType("NVARCHAR2",
        SqlType.ORACLE_TYPES_NCHAR);
    public static final SqlType PLS_INTEGER_TYPE =
    // new SqlType("PLS_INTEGER", OracleTypes.INTEGER);
    new SqlType(new SqlName("PLS_INTEGER", "INTEGER"), OracleTypes.INTEGER);
    // public static final SqlType PLSQL_RECORD_TYPE =
    // new SqlType("PL/SQL RECORD", OracleTypes.UNSUPPORTED);
    public static final SqlType RAW_TYPE = new SqlType("RAW", OracleTypes.RAW);
    public static final SqlType REAL_TYPE = new SqlType("REAL", OracleTypes.REAL);
    public static final SqlType REF_CURSOR_TYPE = new SqlType("REF CURSOR", OracleTypes.CURSOR);
    public static final SqlType PLSQL_REF_CURSOR_TYPE = new SqlType("PL/SQL REF CURSOR",
        OracleTypes.CURSOR);
    public static final SqlType ROWID_TYPE =
    // new SqlType("ROWID", OracleTypes.ROWID);
    new SqlType(new SqlName("ROWID", "VARCHAR2"), OracleTypes.VARCHAR);
    public static final SqlType SMALLINT_TYPE = new SqlType("SMALLINT", OracleTypes.SMALLINT);
    public static final SqlType STRING_TYPE = new SqlType("STRING", OracleTypes.VARCHAR);
    public static final SqlType UROWID_TYPE =
    // new SqlType("UROWID", OracleTypes.ROWID);
    new SqlType(new SqlName("UROWID", "VARCHAR2"), OracleTypes.VARCHAR);
    public static final SqlType VARCHAR_TYPE = new SqlType("VARCHAR", OracleTypes.VARCHAR);
    public static final SqlType VARCHAR2_TYPE = new SqlType("VARCHAR2", OracleTypes.VARCHAR);
    public static SqlType plsqlTableDouble = null;
    public static SqlType plsqlTableFloat = null;
    public static SqlType plsqlTableInt = null;
    public static SqlType plsqlTableShort = null;
    public static SqlType plsqlTableJldouble = null;
    public static SqlType plsqlTableJlfloat = null;
    public static SqlType plsqlTableJlinteger = null;
    public static SqlType plsqlTableJlshort = null;
    public static SqlType plsqlTableJmbigdecimal = null;
    public static SqlType plsqlTableString = null;
    public static final SqlType UNKNOWN_TYPE = new SqlType("<unknown type or type not found>",
        OracleTypes.UNSUPPORTED);

    protected ViewCacheManager m_viewCacheManager;
    protected ViewCache m_viewCache;
    protected Connection m_conn;
    protected Boolean m_isPre920 = null;
    protected boolean m_geq9i;
    protected boolean m_transitive = true;
    protected String m_user;
    // A hashtable holding both predefined types and user types
    // for quick looking up.
    protected Map<Name, TypeClass> m_allTypes;
    protected Map<Name, TypeClass> m_predefTypes;
    /*
     * User types to be published can be added into m_userTypes in difference phases of publishing:
     * (1) First the types specified by the -sql option in the jpub command line are added (2)
     * JavaPublisher starts to publish the types in m_userTypes (3) When publishing a type, the
     * types on which that types depend on are reflected and added to the m_userTypes (4) On
     * finishing a type, JavaPublisher publishes the next type in the m_userTypes list. The
     * publishing order seems to be breadth-first.
     */
    protected List<TypeClass> m_userTypes;
    // -overwritedbtypes=false
    protected HashSet<String> m_allTypeNames;
    protected HashSet<String> m_allGeneratedTypeNames;
    protected int m_allGeneratedTypeNamesMagicNumber;
    protected Map<String, String> m_allDefaultArgsHolderTypeNames;
    protected HashSet<String>m_isReused;
    protected boolean m_getTypeCodeWarning = false;
    protected SqlStmtType m_sqlStmtType;
    protected int m_rowtypeDistinguisher = 0;
    protected WrapperPackageMetadata m_wrapperPackageMetadata;
    protected Map<String, SqlType> m_typeMap = new HashMap<String, SqlType>();

    public SqlReflector(Connection conn, String user) {
        m_viewCacheManager = new ViewCacheManager(conn);
        m_user = user;
        reset(conn);
    }

    public void reset(Connection conn) {
        if (m_conn != null) {
            try {
                m_conn.close();
            }
            catch (SQLException e) {
                // Closing resources. OK to ignore exception.
            }
        }
        m_conn = conn;

        m_viewCache = m_viewCacheManager.get(m_user);
        if (m_viewCache == null) {
            m_viewCache = new ViewCache(m_conn, m_user);
            m_viewCacheManager.add(m_viewCache);
        }
        else {
            m_viewCache.reset(m_conn);
        }

        m_allTypes = new HashMap<Name, TypeClass>();
        m_predefTypes = new HashMap<Name, TypeClass>();
        m_userTypes = new ArrayList<TypeClass>();
        sqlTypeInit();

        m_allTypeNames = new HashSet<String>();
        m_allGeneratedTypeNames = new HashSet<String>();
        m_allGeneratedTypeNamesMagicNumber = MAGIC_NUMBER;
        m_allDefaultArgsHolderTypeNames = new HashMap<String, String>();
        m_sqlStmtType = null;

        m_isReused = new HashSet<String>();
        m_wrapperPackageMetadata = null;

        if (conn != null) {
            m_geq9i = SqlReflector.geqOracle9(conn);
        }
    }

    public void loadAllTypeNames() {
        try {
            Iterator<ViewRow> iter = m_viewCache.getRows(ALL_TYPES, new String[]{TYPE_NAME},
                new String[0], new Object[0], new String[0]);
            while (iter.hasNext()) {
                SingleColumnViewRow row = (SingleColumnViewRow)iter.next();
                m_allTypeNames.add(row.getValue());
            }
        }
        catch (Exception e) { /* Cannot access ALL_TYPES table */
            e.printStackTrace();;
        }
    }

    // Determine the SQL type name for a PL/SQL type
    public String determineSqlName(String packageName, String[] sourceName, TypeClass parentType,
        boolean[] isRowType, List<AttributeField> fields, SqlType elemType, SqlType valueType)
        throws SQLException {
        String parentName = null; // Java name for the PL/SQL package
        if (parentType != null) {
            SqlName parentSqlName = (SqlName)parentType.getNameObject();
            if (parentSqlName != null) {
                parentName = parentSqlName.getTypeName().toUpperCase();
            }
        }
        String name = sourceName[0];
        m_allGeneratedTypeNames.add(name);
        if (name.indexOf('.') >= 0 && parentName != null) {
            // Replace the package name with the correpsonding Java name
            name = parentName + "_" + name.substring(name.indexOf('.') + 1);
            m_allGeneratedTypeNames.add(parentName);
        }
        name = name.replace('.', '_').replace(' ', '_');

        boolean toBeDistinguished = false;
        if (sourceName[0].equals("PL/SQL RECORD")) { // %ROWTYPE
            isRowType[0] = true;
            sourceName[0] = ROWTYPE_PL + (m_rowtypeDistinguisher++);
            name = ROWTYPE_SQL;
            if (packageName != null && !packageName.equals("")) {
                if (parentName != null) {
                    name = parentName + "_" + name;
                }
                else {
                    name = packageName + "_" + name;
                }
            }
            toBeDistinguished = true;
        }
        return determineSqlName(name, toBeDistinguished, fields, elemType, valueType);
    }

    private String determineSqlName(String name, boolean toBeDistinguished,
        List<AttributeField> fields, SqlType elemType, SqlType valueType) throws SQLException {

        String origName = name;
        if (valueType != null) {
            String uniqueName = m_allDefaultArgsHolderTypeNames.get(origName);
            if (uniqueName != null) {
                return uniqueName;
            }
        }

        if (m_allTypeNames.contains(name)) {
            boolean match = true;
            Iterator<ViewRow> iter;
            if (fields != null) {
                HashSet<String> hs = new HashSet<String>();
                for (int i = 0; i < fields.size(); i++) {
                    AttributeField af = fields.get(i);
                    String fieldType = ((SqlName)af.getType().getNameObject())
                        .getTargetTypeName();
                    hs.add(fieldType + af.getName());
                }
                iter = m_viewCache.getRows(ALL_TYPE_ATTRS, new String[]{"CONCAT("
                    + ATTR_TYPE_NAME + "," + ATTR_NAME + ")"},
                    new String[]{TYPE_NAME}, new Object[]{name}, new String[0]);
                int count = 0;
                while (iter.hasNext()) {
                    String attr = ((SingleColumnViewRow)iter.next()).getValue();
                    if (!hs.contains(attr)) {
                        match = false;
                    }
                    count++;
                }
                match = match && (count == hs.size());
            }
            else if (elemType != null) {
                iter = m_viewCache.getRows(ALL_COLL_TYPES, new String[]{ELEM_TYPE_NAME},
                    new String[]{TYPE_NAME}, new Object[]{name}, new String[0]);
                if (iter.hasNext()) {
                    String elemTypeNameInDb = ((SingleColumnViewRow)iter.next()).getValue();
                    String elemTypeName = elemType.getSqlName().getTargetTypeName();
                    match = elemTypeNameInDb.equalsIgnoreCase(elemTypeName);
                }
                else {
                    match = false;
                }
            }
            else if (valueType != null) {
                iter = m_viewCache.getRows(ALL_TYPE_ATTRS, new String[]{ATTR_TYPE_NAME},
                    new String[]{TYPE_NAME}, new Object[]{name}, new String[0]);
                if (iter.hasNext()) {
                    String valueTypeNameInDb = ((SingleColumnViewRow)iter.next()).getValue();
                    String valueTypeName = valueType.getSqlName().getTargetTypeName();
                    match = valueTypeNameInDb.equalsIgnoreCase(valueTypeName);
                }
                else {
                    match = false;
                }
            }
            if (match) {
                m_isReused.add(name);
                return name;
            }
        }
        String uniqueName = name.toUpperCase();
        if (m_allTypeNames.contains(uniqueName)
            || (toBeDistinguished && m_allGeneratedTypeNames.contains(uniqueName))) {
            do {
                int len1 = name.length();
                int len2 = Integer.toString(m_allGeneratedTypeNamesMagicNumber++).length();
                if ((len1 + len2) > MAX_IDENTIFIER_LENGTH) {
                    name = name.substring(0, MAX_IDENTIFIER_LENGTH - len2);
                }
                uniqueName = name.toUpperCase() + m_allGeneratedTypeNamesMagicNumber;
            }
            while (m_allTypeNames.contains(uniqueName)
                || (toBeDistinguished && m_allGeneratedTypeNames.contains(uniqueName)));
        }
        m_allGeneratedTypeNames.add(uniqueName);
        if (valueType != null) {
            m_allDefaultArgsHolderTypeNames.put(origName, uniqueName);
        }

        return uniqueName;
    }

    void addAllGeneratedTypeNames(String name) {
        m_allGeneratedTypeNames.add(name.toUpperCase());
    }

    public boolean isReused(String name) {
        return m_isReused.contains(name);
    }

    /*
     * public String determineDefaultArgsHolderSqlName(String name) throws SQLException { String
     * unique = (String) m_allDefaultArgsHolderTypeNames.get(name); if (unique == null) { unique =
     * determineSqlName( name, true, null , null , name); m_allDefaultArgsHolderTypeNames.put(name,
     * unique); } return unique; }
     */
    public void setViewCachePoolCapacity(int size) {
        m_viewCacheManager.setViewCachePoolCapacity(size);
    }

    private void sqlTypeInit() {
        if (!m_allTypes.isEmpty()) {
            m_allTypes = new HashMap<Name, TypeClass>();
        }
        m_allTypes.put(BFILE_TYPE.m_name, BFILE_TYPE);
        m_allTypes.put(BINARY_INTEGER_TYPE.m_name, BINARY_INTEGER_TYPE);
        m_allTypes.put(BLOB_TYPE.m_name, BLOB_TYPE);
        // m_allTypes.put(BOOLEAN_TYPE.m_name, BOOLEAN_TYPE);
        m_allTypes.put(CHAR_TYPE.m_name, CHAR_TYPE);
        m_allTypes.put(CLOB_TYPE.m_name, CLOB_TYPE);
        m_allTypes.put(DATE_TYPE.m_name, DATE_TYPE);
        m_allTypes.put(NCHAR_TYPE.m_name, NCHAR_TYPE);
        m_allTypes.put(NCLOB_TYPE.m_name, NCLOB_TYPE);
        /*
         * m_allTypes.put(TIME_TYPE.m_name, TIME_TYPE);
         * m_allTypes.put(TIME_WTZ_TYPE.m_name,TIME_WTZ_TYPE);
         * m_allTypes.put(TIMETZ_TYPE.m_name, TIMETZ_TYPE);
         */
        m_allTypes.put(TIMESTAMP_TYPE.m_name, TIMESTAMP_TYPE);
        m_allTypes.put(TIMESTAMP_WTZ_TYPE.m_name, TIMESTAMP_WTZ_TYPE);
        m_allTypes.put(TIMESTAMPTZ_TYPE.m_name, TIMESTAMPTZ_TYPE);
        m_allTypes.put(TIMESTAMPTZ_TYPE0.m_name, TIMESTAMPTZ_TYPE0);
        m_allTypes.put(TIMESTAMP_WLTZ_TYPE.m_name, TIMESTAMP_WLTZ_TYPE);
        m_allTypes.put(TIMESTAMPLTZ_TYPE.m_name, TIMESTAMPLTZ_TYPE);
        m_allTypes.put(TIMESTAMPLTZ_TYPE0.m_name, TIMESTAMPLTZ_TYPE0);
        /*
         * m_allTypes.put(INTERVAL_YM_TYPE.m_name, INTERVAL_YM_TYPE);
         * m_allTypes.put(INTERVAL_YM_TYPE.m_name, INTERVAL_YM_TYPE);
         */
        m_allTypes.put(DECIMAL_TYPE.m_name, DECIMAL_TYPE);
        m_allTypes.put(BINARY_DOUBLE_TYPE.m_name, BINARY_DOUBLE_TYPE);
        m_allTypes.put(DOUBLE_PRECISION_TYPE.m_name, DOUBLE_PRECISION_TYPE);
        m_allTypes.put(FLOAT_TYPE.m_name, FLOAT_TYPE);
        m_allTypes.put(FLOAT38TYPE.m_name, FLOAT38TYPE);
        m_allTypes.put(BINARY_FLOAT_TYPE.m_name, BINARY_FLOAT_TYPE);
        m_allTypes.put(INTEGER_TYPE.m_name, INTEGER_TYPE);
        m_allTypes.put(INT_TYPE.m_name, INT_TYPE);
        m_allTypes.put(LONG_TYPE.m_name, LONG_TYPE);
        m_allTypes.put(LONG_RAW_TYPE.m_name, LONG_RAW_TYPE);
        m_allTypes.put(NUMBER_TYPE.m_name, NUMBER_TYPE);
        m_allTypes.put(NUMERIC_TYPE.m_name, NUMERIC_TYPE);
        m_allTypes.put(NVARCHAR2_TYPE.m_name, NVARCHAR2_TYPE);
        m_allTypes.put(PLS_INTEGER_TYPE.m_name, PLS_INTEGER_TYPE);
        m_allTypes.put(RAW_TYPE.m_name, RAW_TYPE);
        m_allTypes.put(REAL_TYPE.m_name, REAL_TYPE);
        m_allTypes.put(REF_CURSOR_TYPE.m_name, REF_CURSOR_TYPE);
        m_allTypes.put(PLSQL_REF_CURSOR_TYPE.m_name, PLSQL_REF_CURSOR_TYPE);
        m_allTypes.put(ROWID_TYPE.m_name, ROWID_TYPE);
        m_allTypes.put(SMALLINT_TYPE.m_name, SMALLINT_TYPE);
        m_allTypes.put(STRING_TYPE.m_name, STRING_TYPE);
        m_allTypes.put(UROWID_TYPE.m_name, UROWID_TYPE);
        m_allTypes.put(VARCHAR_TYPE.m_name, VARCHAR_TYPE);
        m_allTypes.put(VARCHAR2_TYPE.m_name, VARCHAR2_TYPE);

        String name;
        SqlName sqlName;

        name = "PLSQL_TABLE_DOUBLE";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "double[]", null, "double[]", null));
        plsqlTableDouble = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_FLOAT";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "float[]", null, "float[]", null));
        plsqlTableFloat = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_INT";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "int[]", null, "int[]", null));
        plsqlTableInt = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_SHORT";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "short[]", null, "short[]", null));
        plsqlTableShort = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_JLDOUBLE";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "Double[]", null, "Double[]", null));
        plsqlTableJldouble = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_JLFLOAT";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "Float[]", null, "Float[]", null));
        plsqlTableJlfloat = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_JLINTEGER";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "Integer[]", null, "Integer[]", null));
        plsqlTableJlinteger = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_JLSHORT";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "Short[]", null, "Short[]", null));
        plsqlTableJlshort = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_JLINTEGER";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "Integer[]", null, "Integer[]", null));
        plsqlTableJlinteger = new PlsqlIndexTableType(sqlName, true);

        name = "PLSQL_TABLE_JMBIGDECIMAL";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "java.math.BigDecimal[]", null,
            "java.math.BigDecimal[]", null));
        plsqlTableJmbigdecimal = new PlsqlIndexTableType(sqlName, true);
        name = "PLSQL_TABLE_STRING";
        sqlName = new SqlName(name, name);
        sqlName.setAnnotation(new JavaName("", "String[]", null, "String[]", null));
        plsqlTableString = new PlsqlIndexTableType(sqlName, false);

        m_allTypes.put(plsqlTableDouble.m_name, plsqlTableDouble);
        m_allTypes.put(plsqlTableFloat.m_name, plsqlTableFloat);
        m_allTypes.put(plsqlTableInt.m_name, plsqlTableInt);
        m_allTypes.put(plsqlTableShort.m_name, plsqlTableShort);
        m_allTypes.put(plsqlTableJldouble.m_name, plsqlTableJldouble);
        m_allTypes.put(plsqlTableJlfloat.m_name, plsqlTableJlfloat);
        m_allTypes.put(plsqlTableJlshort.m_name, plsqlTableJlshort);
        m_allTypes.put(plsqlTableJlinteger.m_name, plsqlTableJlinteger);
        m_allTypes.put(plsqlTableJmbigdecimal.m_name, plsqlTableJmbigdecimal);
        m_allTypes.put(plsqlTableString.m_name, plsqlTableString);
        String hint = "/*[32767]*/";
        plsqlTableDouble.setHint(hint);
        plsqlTableFloat.setHint(hint);
        plsqlTableInt.setHint(hint);
        plsqlTableShort.setHint(hint);
        plsqlTableJldouble.setHint(hint);
        plsqlTableJlfloat.setHint(hint);
        plsqlTableJlinteger.setHint(hint);
        plsqlTableJlshort.setHint(hint);
        plsqlTableString.setHint(hint);
        plsqlTableJmbigdecimal.setHint(hint);

        m_allTypes.put(UNKNOWN_TYPE.m_name, UNKNOWN_TYPE);
    }

    public Connection getConnection() {
        return m_conn;
    }

    public SqlType addSqlType(SqlName sqlName, int whatIsIt, boolean mustBeNew, boolean generateMe,
        SqlType parentType, String modifier) throws SQLException, PublisherException {
        return addSqlType(sqlName, whatIsIt, mustBeNew, generateMe, parentType, modifier, false,
            null);
    }

    public SqlType addSqlType(SqlName sqlName, int whatIsIt, boolean mustBeNew, boolean generateMe,
        SqlType parentType, String modifier, boolean ncharFormOfUse, MethodFilter signatureFilter)
        throws SQLException, PublisherException {
        SqlType result = null;
        try {
            if (ncharFormOfUse) {
                if (sqlName.getTypeName().equals("CHAR")) {
                    sqlName = NCHAR_TYPE.getSqlName();
                }
                else if (sqlName.getTypeName().equals("VARCHAR2")) {
                    sqlName = NVARCHAR2_TYPE.getSqlName();
                }
                else if (sqlName.getTypeName().equals("CLOB")) {
                    sqlName = NCLOB_TYPE.getSqlName();
                }
            }

            SqlType t = findType(sqlName);
            boolean predefined = false;
            if (t == null) {
                t = findPredefType(sqlName);
                predefined = true;
            }

            if (t != null) {
                result = t;
                if (mustBeNew && predefined) {
                    throw new PublisherException("duplicate type " + result.toString());
                }
                else if (mustBeNew) {
                    t.setNameObject(sqlName);
                }
                return result;
            }

            String schema = sqlName.getSchemaName();
            String type = sqlName.getTypeName();
            if (whatIsIt == IS_TOPLEVEL) {
                return new SqlToplevelType(sqlName, parentType, signatureFilter, this);
            }
            else if ((whatIsIt & IS_PACKAGE) != 0) {
                Iterator<ViewRow> rowIter = m_viewCache.getRows(ALL_OBJECTS,
                    new String[]{"'PACKAGE' AS TYPECODE"}, new String[]{OWNER, OBJECT_NAME,
                        "OBJECT_TYPE", "STATUS"}, new Object[]{schema, type, "PACKAGE", "VALID"},
                    new String[0]);

                if (rowIter.hasNext()) {
                    m_viewCache.fetch(type, signatureFilter);
                    result = new SqlPackageType(sqlName, parentType, signatureFilter, this);
                }
                if (result != null) {
                    return result;
                }
                if (whatIsIt == IS_PACKAGE) {
                    throw new PublisherException("package not found " + sqlName.toString());
                }
            }

            /* determine whether this is an opaque type */
            Iterator<ViewRow> iter = m_viewCache.getRows(ALL_TYPES, new String[0], new String[]{
                OWNER, TYPE_NAME, "PREDEFINED"}, new Object[]{schema, type, "NO"},
                new String[0]);
            if (iter.hasNext()) {
                AllTypes allTypes = (AllTypes)iter.next();
                String typeCode = allTypes.typeCode;
                byte[] typeOID = allTypes.typeOid;
                int dbTypeCode = 0;
                int kind = 0;
                if (!m_getTypeCodeWarning) {
                    try {
                        Object[] outParams = m_viewCache.getOutParameters(
                            "BEGIN sys.sqljutl.get_typecode(:1, :2, :3, :4); END;",
                            new Object[]{typeOID}, new int[]{OracleTypes.INTEGER,
                                OracleTypes.VARCHAR, OracleTypes.INTEGER});
                        if (outParams == null) {
                            throw new SQLException("no data from sqljutl.get_typecode call");
                        }
                        dbTypeCode = (Integer) outParams[0];
                        kind = (Integer) outParams[2];
                    }
                    catch (SQLException exn) {
                        String msg = exn.getMessage();
                        if (isPre920()) {
                            // an older database version will not have GET_TYPECODE
                            msg = null;
                            m_getTypeCodeWarning = true;
                        }
                        else if (msg.indexOf("PLS-00201") > 0) {
                            msg = "cannot determine type " + type;
                            m_getTypeCodeWarning = true;
                        }
                        else {
                            msg = "error determining type " + type;
                        }
                        if (msg != null) {
                            throw new PublisherException(msg);
                        }
                    }
                }

                if (dbTypeCode == SqlType.CODE_OPAQUE) {
                    result = new SqlObjectType(sqlName, OracleTypes.OPAQUE, generateMe, parentType,
                        this);
                }
                else if (dbTypeCode == SqlType.CODE_SQLJTYPE && kind != 0) {
                    result = new SqlSqljType(sqlName, kind, parentType, this);
                }
                else if (typeCode.equals("OBJECT")) {
                    result = new SqlObjectType(sqlName, generateMe, parentType, this);
                    if (SqlName.langIsOtt()) {
                        /*
                         * For C only. Maura - I'm not sure about this, but
                         * it seems that a ref typedef has to be generated
                         * for every struct. That's the purpose of the
                         * following SqlRefType
                         */
                        new SqlRefType(sqlName, result, parentType, generateMe, this);
                    }
                    if (PublisherModifier.isIncomplete(result.getModifiers())) {
                        /*
                         * give warning
                         * about incomplete
                         * type and
                         * continue
                         */
                        int line = sqlName.getLine();
                        int column = sqlName.getColumn();
                        String mesg = "incomplete type " + sqlName.toString();

                        if (line > 0 || column > 0) {
                            mesg = "" + line + "." + column + ": " + mesg;
                        }
                        System.err.println(mesg);
                    }
                }
                else if (typeCode.equals("COLLECTION")) {
                    if ((whatIsIt & IS_COLLECTION) == 0) {
                        throw new PublisherException("collection found " + sqlName.toString());
                    }
                    Iterator<ViewRow> iter3 = m_viewCache.getRows(ALL_COLL_TYPES, new String[0],
                        new String[]{OWNER, TYPE_NAME}, new Object[]{schema, type},
                        new String[0]);
                    if (iter3.hasNext()) {
                        AllCollTypes act = (AllCollTypes)iter3.next();
                        String collTypeCode = act.collType;
                        if (collTypeCode.equals("TABLE")) {
                            result = new SqlTableType(sqlName, generateMe, parentType, this);
                        }
                        else {
                            // "VARYING ARRAY"
                            result = new SqlArrayType(sqlName, generateMe, parentType, this);
                        }
                    }
                }
            }
            if (result != null) {
                return result;
            }
            else {
                // Note that this type is not supported, so we will not look
                // it up again.
                result = addPredefType(sqlName, OracleTypes.UNSUPPORTED);
                // Now add an error message
                if ((whatIsIt & IS_PACKAGE) != 0) {
                    throw new PublisherException("type not found " + sqlName.toString());
                }
            }
        }
        catch (SQLException e) {
            System.err.println(e.getMessage());
        }
        catch (PublisherException ex) {
            System.err.println(ex.getMessage());
        }
        return result;
    }

    public SqlType addSqlUserType(String schema, String type, int whatIsIt, boolean mustBeNew,
        int line, int col, MethodFilter signatureFilter) throws SQLException, PublisherException {
        SqlName sn = new SqlName(schema, type, false, line, col, this);
        return addSqlType(sn, whatIsIt, mustBeNew, true, null, null, false, signatureFilter);
    }

    private SqlType addSqlDBType(SqlName sqlName, String modifier, boolean ncharFormOfUse,
        SqlType parentType) throws SQLException, PublisherException {

        /* constructed types are not hashed */
        if (modifier != null && modifier.equals("REF")) {
            SqlType t = addSqlType(sqlName, IS_TYPE, false, m_transitive, parentType, modifier);
            SqlType rt = new SqlRefType(sqlName, t, parentType, m_transitive, this);
            return rt;
        }
        else {
            return addSqlType(sqlName, IS_TYPE, false, m_transitive, parentType, modifier,
                ncharFormOfUse, null);
        }
    }

    // Used for adding types other than PL/SQL types
    public SqlType addSqlDBType(String schema, String type, String subtype, String modifier,
        boolean ncharFormOfUse, SqlType parentType) throws SQLException, PublisherException {
        int line = 0;
        int col = 0;

        if (parentType != null) {
            SqlName psqlname = (SqlName)parentType.getNameObject();
            line = psqlname.getLine();
            col = psqlname.getColumn();
        }
        if (subtype != null) {
            if (type != null) {
                type = type + "." + subtype;
            }
            else {
                type = subtype;
            }
            if (schema != null) {
                type = schema + "." + type;
                schema = null;
            }
        }
        SqlName sn = new SqlName(schema, type, true, line, col, this);
        sn.setAnnotation(genPattern((LangName)sn.getAnnotation(), sn.getSimpleName(), true));

        return addSqlDBType(sn, modifier, ncharFormOfUse, parentType);
    }

    /*
     * Add SQL or PL/SQL types from PL/SQL packages (1) For SQL types, delegate to addSqlDBType (2)
     * For PL/SQL, create PlsqlRecorType or PlsqlTableType
     */
    public SqlType addPlsqlDBType(String schema, String type, String subtype, String modifier,
        boolean ncharFormOfUse, String packageName, String methodName, String methodNo,
        int sequence, SqlType parentType) throws SQLException, PublisherException {
        return addPlsqlDBType(schema, type, subtype, modifier, ncharFormOfUse, packageName,
            methodName, methodNo, sequence, parentType, false);
    }

    public SqlType addPlsqlDBType(String schema, String type, String subtype, String modifier,
        boolean ncharFormOfUse, String packageName, String methodName, String methodNo,
        int sequence, SqlType parentType, boolean isGrandparent) throws SQLException,
        PublisherException {
        int line = 0;
        int col = 0;

        if (parentType != null) {
            SqlName psqlname = (SqlName)parentType.getNameObject();
            line = psqlname.getLine();
            col = psqlname.getColumn();
        }
        if (subtype != null) {
            if (type != null) {
                type = type + "." + subtype;
            }
            else {
                type = subtype;
            }
            if (schema != null) {
                type = schema + "." + type;
                schema = null;
            }
        }
        // For SQL types, delegate to addSqlDBType
        if (modifier == null
            || (!modifier.equals("PL/SQL RECORD") && !modifier.equals("PL/SQL TABLE")
                && (!modifier.equals("TABLE") || (subtype == null && type.indexOf(".") == -1)) && (!modifier
                .equals("VARRAY") || (subtype == null && type.indexOf(".") == -1)))) {
            SqlName sn = new SqlName(schema, type, true, line, col, this);
            sn.setAnnotation(genPattern((LangName)sn.getAnnotation(), sn.getSimpleName(), true));
            return addSqlDBType(sn, modifier, ncharFormOfUse, parentType);
        }

        // Start processing PL/SQL types
        // Check wether the ROWTYPE has bee published
        List<RowtypeInfo> rowtypeInfoA = null;
        if (modifier != null && type != null && modifier.equals("PL/SQL RECORD")
            && type.equals("PL/SQL RECORD")) {
            rowtypeInfoA = reflectRowtypeInfo(packageName, methodName, methodNo, sequence);
            for (int i = 0; i < m_userTypes.size(); i++) {
                boolean found = true;
                TypeClass p = m_userTypes.get(i);
                if (!(p instanceof PlsqlRecordType)) {
                    continue;
                }
                List<RowtypeInfo> rowtypeInfoB = ((PlsqlRecordType)p).getRowtypeInfo();
                if (rowtypeInfoB == null || rowtypeInfoA == null
                    || rowtypeInfoA.size() != rowtypeInfoB.size()) {
                    found = false;
                    continue;
                }
                for (int ja = 0; ja < rowtypeInfoA.size(); ja++) {
                    boolean microFound = false;
                    for (int jb = 0; jb < rowtypeInfoB.size(); jb++) {
                        if (rowtypeInfoA.get(ja).equals(rowtypeInfoB.get(jb))) {
                            microFound = true;
                            break;
                        }
                    }
                    if (!microFound) {
                        found = false;
                        break;
                    }
                }
                if (found) {
                    return (SqlType)p;
                }
            }
        }

        // Create the PL/SQL type
        SqlType result = findPredefType(schema, type);
        boolean predefined = (result != null);
        if (!predefined) {
            result = findType(schema, type);
        }
        if (result != null) {
            if (result.getTypecode() != SqlType.ORACLE_TYPES_TBD) {
                return result;
            }
            else if (!predefined) {
                // Deals with PL/SQL types: Augument the predefined type
                // by -typemap with more specific PL/SQL type information.
                if (modifier != null && modifier.equals("PL/SQL RECORD")) {
                    result.setTypecode(OracleTypes.PLSQL_RECORD);
                }
                else if (modifier != null && modifier.equals("PL/SQL TABLE")) {
                    result.setTypecode(OracleTypes.PLSQL_INDEX_TABLE);
                }
                else if (modifier != null && modifier.equals("TABLE")) {
                    result.setTypecode(OracleTypes.PLSQL_NESTED_TABLE);
                }
                else if (modifier != null && modifier.equals("VARRAY")) {
                    result.setTypecode(OracleTypes.PLSQL_VARRAY_TABLE);
                }
                return result;
            }
        }

        // Case 1: result is null
        // Case 2: result not null, predefined, OracleTypes_TBD
        if (modifier != null && modifier.equals("PL/SQL RECORD")) {
            List<FieldInfo> fieldInfo = PlsqlRecordType.getFieldInfo(Util.getSchema(schema, type), packageName, methodName, methodNo,
                sequence, this);
            List<AttributeField> fields = SqlTypeWithFields.reflectFields(false, fieldInfo, this,
                parentType, true /* isGrandparent */);
            // if predefined, overwrite entry already in m_predefiendTypes
            if (predefined) {
                String hint = result.getHint();
                result = new PlsqlRecordType(result.getSqlName(), fieldInfo, fields, rowtypeInfoA,
                    false /* generateMe */, parentType, this);
                result.setHint(hint);
            }
            else {
                // Prepare SqlName for the PL/SQL type
                SqlName sqlName = new PlsqlRecordName(schema, type, true, line, col, packageName,
                    parentType, fields, this);
                sqlName.setAnnotation(genPattern((LangName)sqlName.getAnnotation(), sqlName
                    .getSimpleName(), true));

                result = new PlsqlRecordType(sqlName, fieldInfo, fields, rowtypeInfoA,
                    true /* generateMe */, parentType, this);
            }
        }
        else {
            int oracleType = OracleTypes.UNSUPPORTED;
            if (modifier != null && modifier.equals("PL/SQL TABLE")) {
                oracleType = OracleTypes.PLSQL_INDEX_TABLE;
            }
            else if (modifier != null && modifier.equals("TABLE") && type.indexOf(".") > -1) {
                oracleType = OracleTypes.PLSQL_NESTED_TABLE;
            }
            else if (modifier != null && modifier.equals("VARRAY") && type.indexOf(".") > -1) {
                oracleType = OracleTypes.PLSQL_VARRAY_TABLE;
            }
            if (oracleType != OracleTypes.UNSUPPORTED) {
                ElemInfo elemInfo = PlsqlTableType.getElemInfo(schema, type, packageName,
                    methodName, methodNo, m_viewCache);
                int[] details = new int[PlsqlTableType.NUMBER_OF_DETAILS];

                SqlType elemType = (SqlType)PlsqlTableType.getComponentType(elemInfo, this,
                    parentType, details);

                if (predefined) {
                    String hint = result.getHint();
                    result = PlsqlTableType.newInstance(result.getSqlName(), oracleType, elemInfo,
                        elemType, details, false, parentType, isGrandparent, this);
                    result.setHint(hint);
                }
                else {
                    // Prepare SqlName for the PL/SQL type
                    SqlName sqlName = new PlsqlTableName(schema, type, true, line, col,
                        packageName, parentType, elemType, this);
                    sqlName.setAnnotation(genPattern((LangName)sqlName.getAnnotation(), sqlName
                        .getSimpleName(), true));

                    result = PlsqlTableType.newInstance(sqlName, oracleType, elemInfo, elemType,
                        details, true, parentType, isGrandparent, this);
                }
            }
        }
        if (result != null) {
            return result;
        }
        throw new PublisherException("unsupported Type " + schema + "." + type);
    }

    /*
     * look up rowtype columns
     */
    List<RowtypeInfo> reflectRowtypeInfo(String packageName, String methodName, String methodNo,
        int sequence) throws SQLException {
        // Although package_name and type_name derived from getPlsqlTypeName()
        // can be used for the queries, we use method and sequence
        // to be more general. If this type is defined via CURSOR%ROWTYPE,
        // method, method_no and sequence has to be used to
        // identify this type in ALL_ARGUMENTS.
        Iterator<ViewRow> iter = m_viewCache.getRows(ALL_ARGUMENTS, new String[0], new String[]{
           PACKAGE_NAME, OBJECT_NAME, OVERLOAD}, new Object[]{packageName, methodName,
            methodNo}, new String[0]);
        ArrayList<ViewRow> viewRows = new ArrayList<ViewRow>();
        while (iter.hasNext()) { // DISTINCT not enforced
            UserArguments item = (UserArguments)iter.next();
            viewRows.add(item);
        }
        List<RowtypeInfo> rowtypeInfoA = RowtypeInfo.getRowtypeInfo(viewRows);
        int data_level = 0;
        for (int i = 0; i < rowtypeInfoA.size(); i++) {
            RowtypeInfo rti = rowtypeInfoA.get(i);
            if (sequence == -1 || sequence == rti.sequence()) {
                data_level = rti.data_level();
                break;
            }
        }
        int next_rec_sequence = -1;
        for (int i = 0; i < rowtypeInfoA.size(); i++) {
            RowtypeInfo rti = rowtypeInfoA.get(i);
            if (data_level == rti.data_level() && (sequence == -1 || sequence < rti.sequence())) {
                next_rec_sequence = rti.sequence();
                break;
            }
        }
        data_level++;
        ArrayList<RowtypeInfo> rowtypeInfoW = new ArrayList<RowtypeInfo>();
        for (int i = 0; i < rowtypeInfoA.size(); i++) {
            RowtypeInfo rti = rowtypeInfoA.get(i);
            if ((sequence == -1 || sequence < rti.sequence()) && data_level == rti.data_level()
            // && data_level <= rti.data_level()
                && (next_rec_sequence == -1 || next_rec_sequence > rti.sequence())) {
                rowtypeInfoW.add(rti);
            }
        }
        return rowtypeInfoW;
    }

    public SqlType addPredefType(String schema, String type, int typecode, String javaName,
        String convertInto, String convertOutOf, String conversionTarget) throws PublisherException {
        SqlName sn = new SqlName(schema, type, false, false, true, convertInto, convertOutOf,
            conversionTarget, this);

        // Does the Java type contain a type annotation?
        int pos;
        String annotation;
        boolean isPlsqlIndexTable = false;
        int maxLen = Integer.parseInt(DEFAULT_VARCHAR_LEN);
        int maxElemLen = -1;
        boolean isNumeric = true;
        if ((pos = javaName.indexOf("[")) >= 0) {
            annotation = "/*" + javaName.substring(pos).trim() + "*/";
            isPlsqlIndexTable = true;
            int pos1 = pos;
            int pos2 = javaName.indexOf("]");
            if (pos2 > -1) {
                try {
                    maxLen = Integer.parseInt(javaName.substring(pos1 + 1, pos2));
                }
                catch (NumberFormatException e) {
                    System.err.println("ERROR: number format error: " + javaName);
                }
            }
            pos1 = javaName.indexOf("(");
            pos2 = javaName.indexOf(")");
            if (pos1 > -1 && pos2 > -1) {
                try {
                    maxElemLen = Integer.parseInt(javaName.substring(pos1 + 1, pos2));
                }
                catch (NumberFormatException e) {
                    System.err.println("ERROR: number format error: " + javaName);
                }
            }
            javaName = javaName.substring(0, pos);
            if ("String".equals(javaName) || "java.lang.String".equals(javaName)) {
                isNumeric = false;
            }
            javaName = javaName + "[]";
            if (maxElemLen == -1) {
                maxElemLen = Integer.parseInt(getDefaultTypeLen("VARCHAR2"));
            }
        }
        else {
            annotation = "";
        }

        sn.setLangName(null, javaName, null, null, null, null, null, null, true);

        SqlType st = null;
        if (isPlsqlIndexTable) {
            st = new PlsqlIndexTableType(sn, isNumeric, maxLen, maxElemLen);
            m_predefTypes.put(sn, st);
        }
        else {
            st = addPredefType(sn, typecode);
        }
        st.setHint(annotation);
        return st;
    }

    public SqlType addPredefType(SqlName name, int typecode) throws PublisherException {
        // To determine whether the Java type implements ORAData or CustomData
        boolean isPrimitive = true;
        String declClassName = ((name.getDeclPackage() != null && name.getDeclPackage().length() > 0) ? (name
            .getDeclPackage() + ".")
            : "")
            + name.getDeclClass();
        Class<?> declClass = null;
        try {
            declClass = Class.forName(declClassName);
        }
        catch (Throwable t) {
            try {
                declClass = Class.forName("java.lang." + declClassName);
            }
            catch (Throwable t2) {
                // class did not check out as a primitive class
            }
        }
        if (declClass == null) {
            // Cannot load that class. Assume it is not primitive.
            isPrimitive = false;
        }
        else if (declClass != null) {
            try {
                declClass.getField("_SQL_TYPENAME");
                isPrimitive = false;
            }
            catch (Throwable t) {
                try {
                    declClass.getField("_SQL_NAME");
                    isPrimitive = false;
                }
                catch (Throwable t2) {
                    // class has neither _SQL_TYPENAME nor _SQL_NAME
                }
            }
        }
        if (declClassName.equals("boolean") || declClassName.equals("int")
            || declClassName.equals("short") || declClassName.equals("double")
            || declClassName.equals("float") || declClassName.equals("long")
            || declClassName.equals("byte") || declClassName.equals("char")
            || declClassName.endsWith("[]")) {
            isPrimitive = true;
        }

        if (typecode == OracleTypes.UNSUPPORTED || typecode == SqlType.ORACLE_TYPES_TBD) {
            if ("INTEGER".equals(name.getTargetTypeName())) {
                typecode = OracleTypes.INTEGER;
            }
            if ("CHAR".equals(name.getTargetTypeName())) {
                typecode = OracleTypes.CHAR;
            }
        }

        SqlType st = null;
        if (!isPrimitive) { // for sure this is a SQL Object Type
            try {
                st = new SqlObjectType(name, typecode, false, null, this);
            }
            catch (Exception e) {
                System.err.println(e.getMessage());
            }
        }
        else {
            st = new SqlType(name, typecode, false, isPrimitive, null, this);
        }
        if (st != null) {
            m_predefTypes.put(name, st);
        }
        else {
            throw new PublisherException("Cannot find Type " + name);
        }
        return st;
    }

    public void addType(Name name, TypeClass type, boolean generateMe) {
        if (generateMe) {
            m_userTypes.add(type);
        }
        if (name instanceof SqlName && type instanceof SqlType) {
            m_allTypes.put(name, type);
        }
    }

    /*
     * Add default parameter holder types for PL/SQL methods
     */
    public SqlType addDefaultArgsHolderType(SqlType valueType, String packageName,
        SqlType parentType, boolean ncharFormOfUse) throws SQLException, PublisherException {
        String typeName = "";
        if (valueType.getSqlName().getTypeName().indexOf(".") > -1) {
            typeName += valueType.getSqlName().getSimpleName();
        }
        else {
            typeName += valueType.getSqlName().getTypeName();
        }
        SqlName sqlName = new DefaultArgsHolderName(null, typeName, true, 0, 0, packageName,
            parentType, valueType, this);
        SqlType result = findType(sqlName);
        if (result == null) {
            sqlName.setAnnotation(genPattern((LangName)sqlName.getAnnotation(), sqlName
                .getSimpleName(), true));
            result = new DefaultArgsHolderType(sqlName, valueType, ncharFormOfUse, this);
        }
        return result;
    }

    public boolean isUserType(TypeClass t) {
        if (t instanceof SqlType) {
            for (int i = 0; i < m_userTypes.size(); i++) {
                if (m_userTypes.get(i).equals(t)) {
                    return true;
                }
            }
        }
        return false;
    }

    private SqlType findType(SqlName sqlName) {
        return _findType(m_allTypes, sqlName);
    }

    private SqlType findType(String schema, String type) {
        SqlName sqlName = new SqlName(Util.getSchema(schema, type), Util.getType(schema, type),
            false, this);
        return _findType(m_allTypes, sqlName);
    }

    private SqlType findPredefType(SqlName sqlName) {
        return _findType(m_predefTypes, sqlName);
    }

    private SqlType findPredefType(String schema, String type) {
        SqlName sqlName = new SqlName(schema, type, false, this);
        return _findType(m_predefTypes, sqlName);
    }

    private SqlType _findType(Map<Name, TypeClass> ht, SqlName sqlName) {
        return (SqlType)ht.get(sqlName);
        /*
         * Enumeration keys = ht.keys(); while (keys.hasMoreElements()) { Object key =
         * keys.nextElement(); if (sqlName.equals(key)) { return (SqlType) ht.get(key); } } return
         * null;
         */
    }

    public SqlType findType(String name) {
        String schema = Util.getSchema(null, name);
        name = Util.getType(null, name);
        SqlName sqlName = new SqlName(schema, name, false, this);
        SqlType sqlType = findType(sqlName);
        if (sqlType == null) {
            sqlType = findPredefType(sqlName);
        }
        return sqlType;
    }

    /**
     * Add all types declared in the given schema to the set of types to be translated.
     */
    public void addAllTypes(String schema) throws SQLException, PublisherException {
        if (m_conn != null) {
            Iterator<ViewRow> iter = m_viewCache
                .getRows(ALL_TYPES, new String[0], new String[]{OWNER, "PREDEFINED"},
                    new Object[]{schema, "NO"}, new String[]{TYPE_NAME});
            while (iter.hasNext()) {
                AllTypes allTypes = (AllTypes)iter.next();
                addSqlDBType(schema, allTypes.typeName, null, "", false, null);
            }
        }
    }

    public void addAllPackages(String schema) throws SQLException, PublisherException {
        if (m_conn != null) {
            PreparedStatement stmt = m_conn.prepareStatement("SELECT OBJECT_NAME AS TYPE_NAME FROM " +
                    "ALL_OBJECTS WHERE OWNER = :1 AND OBJECT_TYPE = 'PACKAGE' AND STATUS='VALID'");
            stmt.setString(1, schema);
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                SqlName sn = new SqlName(schema, rs.getString(1), true, this);
                // determine generated Java names using -genPattern setting.
                sn
                    .setAnnotation(genPattern((LangName)sn.getAnnotation(), sn.getSimpleName(),
                        true));
                addSqlType(sn, Util.IS_PACKAGE, false, true, null, null);
            }
            rs.close();
            stmt.close();

            stmt = m_conn
                .prepareStatement("SELECT COUNT(OBJECT_NAME) AS ARG_COUNT FROM ALL_ARGUMENTS WHERE OWNER = :1 AND PACKAGE_NAME IS NULL AND DATA_LEVEL = 0");
            stmt.setString(1, schema);
            rs = stmt.executeQuery();
            if (rs.next()) {
                int count = rs.getInt(1);
                if (count > 0) {
                    SqlType t = addSqlUserType(schema, "", Util.IS_TOPLEVEL, true, 0, 0, null);
                    String userName = SqlName.sqlIdToJavaId(TOPLEVEL, true);
                    t.getSqlName().setLangName("", userName, null, null, null, null, null, null,
                        true);
                }
            }
            rs.close();
            stmt.close();
        }
    }

    /* Add Java non-array types for publishing */
    public JavaType addJavaType(String typeName, List<AttributeField> fields,
        List<ProcedureMethod> methods, boolean genPattern, TypeClass sqlType) throws SQLException {
        if (typeName == null) {
            return null;
        }
        JavaType jt = null;
        for (int i = 0; i < m_userTypes.size(); i++) {
            if (m_userTypes.get(i) instanceof JavaType) {
                JavaType jTypeTmp = (JavaType)m_userTypes.get(i);
                JavaName jNameTmp = new JavaName(null, typeName, null, null, null);
                if (jTypeTmp.getJavaName().equals(jNameTmp)) {
                    jt = jTypeTmp;
                }
            }
        }
        if (jt != null) {
            return jt;
        }
        JavaName javaName = new JavaName(null, typeName, null, null, null);
        if (genPattern) {
            javaName = (JavaName)genPattern(javaName, typeName, false);
        }
        jt = new JavaBaseType(javaName, fields, methods, sqlType);
        m_userTypes.add(jt);
        return jt;
    }

    /**
     * Search among userTypes, and return a boolean indicating whether a subclass of the receiver
     * type has methods
     */
    public boolean hasMethodsInSubclasses(TypeClass who) throws SQLException, PublisherException {
        Iterator<TypeClass> iter = m_userTypes.iterator();
        while (iter.hasNext()) {
            TypeClass t = iter.next();
            if (!(t instanceof SqlType)) {
                continue;
            }
            SqlType st = (SqlType)t;
            boolean stHasMethods = st.hasMethods();
            while ((st = (SqlType)st.getSupertype()) != null) {
                if (who.getName() != null && who.getName().equals(st.getName())) {
                    if (stHasMethods) {
                        return true;
                    }
                    break;
                }
            }
        }
        return false;
    }

    public void createSqlStmtType(SqlName sqlName) throws SQLException {
        if (m_sqlStmtType == null) {
            m_sqlStmtType = new SqlStmtType(sqlName, this);
        }
    }

    public boolean isPre920() {
        if (m_isPre920 == null) {
            try {
                String v = m_conn.getMetaData().getDatabaseProductVersion().toUpperCase();
                if (v.startsWith("ORACLE DATABASE 10G") || v.startsWith("ORACLE DATABASE 11G")) {
                    m_isPre920 = Boolean.FALSE;
                    return false;
                }
                int pos = v.indexOf("ORACLE");
                if (0 < pos) {
                    v = v.substring(pos);
                }
                String vp = v.substring(0, "ORACLExx".length()).toUpperCase();
                if (vp.equals("ORACLE12")
                    || vp.equals("ORACLE11")
                    || vp.equals("ORACLE10")
                    || (vp.equals("ORACLE9I") && (v.indexOf("9.2.") > 0 || v.indexOf("9.3.") > 0 || v
                        .indexOf("9.4.") > 0))) {
                    m_isPre920 = Boolean.FALSE;
                }
            }
            catch (Exception e) {
                // Connection is pre 9.2.0
            }
            if (m_isPre920 == null) {
                m_isPre920 = Boolean.TRUE;
            }
        }
        return m_isPre920;
    }

    public boolean geqOracle9() {
        return m_geq9i;
    }

    public static boolean geqOracle9(Connection conn) {
        boolean geq9i = false;
        try {
            String dv = conn.getMetaData().getDatabaseProductVersion().toUpperCase();

            int pos = dv.indexOf("ORACLE");
            if (0 < pos) {
                dv = dv.substring(pos);
            }
            geq9i = dv.startsWith("ORACLE9") || dv.startsWith("ORACLE DATABASE 10G")
                || dv.startsWith("ORACLE DATABASE 11G") || dv.startsWith("ORACLE1")
                || dv.startsWith("ORACLE2") || dv.startsWith("ORACLE3");
        }
        catch (SQLException se) {
            /* assume the database is old */
        }
        return geq9i;
    }

    public void setTransitive(boolean transitive) {
        m_transitive = transitive;
    }

    // Return true if a column is null
    public static boolean isNull(String col) {
        return (col == null || col.length() == 0);
    }

    public boolean noUserTypes() {
        return m_userTypes.isEmpty();
    }

    public Map<String, SqlType> getTypeMap() {
        return m_typeMap;
    }

    /**
     * Used for implicitly publishing SQL types Based on the -genPattern setting, sets the LangName
     * associated with this SqlName.
     */
    private LangName genPattern(LangName langName, String simpleName, boolean sql2Java) {
        String genPattern = null;
        if (genPattern == null) {
            return langName;
        }
        @SuppressWarnings("unused") String useName = simpleName;
        if (sql2Java) {
            useName = SqlName.sqlIdToJavaId(simpleName, true);
        }
        // return sqlstring entry (e.g., a:b:c#d) according to m_genPattern.
        // Entries in itemTokens are used to replace %?
        // in m_genPattern. For instance, itemTokens can be
        // - {sqlTypeName, JavaTypeName, JavaSubclassName, JavaItf}
        // - {sqlTypeName}
        String sql = genPattern;
        for (int i = genPattern.length() - 1; i >= 0; i--) {
            if (genPattern.charAt(i) == '%' && i != genPattern.length() - 1) {
                int j = genPattern.charAt(i + 1) - '0';
                sql = sql.substring(0, i) + ((j == 1) ? simpleName : useName)
                    + sql.substring(i + 2);
                // System.out.println("SqlName: sql = "+sql); //D+
            }
        }
        // Derive useName, subclassName, interface name
        String useItf = null;
        String generatedName = null;
        String generatedItf = null;
        StringTokenizer st = new StringTokenizer(sql, "#");
        String[] tokens = new String[st.countTokens()];
        for (int i = 0; 0 < st.countTokens(); i++) {
            tokens[i] = st.nextToken();
            if (i == 1) {
                generatedItf = tokens[1];
                useItf = tokens[1];
            }
        }
        st = new StringTokenizer(tokens[0], ":");
        tokens = new String[st.countTokens()];
        for (int i = 0; 0 < st.countTokens(); i++) {
            tokens[i] = st.nextToken();
            if (i == 0) {
                useName = tokens[0];
            }
            else if (i == 1) {
                useName = tokens[1];
                generatedName = tokens[0];
            }
        }
        if (useName == null) {
            useItf = null;
        }
        if (generatedName == null) {
            generatedItf = null;
        }
        if (useItf != null) {
            generatedItf = null;
        }
        JavaName retJavaName = new JavaName("", useName, useItf, generatedName, generatedItf);
        return retJavaName;
    }

    public String determineSqlName(String name, boolean toBeDistinguished) {
        // toBeDistinguished is a marker indicating that the name is chopped
        // or post-fixed due to length over-limit or name conflicts. If true,
        // the new name needs to go through another round of conflicts checking.
        if (name.length() > MAX_IDENTIFIER_LENGTH) {
            name = name.substring(0, MAX_IDENTIFIER_LENGTH);
            toBeDistinguished = true;
        }
        String uniqueName = name.toUpperCase();
        if (m_allTypeNames.contains(uniqueName)
            || (toBeDistinguished && m_allGeneratedTypeNames.contains(uniqueName))) {
            do {
                int len1 = name.length();
                int len2 = Integer.toString(m_allGeneratedTypeNamesMagicNumber++).length();
                if ((len1 + len2) > MAX_IDENTIFIER_LENGTH) {
                    name = name.substring(0, MAX_IDENTIFIER_LENGTH - len2);
                }
                uniqueName = name.toUpperCase() + m_allGeneratedTypeNamesMagicNumber;
            }
            while (m_allTypeNames.contains(uniqueName)
                || (toBeDistinguished && m_allGeneratedTypeNames.contains(uniqueName)));
        }
        m_allGeneratedTypeNames.add(uniqueName);
        return uniqueName;
    }


    public ViewCache getViewCache() {
        return m_viewCache;
    }

    public void getViewCache(ViewCache vc) {
        m_viewCache = vc;
    }

    public void close() {
        try {
            if (m_conn != null) {
                m_conn.close();
            }
            if (m_viewCache != null) {
                m_viewCache.close();
            }
        }
        catch (Exception e) {
            // Closing resources. OK to ignore exception.
        }
    }

    /**
     * Returns all the user-defined SqlTypes. New types may be appended to the end of the
     * enumeration as the existing types are published or navigated.
     */
    public Iterator<TypeClass> getUserTypes() {
        return m_userTypes.iterator();
    }

    /**
     * @return metadata for generated PL/SQL wrapper package
     */

    public WrapperPackageMetadata getWrapperPackageMetadata() {
        return m_wrapperPackageMetadata;
    }

    public void addWrapperMethodMetadata(String name, String[] paramTypes, String[] paramNames,
        String returnType) {
        if (m_wrapperPackageMetadata == null) {
            m_wrapperPackageMetadata = new WrapperPackageMetadata("");
        }
        m_wrapperPackageMetadata.addMethod(new WrapperMethodMetadata(name, paramTypes, paramNames,
            returnType));
    }

}