Attachment #132995 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




        return dataViewUI.get(0).getEditButtons();
    }

    public synchronized void setEditable(final boolean editable) {
        Mutex.EVENT.writeAccess(new Mutex.Action<Object>() {
            @Override
            public Void run() {
                for (DataViewPageContext pageContext : dataPage) {
                    pageContext.getModel().setEditable(editable);
                }
                return null;
            }
        });

    }

    // Used by org.netbeans.modules.db.dataview.api.DataViewPageContext#getPageSize

        return this.dataPage.get(i);
    }

    DataViewPageContext addPageContext(final DataViewDBTable table) {
        final DataViewPageContext pageContext = new DataViewPageContext(initialPageSize);
        this.dataPage.add(pageContext);
        Mutex.EVENT.writeAccess(new Mutex.Action<Object>() {
            @Override
            public Void run() {
                pageContext.setTableMetaData(table);
                pageContext.getModel().setColumns(table.getColumns().toArray(new DBColumn[0]));
                return null;
            }
        });
        return pageContext;
    }


    }

    public void resetEditable() {
        Mutex.EVENT.readAccess(new Runnable() {
            @Override
            public void run() {
                for (DataViewPageContext pageContext : dataPage) {
                    pageContext.resetEditableState();
                }
            }
        });     
    }

    public boolean isEditable() {
        if(dataPage.isEmpty()) {
            return false;
        } else {
            return Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {
                @Override
                public Boolean run() {
                    boolean editable = true;
                    for (DataViewPageContext pageContext : dataPage) {
                        editable &= pageContext.getModel().isEditable();
                    }
                    return editable;
                }
            });
        }
    }





                    .setStoredPageSize(pageSize);
            dataPage.first();
            dataPage.setTotalRows(-1); // force total row refresh
            execHelper.executeQueryOffEDT();
        }
    }

    void firstActionPerformed() {
        if (rejectModifications()) {
            dataPage.first();
            execHelper.executeQueryOffEDT();
        }
    }

    void previousActionPerformed() {
        if (rejectModifications()) {
            dataPage.previous();
            execHelper.executeQueryOffEDT();
        }
    }

    void nextActionPerformed() {
        if (rejectModifications()) {
            dataPage.next();
            execHelper.executeQueryOffEDT();
        }
    }

    void lastActionPerformed() {
        if (rejectModifications()) {
            dataPage.last();
            execHelper.executeQueryOffEDT();
        }
    }



    void refreshActionPerformed() {
        dataPage.setTotalRows(-1); // force total row refresh
        execHelper.executeQueryOffEDT();
    }

    private static Object showYesAllDialog(Object msg, String title) {

Lines 173-182 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewPageContext.java (-4 lines)
173	return (isLastPage() && model.getRowCount() <= pageSize);	173	return (isLastPage() && model.getRowCount() <= pageSize);
174	}	174	}
175		175
176	boolean hasDataRows() {
177	return model.getRowCount() > 0;
178	}
179
180	String pageOf() {	176	String pageOf() {
181	String curPage = NbBundle.getMessage(DataViewUI.class, "LBL_not_available");	177	String curPage = NbBundle.getMessage(DataViewUI.class, "LBL_not_available");
182	String totalPages = NbBundle.getMessage(DataViewUI.class, "LBL_not_available");	178	String totalPages = NbBundle.getMessage(DataViewUI.class, "LBL_not_available");

Lines 146-154 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewTableUI.java (-3 / +1 lines)
146		146
147	@Override	147	@Override
148	public TableCellRenderer getCellRenderer(int row, int column) {	148	public TableCellRenderer getCellRenderer(int row, int column) {
149	if (row < getModel().getRowCount()	149	if (getModel().hasUpdates(
150	&& column < getModel().getColumnCount()
151	&& getModel().hasUpdates(
152	convertRowIndexToModel(row),	150	convertRowIndexToModel(row),
153	convertColumnIndexToModel(column))) {	151	convertColumnIndexToModel(column))) {
154	return new UpdatedResultSetCellRenderer();	152	return new UpdatedResultSetCellRenderer();




import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.swing.SwingUtilities;
import org.netbeans.modules.db.dataview.meta.DBColumn;
import org.netbeans.modules.db.dataview.table.ResultSetTableModel;



    @Override
    public void setValueAt(Object value, int row, int col) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Object oldval = getValueAt(row, col);
        if (noUpdateRequired(oldval, value)) {
            return;

    }

    public Object getOriginalValueAt(int row, int col) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        if(hasUpdates(row, col)) {
            return oldData.get(row).get(col);
        } else {


    @Override
    public void setData(List<Object[]> data) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        super.setData(data);
        oldData.clear();
    }

    @Override
    public void removeRow(int row) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        super.removeRow(row);
        oldData.remove(row);
    }

    @Override
    public void clear() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        super.clear();
        oldData.clear();
    }

    private void addUpdates(int row, int col, Object value) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Map<Integer, Object> rowMap = oldData.get(row);
        if (rowMap == null) {
            rowMap = new LinkedHashMap<Integer, Object>();

    }

    public void removeAllUpdates(boolean discardNewValue) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        for(Integer rowIndex: new HashSet<Integer>(oldData.keySet())) {
            Map<Integer,Object> oldRow = oldData.remove(rowIndex);
            if (discardNewValue) {

    }

    public void removeUpdateForSelectedRow(int row, boolean discardNewValue) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        if (oldData.containsKey(row)) {
            Map<Integer, Object> oldRow = oldData.remove(row);
            if (discardNewValue) {

    }

    public void removeUpdate(int row, int col, boolean discardNewValue) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        if (oldData.containsKey(row)) {
            Map<Integer, Object> oldRow = oldData.get(row);
            if (oldRow.containsKey(col)) {

    }

    public Set<Integer> getUpdateKeys() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return oldData.keySet();
    }

    public Map<Integer, Object> getChangedData(int row) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Set<Integer> changedColumns = oldData.get(row).keySet();
        Map<Integer,Object> result = new HashMap<Integer, Object>();
        for(Integer column: changedColumns) {

    }

    boolean hasUpdates() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return oldData.size() > 0;
    }

    boolean hasUpdates(int row, int col) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Map<Integer, Object> rowMap = oldData.get(new Integer(row));
        return rowMap != null && rowMap.containsKey(new Integer(col));
    }

Lines 61-66 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/InsertRecordDialog.java (-15 / +48 lines)
61	import java.util.Arrays;	61	import java.util.Arrays;
62	import java.util.List;	62	import java.util.List;
63	import java.util.StringTokenizer;	63	import java.util.StringTokenizer;
		64	import java.util.concurrent.ExecutionException;
64	import java.util.logging.Level;	65	import java.util.logging.Level;
65	import java.util.logging.Logger;	66	import java.util.logging.Logger;
66	import javax.swing.AbstractAction;	67	import javax.swing.AbstractAction;
Lines 73-78 Link Here
73	import javax.swing.KeyStroke;	74	import javax.swing.KeyStroke;
74	import javax.swing.SwingConstants;	75	import javax.swing.SwingConstants;
75	import javax.swing.SwingUtilities;	76	import javax.swing.SwingUtilities;
		77	import javax.swing.SwingWorker;
76	import javax.swing.border.EmptyBorder;	78	import javax.swing.border.EmptyBorder;
77	import javax.swing.event.TableModelEvent;	79	import javax.swing.event.TableModelEvent;
78	import javax.swing.event.TableModelListener;	80	import javax.swing.event.TableModelListener;
Lines 98-103 Link Here
98	*	100	*
99	*/	101	*/
100	class InsertRecordDialog extends javax.swing.JDialog {	102	class InsertRecordDialog extends javax.swing.JDialog {
		103	private static final Logger LOG = Logger.getLogger(InsertRecordDialog.class.getName());
		104
101	private final ResultSetTableModel insertDataModel;	105	private final ResultSetTableModel insertDataModel;
102	private final DBTable insertTable;	106	private final DBTable insertTable;
103	private final DataView dataView;	107	private final DataView dataView;
Lines 374-414 Link Here
374	if (insertRecordTableUI.isEditing()) {	378	if (insertRecordTableUI.isEditing()) {
375	insertRecordTableUI.getCellEditor().stopCellEditing();	379	insertRecordTableUI.getCellEditor().stopCellEditing();
376	}	380	}
		381
		382	final int rows = insertRecordTableUI.getRowCount();
		383	final Object[][] insertedRows = new Object[rows][insertTable.getColumnList().size()];
		384
		385	try {
		386	for (int i = 0; i < rows; i++) {
		387	insertedRows[i] = getInsertValues(i);
		388	}
		389	} catch (DBException ex) {
		390	LOG.log(Level.INFO, ex.getLocalizedMessage(), ex);
		391	DialogDisplayer.getDefault().notifyLater(
		392	new NotifyDescriptor.Message(ex.getLocalizedMessage()));
		393	return;
		394	}
		395
377	// Get out of AWT thread because SQLExecutionHelper does calls to AWT	396	// Get out of AWT thread because SQLExecutionHelper does calls to AWT
378	// and we need to wait here to show possible exceptions.	397	// and we need to wait here to show possible exceptions.
379	new Thread("Inserting values") { //NOI18N	398	new SwingWorker<Integer, Void>() {
380		399
381	@Override	400	@Override
382	public void run() {	401	protected Integer doInBackground() throws Exception {
383	String insertSQL = null;
384	SQLStatementGenerator stmtBldr = dataView.getSQLStatementGenerator();	402	SQLStatementGenerator stmtBldr = dataView.getSQLStatementGenerator();
385	SQLExecutionHelper execHelper = dataView.getSQLExecutionHelper();	403	SQLExecutionHelper execHelper = dataView.getSQLExecutionHelper();
386	for (int i = 0; i < insertRecordTableUI.getRowCount(); i++) {	404	for (int i = 0; i < rows; i++) {
387	boolean wasException = false;	405	boolean wasException;
388	try {	406	try {
389	Object[] insertedRow = getInsertValues(i);	407	Object[] insertedRow = insertedRows[i];
390	insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);	408	String insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);
391	RequestProcessor.Task task = execHelper.executeInsertRow(pageContext, insertTable, insertSQL, insertedRow);	409	RequestProcessor.Task task = execHelper.executeInsertRow(pageContext, insertTable, insertSQL, insertedRow);
392	task.waitFinished();	410	task.waitFinished();
393	wasException = dataView.hasExceptions();	411	wasException = dataView.hasExceptions();
394	} catch (DBException ex) {	412	} catch (DBException ex) {
395	Logger.getLogger(InsertRecordDialog.class.getName()).log(Level.INFO, ex.getLocalizedMessage(), ex);	413	LOG.log(Level.INFO, ex.getLocalizedMessage(), ex);
396	DialogDisplayer.getDefault().notifyLater(new NotifyDescriptor.Message(ex.getLocalizedMessage()));	414	DialogDisplayer.getDefault().notifyLater(new NotifyDescriptor.Message(ex.getLocalizedMessage()));
397	wasException = true;	415	wasException = true;
398	}	416	}
399	if (wasException) {	417	if (wasException) {
		418	return i;
		419	}
		420	}
		421	return null;
		422	}
		423
		424	@Override
		425	protected void done() {
		426	Integer brokeOn;
		427	try {
		428	brokeOn = get();
		429
		430	if (brokeOn == null) {
		431	dispose();
		432	} else {
400	// remove i already inserted	433	// remove i already inserted
401	for (int j = 0; j < i; j++) {	434	for (int j = 0; j < brokeOn; j++) {
402	insertRecordTableUI.getModel().removeRow(0);	435	insertRecordTableUI.getModel().removeRow(0);
403	}	436	}
404	// return without closing
405	return;
406	}	437	}
		438	} catch (InterruptedException ex) {
		439	throw new RuntimeException(ex);
		440	} catch (ExecutionException ex) {
		441	throw new RuntimeException(ex);
407	}	442	}
408	// close dialog
409	dispose();
410	}	443	}
411	}.start();	444	}.execute();
412	}	445	}
413		446
414	private void previewBtnActionPerformed(java.awt.event.ActionEvent evt) {	447	private void previewBtnActionPerformed(java.awt.event.ActionEvent evt) {
Lines 607-613 Link Here
607	}	640	}
608	}	641	}
609	} catch (Exception ex) {	642	} catch (Exception ex) {
610	java.util.logging.Logger.getLogger(InsertRecordDialog.class.getName()).info("Failed to paste the contents " + ex);	643	LOG.log(Level.INFO, "Failed to paste the contents ", ex);
611	}	644	}
612	}	645	}
613		646




