Attachment #150737 for bug #247699

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 247699
Collapse All | Expand All




            return;
        }

        // Get out of AWT thread
        // and we need to wait here to show possible exceptions.
        new SwingWorker<Integer, Void>() {

            @Override
            protected Integer doInBackground() throws Exception {
                SQLStatementGenerator stmtBldr = dataView.getSQLStatementGenerator();
                SQLExecutionHelper execHelper = dataView.getSQLExecutionHelper();
                String inserts[] = new String[rows];
                
                for (int i = 0; i < rows; i++) {
                    inserts[i] = stmtBldr.generateInsertStatement(insertTable, insertedRows[i]);
                    try {
                        Object[] insertedRow = insertedRows[i];
                        String insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);
                        RequestProcessor.Task task = execHelper.executeInsertRow(pageContext, insertTable, insertSQL, insertedRow);
                        task.waitFinished();
                        wasException = dataView.hasExceptions();
                    } catch (DBException ex) {
                        LOG.log(Level.INFO, ex.getLocalizedMessage(), ex);
                        DialogDisplayer.getDefault().notifyLater(new NotifyDescriptor.Message(ex.getLocalizedMessage()));
                        wasException = true;
                    }
                
                return execHelper.executeInsertRow(pageContext, insertTable, inserts, insertedRows);
                    }
                }
                return null;
            }

            @Override
            protected void done() {
                Integer doneCount;
                try {
                    doneCount = get();

                    if (doneCount == rows) {
                        dispose();
                    } else {
                        // remove i already inserted
                        for (int j = 0; j < doneCount; j++) {
                            insertRecordTableUI.getModel().removeRow(0);
                        }
                    }
                } catch (InterruptedException | ExecutionException ex) {
                    throw new RuntimeException(ex);
                } catch (ExecutionException ex) {
                    throw new RuntimeException(ex);
                }
            }
        }.execute();




        }
    }

    int executeInsertRow(final DataViewPageContext pageContext,
            final DBTable table,
            final String[] insertSQLs,
            final Object[][] insertedRows) {
        dataView.setEditable(false);

        assert (! SwingUtilities.isEventDispatchThread());
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "", true) {

            @Override
            public void execute() throws SQLException, DBException {
                dataView.setEditable(false);

        int done = 0;
        Exception caughtException = null;

                try {
            List<DBColumn> columns = table.getColumnList();

            for (int j = 0; j < insertSQLs.length; j++) {
                try (PreparedStatement pstmt = dataView.getDatabaseConnection().getJDBCConnection().prepareStatement(insertSQLs[j])) {
                    int pos = 1;
                    for (int i = 0; i < insertedRows[j].length; i++) {
                        Object val = insertedRows[j][i];

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

                        DBReadWriteHelper.setAttributeValue(pstmt, pos++, colType, val);
                    }

                    int rows = pstmt.executeUpdate();

                    if (rows != 1) {
                        throw new SQLException("MSG_failure_insert_rows");
                        errorMsg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_failure_insert_rows");
                    }
                    done++;
                    DataViewUtils.closeResources(pstmt);
                }
            }
        } catch (DBException | SQLException ex) {
            LOGGER.log(Level.INFO, ex.getLocalizedMessage(), ex);
            caughtException = ex;
        } finally {
                dataView.resetEditable();
                commitOrRollback(NbBundle.getMessage(SQLExecutionHelper.class, "LBL_insert_command"));
            }

        final int finalDone = done;
        final Exception finalCaught = caughtException;
        
                // refresh when required
                Boolean needRequery = Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {
                    @Override
                    public Boolean run() {
                if (finalCaught != null) {
                    DialogDisplayer.getDefault().notifyLater(
                            new NotifyDescriptor.Message(
                                    finalCaught.getLocalizedMessage()));
                }
                        if (pageContext.getTotalRows() < 0) {
                            pageContext.setTotalRows(0);
                            pageContext.first();
                        }
                pageContext.incrementRowSize(finalDone);
                        return pageContext.refreshRequiredOnInsert();
            }
        ;
                });
        if (needRequery) {
                    SQLExecutionHelper.this.executeQuery();
                } else {
                    Mutex.EVENT.readAccess(new Runnable() {
                        @Override
                        public void run() {
                    synchronized (dataView) {
                        dataView.resetToolbar(false);
                        }
                }
                    });
                }

        return done;
            }
        };
        RequestProcessor.Task task = rp.create(executor);
        executor.setTask(task);
        task.schedule(0);
        return task;
    }

    void executeDeleteRow(final DataViewPageContext pageContext, final DBTable table, final DataViewTableUI rsTable) {
        dataView.setEditable(false);

Return to bug 247699

Lines 393-444 Link Here

(-)db.dataview/src/org/netbeans/modules/db/dataview/output/InsertRecordDialog.java (-25 / +11 lines)
393	return;	393	return;
394	}	394	}
395		395
396	// Get out of AWT thread because SQLExecutionHelper does calls to AWT	396	// Get out of AWT thread
397	// and we need to wait here to show possible exceptions.
398	new SwingWorker<Integer, Void>() {	397	new SwingWorker<Integer, Void>() {
399		398
400	@Override	399	@Override
401	protected Integer doInBackground() throws Exception {	400	protected Integer doInBackground() throws Exception {
402	SQLStatementGenerator stmtBldr = dataView.getSQLStatementGenerator();	401	SQLStatementGenerator stmtBldr = dataView.getSQLStatementGenerator();
403	SQLExecutionHelper execHelper = dataView.getSQLExecutionHelper();	402	SQLExecutionHelper execHelper = dataView.getSQLExecutionHelper();
		403	String inserts[] = new String[rows];
		404
404	for (int i = 0; i < rows; i++) {	405	for (int i = 0; i < rows; i++) {
405	boolean wasException;	406	inserts[i] = stmtBldr.generateInsertStatement(insertTable, insertedRows[i]);
406	try {
407	Object[] insertedRow = insertedRows[i];
408	String insertSQL = stmtBldr.generateInsertStatement(insertTable, insertedRow);
409	RequestProcessor.Task task = execHelper.executeInsertRow(pageContext, insertTable, insertSQL, insertedRow);
410	task.waitFinished();
411	wasException = dataView.hasExceptions();
412	} catch (DBException ex) {
413	LOG.log(Level.INFO, ex.getLocalizedMessage(), ex);
414	DialogDisplayer.getDefault().notifyLater(new NotifyDescriptor.Message(ex.getLocalizedMessage()));
415	wasException = true;
416	}	407	}
417	if (wasException) {	408
418	return i;	409	return execHelper.executeInsertRow(pageContext, insertTable, inserts, insertedRows);
419	}	410	}
420	}
421	return null;
422	}
423		411
424	@Override	412	@Override
425	protected void done() {	413	protected void done() {
426	Integer brokeOn;	414	Integer doneCount;
427	try {	415	try {
428	brokeOn = get();	416	doneCount = get();
429		417
430	if (brokeOn == null) {	418	if (doneCount == rows) {
431	dispose();	419	dispose();
432	} else {	420	} else {
433	// remove i already inserted	421	// remove i already inserted
434	for (int j = 0; j < brokeOn; j++) {	422	for (int j = 0; j < doneCount; j++) {
435	insertRecordTableUI.getModel().removeRow(0);	423	insertRecordTableUI.getModel().removeRow(0);
436	}	424	}
437	}	425	}
438	} catch (InterruptedException ex) {	426	} catch (InterruptedException \| ExecutionException ex) {
439	throw new RuntimeException(ex);	427	throw new RuntimeException(ex);
440	} catch (ExecutionException ex) {
441	throw new RuntimeException(ex);
442	}	428	}
443	}	429	}
444	}.execute();	430	}.execute();

