browsertableeditingpanel.java

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

    /**
     * Loads database table privileges.
     */
    private void loadPrivileges() {
        CacheObject cacheObject = (CacheObject)cache.get(metaObject);
        if (cacheObject == null) {
            return;
        }

        TablePrivilege[] privileges = null;
        DatabaseTable dt = cacheObject.getDatabaseTable();
        if (!dt.hasPrivileges()) {
            privileges = controller.getPrivileges(
                                            metaObject.getCatalogName(),
                                            metaObject.getSchemaName(),
                                            metaObject.getName());
            dt.setPrivileges(privileges);
        }
        else {
            privileges = dt.getPrivileges();
        }
        tablePrivilegePanel.setValues(privileges);
    }
    
    /**
     * Fires a change in the selected table node and reloads
     * the current table display view.
     *
     * @param metaObject - the selected meta object
     * @param reset - whether to reset the view, regardless of the current 
     *                view which may be the same metaObject
     */
    public void selectionChanged(DatabaseObject metaObject, boolean reset) {
        if (this.metaObject == metaObject && !reset) {
            return;
        }
        this.metaObject = metaObject;
        
        if (columnDataTable.isEditing()) {
            columnDataTable.removeEditor();
        }

        columnDataTable.reset();
        ColumnData[] columnData = null;
        tabPane.setSelectedIndex(0);
        
        DatabaseTable dt = null;
        if (reset || !cache.containsKey(metaObject)) {
            columnData = controller.getColumnData(
                                            metaObject.getCatalogName(),
                                            metaObject.getSchemaName(),
                                            metaObject.getName());

            // populate the table object
            dt = new DatabaseTable();
            dt.setValues(metaObject);
            dt.setColumns(columnData);
            
            CacheObject cacheObject = new CacheObject();
            cacheObject.setDatabaseTable(dt);
            cache.put(metaObject, cacheObject);
        }        
        else {
            CacheObject cacheObject = (CacheObject)cache.get(metaObject);
            dt = cacheObject.getDatabaseTable();
            columnData = dt.getColumns();
        }

        tableNameField.setText(dt.getName());
        schemaNameField.setText(dt.getSchema());
        
        String rowCount = controller.getTableDataRowCount(
                                        metaObject.getSchemaName(),
                                        metaObject.getName());
        rowCountField.setText(rowCount);

        loadColumnData(columnData);
        referencesLoaded = false;
    }
    
    /**
     * Fires a change in the selected table node and reloads
     * the current table display view.
     *
     * @param metaObject - the selected meta object
     */
    public void selectionChanged(DatabaseObject metaObject) {
        selectionChanged(metaObject, false);        
    }
    
    /**
     * Loads the table column data.
     */
    private void loadColumnData(ColumnData[] cda) {

        // let the table handle this first to clear if empty
        columnDataTable.setColumnDataArray(cda, controller.getDataTypesArray());

        // ... then check here
        if (cda == null) {
            return;
        }
        
        // configure the constraints panel
        if (constraintsVector == null) {
            constraintsVector = new Vector<ColumnConstraint>();
        } else {
            constraintsVector.clear();
        }
        
        Vector<ColumnConstraint> ccv = null;        
        for (int i = 0; i < cda.length; i++) {
            
            if (cda[i].isKey()) {
                ccv = cda[i].getColumnConstraintsVector();
                for (int j = 0, k = ccv.size(); j < k; j++) {
                    constraintsVector.add(ccv.get(j));
                }
            }

        }
        
        conPanel.reset();
        conPanel.setData(constraintsVector, false);

        try {
            String createTable = ScriptGenerationUtils.
                                      createTableScript(metaObject.getName(), cda);
            String alterTable = ScriptGenerationUtils.
                                      alterTableConstraintsScript(constraintsVector);
            createSqlText.setSQLText(createTable + alterTable);
        } catch (InterruptedException e) {}
        
        columnDataTable.setOriginalData();
        conPanel.setOriginalData();
        
        //databaseTable.setConstraints(ccv);
    }
    
    public void setBrowserPreferences() {
        tableDataPanel.setTableProperties();
    }
    
    public JTable getTableInFocus() {
        return focusTable;
    }
    
    /** <p>Sets table properties for the index table.<br>
     *  This will set cell selection policies and column
     *  widths for each column in the table.
     *
     *  @param the index table to be configured.
     */
    private void setIndexTableColumnProperties(JTable table) {
        table.setCellSelectionEnabled(true);
        
        TableColumnModel tcm = table.getColumnModel();
        TableColumn col = tcm.getColumn(0);
        col.setPreferredWidth(210);
        
        col = tcm.getColumn(1);
        col.setPreferredWidth(150);
        
        col = tcm.getColumn(2);
        col.setPreferredWidth(90);
    }
    
    /**
     * Returns whether the SQL panel has any text in it.
     */
    public boolean hasSQLText() {
        return !(alterSqlText.isEmpty());
    }

    /**
     * Resets the contents of the SQL panel to nothing.
     */
    public void resetSQLText() {
        alterSqlText.setSQLText(EMPTY);
    }

    /**
     * Returns the contents of the SQL text pane.
     */
    public String getSQLText() {
        return alterSqlText.getSQLText();
    }

    // -----------------------------------------------
    // --- TableConstraintFunction implementations ---
    // -----------------------------------------------

    /** 
     * Deletes the selected row on the currently selected table. 
     */
    public void deleteRow() {
        if (focusTable == columnDataTable.getTable()) {
            columnDataTable.markDeleteRow();
        }        
        else if (focusTable == conPanel.getTable()) {
            conPanel.markDeleteRow();
        }
        setSQLText();
    }
    
    /** 
     * Inserts a row after the selected row on the currently selected table. 
     */
    public void insertAfter() {
        
        if (focusTable == columnDataTable.getTable()) {
            columnDataTable.insertAfter();
            columnDataTable.setOriginalData();
        }
        else if (focusTable == conPanel.getTable()) {
            conPanel.insertRowAfter();
//            conPanel.setCellEditor(2, new ComboBoxCellEditor(
//            columnDataTable.getTableColumnData()));
        }
        
    }
    
    public void setSQLText() {
        sbTemp.setLength(0);
        sbTemp.append(columnDataTable.getSQLText()).
               append(conPanel.getSQLText());        
        alterSqlText.setSQLText(sbTemp.toString());
    }
    
    public void setSQLText(String values, int type) {
        sbTemp.setLength(0);
        
        if (type == TableModifier.COLUMN_VALUES) {
            sbTemp.append(values).
                   append(conPanel.getSQLText());
        }        
        else if (type == TableModifier.CONSTRAINT_VALUES) {
            sbTemp.append(columnDataTable.getSQLText()).
                   append(values);
        }
        
        alterSqlText.setSQLText(sbTemp.toString());
    }
    
    public String getTableName() {
        return tableNameField.getText();
    }
    
    public Vector getHostedSchemasVector() {
        return controller.getHostedSchemas();
    }
    
    public Vector getSchemaTables(String schemaName) {
        return controller.getTables(schemaName);
    }
    
    public Vector getColumnNamesVector(String tableName, String schemaName) {
        return controller.getColumnNamesVector(tableName, schemaName);
    }
    
    public void insertBefore() {}
    public void moveColumnUp() {}
    public void moveColumnDown() {}

    public ColumnData[] getTableColumnData() {
        return columnDataTable.getTableColumnData();
    }
    
    public Vector getTableColumnDataVector() {
        return columnDataTable.getTableColumnDataVector();
    }
    
    /** Tab index of the SQL text panes */
    private static final int SQL_PANE_INDEX = 6;
    
    /**
     * Returns the focused TextEditor panel where the selected
     * tab is the SQL text pane.
     */
    protected TextEditor getFocusedTextEditor() {
        if (tabPane.getSelectedIndex() == SQL_PANE_INDEX) {
            if (lastFocusEditor != null) {
                return lastFocusEditor;
            }
        }
        return null;
    }
    

    /** Stored cache object */
    private class CacheObject {
        
        private DatabaseTable databaseTable;
        private DatabaseObject metaObject;
        private ReferencesCacheObject cacheObject;
        
        private boolean referenceDataLoaded;
        
        public CacheObject() {}
        
        public boolean isReferenceDataLoaded() {
            return referenceDataLoaded;
        }
        
        public void setReferencesObject(ReferencesCacheObject cacheObject) {
            if (cacheObject != null) {
                referenceDataLoaded = true;
            }
            this.cacheObject = cacheObject;
        }

        public ReferencesCacheObject getReferencesObject() {
            return cacheObject;
        }

        public DatabaseTable getDatabaseTable() {
            return databaseTable;
        }

        public void setDatabaseTable(DatabaseTable databaseTable) {
            this.databaseTable = databaseTable;
        }
        
    }
    
}