Attachment #132732 for bug #227588

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 227588
Collapse All | Expand All




    private DatabaseConnection dbConn;
    private List<Throwable> errMessages = new ArrayList<Throwable>();
    private String sqlString; // Once Set, Data View assumes it will never change
    private DataViewDBTable tblMeta;
    private SQLStatementGenerator stmtGenerator;
    private SQLExecutionHelper execHelper;
    private DataViewPageContext dataPage;

        }

        synchronized (this) {
            DataViewDBTable tblMeta = dataPage.getTableMetaData();
            this.dataViewUI = new DataViewUI(this, dataPage, nbOutputComponent);
            dataViewUI.setEditable(tblMeta == null ? false : tblMeta.hasOneTable());
            resetToolbar(hasExceptions());
        }

    }

    // Non API modules follow

    DataViewDBTable getDataViewDBTable() {
        return tblMeta;
    }
    
    void setDataViewDBTable(DataViewDBTable tblMeta) {
        this.tblMeta = tblMeta;
    }
    
    DataViewPageContext getDataViewPageContext() {
        return dataPage;

Lines 43-48 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewActionHandler.java (-5 / +17 lines)
43	*/	43	*/
44	package org.netbeans.modules.db.dataview.output;	44	package org.netbeans.modules.db.dataview.output;
45		45
		46	import org.netbeans.modules.db.dataview.meta.DBTable;
46	import org.openide.DialogDisplayer;	47	import org.openide.DialogDisplayer;
47	import org.openide.NotifyDescriptor;	48	import org.openide.NotifyDescriptor;
48	import org.openide.util.NbBundle;	49	import org.openide.util.NbBundle;
Lines 144-168 Link Here
144	}	145	}
145		146
146	void commitActionPerformed(boolean selectedOnly) {	147	void commitActionPerformed(boolean selectedOnly) {
		148	assert dataPage.getTableMetaData().getTableCount() == 1 : "Only one table allowed in resultset if update is invoked";
		149
147	if (dataViewUI.isDirty()) {	150	if (dataViewUI.isDirty()) {
148	execHelper.executeUpdateRow(dataViewUI.getDataViewTableUI(), selectedOnly);	151	execHelper.executeUpdateRow(
		152	dataPage.getTableMetaData().getTable(0),
		153	dataViewUI.getDataViewTableUI(),
		154	selectedOnly);
149	}	155	}
150	}	156	}
151		157
152	void insertActionPerformed() {	158	void insertActionPerformed() {
153	InsertRecordDialog dialog = new InsertRecordDialog(dataView);	159	DBTable table = dataPage.getTableMetaData().getTable(0);
		160	InsertRecordDialog dialog = new InsertRecordDialog(dataView, table);
154	dialog.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());	161	dialog.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());
155	dialog.setVisible(true);	162	dialog.setVisible(true);
156	}	163	}
157		164
158	void truncateActionPerformed() {	165	void truncateActionPerformed() {
159	String confirmMsg = NbBundle.getMessage(DataViewActionHandler.class, "MSG_confirm_truncate_table") + dataView.getDataViewDBTable().getTable(0).getDisplayName();	166	assert dataPage.getTableMetaData().getTableCount() == 1 : "Only one table allowed in resultset if delete is invoked";
		167
		168	String confirmMsg = NbBundle.getMessage(DataViewActionHandler.class, "MSG_confirm_truncate_table") + dataPage.getTableMetaData().getTable(0).getDisplayName();
160	if ((showYesAllDialog(confirmMsg, confirmMsg)).equals(NotifyDescriptor.YES_OPTION)) {	169	if ((showYesAllDialog(confirmMsg, confirmMsg)).equals(NotifyDescriptor.YES_OPTION)) {
161	execHelper.executeTruncate();	170	execHelper.executeTruncate(dataPage.getTableMetaData().getTable(0));
162	}	171	}
163	}	172	}
164		173
165	void deleteRecordActionPerformed() {	174	void deleteRecordActionPerformed() {
		175	assert dataPage.getTableMetaData().getTableCount() == 1 : "Only one table allowed in resultset if delete is invoked";
		176
166	DataViewTableUI rsTable = dataViewUI.getDataViewTableUI();	177	DataViewTableUI rsTable = dataViewUI.getDataViewTableUI();
167	if (rsTable.getSelectedRowCount() == 0) {	178	if (rsTable.getSelectedRowCount() == 0) {
168	String msg = NbBundle.getMessage(DataViewActionHandler.class, "MSG_select_delete_rows");	179	String msg = NbBundle.getMessage(DataViewActionHandler.class, "MSG_select_delete_rows");
Lines 170-176 Link Here
170	} else {	181	} else {
171	String msg = NbBundle.getMessage(DataViewActionHandler.class, "MSG_confirm_permanent_delete");	182	String msg = NbBundle.getMessage(DataViewActionHandler.class, "MSG_confirm_permanent_delete");
172	if ((showYesAllDialog(msg, NbBundle.getMessage(DataViewActionHandler.class, "MSG_confirm_delete"))).equals(NotifyDescriptor.YES_OPTION)) {	183	if ((showYesAllDialog(msg, NbBundle.getMessage(DataViewActionHandler.class, "MSG_confirm_delete"))).equals(NotifyDescriptor.YES_OPTION)) {
173	execHelper.executeDeleteRow(rsTable);	184	DBTable table = dataPage.getTableMetaData().getTable(0);
		185	execHelper.executeDeleteRow(table, rsTable);
174	}	186	}
175	}	187	}
176	}	188	}




    public static final String PROP_pageSize = "pageSize";
    public static final String PROP_totalRows = "totalRows";
    public static final String PROP_currentPos = "currentPos";
    public static final String PROP_tableMetaData = "tableMetaData";
    private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
    private int pageSize = 10;
    private int totalRows = -1;
    private int currentPos = 1;
    private DataViewDBTable tableMetaData = null;
    private final DataViewTableUIModel model = new DataViewTableUIModel(new DBColumn[0]);

    DataViewPageContext(int pageSize) {
        this.pageSize = pageSize;
    }

    public DataViewDBTable getTableMetaData() {
        return tableMetaData;
    }

    public void setTableMetaData(DataViewDBTable tableMetaData) {
        DataViewDBTable old = this.tableMetaData;
        this.tableMetaData = tableMetaData;
        firePropertyChange(PROP_tableMetaData, old, tableMetaData);
    }
    
    int getPageSize() {
        return pageSize;
    }




        }
    };

    public DataViewTableUI(DataViewUI dataviewUI, DataViewActionHandler handler, DataView dataView, DataViewPageContext pageContext) {
        this.dataviewUI = dataviewUI;
        this.handler = handler;


        this.getColumnModel().getSelectionModel().addListSelectionListener(listener);

        addKeyListener(createControKeyListener());
        createPopupMenu(handler, dataView, pageContext);
    }

    @Override

        }
    }

    private void createPopupMenu(final DataViewActionHandler handler, final DataView dataView, final DataViewPageContext pageContext) {
        // content popup menu on table with results
        tablePopupMenu = new JPopupMenu();
        final JMenuItem miInsertAction = new JMenuItem(NbBundle.getMessage(DataViewTableUI.class, "TOOLTIP_insert"));

            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    DBTable table = pageContext.getTableMetaData().getTable(0);
                    String createSQL = dataView.getSQLStatementGenerator().generateCreateStatement(table);
                    ShowSQLDialog dialog = new ShowSQLDialog();
                    dialog.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());

                        int modelIndex = convertRowIndexToModel(rows[j]);
                        Object[] insertRow = getModel().getRowData(modelIndex);
                        // @todo make table configurable
                        DBTable table = pageContext.getTableMetaData().getTable(0);
                        String sql = dataView.getSQLStatementGenerator()
                                .generateRawInsertStatement(table, insertRow);
                        insertSQL += sql + ";\n"; // NOI18N

                    SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
                    int modelIndex = convertRowIndexToModel(rows[j]);
                    // @todo make table configurable
                    DBTable table = pageContext.getTableMetaData().getTable(0);
                    final String deleteStmt = generator.generateDeleteStatement(table, modelIndex, getModel());
                    rawDeleteStmt += deleteStmt + ";\n"; // NOI18N
                }

                String rawUpdateStmt = "";
                SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
                // @todo make table configurable
                DBTable table = pageContext.getTableMetaData().getTable(0);
                
                try {
                    for (Integer row : getModel().getUpdateKeys()) {




import org.jdesktop.swingx.JXButton;
import org.jdesktop.swingx.JXLabel;
import org.jdesktop.swingx.JXPanel;
import org.jdesktop.swingx.JXTableHeader;
import org.netbeans.modules.db.dataview.meta.DBColumn;
import org.netbeans.modules.db.dataview.table.JXTableRowHeader;
import org.netbeans.modules.db.dataview.table.MultiColPatternFilter;
import org.netbeans.modules.db.dataview.table.ResultSetJXTable;

    private JXButton[] editButtons = new JXButton[5];
    private DataViewTableUI dataPanel;
    private JScrollPane dataPanelScrollPane;
    private final DataViewPageContext pageContext;
    private JXButton cancel;
    private DataViewActionHandler actionHandler;
    private String imgPrefix = "/org/netbeans/modules/db/dataview/images/"; // NOI18N

        }
    };

    DataViewUI(DataView dataView, DataViewPageContext pageContext, boolean nbOutputComponent) {
        assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread";  //NOI18N

        this.pageContext = pageContext;

        //do not show tab view if there is only one tab
        this.putClientProperty("TabPolicy", "HideWhenAlone"); //NOI18N

        actionHandler = new DataViewActionHandler(this, dataView);

        //add resultset data panel
        dataPanel = new DataViewTableUI(this, actionHandler, dataView, pageContext);
        dataPanelScrollPane = new JScrollPane(dataPanel);
        JXTableRowHeader rowHeader = new JXTableRowHeader(dataPanel);
        dataPanelScrollPane.setRowHeaderView(rowHeader);

        dataPanel.revalidate();
        dataPanel.repaint();
        
        dataPanel.setModel(pageContext.getModel());
        pageContext.addPropertyChangeListener(pageContextListener);
        
        updateTotalCountLabel();
    }



    void updateTotalCountLabel() {
        assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread";  //NOI18N

        DataViewPageContext pageContext = dataView.getDataViewPageContext();
        
        if (pageContext.isTotalRowCountAvailable()) {
            totalRowsLabel.setText(
                    pageContext.getTotalRows() + "   " + pageContext.pageOf());
        } else {
            totalRowsLabel.setText(NbBundle.getMessage(DataViewUI.class,
                    "LBL_not_available") + " "
                    + pageContext.pageOf());
        }
    }


        cancel.setEnabled(flag);
    }

    void setDataRows(List<Object[]> rows) {
        assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread";  //NOI18N
        assert rows != null;

        DBColumn[] columns = dataView.getDataViewDBTable().getColumns().toArray(
                new DBColumn[0]);

        DataViewTableUIModel dvtm = getDataViewTableUIModel();

        dvtm.removeAllUpdates(false);

        dvtm.setColumns(columns);
        dvtm.setData(rows);
        }

    void disableButtons() {
        assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread";  //NOI18N


    }

    int getPageSize() {
        int pageSize = pageContext.getPageSize();
        int totalCount = pageContext.getTotalRows();
        try {
            int count = Integer.parseInt(refreshField.getText().trim());
            return count < 0 ? pageSize : count;

        refreshField.setEnabled(true);
        matchBoxField.setEditable(true);
        deleteRow.setEnabled(false);

        if (!wasError) {
            if (pageContext.hasPrevious()) {
                first.setEnabled(true);
                previous.setEnabled(true);
            }

            if (pageContext.hasNext()) {
                next.setEnabled(true);
                if(pageContext.getTotalRows() >= 0) {
                    last.setEnabled(true);
                }
            }

            if (pageContext.hasOnePageOnly()) {
                first.setEnabled(false);
                previous.setEnabled(false);
            }

            if (pageContext.isLastPage()) {
                next.setEnabled(false);
                last.setEnabled(false);
            }

                insert.setEnabled(false);
                truncateButton.setEnabled(false);
            } else {
                if (pageContext.hasRows()) {
                    truncateButton.setEnabled(true);
                } else {
                    deleteRow.setEnabled(false);
                    truncateButton.setEnabled(false);
                    pageContext.first();
                }
                insert.setEnabled(true);
                if (getDataViewTableUIModel().getUpdateKeys().isEmpty()) {

            disableButtons();
        }

        refreshField.setText("" + pageContext.getPageSize());
        if (dataPanel != null) {
            dataPanel.revalidate();
            dataPanel.repaint();




    InsertRecordTableUI insertRecordTableUI;
    private JXTableRowHeader rowHeader;

    public InsertRecordDialog(DataView dataView, DBTable insertTable) {
        super(WindowManager.getDefault().getMainWindow(), true);
        this.dataView = dataView;
        this.insertTable = insertTable;
        // @todo Don't directly choose first table for insert, but let it be passed in
        insertTable = dataView.getDataViewDBTable().getTable(0);
        
        insertDataModel = new ResultSetTableModel(
                insertTable.getColumnList().toArray(new DBColumn[0])

                    try {
                        Object[] insertedRow = getInsertValues(i);
                        insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);
                        RequestProcessor.Task task = execHelper.executeInsertRow(insertTable, insertSQL, insertedRow);
                        task.waitFinished();
                        wasException = dataView.hasExceptions();
                    } catch (DBException ex) {

        }
        insertRecordTableUI.editCellAt(row, col);
        TableCellEditor editor = insertRecordTableUI.getCellEditor();
        List<DBColumn> columns = insertTable.getColumnList();
        if (editor != null) {
            DBColumn dbcol = columns.get(col);
            if (dbcol.isGenerated() || !dbcol.isNullable()) {
                Toolkit.getDefaultToolkit().beep();
                editor.stopCellEditing();

        insertRecordTableUI.editCellAt(row, col);
        TableCellEditor editor = insertRecordTableUI.getCellEditor();
        if (editor != null) {
            List<DBColumn> columns = insertTable.getColumnList();
            DBColumn dbcol = columns.get(col);
            Object val = insertRecordTableUI.getValueAt(row, col);
            if (dbcol.isGenerated() || !dbcol.hasDefault()) {
                Toolkit.getDefaultToolkit().beep();




                    DataViewDBTable dvTable = new DataViewDBTable(tables);
                    dataView.getDataViewPageContext().getModel().setColumns(
                            dvTable.getColumns().toArray(new DBColumn[0]));
                    dataView.getDataViewPageContext().setTableMetaData(dvTable);
                    if (resultSetNeedsReloading(dvTable)) {
                        executeSQLStatement(stmt, sql);
                        rs = stmt.getResultSet();
                    }
                    loadDataFrom(dvTable, rs);
                    
                    if (Thread.interrupted()) {
                        return;

        }
    }

    RequestProcessor.Task executeInsertRow(final DBTable table, final String insertSQL, final Object[] insertedRow) {
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_insert");
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {

            @Override
            public void execute() throws SQLException, DBException {
                dataView.setEditable(false);
                List<DBColumn> columns = table.getColumnList();
                PreparedStatement pstmt = conn.prepareStatement(insertSQL);
                try {
                    int pos = 1;

                        Object val = insertedRow[i];

                        // Check for Constant e.g <NULL>, <DEFAULT>, <CURRENT_TIMESTAMP> etc
                        if (DataViewUtils.isSQLConstantString(val, columns.get(i))) {
                                dataView.getDataViewDBTable().getColumn(i))) {
                            continue;
                        }

                        // literals
                        int colType = columns.get(i).getJdbcType();
                        DBReadWriteHelper.setAttributeValue(pstmt, pos++, colType, val);
                    }


        return task;
    }

    void executeDeleteRow(final DBTable table, final DataViewTableUI rsTable) {        
        // @todo enhance to be able to work with more than one table
        assert dataView.getDataViewDBTable().getTableCount() == 1 : "Deletes only supported for single table in resultset";
        
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_delete");
        final int[] rows = rsTable.getSelectedRows();
        for(int i = 0; i < rows.length; i++) {
            rows[i] = rsTable.convertRowIndexToModel(rows[i]);
        }
        Arrays.sort(rows);
        
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {

            @Override

        task.schedule(0);
    }

    void executeUpdateRow(final DBTable table, final DataViewTableUI rsTable, final boolean selectedOnly) {
        
        assert dataView.getDataViewDBTable().getTableCount() == 1 : "Updates only supported for single table in resultset";

        final DBTable table = dataView.getDataViewDBTable().getTable(0);
        final DataViewTableUIModel dataViewTableUIModel = rsTable.getModel();
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_update");        
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {

    }

    // Truncate is allowed only when there is single table used in the query.
    void executeTruncate(final DBTable dbTable) {
        String msg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_truncate_table_progress");
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_truncate");
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, msg) {


            @Override
            public void execute() throws SQLException, DBException {


                DBTable dbTable = dataView.getDataViewDBTable().getTable(0);
                String truncateSql = "TRUNCATE TABLE " + dbTable.getFullyQualifiedName(true); // NOI18N

                try {

                    executeSQLStatement(stmt, sql);
                    if (dataView.hasResultSet()) {
                        ResultSet rs = stmt.getResultSet();
                        loadDataFrom(dataView.getDataViewPageContext().getTableMetaData(), 
                                rs);

                        if (getTotal) {
                            Integer result = null;

        task.schedule(0);
    }

    void loadDataFrom(DataViewDBTable tblMeta, ResultSet rs) throws SQLException {
        if (rs == null) {
            return;
        }

        int pageSize = dataView.getDataViewPageContext().getPageSize();
        int startFrom = dataView.getDataViewPageContext().getCurrentPos();

        DataViewDBTable tblMeta = dataView.getDataViewDBTable();
        List<Object[]> rows = new ArrayList<Object[]>();
        int colCnt = tblMeta.getColumnCount();
        try {




        dbconn=null;
    }

    public static DBTable getTable(DataView dv, int index){
        return dv.getDataViewDBTable().getTable(index);
    }
    /**
     * Test of geTable method, of class DataViewDBTable.
     */

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        DBTable result = instance.getTable(0);
        assertNotNull(result);
        assertEquals(11, instance.getColumnCount());

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        int expResult = 1;
        int result = instance.getTableCount();
        assertEquals(expResult, result);

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        boolean expResult = true;
        boolean result = instance.hasOneTable();
        assertEquals(expResult, result);

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        String expResult = "SIMPLETABLE";
        String result = instance.getFullyQualifiedName(0, false);
        assertEquals(expResult, result);

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        int expResult = 12;
        int result = instance.getColumnType(2);
        assertEquals(expResult, result);

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        String expResult = "DATEC";
        String result = instance.getColumnName(index);
        assertEquals(expResult, result);

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        String expResult = "TINYINTC";
        String result = instance.getQualifiedName(0, false);
        assertEquals(expResult, result);

        int index = 5;
        String sqlStr = context.getSqlSelect();
        DataView dv = DataView.create(dbconn, sqlStr, index);
        DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
        int expResult = 11;
        int result = instance.getColumnCount();
        assertEquals(expResult, result);

Lines 156-162 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/DataViewTest.java (-1 / +1 lines)
156	ResultSet rset = stmt.executeQuery(sqlStr);	156	ResultSet rset = stmt.executeQuery(sqlStr);
157	Collection<DBTable> tables = dbMeta.generateDBTables(rset, sqlStr, true); //generateDBTables(rset);	157	Collection<DBTable> tables = dbMeta.generateDBTables(rset, sqlStr, true); //generateDBTables(rset);
158	DataViewDBTable expResult = new DataViewDBTable(tables);	158	DataViewDBTable expResult = new DataViewDBTable(tables);
159	DataViewDBTable result = instance.getDataViewDBTable();	159	DataViewDBTable result = instance.getDataViewPageContext().getTableMetaData();
160	assertEquals(expResult.getQualifiedName(0, false), result.getQualifiedName(0, false));	160	assertEquals(expResult.getQualifiedName(0, false), result.getQualifiedName(0, false));
161	assertEquals(expResult.getColumnCount(), result.getColumnCount());	161	assertEquals(expResult.getColumnCount(), result.getColumnCount());
162	assertEquals(expResult.getColumnType(2), result.getColumnType(2));	162	assertEquals(expResult.getColumnType(2), result.getColumnType(2));

Lines 44-53 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/InsertRecordTableUITest.java (-2 / +4 lines)
44	import java.sql.Connection;	44	import java.sql.Connection;
45	import java.sql.Date;	45	import java.sql.Date;
46	import javax.swing.SortOrder;	46	import javax.swing.SortOrder;
47	import javax.swing.table.DefaultTableModel;
48	import org.netbeans.api.db.explorer.DatabaseConnection;	47	import org.netbeans.api.db.explorer.DatabaseConnection;
49	import org.netbeans.junit.MockServices;	48	import org.netbeans.junit.MockServices;
50	import org.netbeans.junit.NbTestCase;	49	import org.netbeans.junit.NbTestCase;
		50	import org.netbeans.modules.db.dataview.meta.DBTable;
51	import org.netbeans.modules.db.dataview.spi.DBConnectionProviderImpl;	51	import org.netbeans.modules.db.dataview.spi.DBConnectionProviderImpl;
52	import org.netbeans.modules.db.dataview.table.ResultSetTableModel;	52	import org.netbeans.modules.db.dataview.table.ResultSetTableModel;
53	import org.netbeans.modules.db.dataview.util.DBTestUtil;	53	import org.netbeans.modules.db.dataview.util.DBTestUtil;
Lines 97-103 Link Here
97	DataView dv = DataView.create(dbconn, sqlString, 5);	97	DataView dv = DataView.create(dbconn, sqlString, 5);
98	dv.createComponents();	98	dv.createComponents();
99		99
100	InsertRecordDialog ird = new InsertRecordDialog(dv);	100	DBTable table = dv.getDataViewPageContext().getTableMetaData().getTable(0);
		101
		102	InsertRecordDialog ird = new InsertRecordDialog(dv, table);
101		103
102	ResultSetTableModel model = ird.insertRecordTableUI.getModel();	104	ResultSetTableModel model = ird.insertRecordTableUI.getModel();
103	ird.insertRecordTableUI.appendEmptyRow();	105	ird.insertRecordTableUI.appendEmptyRow();

Return to bug 227588

Lines 103-109 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewTableUI.java (-7 / +7 lines)
103	}	103	}
104	};	104	};
105		105
106	public DataViewTableUI(final DataViewUI dataviewUI, final DataViewActionHandler handler, final DataView dataView) {	106	public DataViewTableUI(DataViewUI dataviewUI, DataViewActionHandler handler, DataView dataView, DataViewPageContext pageContext) {
107	this.dataviewUI = dataviewUI;	107	this.dataviewUI = dataviewUI;
108	this.handler = handler;	108	this.handler = handler;
109		109
Lines 112-118 Link Here
112	this.getColumnModel().getSelectionModel().addListSelectionListener(listener);	112	this.getColumnModel().getSelectionModel().addListSelectionListener(listener);
113		113
114	addKeyListener(createControKeyListener());	114	addKeyListener(createControKeyListener());
115	createPopupMenu(handler, dataView);	115	createPopupMenu(handler, dataView, pageContext);
116	}	116	}
117		117
118	@Override	118	@Override
Lines 314-320 Link Here
314	}	314	}
315	}	315	}
316		316
317	private void createPopupMenu(final DataViewActionHandler handler, final DataView dataView) {	317	private void createPopupMenu(final DataViewActionHandler handler, final DataView dataView, final DataViewPageContext pageContext) {
318	// content popup menu on table with results	318	// content popup menu on table with results
319	tablePopupMenu = new JPopupMenu();	319	tablePopupMenu = new JPopupMenu();
320	final JMenuItem miInsertAction = new JMenuItem(NbBundle.getMessage(DataViewTableUI.class, "TOOLTIP_insert"));	320	final JMenuItem miInsertAction = new JMenuItem(NbBundle.getMessage(DataViewTableUI.class, "TOOLTIP_insert"));
Lines 415-421 Link Here
415	@Override	415	@Override
416	public void actionPerformed(ActionEvent e) {	416	public void actionPerformed(ActionEvent e) {
417	try {	417	try {
418	DBTable table = dataView.getDataViewDBTable().getTable(0);	418	DBTable table = pageContext.getTableMetaData().getTable(0);
419	String createSQL = dataView.getSQLStatementGenerator().generateCreateStatement(table);	419	String createSQL = dataView.getSQLStatementGenerator().generateCreateStatement(table);
420	ShowSQLDialog dialog = new ShowSQLDialog();	420	ShowSQLDialog dialog = new ShowSQLDialog();
421	dialog.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());	421	dialog.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());
Lines 441-447 Link Here
441	int modelIndex = convertRowIndexToModel(rows[j]);	441	int modelIndex = convertRowIndexToModel(rows[j]);
442	Object[] insertRow = getModel().getRowData(modelIndex);	442	Object[] insertRow = getModel().getRowData(modelIndex);
443	// @todo make table configurable	443	// @todo make table configurable
444	DBTable table = dataView.getDataViewDBTable().getTable(0);	444	DBTable table = pageContext.getTableMetaData().getTable(0);
445	String sql = dataView.getSQLStatementGenerator()	445	String sql = dataView.getSQLStatementGenerator()
446	.generateRawInsertStatement(table, insertRow);	446	.generateRawInsertStatement(table, insertRow);
447	insertSQL += sql + ";\n"; // NOI18N	447	insertSQL += sql + ";\n"; // NOI18N
Lines 469-475 Link Here
469	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();	469	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
470	int modelIndex = convertRowIndexToModel(rows[j]);	470	int modelIndex = convertRowIndexToModel(rows[j]);
471	// @todo make table configurable	471	// @todo make table configurable
472	DBTable table = dataView.getDataViewDBTable().getTable(0);	472	DBTable table = pageContext.getTableMetaData().getTable(0);
473	final String deleteStmt = generator.generateDeleteStatement(table, modelIndex, getModel());	473	final String deleteStmt = generator.generateDeleteStatement(table, modelIndex, getModel());
474	rawDeleteStmt += deleteStmt + ";\n"; // NOI18N	474	rawDeleteStmt += deleteStmt + ";\n"; // NOI18N
475	}	475	}
Lines 489-495 Link Here
489	String rawUpdateStmt = "";	489	String rawUpdateStmt = "";
490	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();	490	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
491	// @todo make table configurable	491	// @todo make table configurable
492	DBTable table = dataView.getDataViewDBTable().getTable(0);	492	DBTable table = pageContext.getTableMetaData().getTable(0);
493		493
494	try {	494	try {
495	for (Integer row : getModel().getUpdateKeys()) {	495	for (Integer row : getModel().getUpdateKeys()) {

Lines 104-115 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/InsertRecordDialog.java (-7 / +7 lines)
104	InsertRecordTableUI insertRecordTableUI;	104	InsertRecordTableUI insertRecordTableUI;
105	private JXTableRowHeader rowHeader;	105	private JXTableRowHeader rowHeader;
106		106
107	public InsertRecordDialog(DataView dataView) {	107	public InsertRecordDialog(DataView dataView, DBTable insertTable) {
108	super(WindowManager.getDefault().getMainWindow(), true);	108	super(WindowManager.getDefault().getMainWindow(), true);
109	this.dataView = dataView;	109	this.dataView = dataView;
110		110	this.insertTable = insertTable;
111	// @todo Don't directly choose first table for insert, but let it be passed in
112	insertTable = dataView.getDataViewDBTable().getTable(0);
113		111
114	insertDataModel = new ResultSetTableModel(	112	insertDataModel = new ResultSetTableModel(
115	insertTable.getColumnList().toArray(new DBColumn[0])	113	insertTable.getColumnList().toArray(new DBColumn[0])
Lines 390-396 Link Here
390	try {	388	try {
391	Object[] insertedRow = getInsertValues(i);	389	Object[] insertedRow = getInsertValues(i);
392	insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);	390	insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);
393	RequestProcessor.Task task = execHelper.executeInsertRow(insertSQL, insertedRow);	391	RequestProcessor.Task task = execHelper.executeInsertRow(insertTable, insertSQL, insertedRow);
394	task.waitFinished();	392	task.waitFinished();
395	wasException = dataView.hasExceptions();	393	wasException = dataView.hasExceptions();
396	} catch (DBException ex) {	394	} catch (DBException ex) {
Lines 621-628 Link Here
621	}	619	}
622	insertRecordTableUI.editCellAt(row, col);	620	insertRecordTableUI.editCellAt(row, col);
623	TableCellEditor editor = insertRecordTableUI.getCellEditor();	621	TableCellEditor editor = insertRecordTableUI.getCellEditor();
		622	List<DBColumn> columns = insertTable.getColumnList();
624	if (editor != null) {	623	if (editor != null) {
625	DBColumn dbcol = dataView.getDataViewDBTable().getColumn(col);	624	DBColumn dbcol = columns.get(col);
626	if (dbcol.isGenerated() \|\| !dbcol.isNullable()) {	625	if (dbcol.isGenerated() \|\| !dbcol.isNullable()) {
627	Toolkit.getDefaultToolkit().beep();	626	Toolkit.getDefaultToolkit().beep();
628	editor.stopCellEditing();	627	editor.stopCellEditing();
Lines 644-650 Link Here
644	insertRecordTableUI.editCellAt(row, col);	643	insertRecordTableUI.editCellAt(row, col);
645	TableCellEditor editor = insertRecordTableUI.getCellEditor();	644	TableCellEditor editor = insertRecordTableUI.getCellEditor();
646	if (editor != null) {	645	if (editor != null) {
647	DBColumn dbcol = dataView.getDataViewDBTable().getColumn(col);	646	List<DBColumn> columns = insertTable.getColumnList();
		647	DBColumn dbcol = columns.get(col);
648	Object val = insertRecordTableUI.getValueAt(row, col);	648	Object val = insertRecordTableUI.getValueAt(row, col);
649	if (dbcol.isGenerated() \|\| !dbcol.hasDefault()) {	649	if (dbcol.isGenerated() \|\| !dbcol.hasDefault()) {
650	Toolkit.getDefaultToolkit().beep();	650	Toolkit.getDefaultToolkit().beep();

Lines 180-191 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/SQLExecutionHelper.java (-23 / +14 lines)
180	DataViewDBTable dvTable = new DataViewDBTable(tables);	180	DataViewDBTable dvTable = new DataViewDBTable(tables);
181	dataView.getDataViewPageContext().getModel().setColumns(	181	dataView.getDataViewPageContext().getModel().setColumns(
182	dvTable.getColumns().toArray(new DBColumn[0]));	182	dvTable.getColumns().toArray(new DBColumn[0]));
183	dataView.setDataViewDBTable(dvTable);	183	dataView.getDataViewPageContext().setTableMetaData(dvTable);
184	if (resultSetNeedsReloading(dvTable)) {	184	if (resultSetNeedsReloading(dvTable)) {
185	executeSQLStatement(stmt, sql);	185	executeSQLStatement(stmt, sql);
186	rs = stmt.getResultSet();	186	rs = stmt.getResultSet();
187	}	187	}
188	loadDataFrom(rs);	188	loadDataFrom(dvTable, rs);
189		189
190	if (Thread.interrupted()) {	190	if (Thread.interrupted()) {
191	return;	191	return;
Lines 258-270 Link Here
258	}	258	}
259	}	259	}
260		260
261	RequestProcessor.Task executeInsertRow(final String insertSQL, final Object[] insertedRow) {	261	RequestProcessor.Task executeInsertRow(final DBTable table, final String insertSQL, final Object[] insertedRow) {
262	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_insert");	262	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_insert");
263	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {	263	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {
264		264
265	@Override	265	@Override
266	public void execute() throws SQLException, DBException {	266	public void execute() throws SQLException, DBException {
267	dataView.setEditable(false);	267	dataView.setEditable(false);
		268	List<DBColumn> columns = table.getColumnList();
268	PreparedStatement pstmt = conn.prepareStatement(insertSQL);	269	PreparedStatement pstmt = conn.prepareStatement(insertSQL);
269	try {	270	try {
270	int pos = 1;	271	int pos = 1;
Lines 272-284 Link Here
272	Object val = insertedRow[i];	273	Object val = insertedRow[i];
273		274
274	// Check for Constant e.g <NULL>, <DEFAULT>, <CURRENT_TIMESTAMP> etc	275	// Check for Constant e.g <NULL>, <DEFAULT>, <CURRENT_TIMESTAMP> etc
275	if (DataViewUtils.isSQLConstantString(val,	276	if (DataViewUtils.isSQLConstantString(val, columns.get(i))) {
276	dataView.getDataViewDBTable().getColumn(i))) {
277	continue;	277	continue;
278	}	278	}
279		279
280	// literals	280	// literals
281	int colType = dataView.getDataViewDBTable().getColumnType(i);	281	int colType = columns.get(i).getJdbcType();
282	DBReadWriteHelper.setAttributeValue(pstmt, pos++, colType, val);	282	DBReadWriteHelper.setAttributeValue(pstmt, pos++, colType, val);
283	}	283	}
284		284
Lines 321-337 Link Here
321	return task;	321	return task;
322	}	322	}
323		323
324	void executeDeleteRow(final DataViewTableUI rsTable) {	324	void executeDeleteRow(final DBTable table, final DataViewTableUI rsTable) {
325	// @todo enhance to be able to work with more than one table
326	assert dataView.getDataViewDBTable().getTableCount() == 1 : "Deletes only supported for single table in resultset";
327
328	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_delete");	325	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_delete");
329	final int[] rows = rsTable.getSelectedRows();	326	final int[] rows = rsTable.getSelectedRows();
330	for(int i = 0; i < rows.length; i++) {	327	for(int i = 0; i < rows.length; i++) {
331	rows[i] = rsTable.convertRowIndexToModel(rows[i]);	328	rows[i] = rsTable.convertRowIndexToModel(rows[i]);
332	}	329	}
333	Arrays.sort(rows);	330	Arrays.sort(rows);
334	final DBTable table = dataView.getDataViewDBTable().getTable(0);	331
335	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {	332	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {
336		333
337	@Override	334	@Override
Lines 391-401 Link Here
391	task.schedule(0);	388	task.schedule(0);
392	}	389	}
393		390
394	void executeUpdateRow(final DataViewTableUI rsTable, final boolean selectedOnly) {	391	void executeUpdateRow(final DBTable table, final DataViewTableUI rsTable, final boolean selectedOnly) {
395	// @todo enhance to be able to work with more than one table	392
396	assert dataView.getDataViewDBTable().getTableCount() == 1 : "Updates only supported for single table in resultset";
397
398	final DBTable table = dataView.getDataViewDBTable().getTable(0);
399	final DataViewTableUIModel dataViewTableUIModel = rsTable.getModel();	393	final DataViewTableUIModel dataViewTableUIModel = rsTable.getModel();
400	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_update");	394	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_update");
401	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {	395	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {
Lines 485-491 Link Here
485	}	479	}
486		480
487	// Truncate is allowed only when there is single table used in the query.	481	// Truncate is allowed only when there is single table used in the query.
488	void executeTruncate() {	482	void executeTruncate(final DBTable dbTable) {
489	String msg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_truncate_table_progress");	483	String msg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_truncate_table_progress");
490	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_truncate");	484	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_truncate");
491	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, msg) {	485	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, msg) {
Lines 494-502 Link Here
494		488
495	@Override	489	@Override
496	public void execute() throws SQLException, DBException {	490	public void execute() throws SQLException, DBException {
497
498
499	DBTable dbTable = dataView.getDataViewDBTable().getTable(0);
500	String truncateSql = "TRUNCATE TABLE " + dbTable.getFullyQualifiedName(true); // NOI18N	491	String truncateSql = "TRUNCATE TABLE " + dbTable.getFullyQualifiedName(true); // NOI18N
501		492
502	try {	493	try {
Lines 563-569 Link Here
563	executeSQLStatement(stmt, sql);	554	executeSQLStatement(stmt, sql);
564	if (dataView.hasResultSet()) {	555	if (dataView.hasResultSet()) {
565	ResultSet rs = stmt.getResultSet();	556	ResultSet rs = stmt.getResultSet();
566	loadDataFrom(rs);	557	loadDataFrom(dataView.getDataViewPageContext().getTableMetaData(),
		558	rs);
567		559
568	if (getTotal) {	560	if (getTotal) {
569	Integer result = null;	561	Integer result = null;
Lines 633-639 Link Here
633	task.schedule(0);	625	task.schedule(0);
634	}	626	}
635		627
636	void loadDataFrom(ResultSet rs) throws SQLException {	628	void loadDataFrom(DataViewDBTable tblMeta, ResultSet rs) throws SQLException {
637	if (rs == null) {	629	if (rs == null) {
638	return;	630	return;
639	}	631	}
Lines 641-647 Link Here
641	int pageSize = dataView.getDataViewPageContext().getPageSize();	633	int pageSize = dataView.getDataViewPageContext().getPageSize();
642	int startFrom = dataView.getDataViewPageContext().getCurrentPos();	634	int startFrom = dataView.getDataViewPageContext().getCurrentPos();
643		635
644	DataViewDBTable tblMeta = dataView.getDataViewDBTable();
645	List<Object[]> rows = new ArrayList<Object[]>();	636	List<Object[]> rows = new ArrayList<Object[]>();
646	int colCnt = tblMeta.getColumnCount();	637	int colCnt = tblMeta.getColumnCount();
647	try {	638	try {

Lines 71-77 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataView.java (-10 / +2 lines)
71	private DatabaseConnection dbConn;	71	private DatabaseConnection dbConn;
72	private List<Throwable> errMessages = new ArrayList<Throwable>();	72	private List<Throwable> errMessages = new ArrayList<Throwable>();
73	private String sqlString; // Once Set, Data View assumes it will never change	73	private String sqlString; // Once Set, Data View assumes it will never change
74	private DataViewDBTable tblMeta;
75	private SQLStatementGenerator stmtGenerator;	74	private SQLStatementGenerator stmtGenerator;
76	private SQLExecutionHelper execHelper;	75	private SQLExecutionHelper execHelper;
77	private DataViewPageContext dataPage;	76	private DataViewPageContext dataPage;
Lines 128-134 Link Here
128	}	127	}
129		128
130	synchronized (this) {	129	synchronized (this) {
131	this.dataViewUI = new DataViewUI(this, nbOutputComponent);	130	DataViewDBTable tblMeta = dataPage.getTableMetaData();
		131	this.dataViewUI = new DataViewUI(this, dataPage, nbOutputComponent);
132	dataViewUI.setEditable(tblMeta == null ? false : tblMeta.hasOneTable());	132	dataViewUI.setEditable(tblMeta == null ? false : tblMeta.hasOneTable());
133	resetToolbar(hasExceptions());	133	resetToolbar(hasExceptions());
134	}	134	}
Lines 206-219 Link Here
206	}	206	}
207		207
208	// Non API modules follow	208	// Non API modules follow
209
210	DataViewDBTable getDataViewDBTable() {
211	return tblMeta;
212	}
213
214	void setDataViewDBTable(DataViewDBTable tblMeta) {
215	this.tblMeta = tblMeta;
216	}
217		209
218	DataViewPageContext getDataViewPageContext() {	210	DataViewPageContext getDataViewPageContext() {
219	return dataPage;	211	return dataPage;

Lines 58-73 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewPageContext.java (+12 lines)
58	public static final String PROP_pageSize = "pageSize";	58	public static final String PROP_pageSize = "pageSize";
59	public static final String PROP_totalRows = "totalRows";	59	public static final String PROP_totalRows = "totalRows";
60	public static final String PROP_currentPos = "currentPos";	60	public static final String PROP_currentPos = "currentPos";
		61	public static final String PROP_tableMetaData = "tableMetaData";
61	private PropertyChangeSupport pcs = new PropertyChangeSupport(this);	62	private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
62	private int pageSize = 10;	63	private int pageSize = 10;
63	private int totalRows = -1;	64	private int totalRows = -1;
64	private int currentPos = 1;	65	private int currentPos = 1;
		66	private DataViewDBTable tableMetaData = null;
65	private final DataViewTableUIModel model = new DataViewTableUIModel(new DBColumn[0]);	67	private final DataViewTableUIModel model = new DataViewTableUIModel(new DBColumn[0]);
66		68
67	DataViewPageContext(int pageSize) {	69	DataViewPageContext(int pageSize) {
68	this.pageSize = pageSize;	70	this.pageSize = pageSize;
69	}	71	}
70		72
		73	public DataViewDBTable getTableMetaData() {
		74	return tableMetaData;
		75	}
		76
		77	public void setTableMetaData(DataViewDBTable tableMetaData) {
		78	DataViewDBTable old = this.tableMetaData;
		79	this.tableMetaData = tableMetaData;
		80	firePropertyChange(PROP_tableMetaData, old, tableMetaData);
		81	}
		82
71	int getPageSize() {	83	int getPageSize() {
72	return pageSize;	84	return pageSize;
73	}	85	}

Lines 73-80 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewUI.java (-39 / +20 lines)
73	import org.jdesktop.swingx.JXButton;	73	import org.jdesktop.swingx.JXButton;
74	import org.jdesktop.swingx.JXLabel;	74	import org.jdesktop.swingx.JXLabel;
75	import org.jdesktop.swingx.JXPanel;	75	import org.jdesktop.swingx.JXPanel;
76	import org.jdesktop.swingx.JXTableHeader;
77	import org.netbeans.modules.db.dataview.meta.DBColumn;
78	import org.netbeans.modules.db.dataview.table.JXTableRowHeader;	76	import org.netbeans.modules.db.dataview.table.JXTableRowHeader;
79	import org.netbeans.modules.db.dataview.table.MultiColPatternFilter;	77	import org.netbeans.modules.db.dataview.table.MultiColPatternFilter;
80	import org.netbeans.modules.db.dataview.table.ResultSetJXTable;	78	import org.netbeans.modules.db.dataview.table.ResultSetJXTable;
Lines 104-110 Link Here
104	private JXButton[] editButtons = new JXButton[5];	102	private JXButton[] editButtons = new JXButton[5];
105	private DataViewTableUI dataPanel;	103	private DataViewTableUI dataPanel;
106	private JScrollPane dataPanelScrollPane;	104	private JScrollPane dataPanelScrollPane;
107	private final DataView dataView;	105	private final DataViewPageContext pageContext;
108	private JXButton cancel;	106	private JXButton cancel;
109	private DataViewActionHandler actionHandler;	107	private DataViewActionHandler actionHandler;
110	private String imgPrefix = "/org/netbeans/modules/db/dataview/images/"; // NOI18N	108	private String imgPrefix = "/org/netbeans/modules/db/dataview/images/"; // NOI18N
Lines 151-160 Link Here
151	}	149	}
152	};	150	};
153		151
154	DataViewUI(DataView dataView, boolean nbOutputComponent) {	152	DataViewUI(DataView dataView, DataViewPageContext pageContext, boolean nbOutputComponent) {
155	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N	153	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N
156		154
157	this.dataView = dataView;	155	this.pageContext = pageContext;
158		156
159	//do not show tab view if there is only one tab	157	//do not show tab view if there is only one tab
160	this.putClientProperty("TabPolicy", "HideWhenAlone"); //NOI18N	158	this.putClientProperty("TabPolicy", "HideWhenAlone"); //NOI18N
Lines 178-184 Link Here
178	actionHandler = new DataViewActionHandler(this, dataView);	176	actionHandler = new DataViewActionHandler(this, dataView);
179		177
180	//add resultset data panel	178	//add resultset data panel
181	dataPanel = new DataViewTableUI(this, actionHandler, dataView);	179	dataPanel = new DataViewTableUI(this, actionHandler, dataView, pageContext);
182	dataPanelScrollPane = new JScrollPane(dataPanel);	180	dataPanelScrollPane = new JScrollPane(dataPanel);
183	JXTableRowHeader rowHeader = new JXTableRowHeader(dataPanel);	181	JXTableRowHeader rowHeader = new JXTableRowHeader(dataPanel);
184	dataPanelScrollPane.setRowHeaderView(rowHeader);	182	dataPanelScrollPane.setRowHeaderView(rowHeader);
Lines 188-196 Link Here
188	dataPanel.revalidate();	186	dataPanel.revalidate();
189	dataPanel.repaint();	187	dataPanel.repaint();
190		188
191	dataPanel.setModel(dataView.getDataViewPageContext().getModel());	189	dataPanel.setModel(pageContext.getModel());
192	dataView.getDataViewPageContext().addPropertyChangeListener(	190	pageContext.addPropertyChangeListener(pageContextListener);
193	pageContextListener);	191
194	updateTotalCountLabel();	192	updateTotalCountLabel();
195	}	193	}
196		194
Lines 218-233 Link Here
218		216
219	void updateTotalCountLabel() {	217	void updateTotalCountLabel() {
220	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N	218	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N
221		219
222	DataViewPageContext pageContext = dataView.getDataViewPageContext();
223
224	if (pageContext.isTotalRowCountAvailable()) {	220	if (pageContext.isTotalRowCountAvailable()) {
225	totalRowsLabel.setText(	221	totalRowsLabel.setText(
226	pageContext.getTotalRows() + " " + pageContext.pageOf());	222	pageContext.getTotalRows() + " " + pageContext.pageOf());
227	} else {	223	} else {
228	totalRowsLabel.setText(NbBundle.getMessage(DataViewUI.class,	224	totalRowsLabel.setText(NbBundle.getMessage(DataViewUI.class,
229	"LBL_not_available") + " "	225	"LBL_not_available") + " "
230	+ dataView.getDataViewPageContext().pageOf());	226	+ pageContext.pageOf());
231	}	227	}
232	}	228	}
233		229
Lines 251-271 Link Here
251	cancel.setEnabled(flag);	247	cancel.setEnabled(flag);
252	}	248	}
253		249
254	void setDataRows(List<Object[]> rows) {
255	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N
256	assert rows != null;
257
258	DBColumn[] columns = dataView.getDataViewDBTable().getColumns().toArray(
259	new DBColumn[0]);
260
261	DataViewTableUIModel dvtm = getDataViewTableUIModel();
262
263	dvtm.removeAllUpdates(false);
264
265	dvtm.setColumns(columns);
266	dvtm.setData(rows);
267	}
268
269	void disableButtons() {	250	void disableButtons() {
270	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N	251	assert SwingUtilities.isEventDispatchThread() : "Must be called from AWT thread"; //NOI18N
271		252
Lines 288-295 Link Here
288	}	269	}
289		270
290	int getPageSize() {	271	int getPageSize() {
291	int pageSize = dataView.getDataViewPageContext().getPageSize();	272	int pageSize = pageContext.getPageSize();
292	int totalCount = dataView.getDataViewPageContext().getTotalRows();	273	int totalCount = pageContext.getTotalRows();
293	try {	274	try {
294	int count = Integer.parseInt(refreshField.getText().trim());	275	int count = Integer.parseInt(refreshField.getText().trim());
295	return count < 0 ? pageSize : count;	276	return count < 0 ? pageSize : count;
Lines 309-334 Link Here
309	refreshField.setEnabled(true);	290	refreshField.setEnabled(true);
310	matchBoxField.setEditable(true);	291	matchBoxField.setEditable(true);
311	deleteRow.setEnabled(false);	292	deleteRow.setEnabled(false);
312	DataViewPageContext dataPage = dataView.getDataViewPageContext();	293
313	if (!wasError) {	294	if (!wasError) {
314	if (dataPage.hasPrevious()) {	295	if (pageContext.hasPrevious()) {
315	first.setEnabled(true);	296	first.setEnabled(true);
316	previous.setEnabled(true);	297	previous.setEnabled(true);
317	}	298	}
318		299
319	if (dataPage.hasNext()) {	300	if (pageContext.hasNext()) {
320	next.setEnabled(true);	301	next.setEnabled(true);
321	if(dataPage.getTotalRows() >= 0) {	302	if(pageContext.getTotalRows() >= 0) {
322	last.setEnabled(true);	303	last.setEnabled(true);
323	}	304	}
324	}	305	}
325		306
326	if (dataPage.hasOnePageOnly()) {	307	if (pageContext.hasOnePageOnly()) {
327	first.setEnabled(false);	308	first.setEnabled(false);
328	previous.setEnabled(false);	309	previous.setEnabled(false);
329	}	310	}
330		311
331	if (dataPage.isLastPage()) {	312	if (pageContext.isLastPage()) {
332	next.setEnabled(false);	313	next.setEnabled(false);
333	last.setEnabled(false);	314	last.setEnabled(false);
334	}	315	}
Lines 341-352 Link Here
341	insert.setEnabled(false);	322	insert.setEnabled(false);
342	truncateButton.setEnabled(false);	323	truncateButton.setEnabled(false);
343	} else {	324	} else {
344	if (dataPage.hasRows()) {	325	if (pageContext.hasRows()) {
345	truncateButton.setEnabled(true);	326	truncateButton.setEnabled(true);
346	} else {	327	} else {
347	deleteRow.setEnabled(false);	328	deleteRow.setEnabled(false);
348	truncateButton.setEnabled(false);	329	truncateButton.setEnabled(false);
349	dataPage.first();	330	pageContext.first();
350	}	331	}
351	insert.setEnabled(true);	332	insert.setEnabled(true);
352	if (getDataViewTableUIModel().getUpdateKeys().isEmpty()) {	333	if (getDataViewTableUIModel().getUpdateKeys().isEmpty()) {
Lines 361-367 Link Here
361	disableButtons();	342	disableButtons();
362	}	343	}
363		344
364	refreshField.setText("" + dataPage.getPageSize());	345	refreshField.setText("" + pageContext.getPageSize());
365	if (dataPanel != null) {	346	if (dataPanel != null) {
366	dataPanel.revalidate();	347	dataPanel.revalidate();
367	dataPanel.repaint();	348	dataPanel.repaint();

Lines 92-100 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/DataViewDBTableTest.java (-11 / +8 lines)
92	dbconn=null;	92	dbconn=null;
93	}	93	}
94		94
95	public static DBTable getTable(DataView dv, int index){
96	return dv.getDataViewDBTable().getTable(index);
97	}
98	/**	95	/**
99	* Test of geTable method, of class DataViewDBTable.	96	* Test of geTable method, of class DataViewDBTable.
100	*/	97	*/
Lines 102-108 Link Here
102	int index = 5;	99	int index = 5;
103	String sqlStr = context.getSqlSelect();	100	String sqlStr = context.getSqlSelect();
104	DataView dv = DataView.create(dbconn, sqlStr, index);	101	DataView dv = DataView.create(dbconn, sqlStr, index);
105	DataViewDBTable instance = dv.getDataViewDBTable();	102	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
106	DBTable result = instance.getTable(0);	103	DBTable result = instance.getTable(0);
107	assertNotNull(result);	104	assertNotNull(result);
108	assertEquals(11, instance.getColumnCount());	105	assertEquals(11, instance.getColumnCount());
Lines 115-121 Link Here
115	int index = 5;	112	int index = 5;
116	String sqlStr = context.getSqlSelect();	113	String sqlStr = context.getSqlSelect();
117	DataView dv = DataView.create(dbconn, sqlStr, index);	114	DataView dv = DataView.create(dbconn, sqlStr, index);
118	DataViewDBTable instance = dv.getDataViewDBTable();	115	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
119	int expResult = 1;	116	int expResult = 1;
120	int result = instance.getTableCount();	117	int result = instance.getTableCount();
121	assertEquals(expResult, result);	118	assertEquals(expResult, result);
Lines 128-134 Link Here
128	int index = 5;	125	int index = 5;
129	String sqlStr = context.getSqlSelect();	126	String sqlStr = context.getSqlSelect();
130	DataView dv = DataView.create(dbconn, sqlStr, index);	127	DataView dv = DataView.create(dbconn, sqlStr, index);
131	DataViewDBTable instance = dv.getDataViewDBTable();	128	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
132	boolean expResult = true;	129	boolean expResult = true;
133	boolean result = instance.hasOneTable();	130	boolean result = instance.hasOneTable();
134	assertEquals(expResult, result);	131	assertEquals(expResult, result);
Lines 141-147 Link Here
141	int index = 5;	138	int index = 5;
142	String sqlStr = context.getSqlSelect();	139	String sqlStr = context.getSqlSelect();
143	DataView dv = DataView.create(dbconn, sqlStr, index);	140	DataView dv = DataView.create(dbconn, sqlStr, index);
144	DataViewDBTable instance = dv.getDataViewDBTable();	141	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
145	String expResult = "SIMPLETABLE";	142	String expResult = "SIMPLETABLE";
146	String result = instance.getFullyQualifiedName(0, false);	143	String result = instance.getFullyQualifiedName(0, false);
147	assertEquals(expResult, result);	144	assertEquals(expResult, result);
Lines 154-160 Link Here
154	int index = 5;	151	int index = 5;
155	String sqlStr = context.getSqlSelect();	152	String sqlStr = context.getSqlSelect();
156	DataView dv = DataView.create(dbconn, sqlStr, index);	153	DataView dv = DataView.create(dbconn, sqlStr, index);
157	DataViewDBTable instance = dv.getDataViewDBTable();	154	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
158	int expResult = 12;	155	int expResult = 12;
159	int result = instance.getColumnType(2);	156	int result = instance.getColumnType(2);
160	assertEquals(expResult, result);	157	assertEquals(expResult, result);
Lines 167-173 Link Here
167	int index = 5;	164	int index = 5;
168	String sqlStr = context.getSqlSelect();	165	String sqlStr = context.getSqlSelect();
169	DataView dv = DataView.create(dbconn, sqlStr, index);	166	DataView dv = DataView.create(dbconn, sqlStr, index);
170	DataViewDBTable instance = dv.getDataViewDBTable();	167	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
171	String expResult = "DATEC";	168	String expResult = "DATEC";
172	String result = instance.getColumnName(index);	169	String result = instance.getColumnName(index);
173	assertEquals(expResult, result);	170	assertEquals(expResult, result);
Lines 180-186 Link Here
180	int index = 5;	177	int index = 5;
181	String sqlStr = context.getSqlSelect();	178	String sqlStr = context.getSqlSelect();
182	DataView dv = DataView.create(dbconn, sqlStr, index);	179	DataView dv = DataView.create(dbconn, sqlStr, index);
183	DataViewDBTable instance = dv.getDataViewDBTable();	180	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
184	String expResult = "TINYINTC";	181	String expResult = "TINYINTC";
185	String result = instance.getQualifiedName(0, false);	182	String result = instance.getQualifiedName(0, false);
186	assertEquals(expResult, result);	183	assertEquals(expResult, result);
Lines 193-199 Link Here
193	int index = 5;	190	int index = 5;
194	String sqlStr = context.getSqlSelect();	191	String sqlStr = context.getSqlSelect();
195	DataView dv = DataView.create(dbconn, sqlStr, index);	192	DataView dv = DataView.create(dbconn, sqlStr, index);
196	DataViewDBTable instance = dv.getDataViewDBTable();	193	DataViewDBTable instance = dv.getDataViewPageContext().getTableMetaData();
197	int expResult = 11;	194	int expResult = 11;
198	int result = instance.getColumnCount();	195	int result = instance.getColumnCount();
199	assertEquals(expResult, result);	196	assertEquals(expResult, result);