Attachment #114287 for bug #206233

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

Lines 102-108 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataView.java (-1 / +1 lines)
102	try {	102	try {
103	dv.dataPage = new DataViewPageContext(pageSize);	103	dv.dataPage = new DataViewPageContext(pageSize);
104	dv.execHelper = new SQLExecutionHelper(dv);	104	dv.execHelper = new SQLExecutionHelper(dv);
105	SQLExecutionHelper.initialDataLoad(dv, dbConn, dv.execHelper);	105	dv.execHelper.initialDataLoad();
106	dv.stmtGenerator = new SQLStatementGenerator(dv);	106	dv.stmtGenerator = new SQLStatementGenerator(dv);
107	} catch (Exception ex) {	107	} catch (Exception ex) {
108	dv.setErrorStatusText(ex);	108	dv.setErrorStatusText(ex);




            Object obj = dataView.getDataViewPageContext().getColumnData(
                    table.convertRowIndexToModel(row),
                    table.convertColumnIndexToModel(column));
            if (value == null) {
                return c;
            }

            if (isSelected) {
                if ((obj == null && value == null) || (obj != null && value != null && value.equals(obj))) {
                    c.setForeground(gray);
                } else {
                    c.setForeground(Color.ORANGE);
                }
            } else {
                if ((obj == null && value == null) || (obj != null && value != null && value.equals(obj))) {
                    c.setForeground(table.getForeground());
                } else {
                    c.setForeground(green);




import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.table.TableModel;
import org.netbeans.api.db.explorer.DatabaseConnection;
import org.netbeans.modules.db.dataview.meta.DBConnectionFactory;
import org.netbeans.modules.db.dataview.meta.DBException;
import org.netbeans.modules.db.dataview.meta.DBMetaDataFactory;

        this.dataView = dataView;
    }

    void initialDataLoad() throws SQLException {
        Statement stmt = null;
        try {
            Connection conn = DBConnectionFactory.getInstance().getConnection(dataView.getDatabaseConnection());
            String msg = "";
            if (conn == null) {
                Throwable ex = DBConnectionFactory.getInstance().getLastException();
                if (ex != null) {
                    msg = ex.getMessage();
                } else {
                    msg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_connection_failure", dataView.getDatabaseConnection());
                }
                NotifyDescriptor nd = new NotifyDescriptor.Message(msg, NotifyDescriptor.ERROR_MESSAGE);
                DialogDisplayer.getDefault().notifyLater(nd);

            }

            DBMetaDataFactory dbMeta = new DBMetaDataFactory(conn);
            dataView.setLimitSupported(dbMeta.supportsLimit());
            String sql = dataView.getSQLString();
            boolean isSelect = isSelectStatement(sql);

            stmt = prepareSQLStatement(conn, sql);
            executeSQLStatement(stmt, sql);

            if (dataView.getUpdateCount() != -1) {
                if (!conn.getAutoCommit()) {
                    conn.commit();
                }
                return;
            }

            ResultSet rs = null;
            if(dataView.hasResultSet()) {
                rs = stmt.getResultSet();
            }

            if (rs == null) {
                if (!conn.getAutoCommit()) {
                    conn.commit();
                }
                return;
                DataViewDBTable dvTable = new DataViewDBTable(tables);
                dv.setDataViewDBTable(dvTable);
                execHelper.loadDataFrom(resultSet);
            } finally {
                DataViewUtils.closeResources(resultSet);
            }
            Collection<DBTable> tables = dbMeta.generateDBTables(rs, sql, isSelect);
            DataViewDBTable dvTable = new DataViewDBTable(tables);
            dataView.setDataViewDBTable(dvTable);
            loadDataFrom(rs);
            DataViewUtils.closeResources(rs);
            getTotalCount(isSelect, sql, stmt);
        } finally {
            DataViewUtils.closeResources(stmt);
        }

        String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_executequery");
        SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, dataView.getSQLString()) {

            private ResultSet rs = null;
            private Statement stmt = null;
            boolean lastEditState = dataView.isEditable();


                try {
                    executeSQLStatement(stmt, sql);
                    if (dataView.hasResultSet()) {
                        ResultSet rs = stmt.getResultSet();
                        loadDataFrom(rs);
                        DataViewUtils.closeResources(rs);
                    } else {
                        return;
                    }

                        dataView.removeComponents();
                    }
                    throw sqlEx;

                } finally {
                    DataViewUtils.closeResources(rs);
                }

                // Get total row count

            try {
                isResultSet = stmt.execute(appendLimitIfRequired(sql));
            } catch (NullPointerException ex) {
                LOGGER.log(Level.SEVERE, "Failed to execute SQL Statement [" + sql + "], cause: " + ex);
                throw new SQLException(ex);
            } catch (SQLException sqlExc) {
                if (sqlExc.getErrorCode() == 1064 && sqlExc.getSQLState().equals("37000")) {
                    isResultSet = stmt.execute(sql);

Lines 184-189 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/SQLStatementGenerator.java (+3 lines)
184	if (value != null && DataViewUtils.isSQLConstantString(value)) {	184	if (value != null && DataViewUtils.isSQLConstantString(value)) {
185	String constStr = ((String) value).substring(1, ((String) value).length() - 1);	185	String constStr = ((String) value).substring(1, ((String) value).length() - 1);
186	updateStmt.append(" = ").append(constStr);	186	updateStmt.append(" = ").append(constStr);
		187	// NULL ist reported as an SQL constant, so treat it as such
		188	} else if ( value == null ) {
		189	updateStmt.append(" = NULL"); // NOI18N
187	} else { // ELSE literals	190	} else { // ELSE literals
188	updateStmt.append(" = ?"); // NOI18N	191	updateStmt.append(" = ?"); // NOI18N
189	values.add(value);	192	values.add(value);




# Portions Copyrighted 2008 Sun Microsystems, Inc.

ResultSetJXTable.columnControl.tooltip=Select/deselect columns

nullLob.title=Set to NULL
saveLob.title=Save to file
loadLob.title=Set from file
loadLob.sourceNotReadable=Source file can't be read.\nCheck file/directory permissions.
saveLob.unknownFormat=Unknown Format for Lob-Handling
saveLob.targetNotWriteable=Target file can't be written.\nCheck file/directory permissions.
saveLob.failure=Failure while saving file: {0}
saveLob.dbError=DB-Failure: {0}

Lines 46-51 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/table/ResultSetCellRenderer.java (+61 lines)
46	import java.awt.Color;	46	import java.awt.Color;
47	import java.awt.Component;	47	import java.awt.Component;
48	import java.awt.Font;	48	import java.awt.Font;
		49	import java.sql.Blob;
		50	import java.sql.Clob;
		51	import java.sql.SQLException;
49	import java.text.SimpleDateFormat;	52	import java.text.SimpleDateFormat;
50	import javax.swing.JComponent;	53	import javax.swing.JComponent;
51	import javax.swing.JLabel;	54	import javax.swing.JLabel;
Lines 90-95 Link Here
90	private final TableCellRenderer NUMNBER_RENDERER = new NumberObjectCellRenderer();	93	private final TableCellRenderer NUMNBER_RENDERER = new NumberObjectCellRenderer();
91	private final TableCellRenderer BOOLEAN_RENDERER = new BooleanCellRenderer();	94	private final TableCellRenderer BOOLEAN_RENDERER = new BooleanCellRenderer();
92	private final TableCellRenderer CELL_FOCUS_RENDERER = new CellFocusCustomRenderer();	95	private final TableCellRenderer CELL_FOCUS_RENDERER = new CellFocusCustomRenderer();
		96	private final TableCellRenderer BLOB_RENDERER = new BlobCellRenderer();
		97	private final TableCellRenderer CLOB_RENDERER = new ClobCellRenderer();
93		98
94	public ResultSetCellRenderer() {	99	public ResultSetCellRenderer() {
95	super(new StringValue() {	100	super(new StringValue() {
Lines 123-128 Link Here
123	return DEFAULT_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);	128	return DEFAULT_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
124	} else if (value instanceof Boolean) {	129	} else if (value instanceof Boolean) {
125	return BOOLEAN_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);	130	return BOOLEAN_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
		131	} else if (value instanceof Blob) {
		132	return BLOB_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
		133	} else if (value instanceof Clob) {
		134	return CLOB_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
126	} else {	135	} else {
127	Component c = CELL_FOCUS_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);	136	Component c = CELL_FOCUS_RENDERER.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
128	//c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);	137	//c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
Lines 202-204 Link Here
202	return c;	211	return c;
203	}	212	}
204	}	213	}
		214
		215	class BlobCellRenderer extends SQLConstantsCellRenderer {
		216	@Override
		217	public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
		218	if (!(value instanceof Blob)) {
		219	throw new IllegalArgumentException("BlobCellRenderer can only be used for Blobs");
		220	}
		221	try {
		222	Long size = 0L;
		223	size = ((Blob) value).length();
		224	StringBuilder stringValue = new StringBuilder();
		225	stringValue.append("<BLOB ");
		226	if(size < 1000) {
		227	stringValue.append(String.format("%1$d bytes", size));
		228	} else if ( size < 1000000) {
		229	stringValue.append(String.format("%1$d kB", size / 1000));
		230	} else {
		231	stringValue.append(String.format("%1$d MB", size / 1000000));
		232	}
		233	stringValue.append(">");
		234	return super.getTableCellRendererComponent(table, stringValue.toString(), isSelected, hasFocus, row, column);
		235	} catch (SQLException ex) {
		236	return super.getTableCellRendererComponent(table, "<BLOB of unkown size>", isSelected, hasFocus, row, column);
		237	}
		238	}
		239	}
		240
		241	class ClobCellRenderer extends SQLConstantsCellRenderer {
		242	@Override
		243	public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
		244	if (!(value instanceof Clob)) {
		245	throw new IllegalArgumentException("ClobCellRenderer can only be used for Blobs");
		246	}
		247	try {
		248	Long size = 0L;
		249	size = ((Clob) value).length();
		250	StringBuilder stringValue = new StringBuilder();
		251	stringValue.append("<CLOB ");
		252	if(size < 1000) {
		253	stringValue.append(String.format("%1$d Chars", size));
		254	} else if ( size < 1000000) {
		255	stringValue.append(String.format("%1$d kChars", size / 1000));
		256	} else {
		257	stringValue.append(String.format("%1$d MChars", size / 1000000));
		258	}
		259	stringValue.append(">");
		260	return super.getTableCellRendererComponent(table, stringValue.toString(), isSelected, hasFocus, row, column);
		261	} catch (SQLException ex) {
		262	return super.getTableCellRendererComponent(table, "<CLOB of unkown size>", isSelected, hasFocus, row, column);
		263	}
		264	}
		265	}

Lines 47-52 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/table/ResultSetJXTable.java (-1 / +5 lines)
47	import java.awt.event.KeyEvent;	47	import java.awt.event.KeyEvent;
48	import java.awt.event.KeyListener;	48	import java.awt.event.KeyListener;
49	import java.awt.event.MouseEvent;	49	import java.awt.event.MouseEvent;
		50	import java.sql.Blob;
		51	import java.sql.Clob;
50	import java.sql.Timestamp;	52	import java.sql.Timestamp;
51	import java.text.SimpleDateFormat;	53	import java.text.SimpleDateFormat;
52	import java.util.ArrayList;	54	import java.util.ArrayList;
Lines 158-164 Link Here
158	setDefaultEditor(Object.class, new StringTableCellEditor(txtFld));	160	setDefaultEditor(Object.class, new StringTableCellEditor(txtFld));
159	setDefaultEditor(String.class, new StringTableCellEditor(txtFld));	161	setDefaultEditor(String.class, new StringTableCellEditor(txtFld));
160	setDefaultEditor(java.sql.Time.class, new StringTableCellEditor(txtFld));	162	setDefaultEditor(java.sql.Time.class, new StringTableCellEditor(txtFld));
161		163	setDefaultEditor(Blob.class, new BlobFieldTableCellEditor());
		164	setDefaultEditor(Clob.class, new ClobFieldTableCellEditor());
		165
162	JTextField numFld = new JTextField();	166	JTextField numFld = new JTextField();
163	txtFld.addKeyListener(kl);	167	txtFld.addKeyListener(kl);
164	setDefaultEditor(Number.class, new NumberFieldEditor(numFld));	168	setDefaultEditor(Number.class, new NumberFieldEditor(numFld));




 * 
 * Portions Copyrighted 2009-2010 Sun Microsystems, Inc.
 */

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

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.Charset;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.EventObject;
import java.util.List;
import javax.swing.AbstractCellEditor;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.BorderFactory;
import javax.swing.DefaultCellEditor;
import javax.swing.DefaultComboBoxModel;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.table.TableCellEditor;

import org.jdesktop.swingx.JXPanel;
import org.jdesktop.swingx.renderer.JRendererCheckBox;
import org.netbeans.modules.db.dataview.meta.DBColumn;
import org.netbeans.modules.db.dataview.util.FileBackedBlob;
import org.netbeans.modules.db.dataview.util.FileBackedClob;
import org.netbeans.modules.db.dataview.util.DBReadWriteHelper;
import org.netbeans.modules.db.dataview.util.DataViewUtils;
import org.netbeans.modules.db.dataview.util.JXDateTimePicker;
import org.netbeans.modules.db.dataview.util.TimestampType;
import org.openide.awt.StatusDisplayer;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.windows.WindowManager;

/**

    }
}

class BlobFieldTableCellEditor extends AbstractCellEditor
        implements TableCellEditor,
        ActionListener {

    protected static final String EDIT = "edit";
    protected Blob currentValue;
    protected JButton button;
    protected JPopupMenu popup;
    protected JTable table;

    public BlobFieldTableCellEditor() {
        button = new JButton();
        button.setActionCommand(EDIT);
        button.addActionListener(this);
        button.setContentAreaFilled(false);
        button.setOpaque(false);
        button.setBorderPainted(false);
        button.setRolloverEnabled(false);
        button.setAlignmentX(0);
        button.setHorizontalAlignment(SwingConstants.LEFT);
        button.setFont(new Font(button.getFont().getFamily(), Font.ITALIC, 9));

        popup = new JPopupMenu();
        final JMenuItem miLobSaveAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "saveLob.title"));
        miLobSaveAction.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                saveLobToFile(currentValue);
                fireEditingCanceled();
            }
        });
        popup.add(miLobSaveAction);
        final JMenuItem miLobLoadAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "loadLob.title"));
        miLobLoadAction.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                Object newValue = loadLobFromFile();
                if (newValue != null) {
                    currentValue = (Blob) newValue;
                }
                fireEditingStopped();
            }
        });
        popup.add(miLobLoadAction);
        final JMenuItem miLobNullAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "nullLob.title"));
        miLobNullAction.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                currentValue = null;
                fireEditingStopped();
            }
        });
        popup.add(miLobNullAction);

    }

    public void actionPerformed(ActionEvent e) {
        if (EDIT.equals(e.getActionCommand())) {
            popup.show(button, 0, button.getHeight());
        }
    }

    @Override
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        currentValue = (java.sql.Blob) value;
        if (currentValue != null) {
            try {
                long size = currentValue.length();
                StringBuilder stringValue = new StringBuilder();
                stringValue.append("<BLOB ");
                if (size < 1000) {
                    stringValue.append(String.format("%1$d bytes", size));
                } else if (size < 1000000) {
                    stringValue.append(String.format("%1$d kB", size / 1000));
                } else {
                    stringValue.append(String.format("%1$d MB", size / 1000000));
                }
                stringValue.append(">");
                button.setText(stringValue.toString());
            } catch (SQLException ex) {
                button.setText("<BLOB of unknown size>");
            }
        } else {
            button.setText("<NULL>");
        }
        this.table = table;
        return button;
    }

    @Override
    public Object getCellEditorValue() {
        return currentValue;
    }

    @Override
    public boolean isCellEditable(EventObject anEvent) {
        if (anEvent instanceof MouseEvent) {
            return ((MouseEvent) anEvent).getClickCount() >= 2;
        }
        return super.isCellEditable(anEvent);
    }

    private void saveLobToFile(Blob b) {
        JFileChooser c = new JFileChooser();
        int fileDialogState = c.showSaveDialog(table);
        if (fileDialogState == JFileChooser.APPROVE_OPTION) {
            File f = c.getSelectedFile();
            InputStream is = null;
            FileOutputStream fos = null;
            try {
                is = b.getBinaryStream();
                fos = new FileOutputStream(f);
                int read = 0;
                byte[] buffer = new byte[1024];
                while((read = is.read(buffer)) > 0) {
                    fos.write(buffer, 0, read);
                }
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            } catch (SQLException ex) {
                throw new RuntimeException(ex);
            } finally {
                try {
                    if(fos != null) fos.close();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
                try {
                    if(is != null) is.close();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        }
    }
    
    private Blob loadLobFromFile() {
        JFileChooser c = new JFileChooser();
        Blob result = null;
        int fileDialogState = c.showOpenDialog(table);
        if (fileDialogState == JFileChooser.APPROVE_OPTION) {
            File f = c.getSelectedFile();
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(f);
                result = new FileBackedBlob(fis);
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            } catch (SQLException ex) {
                throw new RuntimeException(ex);
            } finally {
                try {
                    if(fis != null) fis.close();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        }
        return result;
    }
}

class ClobFieldTableCellEditor extends AbstractCellEditor
        implements TableCellEditor,
        ActionListener {

    private class CharsetSelector extends JPanel {
        private JComboBox charsetSelect;
        
        CharsetSelector() {
            List<Charset> charset = new ArrayList<Charset>(Charset.availableCharsets().values());
            Collections.sort(charset, new Comparator<Charset>() {
                @Override
                public int compare(Charset o1, Charset o2) {
                    return o1.displayName().compareTo(o2.displayName());
                }
            });
            charsetSelect = new JComboBox();
            charsetSelect.setModel(new DefaultComboBoxModel(charset.toArray()));
            charsetSelect.setSelectedItem(Charset.defaultCharset());
            this.add(charsetSelect);
        }

        public Charset getSelectedCharset() {
            return (Charset) charsetSelect.getSelectedItem();
        }

        public void setSelectedCharset(Charset selectedCharset) {
            charsetSelect.setSelectedItem(selectedCharset);
        }
    }
    
    protected static final String EDIT = "edit";
    protected Clob currentValue;
    protected JButton button;
    protected JPopupMenu popup;
    protected JTable table;

    public ClobFieldTableCellEditor() {
        button = new JButton();
        button.setActionCommand(EDIT);
        button.addActionListener(this);
        button.setContentAreaFilled(false);
        button.setOpaque(false);
        button.setBorderPainted(false);
        button.setRolloverEnabled(false);
        button.setAlignmentX(0);
        button.setHorizontalAlignment(SwingConstants.LEFT);
        button.setFont(new Font(button.getFont().getFamily(), Font.ITALIC, 9));

        popup = new JPopupMenu();
        final JMenuItem miLobSaveAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "saveLob.title"));
        miLobSaveAction.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                saveLobToFile(currentValue);
                fireEditingCanceled();
            }
        });
        popup.add(miLobSaveAction);
        final JMenuItem miLobLoadAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "loadLob.title"));
        miLobLoadAction.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                Object newValue = loadLobFromFile();
                if (newValue != null) {
                    currentValue = (Clob) newValue;
                }
                fireEditingStopped();
            }
        });
        popup.add(miLobLoadAction);
        final JMenuItem miLobNullAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "nullLob.title"));
        miLobNullAction.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                currentValue = null;
                fireEditingStopped();
            }
        });
        popup.add(miLobNullAction);

    }

    public void actionPerformed(ActionEvent e) {
        if (EDIT.equals(e.getActionCommand())) {
            popup.show(button, 0, button.getHeight());
        }
    }

    @Override
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        currentValue = (java.sql.Clob) value;
        if (currentValue != null) {
            try {
                long size = currentValue.length();
                StringBuilder stringValue = new StringBuilder();
                stringValue.append("<CLOB ");
                if (size < 1000) {
                    stringValue.append(String.format("%1$d Chars", size));
                } else if (size < 1000000) {
                    stringValue.append(String.format("%1$d kChars", size / 1000));
                } else {
                    stringValue.append(String.format("%1$d MChars", size / 1000000));
                }
                stringValue.append(">");
                button.setText(stringValue.toString());
            } catch (SQLException ex) {
                button.setText("<CLOB of unknown size>");
            }
        } else {
            button.setText("<NULL>");
        }
        this.table = table;
        return button;
    }

    @Override
    public Object getCellEditorValue() {
        return currentValue;
    }

    @Override
    public boolean isCellEditable(EventObject anEvent) {
        if (anEvent instanceof MouseEvent) {
            return ((MouseEvent) anEvent).getClickCount() >= 2;
        }
        return super.isCellEditable(anEvent);
    }
    
    private void saveLobToFile(Clob b) {
        CharsetSelector charset = new CharsetSelector();
        JFileChooser c = new JFileChooser();
        c.setAccessory(charset);
        int fileDialogState = c.showSaveDialog(table);
        if (fileDialogState == JFileChooser.APPROVE_OPTION) {
            File f = c.getSelectedFile();
            Reader r = null;
            Writer w = null;
            try {
                r = b.getCharacterStream();
                w = new OutputStreamWriter(new FileOutputStream(f), charset.getSelectedCharset());
                int read = 0;
                char[] buffer = new char[1024];
                while((read = r.read(buffer)) > 0) {
                    w.write(buffer, 0, read);
                }
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            } catch (SQLException ex) {
                throw new RuntimeException(ex);
            } finally {
                try {
                    if(w != null) w.close();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
                try {
                    if(r != null) r.close();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        }
    }
    
    private Clob loadLobFromFile() {
        CharsetSelector charset = new CharsetSelector();
        JFileChooser c = new JFileChooser();
        c.setAccessory(charset);
        Clob result = null;
        int fileDialogState = c.showOpenDialog(table);
        if (fileDialogState == JFileChooser.APPROVE_OPTION) {
            File f = c.getSelectedFile();
            Reader r = null;
            try {
                r = new InputStreamReader(new FileInputStream(f), charset.getSelectedCharset());
                result = new FileBackedClob(r);
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            } catch (SQLException ex) {
                throw new RuntimeException(ex);
            } finally {
                try {
                    if(r != null) r.close();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        }
        return result;
    }
}

Lines 43-48 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/table/ResultSetTableModel.java (-2 / +7 lines)
43	*/	43	*/
44	package org.netbeans.modules.db.dataview.table;	44	package org.netbeans.modules.db.dataview.table;
45		45
		46	import java.sql.Blob;
		47	import java.sql.Clob;
46	import java.sql.Date;	48	import java.sql.Date;
47	import java.sql.Time;	49	import java.sql.Time;
48	import java.sql.Timestamp;	50	import java.sql.Timestamp;
Lines 92-100 Link Here
92		94
93	case Types.CHAR:	95	case Types.CHAR:
94	case Types.VARCHAR:	96	case Types.VARCHAR:
95	case Types.LONGVARCHAR:
96	case -15:	97	case -15:
97	case -16:
98	case -9:	98	case -9:
99	case -8:	99	case -8:
100	return String.class;	100	return String.class;
Lines 103-110 Link Here
103	case Types.BINARY:	103	case Types.BINARY:
104	case Types.VARBINARY:	104	case Types.VARBINARY:
105	case Types.LONGVARBINARY:	105	case Types.LONGVARBINARY:
		106	case Types.BLOB:
		107	return Blob.class;
		108	case Types.LONGVARCHAR:
		109	case -16:
106	case Types.CLOB:	110	case Types.CLOB:
107	case 2011: /NCLOB /	111	case 2011: /NCLOB /
		112	return Clob.class;
108	case Types.OTHER:	113	case Types.OTHER:
109	default:	114	default:
110	return Object.class;	115	return Object.class;




 */
package org.netbeans.modules.db.dataview.util;

import java.io.InputStream;
import java.io.StringReader;
import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.Clob;

                    return bddata;
                }
            }
            case Types.INTEGER:
            case Types.SMALLINT:
            case Types.TINYINT: {
                try {
                    int idata = rs.getInt(index);
                    if (rs.wasNull()) {
                        return null;
                    } else {
                        return new Integer(idata);
                    }
                } catch (java.sql.SQLDataException ex) {
                    long ldata = rs.getLong(index);
                    if (rs.wasNull()) {
                        return null;
                    } else {
                        return new Long(ldata);
                    }

                }
            }
            // JDBC/ODBC bridge JDK1.4 brings back -9 for nvarchar columns in
            // MS SQL Server tables.

            // JDBC introduced NCHAR(-15), and NVARCHAR (-9), NLONGVARCHAR (-16)
            case Types.CHAR:
            case Types.VARCHAR:
            case Types.LONGVARCHAR:
            case -15:
            case -16:
            case -9:
            case -8: {
                String sdata = rs.getString(index);

                    return sdata;
                }
            }
            case Types.BIT: {
                byte[] bdata = rs.getBytes(index);
                if (rs.wasNull()) {
                    return null;
                } else {
                    Byte[] internal = new Byte[bdata.length];
                    for (int i = 0; i < bdata.length; i++) {
                        internal[i] = new Byte(bdata[i]);
                    }
                    String bStr = BinaryToStringConverter.convertToString(internal, BinaryToStringConverter.BINARY, true);
                    if (colType == Types.BIT && col.getPrecision() != 0 && col.getPrecision() < bStr.length()) {
                        return bStr.substring(bStr.length() - col.getPrecision());
                    }
                }
            }
            case Types.BINARY:
            case Types.VARBINARY:
            case Types.LONGVARBINARY:
            case Types.BLOB: {
                // Try to get a blob object (delay loading till the data is used!)
                try {
                    Blob blob = rs.getBlob(index);

                    Object result = null;
                    
                    if (! rs.wasNull()) {
                        result = new FileBackedBlob(blob.getBinaryStream());
                    }
                    
                    blob.free();
                    
                    return result;
                } catch (SQLException ex) {
                    // Ok - can happen - the jdbc driver might not support
                    // blob data or can for example not provide a longvarbinary
                    // as blob - so fall back to our implementation of blob
                }
                try {
                    InputStream is = rs.getBinaryStream(index);
                    if (is == null) {
                        return null;
                    } else {
                        return new FileBackedBlob(is);
                        for (int i = 0; i < bdata.length; i++) {
                            internal[i] = new Byte(bdata[i]);
                        }
                        String bStr = BinaryToStringConverter.convertToString(internal, BinaryToStringConverter.BINARY, true);
                        if (colType == Types.BIT && col.getPrecision() != 0 && col.getPrecision() < bStr.length()) {
                            return bStr.substring(bStr.length() - col.getPrecision());
                        }
                        return bStr;
                    }
                } catch (SQLDataException x) {
                    // wrong mapping JavaDB JDBC Type -4

                    }
                }
            }
            case Types.LONGVARCHAR:
            case -16:
            case Types.CLOB:
            case 2011: /*NCLOB */ {
                // Try to get a blob object (delay loading till the data is used!)
                try {
                    Clob clob = rs.getClob(index);

                    if (rs.wasNull()) {
                        return null;
                    } else {
                        return new FileBackedClob(clob.getCharacterStream());
                    }
                } catch (SQLException ex) {
                    // Ok - can happen - the jdbc driver might not support
                    // clob data or can for example not provide a longvarchar
                    // as clob - so fall back to our implementation of clob
                }
                String sdata = rs.getString(index);
                if (rs.wasNull()) {
                    return null;
                } else {
                    return new FileBackedClob(sdata);
                byte[] blobData = null;
                if (blob != null) {
                    blobData = blob.getBytes(1, Math.min((int) blob.length(), 2000));
                }
                Byte[] internal = new Byte[blobData.length];
                for (int i = 0; i < blobData.length; i++) {
                    internal[i] = new Byte(blobData[i]);
                }
                return BinaryToStringConverter.convertToString(internal, BinaryToStringConverter.HEX, false);
            }
            case Types.CLOB:
            case 2011: /*NCLOB */ {
                // We always get the CLOB, even when we are not reading the contents.
                // Since the CLOB is just a pointer to the CLOB data rather than the
                // data itself, this operation should not take much time (as opposed
                // to getting all of the data in the clob).
                Clob clob = rs.getClob(index);

                if (rs.wasNull()) {
                    return null;
                }
                // CLOB exists, so try to read the data from it
                if (clob != null) {
                    return clob.getSubString(1, Math.min((int) clob.length(), 2000));
                }
            }
            case Types.OTHER:


                case Types.BINARY:
                case Types.VARBINARY:
                    ps.setBytes(index, valueObj.toString().getBytes());
                    break;

                case Types.LONGVARBINARY:
                case Types.BLOB:
                    ps.setBinaryStream(index, ((Blob) valueObj).getBinaryStream());
                    ps.setBinaryStream(index, new ByteArrayInputStream(byteval), byteval.length);
                    break;

                case Types.CHAR:

                case -15:
                case -9:
                case -8:
                case -16:
                    ps.setString(index, valueObj.toString());
                    break;

                case Types.LONGVARCHAR:
                case -16:
                case Types.CLOB:
                case Types.LONGVARCHAR:
                case 2011: /*NCLOB */
                    ps.setCharacterStream(index, ((Clob) valueObj).getCharacterStream());
                    ps.setCharacterStream(index, new StringReader(charVal), charVal.length());
                    break;

                default:

                    return valueObj instanceof BigDecimal ? valueObj : new BigDecimal(valueObj.toString());

                case Types.INTEGER: {
                    long ldata = Long.parseLong(valueObj.toString());
                        if(ldata >= ((long) Integer.MIN_VALUE) && ldata <= ((long) Integer.MAX_VALUE)) {
                        return new Integer((int) ldata);
                        } else if ( ldata < maxUnsignedInt ) {
                        return new Long(ldata);
                    } else {
                        throw new NumberFormatException("Illegal value for java.sql.Type.Integer");
                    }
                }

                case Types.SMALLINT: {
                    int idata = Integer.parseInt(valueObj.toString());
                        if(idata >= ((int) Short.MIN_VALUE) && idata <= ((int) Short.MAX_VALUE)) {
                        return new Short((short) idata);
                        } else if ( idata < maxUnsignedShort ) {
                        return new Integer(idata);
                    } else {
                        throw new NumberFormatException("Illegal value for java.sql.Type.SMALLINT");
                    }
                }

                case Types.TINYINT: {
                    short sdata = Short.parseShort(valueObj.toString());
                        if(sdata >= ((short) Byte.MIN_VALUE) && sdata <= ((short) Byte.MAX_VALUE)) {
                        return new Byte((byte) sdata);
                        } else if ( sdata < maxUnsignedByte ) {
                        return new Short(sdata);
                    } else {
                        throw new NumberFormatException("Illegal value for java.sql.Type.TINYINT");
                    }
                }

                case Types.CHAR:

                case Types.BINARY:
                case Types.VARBINARY:
                case Types.LONGVARBINARY:
                case Types.BLOB:
                case Types.CLOB:
                case Types.BLOB:
                    char[] bytes = valueObj.toString().toCharArray();
                    Byte[] internal = new Byte[bytes.length];
                    for (int i = 0; i < bytes.length; i++) {
                        internal[i] = new Byte((byte) bytes[i]);
                    }
                    return BinaryToStringConverter.convertToString(internal, BinaryToStringConverter.BINARY, true);

                case Types.OTHER:
                default:
                    return valueObj;




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.db.dataview.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.sql.Blob;
import java.sql.SQLException;
import org.openide.util.Exceptions;

/**
 * A storage implementing a _subset_ of the Blob Interface backed by a file
 * 
 * Currently the following function are not implemented:
 * - all position functions
 * - getBinaryStream(long pos, long length)
 * 
 * @author mblaesing
 */
public class FileBackedBlob implements Blob {

    private boolean freed = false;
    private File backingFile;

    public FileBackedBlob() throws SQLException {
        try {
            backingFile = File.createTempFile("netbeans-db-blob", null);
            backingFile.deleteOnExit();
        } catch (IOException ex) {
            throw new SQLException(ex);
        }
    }

    public FileBackedBlob(InputStream is) throws SQLException {
        this();
        OutputStream os = null;
        try {
            os = setBinaryStream(1);
            int read = 0;
            byte[] buffer = new byte[(int) Math.pow(2, 18)];
            while ((read = is.read(buffer)) > 0) {
                os.write(buffer, 0, read);
            }
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                if(os != null) os.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
            try {
                if(is != null) is.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @Override
    public long length() throws SQLException {
        checkFreed();
        return backingFile.length();
    }

    @Override
    public byte[] getBytes(long pos, int length) throws SQLException {
        checkFreed();
        checkPos(pos);
        checkLength(length);
        InputStream is = null;
        try {
            is = new FileInputStream(backingFile);
            is.skip(pos - 1);
            byte[] result = new byte[length];
            is.read(result);
            return result;
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                is.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @Override
    public InputStream getBinaryStream() throws SQLException {
        checkFreed();
        try {
            return new FileInputStream(backingFile);
        } catch (FileNotFoundException ex) {
            throw new SQLException(ex);
        }
    }

    @Override
    public long position(byte[] pattern, long start) throws SQLException {
        checkFreed();
        checkPos(start);
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public long position(Blob pattern, long start) throws SQLException {
        checkFreed();
        checkPos(start);
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public int setBytes(long pos, byte[] bytes) throws SQLException {
        checkFreed();
        checkPos(pos);
        return setBytes(pos, bytes, 0, bytes.length);
    }

    @Override
    public int setBytes(long pos, byte[] bytes, int offset, int len) throws SQLException {
        checkFreed();
        checkPos(pos);
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile(backingFile, "rw");
            raf.seek(pos - 1);
            int border = Math.min(bytes.length, offset + len);
            int written = 0;
            for (int i = offset; i < border; i++) {
                raf.write(bytes[i]);
                written++;
            }
            return written;
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                raf.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }

    }

    @Override
    public OutputStream setBinaryStream(long pos) throws SQLException {
        checkFreed();
        checkPos(pos);

        try {
            final RandomAccessFile raf = new RandomAccessFile(backingFile, "rw");
            try {
                raf.seek(pos - 1);
            } catch (IOException ex) {
                raf.close();
                throw new SQLException(ex);
            }

            return new RandomAccessOutputStream(raf);
        } catch (IOException ex) {
            throw new SQLException(ex);
        }
    }

    @Override
    public void truncate(long len) throws SQLException {
        checkFreed();
        RandomAccessFile raf = null;
        try {
            raf  = new RandomAccessFile(backingFile, "rw");
            raf.setLength(len);
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                raf.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @Override
    public void free() throws SQLException {
        if (!freed) {
            backingFile.delete();
            freed = true;
        }
    }

    @Override
    public InputStream getBinaryStream(long pos, long length) throws SQLException {
        checkFreed();
        throw new UnsupportedOperationException("Not supported yet.");
    }

    private void checkFreed() throws SQLException {
        if (freed) {
            throw new SQLException("Blob already freed");
        }
    }

    private void checkPos(long pos) throws SQLException {
        if (pos < 1) {
            throw new SQLException("Illegal Value for position: " + Long.toString(pos));
        }
    }

    private void checkLength(long length) throws SQLException {
        if (length < 0) {
            throw new SQLException("Illegal Value for length: " + Long.toString(length));
        }
    }
    
    protected void finalize() throws Throwable {
        free();
        super.finalize();
    }
    
    File getBackingFile() {
        return backingFile;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.db.dataview.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.nio.CharBuffer;
import java.sql.Clob;
import java.sql.SQLException;
import org.openide.util.Exceptions;

/**
 * A storage implementing a _subset_ of the Blob Interface backed by a file
 * 
 * Currently the following function are not implemented:
 * - all position functions
 * - getCharacterStream(long pos, long length)
 * - setAsciiStream
 * - getAsciiStream
 * 
 * @author mblaesing
 */
public class FileBackedClob implements Clob {

    private boolean freed = false;
    private File backingFile;

    public FileBackedClob() throws SQLException {
        try {
            backingFile = File.createTempFile("netbeans-db-blob", null);
            backingFile.deleteOnExit();
        } catch (IOException ex) {
            throw new SQLException(ex);
        }
    }

    public FileBackedClob(String init) throws SQLException {
        this();
        this.setString(1, init);
    }

    public FileBackedClob(Reader r) throws SQLException {
        this();
        Writer w = setCharacterStream(1);
        int read = 0;
        char[] buffer = new char[(int) Math.pow(2, 18)];
        try {
            while ((read = r.read(buffer)) > 0) {
                w.write(buffer, 0, read);
            }
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                if (w != null) {
                    w.close();
                }
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
            try {
                if (r != null) {
                    r.close();
                }
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @Override
    public long length() throws SQLException {
        checkFreed();
        return backingFile.length() / 4;
    }

    @Override
    public void truncate(long len) throws SQLException {
        checkFreed();
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile(backingFile, "rw");
            raf.setLength(len * 4);
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                raf.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @Override
    public void free() throws SQLException {
        if (!freed) {
            backingFile.delete();
            freed = true;
        }
    }

    private void checkFreed() throws SQLException {
        if (freed) {
            throw new SQLException("Blob already freed");
        }
    }

    private void checkPos(long pos) throws SQLException {
        if (pos < 1) {
            throw new SQLException("Illegal Value for position: " + Long.toString(pos));
        }
    }

    private void checkLength(long length) throws SQLException {
        if (length < 0) {
            throw new SQLException("Illegal Value for length: " + Long.toString(length));
        }
    }

    @Override
    public String getSubString(long pos, int length) throws SQLException {
        checkFreed();
        checkPos(pos);
        checkLength(length);
        Reader r = null;
        try {
            r = new InputStreamReader(new FileInputStream(backingFile), "UTF32");
            r.skip(pos - 1);
            CharBuffer c = CharBuffer.allocate(length);
            r.read(c);
            c.rewind();
            return c.toString();
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                r.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }

    }

    @Override
    public Reader getCharacterStream() throws SQLException {
        checkFreed();
        Reader r;
        try {
            r = new InputStreamReader(new FileInputStream(backingFile), "UTF32");
        } catch (FileNotFoundException ex) {
            throw new SQLException(ex);
        } catch (UnsupportedEncodingException ex) {
            throw new SQLException(ex);
        }
        return r;
    }

    @Override
    public InputStream getAsciiStream() throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public long position(String searchstr, long start) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public long position(Clob searchstr, long start) throws SQLException {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public int setString(long pos, String str) throws SQLException {
        return setString(pos, str, 0, str.length());
    }

    @Override
    public int setString(long pos, String str, int offset, int len) throws SQLException {
        checkFreed();
        checkPos(pos);
        Writer w = null;
        try {
            w = setCharacterStream(pos);
            w.write(str.substring(offset, Math.min(offset + len, str.length())));
            return len;
        } catch (IOException ex) {
            throw new SQLException(ex);
        } finally {
            try {
                w.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @Override
    public OutputStream setAsciiStream(long pos) throws SQLException {
        checkFreed();
        checkPos(pos);
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public Writer setCharacterStream(long pos) throws SQLException {
        checkFreed();
        checkPos(pos);

        try {
            final RandomAccessFile raf = new RandomAccessFile(backingFile, "rw");
            try {
                raf.seek((pos - 1) * 4);
            } catch (IOException ex) {
                raf.close();
                throw new SQLException(ex);
            }

            return new OutputStreamWriter(new RandomAccessOutputStream(raf), "UTF32");
        } catch (IOException ex) {
            throw new SQLException(ex);
        }
    }

    @Override
    public Reader getCharacterStream(long pos, long length) throws SQLException {
        checkFreed();
        checkPos(pos);
        checkLength(length);
        throw new UnsupportedOperationException("Not supported yet.");
    }

    protected void finalize() throws Throwable {
        free();
        super.finalize();
    }

    File getBackingFile() {
        return backingFile;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.db.dataview.util;

import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;

class RandomAccessInputStream extends InputStream {

    private RandomAccessFile raf;

    public RandomAccessInputStream(RandomAccessFile raf) {
        this.raf = raf;
    }

    @Override
    public int read(byte[] b) throws IOException {
        return raf.read(b);
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        return raf.read(b, off, len);
    }

    @Override
    public int read() throws IOException {
        return raf.read();
    }

    @Override
    public void close() throws IOException {
        raf.close();
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.db.dataview.util;

import java.io.IOException;
import java.io.OutputStream;
import java.io.RandomAccessFile;

class RandomAccessOutputStream extends OutputStream {

    private RandomAccessFile raf;

    public RandomAccessOutputStream(RandomAccessFile raf) {
        this.raf = raf;
    }

    @Override
    public void write(byte[] b) throws IOException {
        raf.write(b);
    }

    @Override
    public void write(int b) throws IOException {
        raf.write(b);
    }

    @Override
    public void close() throws IOException {
        raf.close();
    }
}

Lines 94-100 Link Here

(-)a/db.dataview/test/unit/src/org/netbeans/modules/db/dataview/output/SQLExecutionHelperTest.java (-2 / +2 lines)
94	int pageSize = 5;	94	int pageSize = 5;
95	DataView dv = DataView.create(dbconn, sqlString, pageSize);	95	DataView dv = DataView.create(dbconn, sqlString, pageSize);
96	SQLExecutionHelper execHelper = new SQLExecutionHelper(dv);	96	SQLExecutionHelper execHelper = new SQLExecutionHelper(dv);
97	SQLExecutionHelper.initialDataLoad(dv, dbconn, execHelper);	97	execHelper.initialDataLoad();
98	assertNotNull(execHelper);	98	assertNotNull(execHelper);
99	assertEquals(sqlString, dv.getSQLString());	99	assertEquals(sqlString, dv.getSQLString());
100	assertEquals(true, dv.hasResultSet());	100	assertEquals(true, dv.hasResultSet());
Lines 105-111 Link Here
105	ResultSet rs = conn.createStatement().executeQuery(context.getSqlSelect());	105	ResultSet rs = conn.createStatement().executeQuery(context.getSqlSelect());
106	DataView dv = DataView.create(dbconn, context.getSqlSelect(), pageSize);	106	DataView dv = DataView.create(dbconn, context.getSqlSelect(), pageSize);
107	SQLExecutionHelper instance = dv.getSQLExecutionHelper();	107	SQLExecutionHelper instance = dv.getSQLExecutionHelper();
108	instance.loadDataFrom(rs);	108	instance.initialDataLoad();
109	assertNotNull(instance);	109	assertNotNull(instance);
110	}	110	}
111	}	111	}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.db.dataview.util;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import org.openide.util.Exceptions;

/**
 *
 * @author mblaesing
 */
public class FileBackedBlobTest {

    private static byte[] testCase1;
    private static byte[] testCase2;
    private static byte[] testCase3;

    private static void assertStreamEquals(InputStream is1, InputStream is2) {
        try {
            long position = 0;
            while (true) {
                int input1 = is1.read();
                int input2 = is2.read();
                if (input1 != input2) {
                    throw new AssertionError("Streams differ at position: " + Long.toString(position));
                }
                if (input1 == -1 || input2 == -1) {
                    return;
                }
                position++;
            }
        } catch (IOException ex) {
            throw new AssertionError(ex);
        } finally {
            try {
                is1.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
            try {
                is2.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    public FileBackedBlobTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
        byte[] testPattern = "TestCase".getBytes();
        int testLength = testPattern.length;
        testCase1 = new byte[10];
        testCase2 = new byte[1024];
        testCase3 = new byte[1024 * 1024];
        for (int i = 0; i < testCase1.length; i++) {
            testCase1[i] = testPattern[ i % testLength];
        }
        for (int i = 0; i < testCase2.length; i++) {
            testCase2[i] = testPattern[ i % testLength];
        }
        for (int i = 0; i < testCase3.length; i++) {
            testCase3[i] = testPattern[ i % testLength];
        }
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
        testCase1 = null;
        testCase2 = null;
        testCase3 = null;
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    @Test
    public void testLength() throws Exception {
        FileBackedBlob b;
        b = new FileBackedBlob(new ByteArrayInputStream(testCase1));
        assertEquals(b.length(), testCase1.length);
        b.free();
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        assertEquals(b.length(), testCase2.length);
        b.free();
        b = new FileBackedBlob(new ByteArrayInputStream(testCase3));
        assertEquals(b.length(), testCase3.length);
        b.free();
    }

    @Test
    public void testGetBytes() throws Exception {
        FileBackedBlob b;
        // Each case is tested with the complete array and then with den range
        // as index: 5.-9.
        byte[] shortReference = new byte[5];
        System.arraycopy(testCase1, 5, shortReference, 0, 5);

        b = new FileBackedBlob(new ByteArrayInputStream(testCase1));
        assertArrayEquals(b.getBytes(1, (int) b.length()), testCase1);
        assertArrayEquals(b.getBytes(6, 5), shortReference);
        b.free();
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        assertArrayEquals(b.getBytes(1, (int) b.length()), testCase2);
        assertArrayEquals(b.getBytes(6, 5), shortReference);
        b.free();
        b = new FileBackedBlob(new ByteArrayInputStream(testCase3));
        assertArrayEquals(b.getBytes(1, (int) b.length()), testCase3);
        assertArrayEquals(b.getBytes(6, 5), shortReference);
        b.free();
    }

    @Test
    public void testGetBinaryStream_0args() throws Exception {
        FileBackedBlob b;
        b = new FileBackedBlob(new ByteArrayInputStream(testCase1));
        assertStreamEquals(b.getBinaryStream(), new ByteArrayInputStream(testCase1));
        b.free();
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        assertStreamEquals(b.getBinaryStream(), new ByteArrayInputStream(testCase2));
        b.free();
        b = new FileBackedBlob(new ByteArrayInputStream(testCase3));
        assertStreamEquals(b.getBinaryStream(), new ByteArrayInputStream(testCase3));
        b.free();
    }

    @Test
    public void testSetBytes_long_byteArr() throws Exception {
        FileBackedBlob b;
        byte[] test1 = "test".getBytes("ASCII");
        byte[] test2 = "test0123456789".getBytes("ASCII");
        byte[] firstPartReference = new byte[testCase2.length - test1.length - 4];
        byte[] secondPartReference = new byte[4];
        System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
        System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        b.setBytes(testCase2.length - test1.length - 4 + 1, test1);
        assertArrayEquals(firstPartReference, b.getBytes(1, testCase2.length - test1.length - 4));
        assertArrayEquals(secondPartReference, b.getBytes(testCase2.length - 4, 4));
        assertArrayEquals(test1, b.getBytes(testCase2.length - 4 - test1.length + 1, test1.length));
        assertEquals(b.length(), 1024);
        b.setBytes(testCase2.length - test1.length - 4 + 1, test2);
        assertArrayEquals(firstPartReference, b.getBytes(1, testCase2.length - test1.length - 4));
        assertEquals(b.length(), 1024 - test1.length - 4 + test2.length);
        assertArrayEquals(test2, b.getBytes(b.length() - test2.length + 1, test2.length));
        b.free();
    }

    @Test
    public void testSetBytes_4args() throws Exception {
        FileBackedBlob b;
        byte[] test1 = "test".getBytes("ASCII");
        byte[] test2 = "01test23456789".getBytes("ASCII");
        byte[] firstPartReference = new byte[testCase2.length - test1.length - 4];
        byte[] secondPartReference = new byte[4];
        System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
        System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        b.setBytes(testCase2.length - test1.length - 4 + 1, test2, 2, 4);
        assertArrayEquals(firstPartReference, b.getBytes(1, testCase2.length - test1.length - 4));
        assertArrayEquals(secondPartReference, b.getBytes(testCase2.length - 4, 4));
        assertArrayEquals(test1, b.getBytes(testCase2.length - 4 - test1.length + 1, test1.length));
        assertEquals(b.length(), 1024);
        b.setBytes(testCase2.length - test1.length - 4 + 1, test2);
        assertArrayEquals(firstPartReference, b.getBytes(1, testCase2.length - test1.length - 4));
        assertEquals(b.length(), 1024 - test1.length - 4 + test2.length);
        assertArrayEquals(test2, b.getBytes(b.length() - test2.length + 1, test2.length));
        b.free();
    }

    @Test
    public void testSetBinaryStream() throws Exception {
        FileBackedBlob b;
        byte[] test1 = "test".getBytes("ASCII");
        byte[] test2 = "test0123456789".getBytes("ASCII");
        byte[] firstPartReference = new byte[testCase2.length - test1.length - 4];
        byte[] secondPartReference = new byte[4];
        System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
        System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        OutputStream os = b.setBinaryStream(testCase2.length - test1.length - 4 + 1);
        os.write(test1);
        os.close();
        assertArrayEquals(firstPartReference, b.getBytes(1, testCase2.length - test1.length - 4));
        assertArrayEquals(secondPartReference, b.getBytes(testCase2.length - 4, 4));
        assertArrayEquals(test1, b.getBytes(testCase2.length - 4 - test1.length + 1, test1.length));
        assertEquals(b.length(), 1024);
        os = b.setBinaryStream(testCase2.length - test1.length - 4 + 1);
        os.write(test2);
        os.close();
        assertArrayEquals(firstPartReference, b.getBytes(1, testCase2.length - test1.length - 4));
        assertEquals(b.length(), 1024 - test1.length - 4 + test2.length);
        assertArrayEquals(test2, b.getBytes(b.length() - test2.length + 1, test2.length));
        b.free();
    }

    @Test
    public void testTruncate() throws Exception {
        FileBackedBlob b;
        byte[] reference;
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        assertEquals(b.length(), testCase2.length);
        b.truncate(1024);
        assertEquals(b.length(), 1024);
        reference = new byte[1024];
        System.arraycopy(testCase2, 0, reference, 0, 1024);
        assertStreamEquals(b.getBinaryStream(), new ByteArrayInputStream(reference));
        b.truncate(10);
        assertEquals(b.length(), 10);
        reference = new byte[10];
        System.arraycopy(testCase2, 0, reference, 0, 10);
        assertStreamEquals(b.getBinaryStream(), new ByteArrayInputStream(reference));
        b.free();
    }

    @Test
    public void testFree() throws Exception {
        FileBackedBlob b;
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        assertTrue(b.getBackingFile().exists());
        b.free();
        assertFalse(b.getBackingFile().exists());
    }

    @Test
    public void testFinalize() throws Exception {
        FileBackedBlob b;
        b = new FileBackedBlob(new ByteArrayInputStream(testCase2));
        assertTrue(b.getBackingFile().exists());
        try {
            b.finalize();
        } catch (Throwable ex) {
            throw new AssertionError(ex);
        }
        assertFalse(b.getBackingFile().exists());
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.db.dataview.util;

import java.io.CharArrayReader;
import java.io.IOException;
import org.openide.util.Exceptions;
import java.io.Reader;
import java.io.Writer;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 *
 * @author mblaesing
 */
public class FileBackedClobTest {
    private static char[] testCase1;
    private static char[] testCase2;
    private static char[] testCase3;

    private static void assertCharacterStreamEquals(Reader is1, Reader is2) {
        try {
            long position = 0;
            while (true) {
                int input1 = is1.read();
                int input2 = is2.read();
                if (input1 != input2) {
                    throw new AssertionError("Reader differ at position: " + Long.toString(position));
                }
                if (input1 == -1 || input2 == -1) {
                    return;
                }
                position++;
            }
        } catch (IOException ex) {
            throw new AssertionError(ex);
        } finally {
            try {
                is1.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
            try {
                is2.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
        char[] testPattern = "Testäöüß".toCharArray();
        int testLength = testPattern.length;
        testCase1 = new char[10];
        testCase2 = new char[1024];
        testCase3 = new char[1024 * 1024];
        for (int i = 0; i < testCase1.length; i++) {
            testCase1[i] = testPattern[ i % testLength];
        }
        for (int i = 0; i < testCase2.length; i++) {
            testCase2[i] = testPattern[ i % testLength];
        }
        for (int i = 0; i < testCase3.length; i++) {
            testCase3[i] = testPattern[ i % testLength];
        }
    }

    
    public FileBackedClobTest() {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
        testCase1 = null;
        testCase2 = null;
        testCase3 = null;
    }
    
    @Before
    public void setUp() {
    }
    
    @After
    public void tearDown() {
    }

    @Test
    public void testLength() throws Exception {
        FileBackedClob c;
        c = new FileBackedClob(new CharArrayReader(testCase1));
        assertEquals(c.length(), testCase1.length);
        assertEquals(c.getBackingFile().length(), testCase1.length * 4);
        c.free();
        c = new FileBackedClob(new String(testCase2));
        assertEquals(c.length(), testCase2.length);
        assertEquals(c.getBackingFile().length(), testCase2.length * 4);
        c.free();
        c = new FileBackedClob(new CharArrayReader(testCase3));
        assertEquals(c.length(), testCase3.length);
        assertEquals(c.getBackingFile().length(), testCase3.length * 4);
        c.free();
    }

    @Test
    public void testTruncate() throws Exception {
        FileBackedClob c;
        c = new FileBackedClob(new CharArrayReader(testCase1));
        c.truncate(5);
        assertEquals(c.length(), 5);
        assertEquals(c.getBackingFile().length(), 5 * 4);
        c.free();
        c = new FileBackedClob(new String(testCase2));
        c.truncate(42);
        assertEquals(c.length(), 42);
        assertEquals(c.getBackingFile().length(), 42 * 4);
        c.free();
        c = new FileBackedClob(new CharArrayReader(testCase3));
        c.truncate(1024);
        assertEquals(c.length(), 1024);
        assertEquals(c.getBackingFile().length(), 1024 * 4);
        c.free();
    }

    @Test
    public void testGetSubString() throws Exception {
        FileBackedClob c;
        char[] referenceChars = new char[5];
        System.arraycopy(testCase1, 5, referenceChars, 0, 5);
        String reference = new String(referenceChars);
        c = new FileBackedClob(new CharArrayReader(testCase1));
        assertEquals(reference, c.getSubString(6, 5));
        c.free();
        c = new FileBackedClob(new String(testCase2));
        assertEquals( reference, c.getSubString(6, 5));
        c.free();
        c = new FileBackedClob(new CharArrayReader(testCase3));
        assertEquals(reference, c.getSubString(6, 5));
        c.free();
    }

    @Test
    public void testGetCharacterStream_0args() throws Exception {
        FileBackedClob c;
        c = new FileBackedClob(new CharArrayReader(testCase1));
        assertCharacterStreamEquals(c.getCharacterStream(), new CharArrayReader(testCase1));
        c.free();
        c = new FileBackedClob(new String(testCase2));
        assertCharacterStreamEquals(c.getCharacterStream(), new CharArrayReader(testCase2));
        c.free();
        c = new FileBackedClob(new CharArrayReader(testCase3));
        assertCharacterStreamEquals(c.getCharacterStream(), new CharArrayReader(testCase3));
        c.free();
    }

    @Test
    public void testSetString_long_String() throws Exception {
        FileBackedClob b;
        char[] test1 = "test".toCharArray();
        char[] test2 = "test0123456789".toCharArray();
        char[] firstPartReference = new char[testCase2.length - test1.length - 4];
        char[] secondPartReference = new char[4];
        System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
        System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
        b = new FileBackedClob(new CharArrayReader(testCase2));
        b.setString(testCase2.length - test1.length - 4 + 1, new String(test1));
        assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
        assertEquals(new String(secondPartReference), b.getSubString(testCase2.length - 4, 4));
        assertEquals(new String(test1), b.getSubString(testCase2.length - 4 - test1.length + 1, test1.length));
        assertEquals(b.length(), 1024);
        b.setString(testCase2.length - test1.length - 4 + 1, new String(test2));
        assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
        assertEquals(b.length(), 1024 - test1.length - 4 + test2.length);
        assertEquals(new String(test2), b.getSubString(b.length() - test2.length + 1, test2.length));
        b.free();
    }

    @Test
    public void testSetString_4args() throws Exception {
        FileBackedClob b;
        char[] test1 = "test".toCharArray();
        char[] test2 = "01test23456789".toCharArray();
        char[] firstPartReference = new char[testCase2.length - test1.length - 4];
        char[] secondPartReference = new char[4];
        System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
        System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
        b = new FileBackedClob(new CharArrayReader(testCase2));
        b.setString(testCase2.length - test1.length - 4 + 1, new String(test2), 2, 4);
        assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
        assertEquals(new String(secondPartReference), b.getSubString(testCase2.length - 4, 4));
        assertEquals(new String(test1), b.getSubString(testCase2.length - 4 - test1.length + 1, test1.length));
        assertEquals(b.length(), 1024);
        b.free();
    }

    @Test
    public void testSetCharacterStream() throws Exception {
        FileBackedClob b;
        char[] test1 = "test".toCharArray();
        char[] test2 = "test0123456789".toCharArray();
        char[] firstPartReference = new char[testCase2.length - test1.length - 4];
        char[] secondPartReference = new char[4];
        System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
        System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
        b = new FileBackedClob(new CharArrayReader(testCase2));
        Writer os = b.setCharacterStream(testCase2.length - test1.length - 4 + 1);
        os.write(test1);
        os.close();
        assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
        assertEquals(new String(secondPartReference), b.getSubString(testCase2.length - 4, 4));
        assertEquals(new String(test1), b.getSubString(testCase2.length - 4 - test1.length + 1, test1.length));
        assertEquals(b.length(), 1024);
        os = b.setCharacterStream(testCase2.length - test1.length - 4 + 1);
        os.write(test2);
        os.close();
        assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
        assertEquals(b.length(), 1024 - test1.length - 4 + test2.length);
        assertEquals(new String(test2), b.getSubString(b.length() - test2.length + 1, test2.length));
        b.free();
    }

    @Test
    public void testFinalize() throws Exception {
        FileBackedClob b;
        b = new FileBackedClob(new CharArrayReader(testCase2));
        assertTrue(b.getBackingFile().exists());
        try {
            b.finalize();
        } catch (Throwable ex) {
            Exceptions.printStackTrace(ex);
        }
        assertFalse(b.getBackingFile().exists());
    }
    
    @Test
    public void testFree() throws Exception {
        FileBackedClob b;
        b = new FileBackedClob(new CharArrayReader(testCase2));
        assertTrue(b.getBackingFile().exists());
        b.free();
        assertFalse(b.getBackingFile().exists());
    }
}

Return to bug 206233

Lines 155-172 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/DataViewTableUI.java (-5 / +2 lines)
155	Object obj = dataView.getDataViewPageContext().getColumnData(	155	Object obj = dataView.getDataViewPageContext().getColumnData(
156	table.convertRowIndexToModel(row),	156	table.convertRowIndexToModel(row),
157	table.convertColumnIndexToModel(column));	157	table.convertColumnIndexToModel(column));
158	if (value == null) {
159	return c;
160	}
161		158
162	if (isSelected) {	159	if (isSelected) {
163	if (obj != null && value.equals(obj)) {	160	if ((obj == null && value == null) \|\| (obj != null && value != null && value.equals(obj))) {
164	c.setForeground(gray);	161	c.setForeground(gray);
165	} else {	162	} else {
166	c.setForeground(Color.ORANGE);	163	c.setForeground(Color.ORANGE);
167	}	164	}
168	} else {	165	} else {
169	if (obj != null && value.equals(obj)) {	166	if ((obj == null && value == null) \|\| (obj != null && value != null && value.equals(obj))) {
170	c.setForeground(table.getForeground());	167	c.setForeground(table.getForeground());
171	} else {	168	} else {
172	c.setForeground(green);	169	c.setForeground(green);

Lines 57-63 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/output/SQLExecutionHelper.java (-32 / +28 lines)
57	import java.util.logging.Level;	57	import java.util.logging.Level;
58	import java.util.logging.Logger;	58	import java.util.logging.Logger;
59	import javax.swing.table.TableModel;	59	import javax.swing.table.TableModel;
60	import org.netbeans.api.db.explorer.DatabaseConnection;
61	import org.netbeans.modules.db.dataview.meta.DBConnectionFactory;	60	import org.netbeans.modules.db.dataview.meta.DBConnectionFactory;
62	import org.netbeans.modules.db.dataview.meta.DBException;	61	import org.netbeans.modules.db.dataview.meta.DBException;
63	import org.netbeans.modules.db.dataview.meta.DBMetaDataFactory;	62	import org.netbeans.modules.db.dataview.meta.DBMetaDataFactory;
Lines 87-103 Link Here
87	this.dataView = dataView;	86	this.dataView = dataView;
88	}	87	}
89		88
90	static void initialDataLoad(DataView dv, DatabaseConnection dbConn, SQLExecutionHelper execHelper) throws SQLException {	89	void initialDataLoad() throws SQLException {
91	Statement stmt = null;	90	Statement stmt = null;
92	try {	91	try {
93	Connection conn = DBConnectionFactory.getInstance().getConnection(dbConn);	92	Connection conn = DBConnectionFactory.getInstance().getConnection(dataView.getDatabaseConnection());
94	String msg = "";	93	String msg = "";
95	if (conn == null) {	94	if (conn == null) {
96	Throwable ex = DBConnectionFactory.getInstance().getLastException();	95	Throwable ex = DBConnectionFactory.getInstance().getLastException();
97	if (ex != null) {	96	if (ex != null) {
98	msg = ex.getMessage();	97	msg = ex.getMessage();
99	} else {	98	} else {
100	msg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_connection_failure", dv.getDatabaseConnection());	99	msg = NbBundle.getMessage(SQLExecutionHelper.class, "MSG_connection_failure", dataView.getDatabaseConnection());
101	}	100	}
102	NotifyDescriptor nd = new NotifyDescriptor.Message(msg, NotifyDescriptor.ERROR_MESSAGE);	101	NotifyDescriptor nd = new NotifyDescriptor.Message(msg, NotifyDescriptor.ERROR_MESSAGE);
103	DialogDisplayer.getDefault().notifyLater(nd);	102	DialogDisplayer.getDefault().notifyLater(nd);
Lines 105-141 Link Here
105	}	104	}
106		105
107	DBMetaDataFactory dbMeta = new DBMetaDataFactory(conn);	106	DBMetaDataFactory dbMeta = new DBMetaDataFactory(conn);
108	dv.setLimitSupported(dbMeta.supportsLimit());	107	dataView.setLimitSupported(dbMeta.supportsLimit());
109	String sql = dv.getSQLString();	108	String sql = dataView.getSQLString();
110	boolean isSelect = execHelper.isSelectStatement(sql);	109	boolean isSelect = isSelectStatement(sql);
111		110
112	stmt = execHelper.prepareSQLStatement(conn, sql);	111	stmt = prepareSQLStatement(conn, sql);
113	execHelper.executeSQLStatement(stmt, sql);	112	executeSQLStatement(stmt, sql);
114		113
115	if (dv.getUpdateCount() != -1) {	114	if (dataView.getUpdateCount() != -1) {
116	if (!conn.getAutoCommit()) {	115	if (!conn.getAutoCommit()) {
117	conn.commit();	116	conn.commit();
118	}	117	}
119	return;	118	return;
120	}	119	}
121		120
122	ResultSet resultSet = null;	121	ResultSet rs = null;
123	try {	122	if(dataView.hasResultSet()) {
124	resultSet = stmt.getResultSet();	123	rs = stmt.getResultSet();
125	if (resultSet == null) {	124	}
126	if (!conn.getAutoCommit()) {	125
127	conn.commit();	126	if (rs == null) {
128	}	127	if (!conn.getAutoCommit()) {
129	return;	128	conn.commit();
130	}	129	}
131	Collection<DBTable> tables = dbMeta.generateDBTables(resultSet, sql, isSelect);	130	return;
132	DataViewDBTable dvTable = new DataViewDBTable(tables);
133	dv.setDataViewDBTable(dvTable);
134	execHelper.loadDataFrom(resultSet);
135	} finally {
136	DataViewUtils.closeResources(resultSet);
137	}	131	}
138	execHelper.getTotalCount(isSelect, sql, stmt);	132	Collection<DBTable> tables = dbMeta.generateDBTables(rs, sql, isSelect);
		133	DataViewDBTable dvTable = new DataViewDBTable(tables);
		134	dataView.setDataViewDBTable(dvTable);
		135	loadDataFrom(rs);
		136	DataViewUtils.closeResources(rs);
		137	getTotalCount(isSelect, sql, stmt);
139	} finally {	138	} finally {
140	DataViewUtils.closeResources(stmt);	139	DataViewUtils.closeResources(stmt);
141	}	140	}
Lines 413-419 Link Here
413	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_executequery");	412	String title = NbBundle.getMessage(SQLExecutionHelper.class, "LBL_sql_executequery");
414	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, dataView.getSQLString()) {	413	SQLStatementExecutor executor = new SQLStatementExecutor(dataView, title, dataView.getSQLString()) {
415		414
416	private ResultSet rs = null;
417	private Statement stmt = null;	415	private Statement stmt = null;
418	boolean lastEditState = dataView.isEditable();	416	boolean lastEditState = dataView.isEditable();
419		417
Lines 428-435 Link Here
428	try {	426	try {
429	executeSQLStatement(stmt, sql);	427	executeSQLStatement(stmt, sql);
430	if (dataView.hasResultSet()) {	428	if (dataView.hasResultSet()) {
431	rs = stmt.getResultSet();	429	ResultSet rs = stmt.getResultSet();
432	loadDataFrom(rs);	430	loadDataFrom(rs);
		431	DataViewUtils.closeResources(rs);
433	} else {	432	} else {
434	return;	433	return;
435	}	434	}
Lines 443-451 Link Here
443	dataView.removeComponents();	442	dataView.removeComponents();
444	}	443	}
445	throw sqlEx;	444	throw sqlEx;
446
447	} finally {
448	DataViewUtils.closeResources(rs);
449	}	445	}
450		446
451	// Get total row count	447	// Get total row count
Lines 603-610 Link Here
603	try {	599	try {
604	isResultSet = stmt.execute(appendLimitIfRequired(sql));	600	isResultSet = stmt.execute(appendLimitIfRequired(sql));
605	} catch (NullPointerException ex) {	601	} catch (NullPointerException ex) {
606	LOGGER.log(Level.SEVERE, "Failed to execute SQL Statement [" + sql + "], cause: " + ex);	602	LOGGER.log(Level.SEVERE, "Failed to execute SQL Statement [" + sql + "], cause: " + ex);
607	throw new SQLException(ex);	603	throw new SQLException(ex);
608	} catch (SQLException sqlExc) {	604	} catch (SQLException sqlExc) {
609	if (sqlExc.getErrorCode() == 1064 && sqlExc.getSQLState().equals("37000")) {	605	if (sqlExc.getErrorCode() == 1064 && sqlExc.getSQLState().equals("37000")) {
610	isResultSet = stmt.execute(sql);	606	isResultSet = stmt.execute(sql);

Lines 39-41 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/table/Bundle.properties (+9 lines)
39	# Portions Copyrighted 2008 Sun Microsystems, Inc.	39	# Portions Copyrighted 2008 Sun Microsystems, Inc.
40		40
41	ResultSetJXTable.columnControl.tooltip=Select/deselect columns	41	ResultSetJXTable.columnControl.tooltip=Select/deselect columns
		42
		43	nullLob.title=Set to NULL
		44	saveLob.title=Save to file
		45	loadLob.title=Set from file
		46	loadLob.sourceNotReadable=Source file can't be read.\nCheck file/directory permissions.
		47	saveLob.unknownFormat=Unknown Format for Lob-Handling
		48	saveLob.targetNotWriteable=Target file can't be written.\nCheck file/directory permissions.
		49	saveLob.failure=Failure while saving file: {0}
		50	saveLob.dbError=DB-Failure: {0}

Lines 39-74 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/table/ResultSetTableCellEditor.java (-1 / +388 lines)
39	*	39	*
40	* Portions Copyrighted 2009-2010 Sun Microsystems, Inc.	40	* Portions Copyrighted 2009-2010 Sun Microsystems, Inc.
41	*/	41	*/
42
43	package org.netbeans.modules.db.dataview.table;	42	package org.netbeans.modules.db.dataview.table;
44		43
45	import java.awt.BorderLayout;	44	import java.awt.BorderLayout;
46	import java.awt.Component;	45	import java.awt.Component;
47	import java.awt.Dimension;	46	import java.awt.Dimension;
		47	import java.awt.Font;
48	import java.awt.Insets;	48	import java.awt.Insets;
49	import java.awt.event.ActionEvent;	49	import java.awt.event.ActionEvent;
50	import java.awt.event.ActionListener;	50	import java.awt.event.ActionListener;
51	import java.awt.event.KeyEvent;	51	import java.awt.event.KeyEvent;
52	import java.awt.event.KeyListener;	52	import java.awt.event.KeyListener;
53	import java.awt.event.MouseEvent;	53	import java.awt.event.MouseEvent;
		54	import java.io.File;
		55	import java.io.FileInputStream;
		56	import java.io.FileOutputStream;
		57	import java.io.IOException;
		58	import java.io.InputStream;
		59	import java.io.InputStreamReader;
		60	import java.io.OutputStreamWriter;
		61	import java.io.Reader;
		62	import java.io.Writer;
		63	import java.nio.charset.Charset;
		64	import java.sql.Blob;
		65	import java.sql.Clob;
		66	import java.sql.SQLException;
54	import java.sql.Timestamp;	67	import java.sql.Timestamp;
55	import java.text.DateFormat;	68	import java.text.DateFormat;
56	import java.text.ParseException;	69	import java.text.ParseException;
57	import java.text.SimpleDateFormat;	70	import java.text.SimpleDateFormat;
		71	import java.util.ArrayList;
		72	import java.util.Collections;
		73	import java.util.Comparator;
58	import java.util.EventObject;	74	import java.util.EventObject;
		75	import java.util.List;
59	import javax.swing.AbstractCellEditor;	76	import javax.swing.AbstractCellEditor;
60	import javax.swing.Action;	77	import javax.swing.Action;
61	import javax.swing.ActionMap;	78	import javax.swing.ActionMap;
62	import javax.swing.BorderFactory;	79	import javax.swing.BorderFactory;
63	import javax.swing.DefaultCellEditor;	80	import javax.swing.DefaultCellEditor;
		81	import javax.swing.DefaultComboBoxModel;
64	import javax.swing.InputMap;	82	import javax.swing.InputMap;
		83	import javax.swing.JButton;
		84	import javax.swing.JComboBox;
65	import javax.swing.JComponent;	85	import javax.swing.JComponent;
		86	import javax.swing.JFileChooser;
		87	import javax.swing.JMenuItem;
66	import javax.swing.JOptionPane;	88	import javax.swing.JOptionPane;
		89	import javax.swing.JPanel;
		90	import javax.swing.JPopupMenu;
67	import javax.swing.JScrollPane;	91	import javax.swing.JScrollPane;
68	import javax.swing.JTable;	92	import javax.swing.JTable;
69	import javax.swing.JTextArea;	93	import javax.swing.JTextArea;
70	import javax.swing.JTextField;	94	import javax.swing.JTextField;
71	import javax.swing.KeyStroke;	95	import javax.swing.KeyStroke;
		96	import javax.swing.SwingConstants;
72	import javax.swing.SwingUtilities;	97	import javax.swing.SwingUtilities;
73	import javax.swing.UIManager;	98	import javax.swing.UIManager;
74	import javax.swing.table.TableCellEditor;	99	import javax.swing.table.TableCellEditor;
Lines 77-87 Link Here
77	import org.jdesktop.swingx.JXPanel;	102	import org.jdesktop.swingx.JXPanel;
78	import org.jdesktop.swingx.renderer.JRendererCheckBox;	103	import org.jdesktop.swingx.renderer.JRendererCheckBox;
79	import org.netbeans.modules.db.dataview.meta.DBColumn;	104	import org.netbeans.modules.db.dataview.meta.DBColumn;
		105	import org.netbeans.modules.db.dataview.util.FileBackedBlob;
		106	import org.netbeans.modules.db.dataview.util.FileBackedClob;
80	import org.netbeans.modules.db.dataview.util.DBReadWriteHelper;	107	import org.netbeans.modules.db.dataview.util.DBReadWriteHelper;
81	import org.netbeans.modules.db.dataview.util.DataViewUtils;	108	import org.netbeans.modules.db.dataview.util.DataViewUtils;
82	import org.netbeans.modules.db.dataview.util.JXDateTimePicker;	109	import org.netbeans.modules.db.dataview.util.JXDateTimePicker;
83	import org.netbeans.modules.db.dataview.util.TimestampType;	110	import org.netbeans.modules.db.dataview.util.TimestampType;
84	import org.openide.awt.StatusDisplayer;	111	import org.openide.awt.StatusDisplayer;
		112	import org.openide.util.Exceptions;
		113	import org.openide.util.NbBundle;
85	import org.openide.windows.WindowManager;	114	import org.openide.windows.WindowManager;
86		115
87	/**	116	/**
Lines 486-489 Link Here
486	}	515	}
487	}	516	}
488		517
		518	class BlobFieldTableCellEditor extends AbstractCellEditor
		519	implements TableCellEditor,
		520	ActionListener {
489		521
		522	protected static final String EDIT = "edit";
		523	protected Blob currentValue;
		524	protected JButton button;
		525	protected JPopupMenu popup;
		526	protected JTable table;
		527
		528	public BlobFieldTableCellEditor() {
		529	button = new JButton();
		530	button.setActionCommand(EDIT);
		531	button.addActionListener(this);
		532	button.setContentAreaFilled(false);
		533	button.setOpaque(false);
		534	button.setBorderPainted(false);
		535	button.setRolloverEnabled(false);
		536	button.setAlignmentX(0);
		537	button.setHorizontalAlignment(SwingConstants.LEFT);
		538	button.setFont(new Font(button.getFont().getFamily(), Font.ITALIC, 9));
		539
		540	popup = new JPopupMenu();
		541	final JMenuItem miLobSaveAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "saveLob.title"));
		542	miLobSaveAction.addActionListener(new ActionListener() {
		543
		544	@Override
		545	public void actionPerformed(ActionEvent e) {
		546	saveLobToFile(currentValue);
		547	fireEditingCanceled();
		548	}
		549	});
		550	popup.add(miLobSaveAction);
		551	final JMenuItem miLobLoadAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "loadLob.title"));
		552	miLobLoadAction.addActionListener(new ActionListener() {
		553
		554	@Override
		555	public void actionPerformed(ActionEvent e) {
		556	Object newValue = loadLobFromFile();
		557	if (newValue != null) {
		558	currentValue = (Blob) newValue;
		559	}
		560	fireEditingStopped();
		561	}
		562	});
		563	popup.add(miLobLoadAction);
		564	final JMenuItem miLobNullAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "nullLob.title"));
		565	miLobNullAction.addActionListener(new ActionListener() {
		566
		567	@Override
		568	public void actionPerformed(ActionEvent e) {
		569	currentValue = null;
		570	fireEditingStopped();
		571	}
		572	});
		573	popup.add(miLobNullAction);
		574
		575	}
		576
		577	public void actionPerformed(ActionEvent e) {
		578	if (EDIT.equals(e.getActionCommand())) {
		579	popup.show(button, 0, button.getHeight());
		580	}
		581	}
		582
		583	@Override
		584	public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
		585	currentValue = (java.sql.Blob) value;
586	if (currentValue != null) {
587	try {
588	long size = currentValue.length();
589	StringBuilder stringValue = new StringBuilder();
590	stringValue.append("<BLOB ");
591	if (size < 1000) {
592	stringValue.append(String.format("%1$d bytes", size));
593	} else if (size < 1000000) {
594	stringValue.append(String.format("%1$d kB", size / 1000));
595	} else {
596	stringValue.append(String.format("%1$d MB", size / 1000000));
597	}
598	stringValue.append(">");
599	button.setText(stringValue.toString());
600	} catch (SQLException ex) {
601	button.setText("<BLOB of unknown size>");
602	}
603	} else {
604	button.setText("<NULL>");
605	}
606	this.table = table;
607	return button;
608	}
609
610	@Override
611	public Object getCellEditorValue() {
612	return currentValue;
613	}
614
615	@Override
616	public boolean isCellEditable(EventObject anEvent) {
617	if (anEvent instanceof MouseEvent) {
618	return ((MouseEvent) anEvent).getClickCount() >= 2;
619	}
620	return super.isCellEditable(anEvent);
621	}
622
623	private void saveLobToFile(Blob b) {
624	JFileChooser c = new JFileChooser();
625	int fileDialogState = c.showSaveDialog(table);
626	if (fileDialogState == JFileChooser.APPROVE_OPTION) {
627	File f = c.getSelectedFile();
628	InputStream is = null;
629	FileOutputStream fos = null;
630	try {
631	is = b.getBinaryStream();
632	fos = new FileOutputStream(f);
633	int read = 0;
634	byte[] buffer = new byte[1024];
635	while((read = is.read(buffer)) > 0) {
636	fos.write(buffer, 0, read);
637	}
638	} catch (IOException ex) {
639	throw new RuntimeException(ex);
640	} catch (SQLException ex) {
641	throw new RuntimeException(ex);
642	} finally {
643	try {
644	if(fos != null) fos.close();
645	} catch (IOException ex) {
646	Exceptions.printStackTrace(ex);
647	}
648	try {
649	if(is != null) is.close();
650	} catch (IOException ex) {
651	Exceptions.printStackTrace(ex);
652	}
653	}
654	}
655	}
656
657	private Blob loadLobFromFile() {
658	JFileChooser c = new JFileChooser();
659	Blob result = null;
660	int fileDialogState = c.showOpenDialog(table);
661	if (fileDialogState == JFileChooser.APPROVE_OPTION) {
662	File f = c.getSelectedFile();
663	FileInputStream fis = null;
664	try {
665	fis = new FileInputStream(f);
666	result = new FileBackedBlob(fis);
667	} catch (IOException ex) {
668	throw new RuntimeException(ex);
669	} catch (SQLException ex) {
670	throw new RuntimeException(ex);
671	} finally {
672	try {
673	if(fis != null) fis.close();
674	} catch (IOException ex) {
675	Exceptions.printStackTrace(ex);
676	}
677	}
678	}
679	return result;
680	}
681	}
682
683	class ClobFieldTableCellEditor extends AbstractCellEditor
684	implements TableCellEditor,
685	ActionListener {
686
687	private class CharsetSelector extends JPanel {
688	private JComboBox charsetSelect;
689
690	CharsetSelector() {
691	List<Charset> charset = new ArrayList<Charset>(Charset.availableCharsets().values());
692	Collections.sort(charset, new Comparator<Charset>() {
693	@Override
694	public int compare(Charset o1, Charset o2) {
695	return o1.displayName().compareTo(o2.displayName());
696	}
697	});
698	charsetSelect = new JComboBox();
699	charsetSelect.setModel(new DefaultComboBoxModel(charset.toArray()));
700	charsetSelect.setSelectedItem(Charset.defaultCharset());
701	this.add(charsetSelect);
702	}
703
704	public Charset getSelectedCharset() {
705	return (Charset) charsetSelect.getSelectedItem();
706	}
707
708	public void setSelectedCharset(Charset selectedCharset) {
709	charsetSelect.setSelectedItem(selectedCharset);
710	}
711	}
712
713	protected static final String EDIT = "edit";
714	protected Clob currentValue;
715	protected JButton button;
716	protected JPopupMenu popup;
717	protected JTable table;
718
719	public ClobFieldTableCellEditor() {
720	button = new JButton();
721	button.setActionCommand(EDIT);
722	button.addActionListener(this);
723	button.setContentAreaFilled(false);
724	button.setOpaque(false);
725	button.setBorderPainted(false);
726	button.setRolloverEnabled(false);
727	button.setAlignmentX(0);
728	button.setHorizontalAlignment(SwingConstants.LEFT);
729	button.setFont(new Font(button.getFont().getFamily(), Font.ITALIC, 9));
730
731	popup = new JPopupMenu();
732	final JMenuItem miLobSaveAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "saveLob.title"));
733	miLobSaveAction.addActionListener(new ActionListener() {
734
735	@Override
736	public void actionPerformed(ActionEvent e) {
737	saveLobToFile(currentValue);
738	fireEditingCanceled();
739	}
740	});
741	popup.add(miLobSaveAction);
742	final JMenuItem miLobLoadAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "loadLob.title"));
743	miLobLoadAction.addActionListener(new ActionListener() {
744
745	@Override
746	public void actionPerformed(ActionEvent e) {
747	Object newValue = loadLobFromFile();
748	if (newValue != null) {
749	currentValue = (Clob) newValue;
750	}
751	fireEditingStopped();
752	}
753	});
754	popup.add(miLobLoadAction);
755	final JMenuItem miLobNullAction = new JMenuItem(NbBundle.getMessage(BlobFieldTableCellEditor.class, "nullLob.title"));
756	miLobNullAction.addActionListener(new ActionListener() {
757
758	@Override
759	public void actionPerformed(ActionEvent e) {
760	currentValue = null;
761	fireEditingStopped();
762	}
763	});
764	popup.add(miLobNullAction);
765
766	}
767
768	public void actionPerformed(ActionEvent e) {
769	if (EDIT.equals(e.getActionCommand())) {
770	popup.show(button, 0, button.getHeight());
771	}
772	}
773
774	@Override
775	public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
776	currentValue = (java.sql.Clob) value;
777	if (currentValue != null) {
778	try {
779	long size = currentValue.length();
780	StringBuilder stringValue = new StringBuilder();
781	stringValue.append("<CLOB ");
782	if (size < 1000) {
783	stringValue.append(String.format("%1$d Chars", size));
784	} else if (size < 1000000) {
785	stringValue.append(String.format("%1$d kChars", size / 1000));
786	} else {
787	stringValue.append(String.format("%1$d MChars", size / 1000000));
788	}
789	stringValue.append(">");
790	button.setText(stringValue.toString());
791	} catch (SQLException ex) {
792	button.setText("<CLOB of unknown size>");
793	}
794	} else {
795	button.setText("<NULL>");
796	}
797	this.table = table;
798	return button;
799	}
800
801	@Override
802	public Object getCellEditorValue() {
803	return currentValue;
804	}
805
806	@Override
807	public boolean isCellEditable(EventObject anEvent) {
808	if (anEvent instanceof MouseEvent) {
809	return ((MouseEvent) anEvent).getClickCount() >= 2;
810	}
811	return super.isCellEditable(anEvent);
812	}
813
814	private void saveLobToFile(Clob b) {
815	CharsetSelector charset = new CharsetSelector();
816	JFileChooser c = new JFileChooser();
817	c.setAccessory(charset);
818	int fileDialogState = c.showSaveDialog(table);
819	if (fileDialogState == JFileChooser.APPROVE_OPTION) {
820	File f = c.getSelectedFile();
821	Reader r = null;
822	Writer w = null;
823	try {
824	r = b.getCharacterStream();
825	w = new OutputStreamWriter(new FileOutputStream(f), charset.getSelectedCharset());
826	int read = 0;
827	char[] buffer = new char[1024];
828	while((read = r.read(buffer)) > 0) {
829	w.write(buffer, 0, read);
830	}
831	} catch (IOException ex) {
832	throw new RuntimeException(ex);
833	} catch (SQLException ex) {
834	throw new RuntimeException(ex);
835	} finally {
836	try {
837	if(w != null) w.close();
838	} catch (IOException ex) {
839	Exceptions.printStackTrace(ex);
840	}
841	try {
842	if(r != null) r.close();
843	} catch (IOException ex) {
844	Exceptions.printStackTrace(ex);
845	}
846	}
847	}
848	}
849
850	private Clob loadLobFromFile() {
851	CharsetSelector charset = new CharsetSelector();
852	JFileChooser c = new JFileChooser();
853	c.setAccessory(charset);
854	Clob result = null;
855	int fileDialogState = c.showOpenDialog(table);
856	if (fileDialogState == JFileChooser.APPROVE_OPTION) {
857	File f = c.getSelectedFile();
858	Reader r = null;
859	try {
860	r = new InputStreamReader(new FileInputStream(f), charset.getSelectedCharset());
861	result = new FileBackedClob(r);
862	} catch (IOException ex) {
863	throw new RuntimeException(ex);
864	} catch (SQLException ex) {
865	throw new RuntimeException(ex);
866	} finally {
867	try {
868	if(r != null) r.close();
869	} catch (IOException ex) {
870	Exceptions.printStackTrace(ex);
871	}
872	}
873	}
874	return result;
875	}
876	}

Line 0 Link Here

(-)a/db.dataview/src/org/netbeans/modules/db/dataview/util/FileBackedBlob.java (+269 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.db.dataview.util;
		43
		44	import java.io.File;
		45	import java.io.FileInputStream;
		46	import java.io.FileNotFoundException;
		47	import java.io.IOException;
		48	import java.io.InputStream;
		49	import java.io.OutputStream;
		50	import java.io.RandomAccessFile;
		51	import java.sql.Blob;
		52	import java.sql.SQLException;
		53	import org.openide.util.Exceptions;
		54
		55	/**
		56	* A storage implementing a _subset_ of the Blob Interface backed by a file
		57	*
		58	* Currently the following function are not implemented:
		59	* - all position functions
		60	* - getBinaryStream(long pos, long length)
		61	*
		62	* @author mblaesing
		63	*/
		64	public class FileBackedBlob implements Blob {
65
66	private boolean freed = false;
67	private File backingFile;
68
69	public FileBackedBlob() throws SQLException {
70	try {
71	backingFile = File.createTempFile("netbeans-db-blob", null);
72	backingFile.deleteOnExit();
73	} catch (IOException ex) {
74	throw new SQLException(ex);
75	}
76	}
77
78	public FileBackedBlob(InputStream is) throws SQLException {
79	this();
80	OutputStream os = null;
81	try {
82	os = setBinaryStream(1);
83	int read = 0;
84	byte[] buffer = new byte[(int) Math.pow(2, 18)];
85	while ((read = is.read(buffer)) > 0) {
86	os.write(buffer, 0, read);
87	}
88	} catch (IOException ex) {
89	throw new SQLException(ex);
90	} finally {
91	try {
92	if(os != null) os.close();
93	} catch (IOException ex) {
94	Exceptions.printStackTrace(ex);
95	}
96	try {
97	if(is != null) is.close();
98	} catch (IOException ex) {
99	Exceptions.printStackTrace(ex);
100	}
101	}
102	}
103
104	@Override
105	public long length() throws SQLException {
106	checkFreed();
107	return backingFile.length();
108	}
109
110	@Override
111	public byte[] getBytes(long pos, int length) throws SQLException {
112	checkFreed();
113	checkPos(pos);
114	checkLength(length);
115	InputStream is = null;
116	try {
117	is = new FileInputStream(backingFile);
118	is.skip(pos - 1);
119	byte[] result = new byte[length];
120	is.read(result);
121	return result;
122	} catch (IOException ex) {
123	throw new SQLException(ex);
124	} finally {
125	try {
126	is.close();
127	} catch (IOException ex) {
128	Exceptions.printStackTrace(ex);
129	}
130	}
131	}
132
133	@Override
134	public InputStream getBinaryStream() throws SQLException {
135	checkFreed();
136	try {
137	return new FileInputStream(backingFile);
138	} catch (FileNotFoundException ex) {
139	throw new SQLException(ex);
140	}
141	}
142
143	@Override
144	public long position(byte[] pattern, long start) throws SQLException {
145	checkFreed();
146	checkPos(start);
147	throw new UnsupportedOperationException("Not supported yet.");
148	}
149
150	@Override
151	public long position(Blob pattern, long start) throws SQLException {
152	checkFreed();
153	checkPos(start);
154	throw new UnsupportedOperationException("Not supported yet.");
155	}
156
157	@Override
158	public int setBytes(long pos, byte[] bytes) throws SQLException {
159	checkFreed();
160	checkPos(pos);
161	return setBytes(pos, bytes, 0, bytes.length);
162	}
163
164	@Override
165	public int setBytes(long pos, byte[] bytes, int offset, int len) throws SQLException {
166	checkFreed();
167	checkPos(pos);
168	RandomAccessFile raf = null;
169	try {
170	raf = new RandomAccessFile(backingFile, "rw");
171	raf.seek(pos - 1);
172	int border = Math.min(bytes.length, offset + len);
173	int written = 0;
174	for (int i = offset; i < border; i++) {
175	raf.write(bytes[i]);
176	written++;
177	}
178	return written;
179	} catch (IOException ex) {
180	throw new SQLException(ex);
181	} finally {
182	try {
183	raf.close();
184	} catch (IOException ex) {
185	Exceptions.printStackTrace(ex);
186	}
187	}
188
189	}
190
191	@Override
192	public OutputStream setBinaryStream(long pos) throws SQLException {
193	checkFreed();
194	checkPos(pos);
195
196	try {
197	final RandomAccessFile raf = new RandomAccessFile(backingFile, "rw");
198	try {
199	raf.seek(pos - 1);
200	} catch (IOException ex) {
201	raf.close();
202	throw new SQLException(ex);
203	}
204
205	return new RandomAccessOutputStream(raf);
206	} catch (IOException ex) {
207	throw new SQLException(ex);
208	}
209	}
210
211	@Override
212	public void truncate(long len) throws SQLException {
213	checkFreed();
214	RandomAccessFile raf = null;
215	try {
216	raf = new RandomAccessFile(backingFile, "rw");
217	raf.setLength(len);
218	} catch (IOException ex) {
219	throw new SQLException(ex);
220	} finally {
221	try {
222	raf.close();
223	} catch (IOException ex) {
224	Exceptions.printStackTrace(ex);
225	}
226	}
227	}
228
229	@Override
230	public void free() throws SQLException {
231	if (!freed) {
232	backingFile.delete();
233	freed = true;
234	}
235	}
236
237	@Override
238	public InputStream getBinaryStream(long pos, long length) throws SQLException {
239	checkFreed();
240	throw new UnsupportedOperationException("Not supported yet.");
241	}
242
243	private void checkFreed() throws SQLException {
244	if (freed) {
245	throw new SQLException("Blob already freed");
246	}
247	}
248
249	private void checkPos(long pos) throws SQLException {
250	if (pos < 1) {
251	throw new SQLException("Illegal Value for position: " + Long.toString(pos));
252	}
253	}
254
255	private void checkLength(long length) throws SQLException {
256	if (length < 0) {
257	throw new SQLException("Illegal Value for length: " + Long.toString(length));
258	}
259	}
260
261	protected void finalize() throws Throwable {
262	free();
263	super.finalize();
264	}
265
266	File getBackingFile() {
267	return backingFile;
268	}
269	}