Using JDBC

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;

public class ConnectToDatabase
{
    public static void main(String[] args)
    {
        Connection conn = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
        }
        catch(ClassNotFoundException ex)
        {
            // The Class.forName() failed to find the class
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            // The getConnection() failed
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
}

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class ConnectToDatabase
{
    public static void main(String[] args)
    {
        Connection conn = null;
        Statement stmt = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
            stmt = conn.createStatement();
            stmt.executeUpdate("CREATE TABLE address " +
                               "(" +
                               "Street     char(50)," +
                               "Town       char(40)," +
                               "State      char(2)," +
                               "PostalCode char(9)" +
                               ")" );
        }
        catch(ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    if (stmt != null)
                        stmt.close();
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
}

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class ConnectToDatabase
{
    public static void main(String[] args)
    {
        Connection conn = null;
        Statement stmt = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
            stmt = conn.createStatement();
            
            int totalCount = 0;
            int count = 0;
            count = addAddress(stmt, 
                            "27 Bellvue Ave", "Carson City", "NV", "94567");
            totalCount += count;
            count = addAddress(stmt, 
                            "9000 Spontadema St", "Jersey City", "NJ", "34267");
            totalCount += count;
            count = addAddress(stmt, 
                            "756 Fickle Circle", "Sun City", "IA", "87345");
            totalCount += count;
            System.out.println(totalCount + " addresses added.");
        }
        catch(ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    if (stmt != null)
                        stmt.close();
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
    
    private static int addAddress(Statement stmt, 
                                  String street, String town, 
                                  String state, String postalCode)
        throws SQLException
    {
        String st = (street != null) ? ("'" + street + "'") : ("NULL");
        String tw = (town != null) ? ("'" + town + "'") : ("NULL");
        String sta = (state != null) ? ("'" + state + "'") : ("NULL");
        String code = (postalCode != null) ? ("'" + postalCode + "'") : ("NULL");
        
        String sql =
            "INSERT INTO address " +
            "VALUES(" + st + ", " + tw + ", " + sta + ", " + code + ")";
        System.out.println("Executing statement:\n" + sql);
        
        int count = stmt.executeUpdate(sql);
        return count;
    }
}

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class ConnectToDatabase
{
    public static void main(String[] args)
    {
        Connection conn = null;
        Statement stmt = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
            stmt = conn.createStatement();
            
            int totalCount = stmt.executeUpdate("DELETE FROM address");
            System.out.println(totalCount + " addresses deleted.");
        }
        catch(ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    if (stmt != null)
                        stmt.close();
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
}

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class ConnectToDatabase
{
    public static void main(String[] args)
    {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
            stmt = conn.createStatement();
            rs = stmt.executeQuery(
                        "SELECT street, town, state, postalCode " +
                        "FROM address " +
                        "ORDER BY state");
            int count = 0;
            while (rs.next())
            {
                String street = rs.getString(1);
                String town   = rs.getString(2);
                String state  = rs.getString(3);
                String postalCode = rs.getString(4);
                System.out.println("[" + ++count + "]");
                System.out.println(" Street: [" + street + "]");
                System.out.println(" Town:   [" + town + "]");
                System.out.println(" State:  [" + state + "]");
                System.out.println(" Postal Code: [" + postalCode + "]");
            }
        }
        catch(ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    if (stmt != null)
                    {
                        if (rs != null)
                            rs.close();
                        stmt.close();
                    }
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
}

package jdbc;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import java.sql.SQLException;
import java.util.Properties;

public class CreateDatabase
{
    /**
     *  Main entry point
     *  @param args command line arguments:
     *  <br>
     *  The name of a file containing the names of tables
     *  to be created, one table name per line.
     *  Each table name must have an associated <tablename>.dat
     *  file to define the fields and data for the table.
     */
    public static void main(String[] args)
    {
        Connection con = null;
        Statement stmt = null;
        try
        {
            con = getConnection();
            stmt = con.createStatement();
            
            String tableList = "";
            if (args.length > 0)
                tableList = args[0];
            else
            {
                System.out.println(
                       "Usage: CreateDatabase <table-list-file>");
                System.exit(0);
            }
            
            // Create the tables listed in the tableList file
            createTables(tableList, stmt);
        }
        catch (SQLException ex)
        {
            dumpSQLException(ex);
        }
        catch (IOException ex)
        {
            dumpIOException(ex);
        }
        finally
        {
            try
            {
                if (stmt != null)
                    stmt.close();
                if (con != null)
                    con.close();
            }
            catch (SQLException ex)
            {   /* Do nothing */ }
        }
    }
    
    /**
     *  Gets a connection to the appropriate database, based
     *  on the contents of a properties file.
     */
    public static Connection getConnection()
        throws SQLException, IOException
    {
        Properties props = new Properties();
        File propsFile = new File("jdbc", "CreateDatabase.properties");
        props.load( new FileInputStream(propsFile) );
        
        String drivers = props.getProperty("jdbc.drivers");
        if (drivers != null)
        {
            // Set the System property "jdbc.drivers"
            System.getProperties().put("jdbc.drivers", drivers);
        }
        String url = props.getProperty("jdbc.url");
        String username = props.getProperty("jdbc.username");
        String password = props.getProperty("jdbc.password");
        
        return DriverManager.getConnection(url, username, password);
    }
    
    /**
     *  Creates the tables listed in the tableList file.
     *  @param tableList the filename containing the table list
     *  @param stmt the Statement to use
     */
    public static void createTables(String tableList,
                                    Statement stmt)
        throws IOException                                   
    {
        BufferedReader in = null;
        try
        {
            in = new BufferedReader(
                       new FileReader(
                            new File("jdbc", tableList) ) );

            // Each line contains the name of a table to create
            String tableName = null;
            while (true)
            {
                tableName = in.readLine();
                if (tableName == null)
                    break;
                tableName = tableName.trim();
                try
                {
                    createTable(tableName, stmt);
                    showTable(tableName, stmt);
                }
                catch (Exception ex)
                {
                    ex.printStackTrace();
                    // Ignore any exceptions, so we can continue
                    // on to the next table
                }
            }
        }
        finally
        {
            if (in != null)
                in.close();
        }
    }
    
    /**
     *  Creates the specified table.
     *  @param tableName the name of the table to create.
     *  (There must be a file with the name tableName.dat
     *  that supplies information about the columns and data.)
     *  @param stmt the Statement to use.
     */
    public static void createTable(String tableName,
                                   Statement stmt)
        throws SQLException, IOException
    {
        BufferedReader in = null;
        try
        {
            in = new BufferedReader(
                       new FileReader(
                            new File("jdbc", tableName + ".dat") ) );

            // First, drop the table in case it already exists
            String command = "DROP TABLE " + tableName;
            System.out.println(
                 "Attempting to drop table " + tableName + "...");
            try
            {
                stmt.executeUpdate(command);
            }
            catch (SQLException ex)
            {
                // Ignore; presumably the table doesn't exist
            }
            
            String line = in.readLine();
            
            command = "CREATE TABLE " + tableName +
                            "(" + line + ")";
        
            System.out.println("Creating table " + tableName + "...");
            System.out.println("Statement:\n" + command);
            
            stmt.executeUpdate(command);
            
            System.out.println("Populating table " + tableName + "...");
            while ( (line = in.readLine()) != null)
            {
                command = "INSERT INTO " + tableName +
                          " VALUES(" + line + ")";
                stmt.executeUpdate(command);
            }
        }
        catch (SQLException ex)
        {
            dumpSQLException(ex);
        }
            
        finally
        {
            if (in != null)
                in.close();
        }
    }
    
    /**
     *  Displays the contents of the table.
     *  @param tableName the name of the table
     *  @param stmt the Statement to use
     */
    public static void showTable(String tableName, 
                                 Statement stmt)
        throws SQLException
    {
        String query = "SELECT * FROM " + tableName;
        ResultSet rs = null;
        try
        {
            rs = stmt.executeQuery(query);
            ResultSetMetaData rsmd = rs.getMetaData();
            int columnCount = rsmd.getColumnCount();
            while (rs.next())
            {
                for (int i = 1; i <= columnCount; i++)
                {
                    if (i > 1)
                        System.out.print(", ");
                    System.out.print(rs.getString(i));
                }
                System.out.println();
            }
        }
        finally
        {
            if (rs != null)
                rs.close();
        }
    }

    private static void dumpSQLException(SQLException ex)
    {
        System.out.println("SQLException:");
        while (ex != null)
        {
            System.out.println("SQLState: " + ex.getSQLState());
            System.out.println("Message:  " + ex.getMessage());
            System.out.println("Vendor:   " + ex.getErrorCode());
            ex = ex.getNextException();
            System.out.println();
        }
    }
    
    private static void dumpIOException(IOException ex)
    {
        System.out.println("IOException: " + ex);
        ex.printStackTrace();
    }
}

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.PreparedStatement;

public class PreparedStatementUse
{
    public static void main(String[] args)
    {
        Connection conn = null;
        PreparedStatement stmt = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
            stmt = conn.prepareStatement(
                        "SELECT name, salary " +
                        "FROM employees " +
                        "WHERE salary > ? " +
                        "ORDER BY salary");

            listEmployees(stmt, 80000.00);
            listEmployees(stmt, 200000.00);
        }
        catch(ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    if (stmt != null)
                    {
                        stmt.close();
                    }
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }

    private static void listEmployees(PreparedStatement stmt, 
                                      double minSalary)
        throws SQLException
    {
        System.out.println(
            "==List of employees with salary > " + minSalary + "==");
        
        ResultSet rs = null;
        try
        {
            stmt.setDouble(1, minSalary);
            rs = stmt.executeQuery();
            
            int count = 0;
            while (rs.next())
            {
                String name = rs.getString(1);
                double salary = rs.getDouble(2);
                System.out.print(" Name:  " + name);
                System.out.println(", Salary: $" + salary);
            }
        }
        finally
        {
            if (rs != null)
            {
                try
                {
                    rs.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
}

package jdbc;

import java.util.Enumeration;
import java.util.Properties;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;

/**
*   Class to list the loaded JDBC drivers, together with their properties.
*
*   @author Bryan J. Higgs, 4 March 2000
*/
public class ListDrivers
{
    public static void main(String[] args)
    {
        try
        {
            // Cause the JDBC drivers to be automatically loaded
            System.getProperties().put("jdbc.drivers",
                                       "sun.jdbc.odbc.JdbcOdbcDriver:" +
                                       "ORG.as220.tinySQL.textFileDriver:" +
                                       "org.gjt.mm.mysql.Driver");
            // List details of the loaded drivers
            listDrivers();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
    private static void listDrivers()
        throws SQLException
    {
        Enumeration drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements())
        {
            Driver driver = (Driver) drivers.nextElement();
            // Display information about the driver
            print("Driver: " + driver.getClass().getName());
            print("  Major version: " + driver.getMajorVersion());
            print("  Minor version: " + driver.getMinorVersion());
            print("  JDBC compliant: " + driver.jdbcCompliant());
            // List details of the driver properties
            listDriverProperties(driver);
        }
    }
    
    private static void listDriverProperties(Driver driver)
        throws SQLException
    {
        DriverPropertyInfo props[] = driver.getPropertyInfo(
					"", new Properties());
        if (props != null && props.length > 0)
        {
            print("  Properties: ");
            // Display each property name and value
            for (int i = 0; i < props.length; i++)
            {
                print("    Name: " + props[i].name);
                print("      Description: " + props[i].description);
                print("      Value: " + props[i].value);
                if (props[i].choices != null)
                {
                    print("      Choices: ");
                    for (int choice = 0; 
                         choice < props[i].choices.length; 
                         choice++)
                    {
                        print("        " + props[i].choices[choice]);
                    }
                }
                print("      Required: " + props[i].required);
            }
        }
}
    
    private static void print(String text)
    {
        System.out.println(text);
    }
}

package jdbc;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

public class GetResultSetMetaData
{
    public static void main(String[] args)
    {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try
        {
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            conn = DriverManager.getConnection("jdbc:odbc:Employees");
            stmt = conn.createStatement();
            rs = stmt.executeQuery(
              "SELECT employees.name, NULL, departments.name, age, salary " + 
              "FROM employees, departments " +
              "WHERE employees.department = departmentID");
                        
            printResultSetMetaData(rs);
            
        }
        catch(ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
        catch(SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (conn != null)
            {
                try
                {
                    if (stmt != null)
                    {
                        if (rs != null)
                            rs.close();
                        stmt.close();
                    }
                    conn.close();
                }
                catch(SQLException ex)
                { /* Do nothing */ }
            }
        }
    }
    
    private static void printResultSetMetaData(ResultSet rs)
        throws SQLException
    {
        ResultSetMetaData rsmd = rs.getMetaData();
        int count = rsmd.getColumnCount();
        System.out.println("ResultSet has " + count + " columns:");
        for (int i = 1; i <= count; i++)
        {
            println("[" + i + "]");
            println(" Name:      " + rsmd.getColumnName(i));
            println(" Label:     " + rsmd.getColumnLabel(i));
            println(" Catalog:   " + rsmd.getCatalogName(i));
            println(" Schema:    " + rsmd.getSchemaName(i));
            println(" Table:     " + rsmd.getTableName(i));
            println(" Type:      " + rsmd.getColumnTypeName(i));
            println(" Display size: " + rsmd.getColumnDisplaySize(i));
            println(" Precision:    " + rsmd.getPrecision(i));
            println(" Scale:        " + rsmd.getScale(i));
            println(" CaseSensitive:" + rsmd.isCaseSensitive(i));
            println(" Currency:     " + rsmd.isCurrency(i));
            println(" Nullable:     " + rsmd.isNullable(i));
            // etc...
        }
    }
    
    private static void println(String text)
    {
        System.out.println(text);
    }
}

package jdbc;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.Label;
import java.awt.Panel;
import java.awt.Rectangle;
import java.awt.TextField;
import java.awt.Toolkit;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import java.sql.SQLException;
import java.sql.SQLWarning;

import java.util.Vector;

import messageBox.MessageBox;

/**
 *  Class to view the tables in a database, and their data.
 *
 *  @author Bryan J. Higgs, 4 March 2000
 */
public class ViewTables extends Frame
{
    public static void main(String[] args)
    {
        Frame f = new ViewTables();
        // Center frame on screen
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Dimension screen = toolkit.getScreenSize();
        Dimension frame = f.getSize();
        f.setLocation( (screen.width - frame.width)/2, 
                       (screen.height - frame.height)/2);
        // Make it visible
        f.setVisible(true);
    }

    /**
     *  Constructs an instance of ViewTables.
     */
    public ViewTables()
    {
        super("View Tables");
        setSize(300, 200);
        addWindowListener(new WindowAdapter()
            {
                public void windowClosing(WindowEvent ev)
                {
                    dispose();
                    System.exit(0);
                }
            }
        );
        
        // Do layout...
        
        // Top panel goes to the North
        Panel top = new Panel( new BorderLayout() );
        top.setBackground(Color.lightGray);
        // Contains a label...
        Label tableLabel = new Label("Table:", Label.RIGHT);
        top.add(tableLabel, BorderLayout.WEST);
        // ...and a Choice
        Choice tableNames = new Choice();
        tableNames.addItemListener(new ItemListener()
            {
                public void itemStateChanged(ItemEvent ev)
                {
                    if (ev.getStateChange() == ItemEvent.SELECTED)
                    {
                        // We have selected a table name, so figure
                        // out what columns we have and lay them out.
                        loadColumnDisplay((String)ev.getItem());
                    }
                }
            }
        );
        top.add(tableNames, BorderLayout.CENTER);
        add(top, BorderLayout.NORTH);
        
        // Data panel goes in the Center
        m_dataPanel = new Panel();
        // Initially contains a helpful label
        m_dataPanel.add( new Label("Select a table to display data.") );
        add(m_dataPanel, BorderLayout.CENTER);
        
        // Bottom panel goes to the South
        Panel bottom = new Panel();
        // Contains just a button
        m_nextButton = new Button("Next >");
        m_nextButton.setEnabled(false);
        m_nextButton.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent ev)
                {
                    // Cause the current data to be displayed
                    // and the next row to be read.
                    displayRow();
                }
            }
        );
        bottom.add(m_nextButton);
        add(bottom, BorderLayout.SOUTH);
        
        // Load the table names into the choice box.
        loadTableNames(tableNames);
    }
    
    /**
     *  Gets a connection to the specified database, 
     *  using the specified driver.
     */
    private static Connection getConnection()
        throws SQLException, ClassNotFoundException
    {
        Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
        Connection con = DriverManager.getConnection(
				"jdbc:odbc:Employees");
        SQLWarning warn = con.getWarnings();
        if (warn != null)
            printSQLWarnings(warn);
        return con;
    }
    
    /**
     *  Loads the specified choice box with the names of all the tables.
     */
    private void loadTableNames(Choice tableNames)
    {
        // Make the connection, then discover all the tables
        // and load their names into the table names choice box.
        ResultSet metaRs = null;
        try
        {
            m_con = getConnection();
            m_stmt = m_con.createStatement();
            // Obtain the metadata for the tables
            DatabaseMetaData dbMd = m_con.getMetaData();
            metaRs = dbMd.getTables(null, // Catalog name
                                    null, // Schema name
                                    null, // Table name
                                    new String [] { "TABLE", "VIEW" }
                                          // Types
                                   );
            SQLWarning warn = metaRs.getWarnings();
            if (warn != null)
                printSQLWarnings(warn);
            while (metaRs.next())
            {
                tableNames.addItem(metaRs.getString(3));
            }
        }
        catch(SQLException ex)
        {
            printSQLExceptions(ex);
            MessageBox.show(this, ex.toString());
        }
        catch(ClassNotFoundException ex)
        {
            MessageBox.show(this, ex.toString());
        }
        finally
        {
            try
            {
                if (metaRs != null)
                    metaRs.close();
            }
            catch (SQLException ex)
            {   /* Do nothing */ }
        }
    }
    
    /**
     *  Adds the specified component to the specified container,
     *  using the specified GridBagConstraints, grid position, 
     *  width & height.
     */
    private void addComponent(
                    Container container, Component component,
                    GridBagConstraints gbc,
                    int x, int y, int width, int height)
    {
        gbc.gridx = x;
        gbc.gridy = y;
        gbc.gridwidth = width;
        gbc.gridheight = height;
        container.add(component, gbc);
    }
    
    /**
     *  Loads the information about the table columns, and
     *  sets up the GUI layout to accommodate the data for a row.
     */
    private void loadColumnDisplay(String tableName)
    {
        // Remove the existing data panel
        remove(m_dataPanel);
        // and replace it with a new one
        m_dataPanel = new Panel()
        {
            public Insets getInsets()
            {
                return new Insets(5, 5, 5, 5);
            }
        };
        m_dataPanel.setLayout( new GridBagLayout() );
        // Remove all the column textfields from the Vector
        m_fields.removeAllElements();
        // Now, execute a SELECT * FROM table query against this 
        // table and then use the ResultSet meta data to find 
        // column information.
        // Then dynamically lay out the data panel.
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.weighty = 100;
        try
        {
            if (m_rs != null)
                m_rs.close();
            m_rs = m_stmt.executeQuery("SELECT * from " + tableName);
            SQLWarning warn = m_rs.getWarnings();
            if (warn != null)
                printSQLWarnings(warn);
            ResultSetMetaData rsmd = m_rs.getMetaData();
            for (int col = 1; col <= rsmd.getColumnCount(); col++)
            {
                String columnName = rsmd.getColumnLabel(col);
                int columnWidth = rsmd.getColumnDisplaySize(col);
                TextField colField = new TextField(columnWidth);
                // Keep track of the TextFields in a Vector
                m_fields.addElement(colField);
                // Add a label for the column, containing the column name
                gbc.weightx = 0;
                gbc.anchor = GridBagConstraints.EAST;
                gbc.fill = GridBagConstraints.NONE;
                addComponent(m_dataPanel, new Label(columnName + ":"), 
                             gbc, 0, col-1, 1, 1);
                // Add a text field for the data in the column
                gbc.weightx = 100;
                gbc.anchor = GridBagConstraints.WEST;
                gbc.fill = GridBagConstraints.HORIZONTAL;
                addComponent(m_dataPanel, colField,
                             gbc, 1, col-1, 1, 1);
            }
            
        }
        catch(Exception ex)
        {
            MessageBox.show(this, ex.toString());
        }
        // Add the new data panel in place of the old one.
        add(m_dataPanel, BorderLayout.CENTER);
        // Force a layout and sizing.
        pack();
        
        // Enable Next button so user can navigate rows
        m_nextButton.setEnabled(true);
        
        // Read first row
        readRow();
        
        // Display row results
        displayRow();
    }
    
    /**
     *  Reads the next row for the table.
     *  When it comes to the end of the rows, closes the ResultSet
     *  and disables the Next button so we can't go any further.
     */
    private void readRow()
    {
        if (m_rs != null)
        {
            try
            {
                if (!m_rs.next())   // Move to next row
                {
                    m_rs.close();   // We're done
                    m_rs = null;
                    
                    // Disable the Next button
                    m_nextButton.setEnabled(false);
                }
            }
            catch (Exception ex)
            {
                MessageBox.show(this, ex.toString());
            }
        }
    }
    
    /**
     *  Displays the current row contents in the GUI text fields.
     *  Then reads the next row, so we're ready for it, and so we
     *  can disable the Next button properly, if there is no next row.
     */
    private void displayRow()
    {
        try
        {
            for (int col = 1; col <= m_fields.size(); col++)
            {
                String colValue = m_rs.getString(col);
                TextField colField = (TextField) m_fields.elementAt(col-1);
                colField.setText(colValue);
            }
        }
        catch (Exception ex)
        {
            MessageBox.show(this, ex.toString());
        }
        
        // Read next row
        readRow();
    }
    
    /**
     *  Prints out a SQLException and its related SQLExceptions
     */
    private static void printSQLExceptions(SQLException ex)
    {
        System.err.println("\n--- SQLException caught ---\n");
        for ( ;ex != null; ex = ex.getNextException())
        {
            System.err.println("Message:   " + ex.getMessage());
            System.err.println("SQLState:  " + ex.getSQLState());
            System.err.println("ErrorCode: " + ex.getErrorCode());
            ex.printStackTrace(System.err);
            System.err.println();
        }
    }
    
    /**
     *  Prints out a SQLWarning and its related SQLWarnings
     */
    private static void printSQLWarnings(SQLWarning warn)
    {
        System.err.println("\n--- SQLWarning ---\n");
        for ( ;warn != null; warn = warn.getNextWarning())
        {
            System.err.println("Message:   " + warn.getMessage());
            System.err.println("SQLState:  " + warn.getSQLState());
            System.err.println("ErrorCode: " + warn.getErrorCode());
            warn.printStackTrace(System.err);
            System.err.println();
        }
    }
    
    ///// Private data /////
    private Button     m_nextButton;    // Next button
    private Panel      m_dataPanel;     // Panel for column data display
    private Vector     m_fields = new Vector();
                                        // Holds column TextFields
    
    private Connection          m_con;  // Connection to use
    private Statement           m_stmt; // Statement to use
    private ResultSet           m_rs;   // ResultSet used to read rows
}

package messageBox;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Panel;
import java.awt.Rectangle;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 *  Shows a message box with the specified text.
 *  @author Bryan J. Higgs, 4 March 2000
 */
public class MessageBox extends Dialog
{
    /**
     *  Shows a message box with the specified message text
     *  with the specified parent Frame.
     */
    public static void show(Frame frame, String msg)
    {
        MessageBox box = new MessageBox(frame, msg);
        box.setVisible(true);
    }
        
    /**
     *  Constructs a MessageBox instance.
     *  (Private, so the only way of using a MessageBox is
     *  via the show() method.)
     */
    private MessageBox(Frame frame, String msg)
    {
        super(frame, "Message");
        addWindowListener
        (
            new WindowAdapter()
            {
                public void windowClosing(WindowEvent ev)
                {
                    closeWindow();
                }
            }
        );
        Panel message = new MessagePanel(msg);
        add(message, BorderLayout.CENTER);
        Panel p = new Panel();
        Button ok = new Button("OK");
        p.add(ok);
        add(p, BorderLayout.SOUTH);
        ok.addActionListener
        (
            new ActionListener()
            {
                public void actionPerformed(ActionEvent ev)
                {
                    closeWindow();
                }
            }
        );
        pack();
        
        // Ensure that the message box displays close to
        // its parent frame.
        Rectangle frameRect = frame.getBounds();
        Rectangle boxRect = getBounds();
        boxRect.x = frameRect.x + 10;
        boxRect.y = frameRect.y + 10;
        setBounds(boxRect.x, boxRect.y, boxRect.width, boxRect.height);
    }
        
    /**
     *  Closes the MessageBox window.
     */
    private void closeWindow()
    {
        setVisible(false);
        dispose();        
    }
    
    /**
     *  Main entry point, for testing.
     */
    public static void main(String[] args)
    {
        Frame frame = new Frame("Testing MessageBox");
        frame.setBounds(100, 100, 300, 200);
        frame.addWindowListener
        (
            new WindowAdapter()
            {
                public void windowClosing(WindowEvent ev)
                {
                    System.exit(0);
                }
            }
        );
        frame.setVisible(true);
        show(frame, "Hello\nHow\nAre\nYou");
    }
    
    ///// Inner classes /////
    
    /**
     *  A Message Panel, to display a message in the MessageBox.
     */
    class MessagePanel extends Panel
    {
        MessagePanel(String msg)
        {
            m_msg = new TextArea(msg, 4, 30, 
                                 TextArea.SCROLLBARS_NONE);
            m_msg.setEditable(false);
            setLayout( new BorderLayout() );
            add(m_msg, BorderLayout.CENTER);
        }
        
        public Insets getInsets()
        {
            return new Insets(10, 10, 10, 10);
        }
        
        //// Private Data ////
        private TextArea  m_msg;
        private Dimension m_dim = null;
    }
}