executeprocedurepanel.java

eq跨平台查询工具源码 eq跨平台查询工具源码

     * The code written for this method performs the operations
     * that need to occur when an item is selected (or deselected).
     */    
    public void itemStateChanged(ItemEvent e) {
        // interested in selections only
        if (e.getStateChange() == ItemEvent.DESELECTED) {
            return;
        }

        final Object source = e.getSource();
        GUIUtils.startWorker(new Runnable() {
            public void run() {
                try {
                    setInProcess(true);
                    reloadProcedureList(source);
                }
                finally {
                    setInProcess(false);
                }
            }
        });
    }

    private void reloadProcedureList(Object source) {
        if (source == connectionsCombo) {
            // retrieve connection selection
            DatabaseConnection connection = 
                    (DatabaseConnection)connectionsCombo.getSelectedItem();
            // reset meta data
            metaData.setDatabaseConnection(connection);

            // reset schema values
            Vector schemas = null;
            try {
                schemas = metaData.getHostedSchemasVector();
                if (schemas == null || schemas.isEmpty()) {
                    useCatalogs = true;
                    schemas = metaData.getHostedCatalogsVector();
                }
            }
            catch (DataSourceException e) {
                GUIUtilities.displayExceptionErrorDialog(
                        "Error retrieving the catalog/schema names for " +
                        "the current connection.\n\nThe system returned:\n" + 
                        e.getExtendedMessage(), e);
                schemas = new Vector<String>(0);
            }
            populateSchemaValues(schemas);
        }
        else if (source == schemaCombo) {
            schemaChanged();
        }
        else if (source == objectTypeCombo) {
            objectTypeChanged();
        }
    }
    
    private void populateSchemaValues(final Vector schemas) {
        GUIUtils.invokeAndWait(new Runnable() {
            public void run() {
                // enable the object type combo
                objectTypeCombo.setEnabled(true);

                // remall all and disable the procedures combo
                proceduresModel.removeAllElements();
                procedureCombo.setEnabled(false);

                if (schemas != null) {
                    schemaModel.setElements(schemas);
                    schemaCombo.setEnabled(true);

                    if (!schemas.isEmpty()) {
                        schemaCombo.setSelectedIndex(0);
                    }

                } 
                else {
                    schemaModel.removeAllElements();
                    schemaCombo.setEnabled(false);
                }
            }
        });
    }

    private void objectTypeChanged() {
        DatabaseProcedure[] procs = null;
        try {
            String catalogName = null;
            String schemaName = null;
            Object value = schemaCombo.getSelectedItem();

            if (value != null) {
                if (useCatalogs) {
                    catalogName = value.toString();
                }
                else {                    
                    schemaName = value.toString();
                }
            }

            // set the connection on the meta data
            DatabaseConnection dc = (DatabaseConnection)
                            connectionsCombo.getSelectedItem();
            metaData.setDatabaseConnection(dc);

            if (objectTypeCombo.isEnabled()) {
            
                // check for 'normal' object types - non proc term
                String[] type = objectTypeCombo.getSelectedIndex() == 0 ?
                                                        FUNCTION : PROCEDURE;

                String schema = useCatalogs ? catalogName : schemaName;              
                procs = metaData.getStoredObjects(schema, type);

                // check the other object type
                if (procs == null || procs.length == 0) {
                    // swap the type over
                    if (type == FUNCTION) {
                        type = PROCEDURE;
                    } else {
                        type = FUNCTION;
                    }

                    // if still empty continue, otherwise bail and
                    // let the user pick the other type
                    if (metaData.hasStoredObjects(schema, type)) {
                        GUIUtils.invokeAndWait(new Runnable() {
                            public void run() {
                                proceduresModel.removeAllElements();
                                procedureCombo.setEnabled(false);                                
                            }
                        });
                        return;
                    }

                }

            }
            
            boolean usedProcedureTerm = false;
            
            // if we don't have any, try the meta data proc term
            if (procs == null || procs.length == 0) {

                // retrieve the procedure names
                String[] procedures = metaData.getProcedureNames(
                                                    catalogName, schemaName, null);

                // check the proc term if we have nothing
                if (procedures == null || procedures.length == 0) {
                    procedures = checkProcedureTerm(catalogName, schemaName);
                }

                // check if we still have none and get the proc details
                if (procedures != null || procedures.length > 0) {
                    procs = metaData.getProcedures(catalogName, schemaName, procedures);
                }

                /*
                // loop through and get the procs
                procs = new DatabaseProcedure[procedures.length];
                for (int i = 0; i < procedures.length; i++) {
                    procs[i] = metaData.getProcedureColumns(catalogName, schemaName, procedures[i]);
                }
                */

                usedProcedureTerm = (procs != null && procs.length > 0);                
            }

            populateProcedureValues(procs, usedProcedureTerm);
        }
        catch (DataSourceException e) {
            GUIUtilities.displayExceptionErrorDialog(
                    "Error retrieving a list of stored object for the " +
                    "selected connection:.\n\nThe system returned:\n" + 
                    e.getExtendedMessage(), e);
        }

    }

    private void populateProcedureValues(final DatabaseProcedure[] procs, 
                                         final boolean usedProcedureTerm) {
        GUIUtils.invokeAndWait(new Runnable() {
            public void run() {
                // check that we finally have some
                if (procs != null && procs.length > 0) {
                    // reset the procedures combo
                    proceduresModel.setElements(procs);
                    procedureCombo.setSelectedIndex(0);
                    procedureCombo.setEnabled(true);

                    // disable the object type combo if it wasn't 
                    // used to retrieve the procs list
                    if (usedProcedureTerm) {
                        objectTypeCombo.setEnabled(false);
                    } else {
                        objectTypeCombo.setEnabled(true);
                    }

                }
                else {
                    proceduresModel.removeAllElements();
                    procedureCombo.setEnabled(false);
                }

            }
        });
    }
    
    /**
     * Checks the procedure term against a function or procedure node
     * when the returned results from getTables(...) is null or empty.
     *
     * @param object - the meta object
     */
    private String[] checkProcedureTerm(String catalog, String schema) {
        DatabaseConnection dc = (DatabaseConnection)
                        connectionsCombo.getSelectedItem();
        metaData.setDatabaseConnection(dc);
        
        try {
            String procedureTerm = metaData.getProcedureTerm();            
            if (procedureTerm != null) {
                return metaData.getProcedureNames(catalog, schema, null);
            }
        }
        catch (DataSourceException e) {}
        return new String[0];
    }

    /**
     * Called when a schema selection has changed.
     */
    private void schemaChanged() {
        GUIUtils.invokeAndWait(new Runnable() {
            public void run() {
                // reset the procedures combo
                proceduresModel.removeAllElements();
                procedureCombo.setEnabled(false);

                // enable the type combo
                objectTypeCombo.setEnabled(true);

                // run action on object type combo
                if (objectTypeCombo.getSelectedIndex() == 0) {
                    objectTypeChanged();
                } else {
                    objectTypeCombo.setSelectedIndex(0);
                }
            }
        });
    }

    public void cleanup() {
        EventMediator.deregisterListener(EventMediator.CONNECTION_EVENT, this);
        if (metaData != null) {
            closeConnection();
        }
        if (querySender != null) {
            try {
                querySender.destroyConnection();
            } catch (SQLException e) {}
        }
    }
    
    public void closeConnection() {
        metaData.closeConnection();
    }

    /**
     * Invoked on selection of a procedure from the combo.
     */
    public void procedureSelectionChanged() {
        int index = procedureCombo.getSelectedIndex();
        DatabaseProcedure proc = (DatabaseProcedure)proceduresModel.getElementAt(index);

        if (proc != null) {
            tableModel.setValues(proc.getParameters());
        } else {
            tableModel.clear();
        }

        tableModel.fireTableDataChanged();
    }
    
    /**
     * Executes the selected procedure.
     */
    public void execute() {
        int selectedRow = table.getSelectedRow();
        int selectedColumn = table.getSelectedColumn();

        if (selectedRow != -1 && selectedColumn != -1) {
            if (table.isEditing()) {
                table.getCellEditor(
                        selectedRow, selectedColumn).stopCellEditing();
            }
        }

        GUIUtils.startWorker(new Runnable() {
            public void run() {