import java.util.concurrent.Future;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import org.netbeans.modules.db.dataview.meta.DBColumn;
import org.netbeans.modules.db.dataview.meta.DBConnectionFactory;
import org.netbeans.modules.db.dataview.meta.DBException;

import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.util.Cancellable;
import org.openide.util.Mutex;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;


    }

    void initialDataLoad() throws SQLException {
        assert (! SwingUtilities.isEventDispatchThread()) : "Must be called of the EDT!";
        
        /**
         * Wrap initializing the SQL result into a runnable. This makes it
         * possible to wait for the result in the main thread and cancel the

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



            @Override
            protected void executeOnSucess() {
                // refresh when required
                Boolean needRequery = Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {
                    @Override
                    public Boolean run() {
                        if (pageContext.getTotalRows() < 0) {
                            pageContext.setTotalRows(0);
                            pageContext.first();
                        }
                        pageContext.incrementRowSize(1);

                        return pageContext.refreshRequiredOnInsert();
                    };
                });
                if(needRequery) {
                    SQLExecutionHelper.this.executeQuery();
                } else {
                    Mutex.EVENT.readAccess(new Runnable() {
                        @Override
                        public void run() {
                            reinstateToolbar();
                        }
                    });
                }
            }
        };

    }

    void executeDeleteRow(final DataViewPageContext pageContext, final DBTable table, final DataViewTableUI rsTable) {
        dataView.setEditable(false);
        
        SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_delete");
        
        class DeleteElement {
            public List<Object> values = new ArrayList<Object>();
            public List<Integer> types = new ArrayList<Integer>();
            public String sql;
        }
        
        final List<DeleteElement> rows = new ArrayList<DeleteElement>();
        for(int viewRow: rsTable.getSelectedRows()) {
            int modelRow = rsTable.convertRowIndexToModel(viewRow);
            DeleteElement de = new DeleteElement();
            de.sql = generator.generateDeleteStatement(table, de.types, de.values, modelRow, rsTable.getModel());
            rows.add(de);
        }

        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {

            @Override
            public void execute() throws SQLException, DBException {
                dataView.setEditable(false);
                for (DeleteElement de: rows) {
                    if (Thread.currentThread().isInterrupted() || error) {
                        break;
                    }
                    deleteARow(de);
                }
            }

            private void deleteARow(DeleteElement deleteRow) throws SQLException, DBException {
                PreparedStatement pstmt = conn.prepareStatement(deleteRow.sql);
                final List<Integer> types = new ArrayList<Integer>();

                SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
                final String deleteStmt = generator.generateDeleteStatement(table, types, values, rowNum, tblModel);
                PreparedStatement pstmt = conn.prepareStatement(deleteStmt);
                try {
                    int pos = 1;
                    for (Object val : deleteRow.values) {
                        DBReadWriteHelper.setAttributeValue(pstmt, pos, deleteRow.types.get(pos - 1), val);
                        pos++;
                    }



            @Override
            protected void executeOnSucess() {
                pageContext.decrementRowSize(rows.size());
                SQLExecutionHelper.this.executeQuery();
            }
        };

    }

    void executeUpdateRow(final DBTable table, final DataViewTableUI rsTable, final boolean selectedOnly) {
        dataView.setEditable(false);
        
        SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
        final DataViewTableUIModel dataViewTableUIModel = rsTable.getModel();
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_update");
        
        class UpdateElement {
            public List<Object> values = new ArrayList<Object>();
            public List<Integer> types = new ArrayList<Integer>();
            public String sql;
            public Integer key;
        }
        
        final List<UpdateElement> updateSet = new ArrayList<UpdateElement>();

        int[] viewRows = rsTable.getSelectedRows();
        List<Integer> modelRows = new ArrayList<Integer>();
        for(Integer viewRow: viewRows) {
            modelRows.add(rsTable.convertRowIndexToModel(viewRow));
        }

        for (Integer key : dataViewTableUIModel.getUpdateKeys()) {
            if (modelRows.contains(key) || (!selectedOnly)) {
                UpdateElement ue = new UpdateElement();
                try {
                    ue.key = key;
                    ue.sql = generator.generateUpdateStatement(table, key,
                            dataViewTableUIModel.getChangedData(key), ue.values, ue.types,
                            rsTable.getModel());
                    updateSet.add(ue);
                } catch (DBException ex) {
                    // The model protects against illegal values, so rethrow
                    throw new RuntimeException(ex);
                }
            }
        }


        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {

            private PreparedStatement pstmt;


            @Override
            public void execute() throws SQLException, DBException {
                for (UpdateElement ue : updateSet) {
                    if(Thread.interrupted()) {
                        break;
                } else {
                    for (Integer key : dataViewTableUIModel.getUpdateKeys()) {
                        if (Thread.currentThread().isInterrupted()) {
                            break;
                        } else {
                            updateARow(key);
                            keysToRemove.add(key);
                        }
                    }
                    updateARow(ue);
                    keysToRemove.add(ue.key);
                }
            }

            private void updateARow(UpdateElement ue) throws SQLException, DBException {
                pstmt = conn.prepareStatement(ue.sql);
                for (int j = 0; j < rows.length && !error; j++) {
                    Set<Integer> keys = dataViewTableUIModel.getUpdateKeys();
                    for (Integer key : keys) {
                        if (Thread.currentThread().isInterrupted()) {
                            break;
                        } else if (key == rows[j]) {
                            updateARow(key);
                            keysToRemove.add(key);
                        }
                    }
                }
            }

            private void updateARow(Integer key) throws SQLException, DBException {
                SQLStatementGenerator generator = dataView.getSQLStatementGenerator();

                List<Object> values = new ArrayList<Object>();
                List<Integer> types = new ArrayList<Integer>();
                String updateStmt = generator.generateUpdateStatement(table, key, dataViewTableUIModel.getChangedData(key), values, types, rsTable.getModel());

                pstmt = conn.prepareStatement(updateStmt);
                int pos = 1;
                for (Object val : ue.values) {
                    DBReadWriteHelper.setAttributeValue(pstmt, pos, ue.types.get(pos - 1), val);
                    pos++;
                }



            @Override
            protected void executeOnSucess() {
                Mutex.EVENT.writeAccess(new Runnable() {
                    @Override
                    public void run() {
                        DataViewTableUIModel tblContext = rsTable.getModel();
                        for (Integer key : keysToRemove) {
                            tblContext.removeUpdateForSelectedRow(key, false);
                        }

                        reinstateToolbar();
                    }
                });
            }
        };
        RequestProcessor.Task task = rp.create(executor);

        task.schedule(0);
    }

    void executeQueryOffEDT() {
        rp.post(new Runnable() {
            @Override
            public void run() {
                executeQuery();
            }
        });
    }
    
    // Once Data View is created the it assumes the query never changes.
    void executeQuery() {
        assert (! SwingUtilities.isEventDispatchThread());
        
        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_executequery");
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, dataView.getSQLString()) {


        task.schedule(0);
    }

    private void loadDataFrom(final DataViewPageContext pageContext, ResultSet rs, boolean getTotal) throws SQLException {
        if (rs == null) {
            return;
        }

        int pageSize = pageContext.getPageSize();
        int startFrom = pageContext.getCurrentPos();

        final List<Object[]> rows = new ArrayList<Object[]>();
        int colCnt = pageContext.getTableMetaData().getColumnCount();
        try {
            boolean hasNext = false;

            LOGGER.log(Level.SEVERE, "Failed to set up table model.", e); // NOI18N
            throw e;
        } finally {
            Mutex.EVENT.writeAccess(new Mutex.Action<Void>() {
                @Override
                public Void run() {
                    pageContext.getModel().setData(rows);
                    return null;
                }
            });
        }
    }


Lines 54-59 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/SQLStatementGenerator.java (+5 lines)
54	import java.util.Set;	54	import java.util.Set;
55	import java.util.logging.Level;	55	import java.util.logging.Level;
56	import java.util.logging.Logger;	56	import java.util.logging.Logger;
		57	import javax.swing.SwingUtilities;
57	import org.netbeans.modules.db.dataview.meta.DBColumn;	58	import org.netbeans.modules.db.dataview.meta.DBColumn;
58	import org.netbeans.modules.db.dataview.meta.DBException;	59	import org.netbeans.modules.db.dataview.meta.DBException;
59	import org.netbeans.modules.db.dataview.meta.DBMetaDataFactory;	60	import org.netbeans.modules.db.dataview.meta.DBMetaDataFactory;
Lines 367-372 Link Here
367	}	368	}
368		369
369	void generateWhereCondition(DBTable table, StringBuilder result, List<Integer> types, List<Object> values, int rowNum, DataViewTableUIModel model) {	370	void generateWhereCondition(DBTable table, StringBuilder result, List<Integer> types, List<Object> values, int rowNum, DataViewTableUIModel model) {
		371	assert SwingUtilities.isEventDispatchThread() : "Needs to be called on the EDT";
		372
370	DBPrimaryKey key = table.getPrimaryKey();	373	DBPrimaryKey key = table.getPrimaryKey();
371	Set<String> columnsSelected = new HashSet<String>();	374	Set<String> columnsSelected = new HashSet<String>();
372	boolean and = false;	375	boolean and = false;
Lines 411-416 Link Here
411	}	414	}
412		415
413	void generateWhereCondition(DBTable table, StringBuilder sql, int rowNum, DataViewTableUIModel model) {	416	void generateWhereCondition(DBTable table, StringBuilder sql, int rowNum, DataViewTableUIModel model) {
		417	assert SwingUtilities.isEventDispatchThread() : "Needs to be called on the EDT";
		418
414	DBPrimaryKey key = table.getPrimaryKey();	419	DBPrimaryKey key = table.getPrimaryKey();
415	Set<String> columnsSelected = new HashSet<String>();	420	Set<String> columnsSelected = new HashSet<String>();
416	boolean and = false;	421	boolean and = false;




import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;
import org.netbeans.modules.db.dataview.meta.DBColumn;
import org.netbeans.modules.db.dataview.util.DBReadWriteHelper;

    private final List<Object[]> data = new ArrayList<Object[]>();
    private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

    protected static Class<? extends Object> getTypeClass(DBColumn col) {
        int colType = col.getJdbcType();

        if (colType == Types.BIT && col.getPrecision() <= 1) {

    }

    public void setColumns(DBColumn[] columns) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        this.data.clear();
        this.columns = columns;
        fireTableStructureChanged();
    }

    public DBColumn[] getColumns() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return Arrays.copyOf(columns, columns.length);
    }

    public void setEditable(boolean editable) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        boolean old = this.editable;
        this.editable = editable;
        pcs.firePropertyChange("editable", old, editable);
    }

    public boolean isEditable() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return editable;
    }

    @Override
    public boolean isCellEditable(int row, int column) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        if (!editable) {
            return false;
        }


    @Override
    public void setValueAt(Object value, int row, int col) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Object oldVal = getValueAt(row, col);
        if (noUpdateRequired(oldVal, value)) {
            return;

    @Override
    @SuppressWarnings("unchecked")
    public Class<? extends Object> getColumnClass(int columnIndex) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        if (columns[columnIndex] == null) {
            return super.getColumnClass(columnIndex);
        } else {

    }

    public DBColumn getColumn(int columnIndex) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return columns[columnIndex];
    }

    @Override
    public int getColumnCount() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return columns.length;
    }

    public String getColumnTooltip(int columnIndex) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return DataViewUtils.getColumnToolTip(columns[columnIndex]);
    }

    @Override
    public String getColumnName(int columnIndex) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        String displayName = columns[columnIndex].getDisplayName();
        return displayName != null ? displayName : "COL_" + columnIndex;
    }


    @Override
    public int getRowCount() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        return data.size();
    }
        
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Object[] dataRow = data.get(rowIndex);
        return dataRow[columnIndex];
    }

    public Object[] getRowData(int rowIndex) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        Object[] dataRow = data.get(rowIndex);
        return Arrays.copyOf(dataRow, dataRow.length);
    }

    public void setData(List<Object[]> data) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        this.data.clear();
        for (Object[] dataRow : data) {
            this.data.add(Arrays.copyOf(dataRow, dataRow.length));

    }

    public List<Object[]> getData() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        ArrayList<Object[]> result = new ArrayList<Object[]>();
        for (Object[] dataRow : this.data) {
            result.add(Arrays.copyOf(dataRow, dataRow.length));

    }

    public void addRow(Object[] dataRow) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        int addedRowIndex = this.data.size();
        this.data.add(Arrays.copyOf(dataRow, dataRow.length));
        fireTableRowsInserted(addedRowIndex, addedRowIndex);
    }

    public void removeRow(int row) {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        this.data.remove(row);
        fireTableRowsDeleted(row, row);
    }

    public void clear() {
        assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
        this.data.clear();
        fireTableDataChanged();
    }





package org.netbeans.modules.db.dataview.output;

import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.netbeans.modules.db.dataview.util.DbUtil;
import org.netbeans.modules.db.dataview.util.TestCaseContext;
import org.openide.util.Exceptions;
import org.openide.util.Mutex;

/**
 *


    @Override
    public boolean runInEQ () {
        return false;
    }

    @Override

        String sqlStr =context.getSqlSelect();
        int pageSize = 4;
        DataView instance = DataView.create(dbconn, sqlStr, pageSize);
        final DataViewPageContext result = instance.getPageContext(0);
        assertEquals(1, result.getTotalRows());
        assertTrue(Mutex.EVENT.writeAccess(new Mutex.Action<Boolean>() {
            @Override
            public Boolean run() {
                return result.hasRows();
            }
        }));
    }

    public void testGetDatabaseConnection() {

Lines 53-58 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/InsertRecordTableUITest.java (-18 / +26 lines)
53	import org.netbeans.modules.db.dataview.util.DBTestUtil;	53	import org.netbeans.modules.db.dataview.util.DBTestUtil;
54	import org.netbeans.modules.db.dataview.util.DbUtil;	54	import org.netbeans.modules.db.dataview.util.DbUtil;
55	import org.netbeans.modules.db.dataview.util.TestCaseContext;	55	import org.netbeans.modules.db.dataview.util.TestCaseContext;
		56	import org.openide.util.Mutex;
56		57
57	/**	58	/**
58	* Test for InsertRecordTableUI	59	* Test for InsertRecordTableUI
Lines 69-75 Link Here
69		70
70	@Override	71	@Override
71	public boolean runInEQ() {	72	public boolean runInEQ() {
72	return true;	73	return false;
73	}	74	}
74		75
75	@Override	76	@Override
Lines 94-119 Link Here
94	//--------------------- Test Case ---------------------	95	//--------------------- Test Case ---------------------
95	public void testCreate() {	96	public void testCreate() {
96	String sqlString = context.getSqlSelect();	97	String sqlString = context.getSqlSelect();
97	DataView dv = DataView.create(dbconn, sqlString, 5);	98	final DataView dv = DataView.create(dbconn, sqlString, 5);
98	dv.createComponents();
99		99
100	DataViewPageContext pageContext = dv.getPageContext(0);	100	Mutex.EVENT.writeAccess(new Mutex.Action<Object>() {
101	DBTable table = pageContext.getTableMetaData().getTable(0);	101	@Override
		102	public Void run() {
		103	dv.createComponents();
102		104
103	InsertRecordDialog ird = new InsertRecordDialog(dv, pageContext, table);	105	DataViewPageContext pageContext = dv.getPageContext(0);
		106	DBTable table = pageContext.getTableMetaData().getTable(0);
104		107
105	ResultSetTableModel model = ird.insertRecordTableUI.getModel();	108	InsertRecordDialog ird = new InsertRecordDialog(dv, pageContext, table);
106	ird.insertRecordTableUI.appendEmptyRow();
107	ird.insertRecordTableUI.appendEmptyRow();
108		109
109	// Column 5 is the date column => Insert a "real" Date	110	ResultSetTableModel model = ird.insertRecordTableUI.getModel();
110	// => creates conflict with String inserted by "createNewRow"	111	ird.insertRecordTableUI.appendEmptyRow();
111	ird.insertRecordTableUI.setValueAt(	112	ird.insertRecordTableUI.appendEmptyRow();
112	new Date(new java.util.Date().getTime()), 1, 5);	113
113	try {	114	// Column 5 is the date column => Insert a "real" Date
114	ird.insertRecordTableUI.setSortOrder(5, SortOrder.ASCENDING);	115	// => creates conflict with String inserted by "createNewRow"
115	} catch (ClassCastException ex) {	116	ird.insertRecordTableUI.setValueAt(
116	assert false : "Bug 219011 - should not be reached!";	117	new Date(new java.util.Date().getTime()), 1, 5);
117	}	118	try {
		119	ird.insertRecordTableUI.setSortOrder(5, SortOrder.ASCENDING);
		120	} catch (ClassCastException ex) {
		121	assert false : "Bug 219011 - should not be reached!";
		122	}
		123	return null;
		124	}
		125	});
118	}	126	}
119	}	127	}

Lines 69-75 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/SQLExecutionHelperTest.java (-1 / +6 lines)
69	org.netbeans.junit.NbTestSuite suite = new org.netbeans.junit.NbTestSuite(SQLExecutionHelperTest.class);	69	org.netbeans.junit.NbTestSuite suite = new org.netbeans.junit.NbTestSuite(SQLExecutionHelperTest.class);
70	return suite;	70	return suite;
71	}	71	}
72		72
73	@Override	73	@Override
74	protected void setUp() throws Exception {	74	protected void setUp() throws Exception {
75	super.setUp();	75	super.setUp();
Lines 89-94 Link Here
89	dbconn = null;	89	dbconn = null;
90	}	90	}
91		91
		92	@Override
		93	protected boolean runInEQ() {
		94	return false;
		95	}
		96
92	//------------Test Case ----------------	97	//------------Test Case ----------------
93		98
94	public void testInitialDataLoad() throws Exception {	99	public void testInitialDataLoad() throws Exception {

Lines 68-74 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/SQLStatementGeneratorTest.java (-1 / +6 lines)
68	* @author jawed	68	* @author jawed
69	*/	69	*/
70	public class SQLStatementGeneratorTest extends NbTestCase {	70	public class SQLStatementGeneratorTest extends NbTestCase {
71		71
72	TestCaseContext context;	72	TestCaseContext context;
73	DatabaseConnection dbconn;	73	DatabaseConnection dbconn;
74	Connection conn;	74	Connection conn;
Lines 98-103 Link Here
98	DbUtil.dropTable();	98	DbUtil.dropTable();
99	}	99	}
100		100
		101	@Override
		102	protected boolean runInEQ() {
		103	return true;
		104	}
		105
101	public void testGenerateWhereConditionWithPK() throws SQLException {	106	public void testGenerateWhereConditionWithPK() throws SQLException {
102	DBMetaDataFactory dbMeta = new DBMetaDataFactory(conn);	107	DBMetaDataFactory dbMeta = new DBMetaDataFactory(conn);
103	Statement s = conn.createStatement();	108	Statement s = conn.createStatement();

Return to bug 227588

Lines 218-227 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataView.java (-16 / +39 lines)
218	return dataViewUI.get(0).getEditButtons();	218	return dataViewUI.get(0).getEditButtons();
219	}	219	}
220		220
221	public synchronized void setEditable(boolean editable) {	221	public synchronized void setEditable(final boolean editable) {
222	for (DataViewPageContext pageContext : dataPage) {	222	Mutex.EVENT.writeAccess(new Mutex.Action<Object>() {
223	pageContext.getModel().setEditable(editable);	223	@Override
224	}	224	public Void run() {
		225	for (DataViewPageContext pageContext : dataPage) {
		226	pageContext.getModel().setEditable(editable);
		227	}
		228	return null;
		229	}
		230	});
		231
225	}	232	}
226		233
227	// Used by org.netbeans.modules.db.dataview.api.DataViewPageContext#getPageSize	234	// Used by org.netbeans.modules.db.dataview.api.DataViewPageContext#getPageSize
Lines 242-252 Link Here
242	return this.dataPage.get(i);	249	return this.dataPage.get(i);
243	}	250	}
244		251
245	DataViewPageContext addPageContext(DataViewDBTable table) {	252	DataViewPageContext addPageContext(final DataViewDBTable table) {
246	DataViewPageContext pageContext = new DataViewPageContext(initialPageSize);	253	final DataViewPageContext pageContext = new DataViewPageContext(initialPageSize);
247	this.dataPage.add(pageContext);	254	this.dataPage.add(pageContext);
248	pageContext.setTableMetaData(table);	255	Mutex.EVENT.writeAccess(new Mutex.Action<Object>() {
249	pageContext.getModel().setColumns(table.getColumns().toArray(new DBColumn[0]));	256	@Override
		257	public Void run() {
		258	pageContext.setTableMetaData(table);
		259	pageContext.getModel().setColumns(table.getColumns().toArray(new DBColumn[0]));
		260	return null;
		261	}
		262	});
250	return pageContext;	263	return pageContext;
251	}	264	}
252		265
Lines 273-292 Link Here
273	}	286	}
274		287
275	public void resetEditable() {	288	public void resetEditable() {
276	for(DataViewPageContext pageContext: dataPage) {	289	Mutex.EVENT.readAccess(new Runnable() {
277	pageContext.resetEditableState();	290	@Override
278	}	291	public void run() {
		292	for (DataViewPageContext pageContext : dataPage) {
		293	pageContext.resetEditableState();
		294	}
		295	}
		296	});
279	}	297	}
280		298
281	public boolean isEditable() {	299	public boolean isEditable() {
282	if(dataPage.isEmpty()) {	300	if(dataPage.isEmpty()) {
283	return false;	301	return false;
284	} else {	302	} else {
285	boolean editable = true;	303	return Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {
286	for(DataViewPageContext pageContext: dataPage) {	304	@Override
287	editable &= pageContext.getModel().isEditable();	305	public Boolean run() {
288	}	306	boolean editable = true;
289	return editable;	307	for (DataViewPageContext pageContext : dataPage) {
		308	editable &= pageContext.getModel().isEditable();
		309	}
		310	return editable;
		311	}
		312	});
290	}	313	}
291	}	314	}
292		315

