* Copyright (c) 1998, 2011 Oracle. All rights reserved.

* This program and the accompanying materials are made available under the

* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0

* which accompanies this distribution.

* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html

* and the Eclipse Distribution License is available at

* http://www.eclipse.org/org/documents/edl-v10.php.

*

* Contributors:

*     Mike Norman - May 01 2008, creating DBWS tools package

******************************************************************************/

    public static final String BUILDER_FILE_PATH = "-builderFile";

    public static final String BUILDER_PACKAGING = "-packageAs";

    public static final String STAGE_DIR = "-stageDir";

    public static final String DRIVER_KEY = "driver";

    public static final String USERNAME_KEY= "username";

    public static final String PASSWORD_KEY = "password";

    public static final String URL_KEY = "url";

    public static final String PROJNAME_KEY = "projectName";

    public static final String CONTEXT_ROOT_KEY = "contextRoot";

    public static final String DATASOURCE_KEY = "dataSource";

    public static final String SESSIONS_FILENAME_KEY = "sessionsFileName";

    public static final String NO_SESSIONS_FILENAME = "no-sessions-fileName";

    public static final String PLATFORM_CLASSNAME_KEY = "platformClassname";

    public static final String ORSESSION_CUSTOMIZER_KEY = "orSessionCustomizerClassName";

    public static final String OXSESSION_CUSTOMIZER_KEY = "oxSessionCustomizerClassName";

    public static final String WSDL_URI_KEY = "wsdlLocationURI";

    public static final String LOG_LEVEL_KEY = "logLevel";

    public static final String TARGET_NAMESPACE_KEY = "targetNamespace";

    public static final String USE_SOAP12_KEY = "useSOAP12";

    public static final String WSI_SWAREF_XSD =

        "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" +

        "<xsd:schema targetNamespace=\"" + WSI_SWAREF_URI + "\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"> \n" +

        "  <xsd:simpleType name=\"" + WSI_SWAREF + "\"> \n" +

        "    <xsd:restriction base=\"xsd:anyURI\"/> \n" +

        "  </xsd:simpleType> \n" +

        "</xsd:schema>";

    public static Map<String,DBWSPackager> PACKAGERS = new HashMap<String,DBWSPackager>();

    static {

        ServiceLoader<DBWSPackager> packagers = ServiceLoader.load(DBWSPackager.class);

        for (DBWSPackager packager : packagers) {

            PACKAGERS.put(packager.getPackagerLabel(), packager);

        }

    }

    protected DBWSPackager packager;

    protected Logger logger;

    public boolean quiet = false;

    protected String destDir;

    protected DatabasePlatform databasePlatform;

    protected Connection conn;

    protected Project orProject;

    protected Project oxProject;

    protected WSDLGenerator wsdlGenerator = null;

    protected Schema schema = new Schema();

    protected NamespaceResolver ns = schema.getNamespaceResolver();

    protected XRServiceModel xrServiceModel = new DBWSModel();

    protected List<DbTable> dbTables = new ArrayList<DbTable>();

    protected List<DbStoredProcedure> dbStoredProcedures = new ArrayList<DbStoredProcedure>();

    protected Map<DbStoredProcedure, DbStoredProcedureNameAndModel> dbStoredProcedure2QueryName =

        new HashMap<DbStoredProcedure, DbStoredProcedureNameAndModel>();

    protected NamingConventionTransformer topTransformer;

    protected Set<String> typeDDL = new HashSet<String>();

    protected Set<String> typeDropDDL = new HashSet<String>();

    public DBWSBuilder() {

        super();

        ns.put("xsi", W3C_XML_SCHEMA_INSTANCE_NS_URI);

        ns.put("xsd", W3C_XML_SCHEMA_NS_URI);

    }

    public static void main(String[] args) throws WSDLException {

        DBWSBuilder builder = new DBWSBuilder();

        builder.start(args);

    }

    public void start(String[] args) throws WSDLException {

        if (args.length > 5 && BUILDER_FILE_PATH.equals(args[0]) &&

            STAGE_DIR.equals(args[2]) &&

            args[4].startsWith(BUILDER_PACKAGING)) {

            String builderFilename = args[1];

            String stageDirname = args[3];

            String packagerTag = args[5];

            String archiverTag = null;

            ArchiveUse archiveUse = ignore;

            int cIdx = args[4].indexOf(':');

            if (cIdx == 10) {

                archiverTag = args[4].substring(cIdx+1);

                if (archive.name().equals(archiverTag)) {

                    archiveUse = archive;

                }

                else if (noArchive.name().equals(archiverTag)) {

                    archiveUse = noArchive;

                }

            }

            String[] additionalArgs = null;

            if (args.length > 6) {

                additionalArgs = new String[args.length - 6];

                System.arraycopy(args, 6, additionalArgs, 0, args.length - 6);

            }

            File builderFile = new File(builderFilename);

            if (builderFile.exists() && builderFile.isFile()) {

                File stageDir = new File(stageDirname);

                if (stageDir.exists() && stageDir.isDirectory()) {

                    XMLContext context = new XMLContext(new DBWSBuilderModelProject());

                    XMLUnmarshaller unmarshaller = context.createUnmarshaller();

                    DBWSBuilderModel model = (DBWSBuilderModel)unmarshaller.unmarshal(builderFile);

                    properties = model.properties;

                    operations = model.operations;

                    if (operations.size() == 0) {

                        logMessage(SEVERE, "No operations specified");

                        return;

                    }

                    packager = PACKAGERS.get(packagerTag);

                    if (packager != null) {

                        packager.setDBWSBuilder(this);

                        packager.setArchiveUse(archiveUse);

                        packager.setAdditionalArgs(additionalArgs);

                        packager.setStageDir(stageDir);

                        packager.setSessionsFileName(getSessionsFileName());

                        start();

                        return;

                    }

                }

                else {

                    logMessage(SEVERE, "DBWSBuilder unable to locate stage directory " +

                        stageDirname);

                    return;

                }

            }

            else {

                logMessage(SEVERE, "DBWSBuilder unable to locate dbws-builder.xml file " +

                    builderFilename);

                return;

            }

        }

prompt> java -cp eclipselink.jar:eclipselink-dbwsutils.jar:your_favourite_jdbc_driver.jar org.eclipse.persistence.tools.dbws.DBWSBuilder -builderFile {path_to_dbws_builder.xml_file} -stageDir {path_to_staging_directory} -packageAs {how_to_package_output} [additionalArgs]

*/

        StringBuilder sb = new StringBuilder(30);

        sb.append("DBWSBuilder usage ([] indicates optional argument):\nprompt> java -cp eclipselink.jar:eclipselink-dbwsutils.jar:your_favourite_jdbc_driver.jar \\\n\t");

        sb.append(this.getClass().getName());

        sb.append(" ");

        sb.append(BUILDER_FILE_PATH);

        sb.append(" {path_to_dbwsbuilder.xml} \\\n\t");

        sb.append(STAGE_DIR);

        sb.append(" ");

        sb.append(" {path_to_stageDir}");

        sb.append(" ");

        sb.append(BUILDER_PACKAGING);

        sb.append("[:archive_flag - archive, noArchive, ignore] {packager} [additional arguments]\nAvailable packagers:\n\t");

        for (Iterator<Map.Entry<String, DBWSPackager>> i = PACKAGERS.entrySet().iterator(); i.hasNext();) {

            Map.Entry<String, DBWSPackager> me = i.next();

            sb.append(me.getValue().getUsage());

            if (i.hasNext()) {

                sb.append("\n\t");

            }

        }

        logMessage(SEVERE, sb.toString());

        return;

    }

    public void start() throws WSDLException {

        packager.setHasAttachments(hasAttachments());

        OutputStream dbwsSchemaStream = null;

        try {

            dbwsSchemaStream = packager.getSchemaStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + DBWS_SCHEMA_XML, fnfe);

            return;

        }

        OutputStream dbwsSessionsStream = null;

        try {

            dbwsSessionsStream = packager.getSessionsStream(getSessionsFileName());

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + DBWS_SESSIONS_XML, fnfe);

            return;

        };

        OutputStream dbwsServiceStream = null;

        try {

            dbwsServiceStream = packager.getServiceStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + DBWS_SERVICE_XML, fnfe);

            return;

        };

        OutputStream dbwsOrStream = null;

        try {

            dbwsOrStream = packager.getOrStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + DBWS_OR_XML, fnfe);

            return;

        };

        OutputStream dbwsOxStream = null;

        try {

            dbwsOxStream = packager.getOxStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + DBWS_OX_XML, fnfe);

            return;

        };

        OutputStream wsdlStream = null;

        try {

            wsdlStream = packager.getWSDLStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + DBWS_WSDL, fnfe);

            return;

        };

        OutputStream swarefStream = null;

        try {

            swarefStream = packager.getSWARefStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + SWAREF_FILENAME, fnfe);

            return;

        };

        OutputStream webXmlStream = null;

        try {

            webXmlStream = packager.getWebXmlStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE, "DBWSBuilder unable to create " + WEB_XML_FILENAME, fnfe);

            return;

        };

        OutputStream classProviderStream = null;

        try {

            classProviderStream = packager.getProviderClassStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE,

                "DBWSBuilder unable to create " + DBWS_PROVIDER_CLASS_FILE, fnfe);

            return;

        };

        OutputStream sourceProviderStream = null;

        try {

            sourceProviderStream = packager.getProviderSourceStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE,

                "DBWSBuilder unable to create " + DBWS_PROVIDER_SOURCE_FILE, fnfe);

            return;

        };

        OutputStream classProviderListenerStream = null;

        try {

            classProviderListenerStream = packager.getProviderListenerClassStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE,

                "DBWSBuilder unable to create " + PROVIDER_LISTENER_CLASS_FILE, fnfe);

            return;

        };

        OutputStream sourceProviderListenerStream = null;

        try {

            sourceProviderListenerStream = packager.getProviderListenerSourceStream();

        }

        catch (FileNotFoundException fnfe) {

            logMessage(SEVERE,

                "DBWSBuilder unable to create " + PROVIDER_LISTENER_SOURCE_FILE, fnfe);

            return;

        };

        build(dbwsSchemaStream, dbwsSessionsStream, dbwsServiceStream, dbwsOrStream,

            dbwsOxStream, swarefStream, webXmlStream, wsdlStream, classProviderStream,

            sourceProviderStream, classProviderListenerStream, sourceProviderListenerStream,

            logger);

    }

    public void build(OutputStream dbwsSchemaStream, OutputStream dbwsSessionsStream,

        OutputStream dbwsServiceStream, OutputStream dbwsOrStream, OutputStream dbwsOxStream,

        OutputStream swarefStream, OutputStream webXmlStream, OutputStream wsdlStream,

        OutputStream classProviderStream, OutputStream sourceProviderStream,

        OutputStream classProviderListenerStream, OutputStream sourceProviderListenerStream,

        Logger logger)

        throws WSDLException {

        this.logger = logger; // in case some other tool wishes to use a java.util.logger

        // misc setup

        xrServiceModel.setName(getProjectName());

        String sessionsFileName = getSessionsFileName();

        if (sessionsFileName != null && sessionsFileName.length() > 0) {

            xrServiceModel.setSessionsFile(sessionsFileName);

        }

        //has someone manually set a custom NamingConventionTransformer?

        if (topTransformer == null) {

            // setup the NamingConventionTransformers

            ServiceLoader<NamingConventionTransformer> transformers =

                ServiceLoader.load(NamingConventionTransformer.class);

            Iterator<NamingConventionTransformer> transformerIter = transformers.iterator();

            topTransformer = transformerIter.next();

            LinkedList<NamingConventionTransformer> transformerList =

                new LinkedList<NamingConventionTransformer>();

            // check for user-provided transformer in front of default transformers

            if (!((DefaultNamingConventionTransformer)topTransformer).isDefaultTransformer()) {

                // ditch all default transformers, except for the last one - SQLX2003Transformer

                for (; transformerIter.hasNext(); ) {

                    NamingConventionTransformer nextTransformer = transformerIter.next();

                    if (!((DefaultNamingConventionTransformer)nextTransformer).isDefaultTransformer()) {

                        transformerList.addLast(nextTransformer);

                    }

                    else if (nextTransformer instanceof SQLX2003Transformer) {

                        transformerList.addLast(nextTransformer);

                    }

                }

            }

            else {

                // assume usual configuration: ToLowerTransformer -> TypeSuffixTransformer -> SQLX2003Transformer

                for (; transformerIter.hasNext(); ) {

                    transformerList.addLast(transformerIter.next());

                }

            }

            // hook up the chain-of-responsibility

            NamingConventionTransformer nextTransformer = topTransformer;

            for (Iterator<NamingConventionTransformer> i = transformerList.iterator(); i.hasNext();) {

                NamingConventionTransformer nct = i.next();

                ((DefaultNamingConventionTransformer)nextTransformer).setNextTransformer(nct);

                nextTransformer = nct;

            }

        }

        packager.start();

        buildDbArtifacts();

        buildOROXProjects(topTransformer); // don't write out projects yet; buildDBWSModel may add additional mappings

        // don't write out schema yet; buildDBWSModel/buildWSDL may add additional schema elements

        buildSchema(topTransformer);

        buildSessionsXML(dbwsSessionsStream);

        buildDBWSModel(topTransformer, dbwsServiceStream);

        writeAttachmentSchema(swarefStream);

        buildWSDL(wsdlStream, topTransformer);

        writeWebXML(webXmlStream);

        generateDBWSProvider(sourceProviderStream, classProviderStream, sourceProviderListenerStream,

            classProviderListenerStream);

        writeSchema(dbwsSchemaStream); // now write out schema

        writeOROXProjects(dbwsOrStream, dbwsOxStream);

        packager.end();

    }

    public OutputStream getShadowDDLStream() {

        return __nullStream;

    }

    public void buildDbArtifacts() {

        // do Table operations first

        boolean isOracle =

            getDatabasePlatform().getClass().getName().contains("Oracle") ? true : false;

        for (OperationModel operation : operations) {

            if (operation.isTableOperation()) {

                TableOperationModel tableModel = (TableOperationModel)operation;

                String catalogPattern =

                    isOracle ? null : tableModel.getCatalogPattern();

                String schemaPattern = tableModel.getSchemaPattern();

                String tableNamePattern = tableModel.getTablePattern();

                List<DbTable> tables = checkTables(loadTables(catalogPattern,

                    schemaPattern, tableNamePattern));

                if (tables.isEmpty()) {

                    StringBuilder sb = new StringBuilder();

                    sb.append("No matching tables for pattern ");

                    if (catalogPattern != null) {

                        sb.append(catalogPattern);

                        sb.append(".");

                    }

                    if (schemaPattern != null) {

                        sb.append(schemaPattern);

                        sb.append(".");

                    }

                    sb.append(tableNamePattern);

                    logMessage(FINEST, sb.toString());

                }

                else {

                    dbTables.addAll(tables);

                }

            }

        }

        // next do StoredProcedure operations

        for (OperationModel operation : operations) {

            if (operation.isProcedureOperation()) {

                ProcedureOperationModel procedureModel = (ProcedureOperationModel)operation;

                String catalogPattern = procedureModel.getCatalogPattern();

                String schemaPattern = procedureModel.getSchemaPattern();

                String procedurePattern = procedureModel.getProcedurePattern();

                List<DbStoredProcedure> procs = loadProcedures(procedureModel, isOracle);

                if (procs.isEmpty()) {

                    StringBuilder sb = new StringBuilder();

                    sb.append("No matching procedures for pattern ");

                    if (catalogPattern != null) {

                        sb.append(catalogPattern);

                        sb.append(".");

                    }

                    if (schemaPattern != null) {

                        sb.append(schemaPattern);

                        sb.append(".");

                    }

                    sb.append(procedurePattern);

                    logMessage(FINEST, sb.toString());

                }

                else {

                    dbStoredProcedures.addAll(procs);

                }

            }

        }

        buildDbStoredProcedure2QueryNameMap(dbStoredProcedure2QueryName, dbStoredProcedures,

            operations, isOracle);

    }

    protected List<DbTable> loadTables(String catalogPattern, String schemaPattern,

        String tableNamePattern) {

        return checkTables(JDBCHelper.buildDbTable(getConnection(),

                databasePlatform, catalogPattern, schemaPattern, tableNamePattern));

    }

    public List<DbTable> checkTables(List<DbTable> dbTables) {

        List<DbTable> supportedTables = new ArrayList<DbTable>(dbTables.size());

        for (DbTable dbTable : dbTables) {

            boolean unSupportedColumnType = false;

            for (DbColumn dbColumn : dbTable.getColumns()) {

                switch (dbColumn.getJDBCType()) {

                    case Types.ARRAY :

                    case Types.STRUCT :

                    case Types.OTHER :

                    case Types.DATALINK :

                    case Types.JAVA_OBJECT :

                        unSupportedColumnType = true;

                        break;

                }

            }

            if (!unSupportedColumnType) {

                supportedTables.add(dbTable);

            }

        }

        return supportedTables;

    }

    public void addDbTable(DbTable dbTable) {

        dbTables.add(dbTable);

    }

    protected List<DbStoredProcedure> loadProcedures(ProcedureOperationModel procedureModel,

        boolean isOracle) {

        //bug 296114 - Problem using JDBC metadata for Oracle Stored Function in package with overloading

        //             use OracleHelper for all StoredProcedure operations, not just PL/SQL or

        //             advancedJDBC

        if (isOracle) {

            return OracleHelper.buildStoredProcedure(getConnection(), getUsername(), databasePlatform,

                procedureModel);

        }

        else {

            // use JDBC helper

            return checkStoredProcedures(JDBCHelper.buildStoredProcedure(getConnection(),

                databasePlatform, procedureModel), 0);

        }

    }

    public List<DbStoredProcedure> checkStoredProcedures(List<DbStoredProcedure> procedures,

        int oracleOverload) {

        List<DbStoredProcedure> supportedProcedures =

            new ArrayList<DbStoredProcedure>(procedures.size());

        List<DbStoredProcedure> copyOfProcedures =

            new ArrayList<DbStoredProcedure>(procedures.size());

        List<DbStoredProcedure> overloadedProcedure =

            new ArrayList<DbStoredProcedure>(1);

        if (oracleOverload == 0) {

            copyOfProcedures.addAll(procedures);

        }

        else {

            // For Oracle, storedProcedures can be overloaded - we are looking for

            // a specific version

            for (DbStoredProcedure storedProcedure : procedures) {

                if (storedProcedure.getOverload() == oracleOverload) {

                    overloadedProcedure.add(storedProcedure);

                    break;

                }

            }

            copyOfProcedures.addAll(overloadedProcedure);

        }

        for (DbStoredProcedure storedProcedure : copyOfProcedures) {

            boolean unSupportedArgType = false;

            for (DbStoredArgument arg : storedProcedure.getArguments()) {

                int jdbcType = arg.getJdbcType();

                if (jdbcType == OTHER) {

                    // For Oracle, the only way to get anything 'out' of a Stored Procedure

                    // is via a CURSOR - so this type of 'OTHER' is allowed

                    if (arg.getJdbcTypeName().contains("CURSOR") && arg.getInOut() == OUT) {

                        continue;

                    }

                    else {

                        unSupportedArgType = true;

                        break;

                    }

                }

                else if (jdbcType == ARRAY ||

                         jdbcType == STRUCT ||

                         jdbcType == DATALINK ||

                         jdbcType == JAVA_OBJECT) {

                        unSupportedArgType = true;

                        break;

                }

            }

            if (!unSupportedArgType) {

                supportedProcedures.add(storedProcedure);

            }

        }

        return supportedProcedures;

    }

    public void addDbStoredProcedure(DbStoredProcedure dbStoredProcedure) {

        dbStoredProcedures.add(dbStoredProcedure);

    }

    public void addSqlOperation(SQLOperationModel sqlOperation) {

        operations.add(sqlOperation);

    }

    protected void buildOROXProjects(NamingConventionTransformer nct) {

        String projectName = getProjectName();

        orProject = new Project();

        orProject.setName(projectName + "-" + DBWS_OR_LABEL);

        if (dbTables.isEmpty() && !hasBuildSqlOperations()) {

            logMessage(FINEST, "No tables specified");

            oxProject = new SimpleXMLFormatProject();

        }

        else {

            oxProject = new Project();

        }

        oxProject.setName(projectName + "-" + DBWS_OX_LABEL);

        for (DbTable dbTable : dbTables) {

            String tableName = dbTable.getName();

            RelationalDescriptor desc = buildORDescriptor(tableName, nct);

            orProject.addDescriptor(desc);

            XMLDescriptor xdesc = buildOXDescriptor(tableName, nct);

            oxProject.addDescriptor(xdesc);

            for (DbColumn dbColumn : dbTable.getColumns()) {

                String columnName = dbColumn.getName();

                ElementStyle style = nct.styleForElement(columnName);

                if (style == NONE) {

                    continue;

                }

                logMessage(FINE, "Building mappings for " + tableName + "." + columnName);

                DirectToFieldMapping orFieldMapping = buildORFieldMappingFromColumn(dbColumn, desc, nct);

                desc.addMapping(orFieldMapping);

                XMLDirectMapping oxFieldMapping = buildOXFieldMappingFromColumn(dbColumn, xdesc, nct);

                xdesc.addMapping(oxFieldMapping);

                // check for switch from Byte[] to byte[]

                if (oxFieldMapping.getAttributeClassificationName() == APBYTE.getName()) {

                    orFieldMapping.setAttributeClassificationName(APBYTE.getName());

                }

          }

          ReadObjectQuery roq = new ReadObjectQuery();

          String generatedJavaClassName = getGeneratedJavaClassName(tableName);

          roq.setReferenceClassName(generatedJavaClassName);

          Expression expression = null;

          Expression builder = new ExpressionBuilder();

          Expression subExp1;

          Expression subExp2;

          Expression subExpression;

          List<DatabaseField> primaryKeyFields = desc.getPrimaryKeyFields();

          for (int index = 0; index < primaryKeyFields.size(); index++) {

              DatabaseField primaryKeyField = primaryKeyFields.get(index);

              subExp1 = builder.getField(primaryKeyField);

              subExp2 = builder.getParameter(primaryKeyField.getName().toLowerCase());

              subExpression = subExp1.equal(subExp2);

              if (expression == null) {

                  expression = subExpression;

              }

              else {

                  expression = expression.and(subExpression);

              }

              roq.addArgument(primaryKeyField.getName().toLowerCase());

          }

          roq.setSelectionCriteria(expression);

          desc.getQueryManager().addQuery(PK_QUERYNAME, roq);

          ReadAllQuery raq = new ReadAllQuery();

          raq.setReferenceClassName(generatedJavaClassName);

          desc.getQueryManager().addQuery(FINDALL_QUERYNAME, raq);

        }

        for (OperationModel opModel : operations) {

            if (opModel.isProcedureOperation()) {

                ProcedureOperationModel procOpModel = (ProcedureOperationModel)opModel;

                if (procOpModel.getJPubType() != null) {

                    if (procOpModel.isPLSQLProcedureOperation()) {

                        buildOROXProjectsForAdvancedPLSQLProcedure(procOpModel);

                    }

                    else {

                        buildOROXProjectsForAdvancedProcedure(procOpModel, nct);

                    }

                }

            }

            if (opModel.isSQLOperation() && ((SQLOperationModel)opModel).hasBuildSql()) {

                buildOROXProjectsForSecondarySql((SQLOperationModel)opModel, nct);

            }

        }

        DatabaseLogin databaseLogin = new DatabaseLogin();

        databaseLogin.removeProperty("user");

        databaseLogin.removeProperty("password");

        databaseLogin.setDriverClassName(null);

        databaseLogin.setConnectionString(null);

        orProject.setLogin(databaseLogin);

        XMLLogin xmlLogin = new XMLLogin();

        xmlLogin.setDatasourcePlatform(new DOMPlatform());

        xmlLogin.getProperties().remove("user");

        xmlLogin.getProperties().remove("password");

        oxProject.setLogin(xmlLogin);

    }

    protected void buildOROXProjectsForSecondarySql(SQLOperationModel sqlOm,

        NamingConventionTransformer nct) {

        List<DbColumn> columns = JDBCHelper.buildDbColumns(getConnection(),

            sqlOm.getBuildSql());

        String tableName = sqlOm.getReturnType();

        // need custom NamingConventionTransformer so that returnType/tableName is

        // used verbatim

        NamingConventionTransformer extraNct = new DefaultNamingConventionTransformer() {

            @Override

            protected boolean isDefaultTransformer() {

                return false;

            }

            @Override

            public String generateSchemaAlias(String tableName) {

                return tableName;

            }

        };

        ((DefaultNamingConventionTransformer)extraNct).setNextTransformer(nct);

        RelationalDescriptor desc = buildORDescriptor(tableName, extraNct);

        desc.descriptorIsAggregate();

        orProject.addDescriptor(desc);

        XMLDescriptor xdesc = buildOXDescriptor(tableName, extraNct);

        oxProject.addDescriptor(xdesc);

        List<String> columnsAlreadyProcessed = new ArrayList<String>();

        for (DbColumn dbColumn : columns) {

            String columnName = dbColumn.getName();

            if (!columnsAlreadyProcessed.contains(columnName)) {

                columnsAlreadyProcessed.add(columnName);

                ElementStyle style = nct.styleForElement(columnName);

                if (style == NONE) {

                    continue;

                }

                logMessage(FINE, "Building mappings for " + columnName);

                DirectToFieldMapping orFieldMapping = buildORFieldMappingFromColumn(dbColumn, desc, nct);

                desc.addMapping(orFieldMapping);

                XMLDirectMapping oxFieldMapping = buildOXFieldMappingFromColumn(dbColumn, xdesc, nct);

                xdesc.addMapping(oxFieldMapping);

            }

            else {

                logMessage(SEVERE, "Duplicate ResultSet columns not supported '" + columnName + "'");

                throw new RuntimeException("Duplicate ResultSet columns not supported");

            }

        }

    }

    @SuppressWarnings("unchecked")

    protected void buildOROXProjectsForAdvancedPLSQLProcedure(ProcedureOperationModel procOpModel) {

        /*

         * Walk-thru sqlType, building PLSQLCollection/PLSQLrecord helper objects,

         * ObjectRelationalDataTypeDescriptors and mappings, XMLDescriptors and mappings

         */

        PLSQLHelperObjectsBuilder helperObjectsBuilder = new PLSQLHelperObjectsBuilder(this, procOpModel);

        PLSQLORDescriptorBuilder orDescriptorBuilder = new PLSQLORDescriptorBuilder();

        PLSQLOXDescriptorBuilder oxDescriptorBuilder = new PLSQLOXDescriptorBuilder(getTargetNamespace());

        PublisherListenerChainAdapter chain = new PublisherListenerChainAdapter();

        chain.addListener(helperObjectsBuilder);

        chain.addListener(orDescriptorBuilder);

        chain.addListener(oxDescriptorBuilder);

        PublisherWalker walker = new PublisherWalker(chain);

        procOpModel.getJPubType().accept(walker);

        if (orDescriptorBuilder.getDescriptors() != null) {

            for (ObjectRelationalDataTypeDescriptor ordtDescriptor : orDescriptorBuilder.getDescriptors()) {

                orProject.addDescriptor(ordtDescriptor);

            }

        }

        if (oxDescriptorBuilder.getDescriptors() != null) {

            for (XMLDescriptor xdesc : oxDescriptorBuilder.getDescriptors()) {

                oxProject.addDescriptor(xdesc);

            }

        }

        if (procOpModel.hasDbStoredProcedures()) {

            for (int i=0; i< procOpModel.getDbStoredProcedures().size(); i++) {

                DbStoredProcedure storedProcedure = procOpModel.getDbStoredProcedures().get(i);

                boolean isPLSQLStoredProc = false;

                for (DbStoredArgument arg : storedProcedure.getArguments()) {

                    if (arg.isPLSQLArgument() || storedProcedure.getOverload() > 0) {

                        isPLSQLStoredProc = true;

                        break;

                    }

                }

               

                PLSQLStoredProcedureCall call;

                if (storedProcedure.isFunction()) {

                    if (procOpModel.getDbStoredFunctionReturnType() != null) {

                        call = new PLSQLStoredFunctionCall(procOpModel.getDbStoredFunctionReturnType());

                    } else {

                        call = new PLSQLStoredFunctionCall();

                    }

                } else {

                    call = new PLSQLStoredProcedureCall();

                }

               

                if (isPLSQLStoredProc) {

                    String catalogPrefix = null;

                    String cat = storedProcedure.getCatalog();

                    if (cat == null | cat.length() == 0) {

                        catalogPrefix = "";

                    }

                    else {

                        catalogPrefix = cat + ".";

                    }

                    call.setProcedureName(catalogPrefix + storedProcedure.getName());

                    DatabaseQuery dq = null;

                    DbStoredProcedureNameAndModel nameAndModel =

                        dbStoredProcedure2QueryName.get(storedProcedure);

                    String returnType = nameAndModel.procOpModel.getReturnType();

                    boolean hasResponse = returnType != null;

                    String typ = null;

                    ClassDescriptor xdesc = null;

                    if (hasResponse) {

                        int idx = 0;

                        int colonIdx = returnType.indexOf(":");

                        if (colonIdx == -1) {

                            idx = returnType.indexOf("}");

                        }

                        else {

                            idx = colonIdx;

                        }

                        if (idx > 0) {

                            typ = returnType.substring(idx+1);

                            for (XMLDescriptor xd : (List<XMLDescriptor>)(List)oxProject.getOrderedDescriptors()) {

                                if (xd.getSchemaReference() != null) {

                                    String context = xd.getSchemaReference().getSchemaContext();

                                    if (context.substring(1).equals(typ)) {

                                        xdesc = xd;

                                        break;

                                    }

                                }

                            }

                        }

                    }

                    if (hasResponse) {

                        if (nameAndModel.procOpModel.isCollection) {

                            dq = new DataReadQuery();

                        }

                        else {

                            dq = new ValueReadQuery();

                        }

                    }

                    else {

                        dq = new ValueReadQuery();

                    }

                    dq.bindAllParameters();

                    dq.setName(nameAndModel.name);

                    dq.setCall(call);

                    DatabaseType[] typesForMethod = procOpModel.getArgumentTypes().get(i);

                    for (int j=0, len=typesForMethod.length; j<len; j++) {

                        DbStoredArgument arg = storedProcedure.getArguments().get(j);

                        DatabaseType databaseType = typesForMethod[j];

                        InOut direction = arg.getInOut();

                        if (direction == OUT) {

                            call.addNamedOutputArgument(arg.getName(), databaseType);

                        }

                        else if (direction == IN) {

                            call.addNamedArgument(arg.getName(), databaseType);

                        }

                        else {

                            call.addNamedInOutputArgument(arg.getName(), databaseType);

                        }

                        if (direction == IN | direction == INOUT) {

                            if (xdesc != null) {

                                dq.addArgumentByTypeName(arg.getName(), xdesc.getJavaClassName());

                            }

                            else {

                                if (databaseType instanceof PLSQLCollection) {

                                    dq.addArgument(arg.getName(), Array.class);

                                }

                                else if (databaseType instanceof PLSQLrecord) {

                                    dq.addArgument(arg.getName(), Struct.class);

                                }

                                else {

                                    dq.addArgument(arg.getName(),

                                        JDBCTypes.getClassForCode(databaseType.getConversionCode()));

                                }

                            }

                        }

                    }

                    orProject.getQueries().add(dq);

                }

            }

        }

    }

    protected void buildOROXProjectsForAdvancedProcedure(ProcedureOperationModel procOpModel,

        NamingConventionTransformer nct) {

        // bug 271679 Advanced JDBC types (table, object, array)

        /*

         * Walk-thru sqlType, building ObjectRelationalDataTypeDescriptors (and mappings),

         * XMLDescriptors (and mappings) and DatabaseQuery's

         */

        AdvancedJDBCQueryBuilder queryBuilder =

            new AdvancedJDBCQueryBuilder(dbStoredProcedures, dbStoredProcedure2QueryName);

        AdvancedJDBCORDescriptorBuilder orDescriptorBuilder = new AdvancedJDBCORDescriptorBuilder();

        AdvancedJDBCOXDescriptorBuilder oxDescriptorBuilder =

            new AdvancedJDBCOXDescriptorBuilder(getTargetNamespace(), nct);

        PublisherListenerChainAdapter chain = new PublisherListenerChainAdapter();

        chain.addListener(queryBuilder);

        chain.addListener(orDescriptorBuilder);

        chain.addListener(oxDescriptorBuilder);

        PublisherWalker walker = new PublisherWalker(chain);

        procOpModel.getJPubType().accept(walker);

        if (orDescriptorBuilder.getDescriptors() != null) {

            for (ObjectRelationalDataTypeDescriptor ordtDescriptor : orDescriptorBuilder.getDescriptors()) {

                orProject.addDescriptor(ordtDescriptor);

            }

        }

        if (oxDescriptorBuilder.getDescriptors() != null) {

            for (XMLDescriptor xdesc : oxDescriptorBuilder.getDescriptors()) {

                oxProject.addDescriptor(xdesc);

            }

        }

        List<DatabaseQuery> newQueries = queryBuilder.getQueries();

        if (newQueries != null) {

            orProject.getQueries().addAll(newQueries);

        }

    }

    protected void writeOROXProjects(OutputStream dbwsOrStream, OutputStream dbwsOxStream) {

        boolean writeORProject = false;

        if (dbTables.size() > 0 || hasBuildSqlOperations()) {

            writeORProject = true;

        }

        else if (dbStoredProcedures.size() > 0) {

            for (DbStoredProcedure storedProcedure : dbStoredProcedures) {

                for (DbStoredArgument storedArgument : storedProcedure.getArguments()) {

                    if (storedArgument instanceof PLSQLStoredArgument) {

                        writeORProject = true;

                        break;