Lines 295-318 Link Here

(-)db.dataview/src/org/netbeans/modules/db/dataview/output/SQLExecutionHelper.java (-34 / +39 lines)
295	}	295	}
296	}	296	}
297		297
298	RequestProcessor.Task executeInsertRow(final DataViewPageContext pageContext,	298	int executeInsertRow(final DataViewPageContext pageContext,
299	final DBTable table,	299	final DBTable table,
300	final String insertSQL,	300	final String[] insertSQLs,
301	final Object[] insertedRow) {	301	final Object[][] insertedRows) {
302	dataView.setEditable(false);
303		302
304	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_insert");	303	assert (! SwingUtilities.isEventDispatchThread());
305	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, "", true) {
306		304
307	@Override
308	public void execute() throws SQLException, DBException {
309	dataView.setEditable(false);	305	dataView.setEditable(false);
310	List<DBColumn> columns = table.getColumnList();	306
311	PreparedStatement pstmt = conn.prepareStatement(insertSQL);	307	int done = 0;
		308	Exception caughtException = null;
		309
312	try {	310	try {
		311	List<DBColumn> columns = table.getColumnList();
		312
		313	for (int j = 0; j < insertSQLs.length; j++) {
		314	try (PreparedStatement pstmt = dataView.getDatabaseConnection().getJDBCConnection().prepareStatement(insertSQLs[j])) {
313	int pos = 1;	315	int pos = 1;
314	for (int i = 0; i < insertedRow.length; i++) {	316	for (int i = 0; i < insertedRows[j].length; i++) {
315	Object val = insertedRow[i];	317	Object val = insertedRows[j][i];
316		318
317	// Check for Constant e.g <NULL>, <DEFAULT>, <CURRENT_TIMESTAMP> etc	319	// Check for Constant e.g <NULL>, <DEFAULT>, <CURRENT_TIMESTAMP> etc
318	if (DataViewUtils.isSQLConstantString(val, columns.get(i))) {	320	if (DataViewUtils.isSQLConstantString(val, columns.get(i))) {
Lines 324-377 Link Here
324	DBReadWriteHelper.setAttributeValue(pstmt, pos++, colType, val);	326	DBReadWriteHelper.setAttributeValue(pstmt, pos++, colType, val);
325	}	327	}
326		328
327	executePreparedStatement(pstmt);	329	int rows = pstmt.executeUpdate();
328	int rows = dataView.getUpdateCount();	330
329	if (rows != 1) {	331	if (rows != 1) {
330	error = true;	332	throw new SQLException("MSG_failure_insert_rows");
331	errorMsg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_failure_insert_rows");
332	}	333	}
333	} finally {	334	done++;
334	DataViewUtils.closeResources(pstmt);
335	}	335	}
336	}	336	}
337		337	} catch (DBException \| SQLException ex) {
338	@Override	338	LOGGER.log(Level.INFO, ex.getLocalizedMessage(), ex);
339	public void finished() {	339	caughtException = ex;
		340	} finally {
340	dataView.resetEditable();	341	dataView.resetEditable();
341	commitOrRollback(NbBundle.getMessage(SQLExecutionHelper.class, "LBL_insert_command"));
342	}	342	}
343		343
344	@Override	344	final int finalDone = done;
345	protected void executeOnSucess() {	345	final Exception finalCaught = caughtException;
		346
346	// refresh when required	347	// refresh when required
347	Boolean needRequery = Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {	348	Boolean needRequery = Mutex.EVENT.readAccess(new Mutex.Action<Boolean>() {
348	@Override	349	@Override
349	public Boolean run() {	350	public Boolean run() {
		351	if (finalCaught != null) {
		352	DialogDisplayer.getDefault().notifyLater(
		353	new NotifyDescriptor.Message(
		354	finalCaught.getLocalizedMessage()));
		355	}
350	if (pageContext.getTotalRows() < 0) {	356	if (pageContext.getTotalRows() < 0) {
351	pageContext.setTotalRows(0);	357	pageContext.setTotalRows(0);
352	pageContext.first();	358	pageContext.first();
353	}	359	}
354	pageContext.incrementRowSize(1);	360	pageContext.incrementRowSize(finalDone);
355	return pageContext.refreshRequiredOnInsert();	361	return pageContext.refreshRequiredOnInsert();
356	};	362	}
		363	;
357	});	364	});
358	if(needRequery) {	365	if (needRequery) {
359	SQLExecutionHelper.this.executeQuery();	366	SQLExecutionHelper.this.executeQuery();
360	} else {	367	} else {
361	Mutex.EVENT.readAccess(new Runnable() {	368	Mutex.EVENT.readAccess(new Runnable() {
362	@Override	369	@Override
363	public void run() {	370	public void run() {
364	reinstateToolbar();	371	synchronized (dataView) {
		372	dataView.resetToolbar(false);
365	}	373	}
		374	}
366	});	375	});
367	}	376	}
		377
		378	return done;
368	}	379	}
369	};
370	RequestProcessor.Task task = rp.create(executor);
371	executor.setTask(task);
372	task.schedule(0);
373	return task;
374	}
375		380
376	void executeDeleteRow(final DataViewPageContext pageContext, final DBTable table, final DataViewTableUI rsTable) {	381	void executeDeleteRow(final DataViewPageContext pageContext, final DBTable table, final DataViewTableUI rsTable) {
377	dataView.setEditable(false);	382	dataView.setEditable(false);