Lines 112-146 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewActionHandler.java (-6 / +6 lines)
112	.setStoredPageSize(pageSize);	112	.setStoredPageSize(pageSize);
113	dataPage.first();	113	dataPage.first();
114	dataPage.setTotalRows(-1); // force total row refresh	114	dataPage.setTotalRows(-1); // force total row refresh
115	execHelper.executeQuery();	115	execHelper.executeQueryOffEDT();
116	}	116	}
117	}	117	}
118		118
119	void firstActionPerformed() {	119	void firstActionPerformed() {
120	if (rejectModifications()) {	120	if (rejectModifications()) {
121	dataPage.first();	121	dataPage.first();
122	execHelper.executeQuery();	122	execHelper.executeQueryOffEDT();
123	}	123	}
124	}	124	}
125		125
126	void previousActionPerformed() {	126	void previousActionPerformed() {
127	if (rejectModifications()) {	127	if (rejectModifications()) {
128	dataPage.previous();	128	dataPage.previous();
129	execHelper.executeQuery();	129	execHelper.executeQueryOffEDT();
130	}	130	}
131	}	131	}
132		132
133	void nextActionPerformed() {	133	void nextActionPerformed() {
134	if (rejectModifications()) {	134	if (rejectModifications()) {
135	dataPage.next();	135	dataPage.next();
136	execHelper.executeQuery();	136	execHelper.executeQueryOffEDT();
137	}	137	}
138	}	138	}
139		139
140	void lastActionPerformed() {	140	void lastActionPerformed() {
141	if (rejectModifications()) {	141	if (rejectModifications()) {
142	dataPage.last();	142	dataPage.last();
143	execHelper.executeQuery();	143	execHelper.executeQueryOffEDT();
144	}	144	}
145	}	145	}
146		146
Lines 189-195 Link Here
189		189
190	void refreshActionPerformed() {	190	void refreshActionPerformed() {
191	dataPage.setTotalRows(-1); // force total row refresh	191	dataPage.setTotalRows(-1); // force total row refresh
192	execHelper.executeQuery();	192	execHelper.executeQueryOffEDT();
193	}	193	}
194		194
195	private static Object showYesAllDialog(Object msg, String title) {	195	private static Object showYesAllDialog(Object msg, String title) {

Lines 60-65 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/SQLExecutionHelper.java (-71 / +126 lines)
60	import java.util.concurrent.Future;	60	import java.util.concurrent.Future;
61	import java.util.logging.Level;	61	import java.util.logging.Level;
62	import java.util.logging.Logger;	62	import java.util.logging.Logger;
		63	import javax.swing.SwingUtilities;
63	import org.netbeans.modules.db.dataview.meta.DBColumn;	64	import org.netbeans.modules.db.dataview.meta.DBColumn;
64	import org.netbeans.modules.db.dataview.meta.DBConnectionFactory;	65	import org.netbeans.modules.db.dataview.meta.DBConnectionFactory;
65	import org.netbeans.modules.db.dataview.meta.DBException;	66	import org.netbeans.modules.db.dataview.meta.DBException;
Lines 70-75 Link Here
70	import org.openide.DialogDisplayer;	71	import org.openide.DialogDisplayer;
71	import org.openide.NotifyDescriptor;	72	import org.openide.NotifyDescriptor;
72	import org.openide.util.Cancellable;	73	import org.openide.util.Cancellable;
		74	import org.openide.util.Mutex;
73	import org.openide.util.NbBundle;	75	import org.openide.util.NbBundle;
74	import org.openide.util.RequestProcessor;	76	import org.openide.util.RequestProcessor;
75		77
Lines 92-98 Link Here
92	}	94	}
93		95
94	void initialDataLoad() throws SQLException {	96	void initialDataLoad() throws SQLException {
95		97	assert (! SwingUtilities.isEventDispatchThread()) : "Must be called of the EDT!";
		98
96	/**	99	/**
97	* Wrap initializing the SQL result into a runnable. This makes it	100	* Wrap initializing the SQL result into a runnable. This makes it
98	* possible to wait for the result in the main thread and cancel the	101	* possible to wait for the result in the main thread and cancel the
Lines 295-300 Link Here
295	final DBTable table,	298	final DBTable table,
296	final String insertSQL,	299	final String insertSQL,
297	final Object[] insertedRow) {	300	final Object[] insertedRow) {
		301	dataView.setEditable(false);
		302
298	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_insert");	303	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_insert");
299	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {	304	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {
300		305
Lines 337-353 Link Here
337		342
338	@Override	343	@Override
339	protected void executeOnSucess() {	344	protected void executeOnSucess() {
340	if (pageContext.getTotalRows() < 0) {	345	// refresh when required
341	pageContext.setTotalRows(0);	346	Boolean needRequery = Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {
342	pageContext.first();	347	@Override
343	}	348	public Boolean run() {
344	pageContext.incrementRowSize(1);	349	if (pageContext.getTotalRows() < 0) {
		350	pageContext.setTotalRows(0);
		351	pageContext.first();
		352	}
		353	pageContext.incrementRowSize(1);
345		354
346	// refresh when required	355	return pageContext.refreshRequiredOnInsert();
347	if (pageContext.refreshRequiredOnInsert()) {	356	};
		357	});
		358	if(needRequery) {
348	SQLExecutionHelper.this.executeQuery();	359	SQLExecutionHelper.this.executeQuery();
349	} else {	360	} else {
350	reinstateToolbar();	361	Mutex.EVENT.readAccess(new Runnable() {
		362	@Override
		363	public void run() {
		364	reinstateToolbar();
		365	}
		366	});
351	}	367	}
352	}	368	}
353	};	369	};
Lines 358-393 Link Here
358	}	374	}
359		375
360	void executeDeleteRow(final DataViewPageContext pageContext, final DBTable table, final DataViewTableUI rsTable) {	376	void executeDeleteRow(final DataViewPageContext pageContext, final DBTable table, final DataViewTableUI rsTable) {
		377	dataView.setEditable(false);
		378
		379	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
361	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_delete");	380	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_delete");
362	final int[] rows = rsTable.getSelectedRows();	381
363	for(int i = 0; i < rows.length; i++) {	382	class DeleteElement {
364	rows[i] = rsTable.convertRowIndexToModel(rows[i]);	383	public List<Object> values = new ArrayList<Object>();
		384	public List<Integer> types = new ArrayList<Integer>();
		385	public String sql;
365	}	386	}
366	Arrays.sort(rows);	387
		388	final List<DeleteElement> rows = new ArrayList<DeleteElement>();
		389	for(int viewRow: rsTable.getSelectedRows()) {
		390	int modelRow = rsTable.convertRowIndexToModel(viewRow);
		391	DeleteElement de = new DeleteElement();
		392	de.sql = generator.generateDeleteStatement(table, de.types, de.values, modelRow, rsTable.getModel());
		393	rows.add(de);
		394	}
		395
367	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {	396	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {
368
369	@Override	397	@Override
370	public void execute() throws SQLException, DBException {	398	public void execute() throws SQLException, DBException {
371	dataView.setEditable(false);	399	dataView.setEditable(false);
372	for (int j = (rows.length - 1); j >= 0 && !error; j--) {	400	for (DeleteElement de: rows) {
373	if (Thread.currentThread().isInterrupted()) {	401	if (Thread.currentThread().isInterrupted() \|\| error) {
374	break;	402	break;
375	}	403	}
376	deleteARow(rows[j], rsTable.getModel());	404	deleteARow(de);
377	}	405	}
378	}	406	}
379		407
380	private void deleteARow(int rowNum, DataViewTableUIModel tblModel) throws SQLException, DBException {	408	private void deleteARow(DeleteElement deleteRow) throws SQLException, DBException {
381	final List<Object> values = new ArrayList<Object>();	409	PreparedStatement pstmt = conn.prepareStatement(deleteRow.sql);
382	final List<Integer> types = new ArrayList<Integer>();
383
384	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
385	final String deleteStmt = generator.generateDeleteStatement(table, types, values, rowNum, tblModel);
386	PreparedStatement pstmt = conn.prepareStatement(deleteStmt);
387	try {	410	try {
388	int pos = 1;	411	int pos = 1;
389	for (Object val : values) {	412	for (Object val : deleteRow.values) {
390	DBReadWriteHelper.setAttributeValue(pstmt, pos, types.get(pos - 1), val);	413	DBReadWriteHelper.setAttributeValue(pstmt, pos, deleteRow.types.get(pos - 1), val);
391	pos++;	414	pos++;
392	}	415	}
393		416
Lines 413-419 Link Here
413		436
414	@Override	437	@Override
415	protected void executeOnSucess() {	438	protected void executeOnSucess() {
416	pageContext.decrementRowSize(rows.length);	439	pageContext.decrementRowSize(rows.size());
417	SQLExecutionHelper.this.executeQuery();	440	SQLExecutionHelper.this.executeQuery();
418	}	441	}
419	};	442	};
Lines 424-431 Link Here
424	}	447	}
425		448
426	void executeUpdateRow(final DBTable table, final DataViewTableUI rsTable, final boolean selectedOnly) {	449	void executeUpdateRow(final DBTable table, final DataViewTableUI rsTable, final boolean selectedOnly) {
		450	dataView.setEditable(false);
		451
		452	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
427	final DataViewTableUIModel dataViewTableUIModel = rsTable.getModel();	453	final DataViewTableUIModel dataViewTableUIModel = rsTable.getModel();
428	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_update");	454	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_update");
		455
		456	class UpdateElement {
		457	public List<Object> values = new ArrayList<Object>();
		458	public List<Integer> types = new ArrayList<Integer>();
		459	public String sql;
		460	public Integer key;
		461	}
		462
		463	final List<UpdateElement> updateSet = new ArrayList<UpdateElement>();
		464
		465	int[] viewRows = rsTable.getSelectedRows();
		466	List<Integer> modelRows = new ArrayList<Integer>();
		467	for(Integer viewRow: viewRows) {
		468	modelRows.add(rsTable.convertRowIndexToModel(viewRow));
		469	}
		470
		471	for (Integer key : dataViewTableUIModel.getUpdateKeys()) {
		472	if (modelRows.contains(key) \|\| (!selectedOnly)) {
		473	UpdateElement ue = new UpdateElement();
		474	try {
		475	ue.key = key;
		476	ue.sql = generator.generateUpdateStatement(table, key,
		477	dataViewTableUIModel.getChangedData(key), ue.values, ue.types,
		478	rsTable.getModel());
		479	updateSet.add(ue);
		480	} catch (DBException ex) {
		481	// The model protects against illegal values, so rethrow
		482	throw new RuntimeException(ex);
		483	}
		484	}
		485	}
		486
		487
429	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {	488	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "") {
430		489
431	private PreparedStatement pstmt;	490	private PreparedStatement pstmt;
Lines 433-479 Link Here
433		492
434	@Override	493	@Override
435	public void execute() throws SQLException, DBException {	494	public void execute() throws SQLException, DBException {
436	dataView.setEditable(false);	495	for (UpdateElement ue : updateSet) {
437	if (selectedOnly) {	496	if(Thread.interrupted()) {
438	updateSelected();	497	break;
439	} else {
440	for (Integer key : dataViewTableUIModel.getUpdateKeys()) {
441	if (Thread.currentThread().isInterrupted()) {
442	break;
443	} else {
444	updateARow(key);
445	keysToRemove.add(key);
446	}
447	}	498	}
		499	updateARow(ue);
		500	keysToRemove.add(ue.key);
448	}	501	}
449	}	502	}
450		503
451	private void updateSelected() throws SQLException, DBException {	504	private void updateARow(UpdateElement ue) throws SQLException, DBException {
452	int[] rows = rsTable.getSelectedRows();	505	pstmt = conn.prepareStatement(ue.sql);
453	for (int j = 0; j < rows.length && !error; j++) {
454	Set<Integer> keys = dataViewTableUIModel.getUpdateKeys();
455	for (Integer key : keys) {
456	if (Thread.currentThread().isInterrupted()) {
457	break;
458	} else if (key == rows[j]) {
459	updateARow(key);
460	keysToRemove.add(key);
461	}
462	}
463	}
464	}
465
466	private void updateARow(Integer key) throws SQLException, DBException {
467	SQLStatementGenerator generator = dataView.getSQLStatementGenerator();
468
469	List<Object> values = new ArrayList<Object>();
470	List<Integer> types = new ArrayList<Integer>();
471	String updateStmt = generator.generateUpdateStatement(table, key, dataViewTableUIModel.getChangedData(key), values, types, rsTable.getModel());
472
473	pstmt = conn.prepareStatement(updateStmt);
474	int pos = 1;	506	int pos = 1;
475	for (Object val : values) {	507	for (Object val : ue.values) {
476	DBReadWriteHelper.setAttributeValue(pstmt, pos, types.get(pos - 1), val);	508	DBReadWriteHelper.setAttributeValue(pstmt, pos, ue.types.get(pos - 1), val);
477	pos++;	509	pos++;
478	}	510	}
479		511
Lines 500-510 Link Here
500		532
501	@Override	533	@Override
502	protected void executeOnSucess() {	534	protected void executeOnSucess() {
503	DataViewTableUIModel tblContext = rsTable.getModel();	535	Mutex.EVENT.writeAccess(new Runnable() {
504	for (Integer key : keysToRemove) {	536	@Override
505	tblContext.removeUpdateForSelectedRow(key, false);	537	public void run() {
506	}	538	DataViewTableUIModel tblContext = rsTable.getModel();
507	reinstateToolbar();	539	for (Integer key : keysToRemove) {
		540	tblContext.removeUpdateForSelectedRow(key, false);
		541	}
		542
		543	reinstateToolbar();
		544	}
		545	});
508	}	546	}
509	};	547	};
510	RequestProcessor.Task task = rp.create(executor);	548	RequestProcessor.Task task = rp.create(executor);
Lines 555-562 Link Here
555	task.schedule(0);	593	task.schedule(0);
556	}	594	}
557		595
		596	void executeQueryOffEDT() {
		597	rp.post(new Runnable() {
		598	@Override
		599	public void run() {
		600	executeQuery();
		601	}
		602	});
		603	}
		604
558	// Once Data View is created the it assumes the query never changes.	605	// Once Data View is created the it assumes the query never changes.
559	void executeQuery() {	606	void executeQuery() {
		607	assert (! SwingUtilities.isEventDispatchThread());
		608
560	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_executequery");	609	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_executequery");
561	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, dataView.getSQLString()) {	610	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, dataView.getSQLString()) {
562		611
Lines 662-668 Link Here
662	task.schedule(0);	711	task.schedule(0);
663	}	712	}
664		713
665	void loadDataFrom(DataViewPageContext pageContext, ResultSet rs, boolean getTotal) throws SQLException {	714	private void loadDataFrom(final DataViewPageContext pageContext, ResultSet rs, boolean getTotal) throws SQLException {
666	if (rs == null) {	715	if (rs == null) {
667	return;	716	return;
668	}	717	}
Lines 670-676 Link Here
670	int pageSize = pageContext.getPageSize();	719	int pageSize = pageContext.getPageSize();
671	int startFrom = pageContext.getCurrentPos();	720	int startFrom = pageContext.getCurrentPos();
672		721
673	List<Object[]> rows = new ArrayList<Object[]>();	722	final List<Object[]> rows = new ArrayList<Object[]>();
674	int colCnt = pageContext.getTableMetaData().getColumnCount();	723	int colCnt = pageContext.getTableMetaData().getColumnCount();
675	try {	724	try {
676	boolean hasNext = false;	725	boolean hasNext = false;
Lines 742-748 Link Here
742	LOGGER.log(Level.SEVERE, "Failed to set up table model.", e); // NOI18N	791	LOGGER.log(Level.SEVERE, "Failed to set up table model.", e); // NOI18N
743	throw e;	792	throw e;
744	} finally {	793	} finally {
745	pageContext.getModel().setData(rows);	794	Mutex.EVENT.writeAccess(new Mutex.Action<Void>() {
		795	@Override
		796	public Void run() {
		797	pageContext.getModel().setData(rows);
		798	return null;
		799	}
		800	});
746	}	801	}
747	}	802	}
748		803

Lines 55-60 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/table/ResultSetTableModel.java (-1 / +21 lines)
55	import java.util.ArrayList;	55	import java.util.ArrayList;
56	import java.util.Arrays;	56	import java.util.Arrays;
57	import java.util.List;	57	import java.util.List;
		58	import javax.swing.SwingUtilities;
58	import javax.swing.table.AbstractTableModel;	59	import javax.swing.table.AbstractTableModel;
59	import org.netbeans.modules.db.dataview.meta.DBColumn;	60	import org.netbeans.modules.db.dataview.meta.DBColumn;
60	import org.netbeans.modules.db.dataview.util.DBReadWriteHelper;	61	import org.netbeans.modules.db.dataview.util.DBReadWriteHelper;
Lines 72-78 Link Here
72	private final List<Object[]> data = new ArrayList<Object[]>();	73	private final List<Object[]> data = new ArrayList<Object[]>();
73	private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);	74	private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);
74		75
75	public static Class<? extends Object> getTypeClass(DBColumn col) {	76	protected static Class<? extends Object> getTypeClass(DBColumn col) {
76	int colType = col.getJdbcType();	77	int colType = col.getJdbcType();
77		78
78	if (colType == Types.BIT && col.getPrecision() <= 1) {	79	if (colType == Types.BIT && col.getPrecision() <= 1) {
Lines 135-161 Link Here
135	}	136	}
136		137
137	public void setColumns(DBColumn[] columns) {	138	public void setColumns(DBColumn[] columns) {
		139	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
138	this.data.clear();	140	this.data.clear();
139	this.columns = columns;	141	this.columns = columns;
140	fireTableStructureChanged();	142	fireTableStructureChanged();
141	}	143	}
142		144
143	public DBColumn[] getColumns() {	145	public DBColumn[] getColumns() {
		146	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
144	return Arrays.copyOf(columns, columns.length);	147	return Arrays.copyOf(columns, columns.length);
145	}	148	}
146		149
147	public void setEditable(boolean editable) {	150	public void setEditable(boolean editable) {
		151	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
148	boolean old = this.editable;	152	boolean old = this.editable;
149	this.editable = editable;	153	this.editable = editable;
150	pcs.firePropertyChange("editable", old, editable);	154	pcs.firePropertyChange("editable", old, editable);
151	}	155	}
152		156
153	public boolean isEditable() {	157	public boolean isEditable() {
		158	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
154	return editable;	159	return editable;
155	}	160	}
156		161
157	@Override	162	@Override
158	public boolean isCellEditable(int row, int column) {	163	public boolean isCellEditable(int row, int column) {
		164	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
159	if (!editable) {	165	if (!editable) {
160	return false;	166	return false;
161	}	167	}
Lines 165-170 Link Here
165		171
166	@Override	172	@Override
167	public void setValueAt(Object value, int row, int col) {	173	public void setValueAt(Object value, int row, int col) {
		174	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
168	Object oldVal = getValueAt(row, col);	175	Object oldVal = getValueAt(row, col);
169	if (noUpdateRequired(oldVal, value)) {	176	if (noUpdateRequired(oldVal, value)) {
170	return;	177	return;
Lines 185-190 Link Here
185	@Override	192	@Override
186	@SuppressWarnings("unchecked")	193	@SuppressWarnings("unchecked")
187	public Class<? extends Object> getColumnClass(int columnIndex) {	194	public Class<? extends Object> getColumnClass(int columnIndex) {
		195	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
188	if (columns[columnIndex] == null) {	196	if (columns[columnIndex] == null) {
189	return super.getColumnClass(columnIndex);	197	return super.getColumnClass(columnIndex);
190	} else {	198	} else {
Lines 193-212 Link Here
193	}	201	}
194		202
195	public DBColumn getColumn(int columnIndex) {	203	public DBColumn getColumn(int columnIndex) {
		204	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
196	return columns[columnIndex];	205	return columns[columnIndex];
197	}	206	}
198		207
199	@Override	208	@Override
200	public int getColumnCount() {	209	public int getColumnCount() {
		210	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
201	return columns.length;	211	return columns.length;
202	}	212	}
203		213
204	public String getColumnTooltip(int columnIndex) {	214	public String getColumnTooltip(int columnIndex) {
		215	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
205	return DataViewUtils.getColumnToolTip(columns[columnIndex]);	216	return DataViewUtils.getColumnToolTip(columns[columnIndex]);
206	}	217	}
207		218
208	@Override	219	@Override
209	public String getColumnName(int columnIndex) {	220	public String getColumnName(int columnIndex) {
		221	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
210	String displayName = columns[columnIndex].getDisplayName();	222	String displayName = columns[columnIndex].getDisplayName();
211	return displayName != null ? displayName : "COL_" + columnIndex;	223	return displayName != null ? displayName : "COL_" + columnIndex;
212	}	224	}
Lines 222-242 Link Here
222		234
223	@Override	235	@Override
224	public int getRowCount() {	236	public int getRowCount() {
		237	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
225	return data.size();	238	return data.size();
226	}	239	}
227		240
228	@Override	241	@Override
229	public Object getValueAt(int rowIndex, int columnIndex) {	242	public Object getValueAt(int rowIndex, int columnIndex) {
		243	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
230	Object[] dataRow = data.get(rowIndex);	244	Object[] dataRow = data.get(rowIndex);
231	return dataRow[columnIndex];	245	return dataRow[columnIndex];
232	}	246	}
233		247
234	public Object[] getRowData(int rowIndex) {	248	public Object[] getRowData(int rowIndex) {
		249	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
235	Object[] dataRow = data.get(rowIndex);	250	Object[] dataRow = data.get(rowIndex);
236	return Arrays.copyOf(dataRow, dataRow.length);	251	return Arrays.copyOf(dataRow, dataRow.length);
237	}	252	}
238		253
239	public void setData(List<Object[]> data) {	254	public void setData(List<Object[]> data) {
		255	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
240	this.data.clear();	256	this.data.clear();
241	for (Object[] dataRow : data) {	257	for (Object[] dataRow : data) {
242	this.data.add(Arrays.copyOf(dataRow, dataRow.length));	258	this.data.add(Arrays.copyOf(dataRow, dataRow.length));
Lines 245-250 Link Here
245	}	261	}
246		262
247	public List<Object[]> getData() {	263	public List<Object[]> getData() {
		264	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
248	ArrayList<Object[]> result = new ArrayList<Object[]>();	265	ArrayList<Object[]> result = new ArrayList<Object[]>();
249	for (Object[] dataRow : this.data) {	266	for (Object[] dataRow : this.data) {
250	result.add(Arrays.copyOf(dataRow, dataRow.length));	267	result.add(Arrays.copyOf(dataRow, dataRow.length));
Lines 253-269 Link Here
253	}	270	}
254		271
255	public void addRow(Object[] dataRow) {	272	public void addRow(Object[] dataRow) {
		273	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
256	int addedRowIndex = this.data.size();	274	int addedRowIndex = this.data.size();
257	this.data.add(Arrays.copyOf(dataRow, dataRow.length));	275	this.data.add(Arrays.copyOf(dataRow, dataRow.length));
258	fireTableRowsInserted(addedRowIndex, addedRowIndex);	276	fireTableRowsInserted(addedRowIndex, addedRowIndex);
259	}	277	}
260		278
261	public void removeRow(int row) {	279	public void removeRow(int row) {
		280	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
262	this.data.remove(row);	281	this.data.remove(row);
263	fireTableRowsDeleted(row, row);	282	fireTableRowsDeleted(row, row);
264	}	283	}
265		284
266	public void clear() {	285	public void clear() {
		286	assert SwingUtilities.isEventDispatchThread() : "Not on EDT";
267	this.data.clear();	287	this.data.clear();
268	fireTableDataChanged();	288	fireTableDataChanged();
269	}	289	}

Lines 42-47 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/DataViewTest.java (-3 / +10 lines)
42		42
43	package org.netbeans.modules.db.dataview.output;	43	package org.netbeans.modules.db.dataview.output;
44		44
		45	import java.lang.reflect.InvocationTargetException;
45	import java.sql.Connection;	46	import java.sql.Connection;
46	import java.sql.ResultSet;	47	import java.sql.ResultSet;
47	import java.sql.SQLException;	48	import java.sql.SQLException;
Lines 56-61 Link Here
56	import org.netbeans.modules.db.dataview.util.DbUtil;	57	import org.netbeans.modules.db.dataview.util.DbUtil;
57	import org.netbeans.modules.db.dataview.util.TestCaseContext;	58	import org.netbeans.modules.db.dataview.util.TestCaseContext;
58	import org.openide.util.Exceptions;	59	import org.openide.util.Exceptions;
		60	import org.openide.util.Mutex;
59		61
60	/**	62	/**
61	*	63	*
Lines 78-84 Link Here
78		80
79	@Override	81	@Override
80	public boolean runInEQ () {	82	public boolean runInEQ () {
81	return true;	83	return false;
82	}	84	}
83		85
84	@Override	86	@Override
Lines 171-179 Link Here
171	String sqlStr =context.getSqlSelect();	173	String sqlStr =context.getSqlSelect();
172	int pageSize = 4;	174	int pageSize = 4;
173	DataView instance = DataView.create(dbconn, sqlStr, pageSize);	175	DataView instance = DataView.create(dbconn, sqlStr, pageSize);
174	DataViewPageContext result = instance.getPageContext(0);	176	final DataViewPageContext result = instance.getPageContext(0);
175	assertEquals(1, result.getTotalRows());	177	assertEquals(1, result.getTotalRows());
176	assertTrue(result.hasDataRows());	178	assertTrue(Mutex.EVENT.writeAccess(new Mutex.Action<Boolean>() {
		179	@Override
		180	public Boolean run() {
		181	return result.hasRows();
		182	}
		183	}));
177	}	184	}
178		185
179	public void testGetDatabaseConnection() {	186	public void testGetDatabaseConnection() {