executeprocedurepanel.java

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

                try {
                    setInProcess(true);
                    DatabaseConnection dc = (DatabaseConnection)
                                    connectionsCombo.getSelectedItem();
                    if (dc == null) {
                        GUIUtilities.displayErrorMessage(
                                "No database connection is available.");
                        return;
                    }

                    int index = procedureCombo.getSelectedIndex();
                    DatabaseProcedure proc =
                            (DatabaseProcedure)proceduresModel.getElementAt(index);

                    if (proc == null) {
                        return;
                    }

                    //resultsPanel.clearErrorPanel();
                    int type = objectTypeCombo.getSelectedIndex();
                    String text = type == 0 ? " function " : " procedure ";
                    setActionMessage("Executing" + text + proc.getName() + "...");

                    if (querySender == null) {
                        querySender = new QuerySender(dc);
                    } else {
                        querySender.setDatabaseConnection(dc);
                    }

                    SqlStatementResult result = querySender.executeProcedure(proc);
                    Hashtable results = (Hashtable)result.getOtherResult();

                    if (results == null) {
                        setErrorMessage(result.getErrorMessage());
                    }
                    else {
                        setPlainMessage("Statement executed successfully.");
                        int updateCount = result.getUpdateCount();

                        if (updateCount > 0) {
                            setPlainMessage(updateCount + 
                                    updateCount > 1 ? " rows affected." : " row affected.");
                        }

                        String SPACE = " = ";
                        Enumeration keys = results.keys();

                        while (keys.hasMoreElements()) {
                            String key = keys.nextElement().toString();
                            setPlainMessage(key + SPACE + results.get(key));
                        }

                    }

                }
                catch(Exception exc) {
                    exc.printStackTrace();
                }
                finally {
                    setInProcess(false);
                }
            }
        });
    }

    private void setActionMessage(final String message) {
        GUIUtils.invokeAndWait(new Runnable() {
            public void run() {
                resultsPanel.setActionMessage(message);
            }
        });        
    }
    
    private void setPlainMessage(final String message) {
        GUIUtils.invokeAndWait(new Runnable() {
            public void run() {
                resultsPanel.setPlainMessage(message);
            }
        });
    }

    private void setErrorMessage(final String message) {
        GUIUtils.invokeAndWait(new Runnable() {
            public void run() {
                resultsPanel.setErrorMessage(message);
            }
        });
    }
    
    // ---------------------------------------------
    // ConnectionListener implementation
    // ---------------------------------------------
    
    /**
     * Indicates a connection has been established.
     * 
     * @param the encapsulating event
     */
    public void connected(ConnectionEvent connectionEvent) {
        enableCombos(true);
        connectionsModel.addElement(connectionEvent.getSource());
    }

    /**
     * Indicates a connection has been closed.
     * 
     * @param the encapsulating event
     */
    public void disconnected(ConnectionEvent connectionEvent) {
        connectionsModel.removeElement(connectionEvent.getSource());
        if (connectionsModel.getSize() == 0) {
            enableCombos(false);
        }
        // TODO: NEED TO CHECK OPEN CONN
        
    }

    /**
     * Returns the display name for this view.
     *
     * @return the display name
     */
    public String getDisplayName() {
        return TITLE + (count++);
    }

    /**
     * Indicates the panel is being removed from the pane
     */
    public boolean tabViewClosing() {
        cleanup();
        return true;
    }
    
    
    class ParameterTableModel extends AbstractTableModel {
        
        private String UNKNOWN = "UNKNOWN";
        private String RETURN = "RETURN";
        private String RESULT = "RESULT";
        private String IN = "IN";
        private String INOUT = "INOUT";
        private String OUT = "OUT";
        
        private String[] columns = {"Parameter", "Data Type", "Mode", "Value"};
        private ProcedureParameter[] values;
        
        public ParameterTableModel() {}
        
        public ParameterTableModel(ProcedureParameter[] _procParams) {
            values = _procParams;
        }
        
        public int getRowCount() {
            if (values == null) {
                return 0;
            }            
            return values.length;
        }
        
        public int getColumnCount() {
            return 4;
        }
        
        public void clear() {
            values = null;
        }
        
        public void setValues(ProcedureParameter[] _procParams) {
            values = _procParams;
        }
        
        public Object getValueAt(int row, int col) {
            if (values == null) {
                return "";
            }

            ProcedureParameter param = values[row];
            
            switch (col) {
                
                case 0:
                    return param.getName();
                    
                case 1:
                    
                    if (param.getSize() > 0)
                        return param.getSqlType() + "(" + param.getSize() + ")";
                    else
                        return param.getSqlType();
                    
                case 2:
                    int mode = param.getType();
                    
                    switch (mode) {                        
                        case DatabaseMetaData.procedureColumnIn:
                            return IN;
                        case DatabaseMetaData.procedureColumnOut:
                            return OUT;
                        case DatabaseMetaData.procedureColumnInOut:
                            return INOUT;
                        case DatabaseMetaData.procedureColumnUnknown:
                            return UNKNOWN;
                        case DatabaseMetaData.procedureColumnResult:
                            return RESULT;
                        case DatabaseMetaData.procedureColumnReturn:
                            return RETURN;
                        default:
                            return UNKNOWN;
                    }
                    
                case 3:
                    String value = param.getValue();
                    return value == null ? Constants.EMPTY : value;
                    
                default:
                    return UNKNOWN;
                    
            }
            
        }
        
        public void setValueAt(Object value, int row, int col) {
            ProcedureParameter param = values[row];
            
            switch (col) {
                
                case 0:
                    param.setName((String)value);
                    break;
                    
                case 1:
                    param.setSqlType((String)value);
                    break;
                    
                case 2:
                    if (value == IN) {
                        param.setType(DatabaseMetaData.procedureColumnIn);
                    }
                    else if (value == OUT) {
                        param.setType(DatabaseMetaData.procedureColumnOut);
                    }
                    else if (value == INOUT) {
                        param.setType(DatabaseMetaData.procedureColumnInOut);
                    }
                    else if (value == UNKNOWN) {
                        param.setType(DatabaseMetaData.procedureColumnUnknown);
                    }
                    else if (value == RESULT) {
                        param.setType(DatabaseMetaData.procedureColumnResult);
                    }
                    else if (value == RETURN) {
                        param.setType(DatabaseMetaData.procedureColumnReturn);
                    }
                case 3:
                    param.setValue((String)value);
                    
            }
            
            fireTableCellUpdated(row, col);
            
        }
        
        public String getColumnName(int col) {
            return columns[col];
        }
        
        public boolean isCellEditable(int row, int col) {
            
            if (col != 3) {
                return false;
            }
            
            ProcedureParameter param = values[row];
            int mode = param.getType();
            switch (mode) {
                
                case DatabaseMetaData.procedureColumnIn:
                case DatabaseMetaData.procedureColumnInOut:
                    return true;
                    
                case DatabaseMetaData.procedureColumnOut:
                case DatabaseMetaData.procedureColumnUnknown:
                case DatabaseMetaData.procedureColumnResult:
                case DatabaseMetaData.procedureColumnReturn:
                    return false;
                    
                default:
                    return true;
                    
            }
            
        }
        
    } // class ParameterTableModel
    
}