Attachment #63586 for bug #128546

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




    <!-- ACTUAL CHANGES BEGIN HERE: -->

    <changes>
        <change>
            <api name="database_explorer_api"/>
            <summary>Add ability to connect a database connection directly with no UI</summary>
            <version major="1" minor="26"/>
            <date day="26" month="6" year="2008"/>
            <author login="davidvc"/>
            <compatibility addition="yes"/>
            <description>
                Add the ability to connect a database connection directly from the API
                without having any kind of UI pop up, be it a dialog or a progress window.
            </description>
            <issue number="128546"/>
        </change>
        <change>
            <api name="database_explorer_api"/>
            <summary>Add ability to remove a database connection</summary>

Lines 325-330 Link Here

(-)a/db/arch.xml (+4 lines)
325	<a href="@TOP@org/netbeans/api/db/explorer/DatabaseConnection.html#getJDBCConnection()">getJDBCConnection()</a>	325	<a href="@TOP@org/netbeans/api/db/explorer/DatabaseConnection.html#getJDBCConnection()">getJDBCConnection()</a>
326	method.	326	method.
327	</p>	327	</p>
		328	<p>
		329	If you want to connect to the database without showing a dialog or any kind of UI, you can us the
		330	<a href="@TOP@org/netbeans/api/db/explorer/ConnectionManager.html#connect(org.netbeans.api.db.explorer.DatabaseConnection)">DatabaseConnectoin.connect()</a>
		331	method.
328	</usecase>	332	</usecase>
329	<usecase id="connections-combo-box" name="Displaying the database connections in the UI">	333	<usecase id="connections-combo-box" name="Displaying the database connections in the UI">
330	<p>	334	<p>

Lines 1-7 Link Here

(-)a/db/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.db/1	2	OpenIDE-Module: org.netbeans.modules.db/1
3	OpenIDE-Module-Install: org/netbeans/modules/db/DatabaseModule.class	3	OpenIDE-Module-Install: org/netbeans/modules/db/DatabaseModule.class
4	OpenIDE-Module-Implementation-Version: 5	4	OpenIDE-Module-Implementation-Version: 26
5	OpenIDE-Module-Layer: org/netbeans/modules/db/resources/mf-layer.xml	5	OpenIDE-Module-Layer: org/netbeans/modules/db/resources/mf-layer.xml
6	OpenIDE-Module-Requires: org.netbeans.api.javahelp.Help	6	OpenIDE-Module-Requires: org.netbeans.api.javahelp.Help
7	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/db/resources/Bundle.properties	7	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/db/resources/Bundle.properties




        }
        ((RootNodeInfo)RootNode.getInstance().getInfo()).addConnectionNoConnect(dbconn.getDelegate());
    }
     /**
     * Connects this connection to the database <b>without opening any
     * dialog</b>.  If not all the necessary parameters are set, this
     * method will throw an exception (versus prompting the user for input>
     * <p>
     * This method is called synchronously, and will throw an exception
     * if called on the AWT event thread
     */
    public void connect(DatabaseConnection dbconn) throws DatabaseException {
        if (dbconn == null) {
            throw new NullPointerException();
        }
        if (!ConnectionList.getDefault().contains(dbconn.getDelegate())) {
            throw new IllegalStateException("This connection is not added to the ConnectionManager."); // NOI18N
        }
        dbconn.getDelegate().connectSync();
    }

    /**
    
    /**
     * Remove an existing connection from the Database Explorer.  This method 




package org.netbeans.modules.db.explorer;

import java.awt.Component;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;
import java.io.ObjectStreamException;
import java.sql.Connection;

import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.modules.db.explorer.actions.ConnectAction;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.Mutex;

import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.Task ;

import org.netbeans.lib.ddl.DBConnection;
import org.netbeans.lib.ddl.DDLException;

import org.netbeans.api.db.explorer.JDBCDriverManager;

import org.netbeans.modules.db.ExceptionListener;
import org.netbeans.modules.db.explorer.actions.ConnectAction;
import org.netbeans.modules.db.explorer.infos.ConnectionNodeInfo;
import org.netbeans.modules.db.explorer.infos.DatabaseNodeInfo;
import org.netbeans.modules.db.explorer.infos.RootNodeInfo;
import org.netbeans.modules.db.explorer.nodes.DatabaseNode;
import org.netbeans.modules.db.explorer.nodes.RootNode;

import org.netbeans.modules.db.runtime.DatabaseRuntimeManager;
import org.netbeans.spi.db.explorer.DatabaseRuntime;
import org.openide.explorer.ExplorerManager;

import org.openide.nodes.NodeNotFoundException;
import org.openide.nodes.NodeOp;
import org.openide.util.Exceptions;
import org.openide.util.Mutex;
import org.openide.util.RequestProcessor;
import org.openide.windows.TopComponent;



/**

 * open connection.
 */
public class DatabaseConnection implements DBConnection {

    private static final Logger LOGGER = Logger.getLogger(DatabaseConnection.class.getName());
    private static final boolean LOG = LOGGER.isLoggable(Level.FINE);



    /** Connection name */
    private String name;

    /**
     * The API DatabaseConnection (delegates to this instance)
     */

                    openConnectionServices = null;
                }
            }
        });
    }

    /** Default constructor */

        dbconn = DatabaseConnectionAccessor.DEFAULT.createDatabaseConnection(this);
        propertySupport = new PropertyChangeSupport(this);
    }

    /** Advanced constructor
     * Allows to specify all needed information.
     * @param driver Driver URL

    public DatabaseConnection(String driver, String database, String user, String password) {
        this(driver, null, database, null, user, password, false);
    }

    public DatabaseConnection(String driver, String driverName, String database,
            String theschema, String user, String password) {
        this(driver, driverName, database, theschema, user, password, false);
    }

    public DatabaseConnection(String driver, String driverName, String database,
            String theschema, String user, String password,
            boolean rememberPassword) {
        this();

        name = getName();
        rpwd = Boolean.valueOf(rememberPassword);
    }

    public JDBCDriver findJDBCDriver() {
        JDBCDriver[] drvs = JDBCDriverManager.getDefault().getDrivers(drv);
        if (drvs.length <= 0) {

     private OpenConnectionInterface getOpenConnection() {
         if (openConnection != null)
             return openConnection;

         openConnection = new OpenConnection();
         String driver = getDriver();
         if (driver == null) {
             return openConnection;
         }

         // For Java Studio Enterprise. Create instanceof OpenConnection
         try {
             Collection c = getOpenConnections();

         }
         return openConnection;
     }

    /** Returns driver class */
    public String getDriver() {
        return drv;

        if (LOG) {
            LOGGER.log(Level.FINE, "createJDBCConnection()");
        }

        if (drv == null || db == null || usr == null )
            throw new DDLException(NbBundle.getBundle("org.netbeans.modules.db.resources.Bundle").getString("EXC_InsufficientConnInfo"));


            // For Java Studio Enterprise.
            getOpenConnection().enable();
            startRuntimes();

            // hack for Derby
            DerbyConectionEventListener.getDefault().beforeConnect(this);

            JDBCDriver useDriver = findJDBCDriver();
            if (useDriver == null) {
                // will be loaded through DriverManager, make sure it is loaded


            Connection connection = DbDriverManager.getDefault().getConnection(db, dbprops, useDriver);
            setConnection(connection);

            DatabaseUILogger.logConnection(drv);

            propertySupport.firePropertyChange("connected", null, null);

            // For Java Studio Enterprise.
            getOpenConnection().disable();


            //                    message = MessageFormat.format(bundle.getString("EXC_PointbaseServerRejected"), new String[] {message, db}); // NOI18N

            propertySupport.firePropertyChange("failed", null, null);

            // For Java Studio Enterprise.
            getOpenConnection().disable();


        }
    }

    public void connectSync() throws DatabaseException {
        try {
            doConnect();

            // Let the CNI know we're connected and set things up
            // appropriately
            ConnectionNodeInfo cni = findConnectionNodeInfo(getName());
            cni.connect(this);
        } catch (Exception exc) {
            try {
                getConnection().close();
            } catch (SQLException e) {
                LOGGER.log(Level.FINE, null, e);
            }
            throw new DatabaseException(exc);
        }
    }

    private void doConnect() throws DDLException {
        if (drv == null || db == null || usr == null )
            sendException(new DDLException(NbBundle.getBundle("org.netbeans.modules.db.resources.Bundle").getString("EXC_InsufficientConnInfo")));

        Properties dbprops = new Properties();
        if ( usr.length() > 0 ) {
            dbprops.put("user", usr); //NOI18N
        }
        if ((pwd != null && pwd.length() > 0)) {
            dbprops.put("password", pwd); //NOI18N
        }

        Connection conn = null;
        try {
            propertySupport.firePropertyChange("connecting", null, null);

            // For Java Studio Enterprise.
            getOpenConnection().enable();

            startRuntimes();

            // hack for Derby
            DerbyConectionEventListener.getDefault().beforeConnect(DatabaseConnection.this);

            JDBCDriver useDriver = findJDBCDriver();
            if (useDriver == null) {
                // will be loaded through DriverManager, make sure it is loaded
                Class.forName(drv);
            }

            conn = DbDriverManager.getDefault().getConnection(db, dbprops, useDriver);
            setConnection(conn);

            DatabaseUILogger.logConnection(drv);

            propertySupport.firePropertyChange("connected", null, null);
        } catch (Exception e) {
            String message = MessageFormat.format(
                    NbBundle.getBundle("org.netbeans.modules.db.resources.Bundle").getString("EXC_CannotEstablishConnection"),
                    db, drv, e.getMessage()); // NOI18N

            propertySupport.firePropertyChange("failed", null, null);

            if (e instanceof SQLException) {
                initSQLException((SQLException)e);
            }

            DDLException ddle = new DDLException(message);
            ddle.initCause(e);

            if (conn != null) {
                setConnection(null);
                try {
                    conn.close();
                } catch (SQLException sqle) {
                    Logger.getLogger("global").log(Level.WARNING, null, sqle); // NOI18N
                }
            }

            throw ddle;
        } finally {
            getOpenConnection().disable();
        }
    }

    public void connectAsync() {
        if (LOG) {
            LOGGER.log(Level.FINE, "connect()");
        }
        
        createConnectTask() ;
    }

        RequestProcessor.getDefault().post(new Runnable() {
        return RequestProcessor.getDefault().post(new Runnable() {
            public void run() {
                if (drv == null || db == null || usr == null )
                    sendException(new DDLException(NbBundle.getBundle("org.netbeans.modules.db.resources.Bundle").getString("EXC_InsufficientConnInfo")));

                Properties dbprops = new Properties();
                if ( usr.length() > 0 ) {
                    dbprops.put("user", usr); //NOI18N
                }
                if ((pwd != null && pwd.length() > 0)) {
                    dbprops.put("password", pwd); //NOI18N
                }
                
                Connection conn = null;
                try {
                    doConnect();
                } catch (Exception e) {
                    sendException(e);
                    getOpenConnection().enable();

                    // For Java Studio Enterprise.
                    getOpenConnection().enable();
                    startRuntimes();
                    
                    // hack for Derby
                    DerbyConectionEventListener.getDefault().beforeConnect(DatabaseConnection.this);
                    
                    JDBCDriver useDriver = findJDBCDriver();
                    if (useDriver == null) {
                        // will be loaded through DriverManager, make sure it is loaded
                        Class.forName(drv);
                    }
                    
                    conn = DbDriverManager.getDefault().getConnection(db, dbprops, useDriver);
                    setConnection(conn);
                    
                    DatabaseUILogger.logConnection(drv);
                        
                    propertySupport.firePropertyChange("connected", null, null);

                    // For Java Studio Enterprise.
                    getOpenConnection().disable();

                } catch (SQLException e) {
                    String message = MessageFormat.format(NbBundle.getBundle("org.netbeans.modules.db.resources.Bundle").getString("EXC_CannotEstablishConnection"), new String[] {db, drv, e.getMessage()}); // NOI18N

                    //commented out for 3.6 release, need to solve for next Studio release
                    // hack for Pointbase Network Server
                    //                    if (drv.equals(PointbasePlus.DRIVER))
                    //                        if (e.getErrorCode() == PointbasePlus.ERR_SERVER_REJECTED)
                    //                            message = MessageFormat.format(bundle.getString("EXC_PointbaseServerRejected"), new String[] {message, db}); // NOI18N

                    propertySupport.firePropertyChange("failed", null, null);

                    // For Java Studio Enterprise.
                    getOpenConnection().disable();

                    initSQLException(e);
                    DDLException ddle = new DDLException(message);
                    ddle.initCause(e);
                    sendException(ddle);
                    
                    if (conn != null) {
                        setConnection(null);
                        try {
                            conn.close();
                        } catch (SQLException sqle) {
                            Logger.getLogger("global").log(Level.WARNING, null, sqle); // NOI18N
                        }
                    }
                } catch (Exception exc) {
                    propertySupport.firePropertyChange("failed", null, null);

                    // For Java Studio Enterprise.
                    getOpenConnection().disable();

                    sendException(exc);
                    
                    setConnection(null);
                    if (conn != null) {
                        try {
                            conn.close();
                        } catch (SQLException sqle) {
                            Logger.getLogger("global").log(Level.WARNING, null, sqle); // NOI18N
                        }
                    }
                }
            }
        }, 0);
    }

    /** Calls the initCause() for SQLException with the value
      * of getNextException() so this exception's stack trace contains
      * the complete data.
      */
    private void initSQLException(SQLException e) {


    private void startRuntimes() {
        DatabaseRuntime[] runtimes = DatabaseRuntimeManager.getDefault().getRuntimes(drv);

        for (int i = 0; i < runtimes.length; i++) {
            DatabaseRuntime runtime = runtimes[i];
            if (runtime.isRunning()) {

        } catch (Exception exc) {
            //IGNORE - not stored in 3.6 and earlier
        }

        // boston setting/pilsen setting?
        if ((name != null) && (name.equals(DatabaseConnection.SUPPORT))) {
            // pilsen

        }
        name = null;
        name = getName();

        dbconn = DatabaseConnectionAccessor.DEFAULT.createDatabaseConnection(this);
    }


        out.writeObject(db);
        out.writeObject(usr);
        out.writeObject(schema);
        out.writeObject(DatabaseConnection.SUPPORT);
        out.writeObject(drvname);
    }

    public String toString() {
        return "Driver:" + getDriver() + "Database:" + getDatabase().toLowerCase() + "User:" + getUser().toLowerCase() + "Schema:" + getSchema().toLowerCase(); // NOI18N
    }

    /**
     * Gets the API DatabaseConnection which corresponds to this connection.
     */
    public org.netbeans.api.db.explorer.DatabaseConnection getDatabaseConnection() {
        return dbconn;
    }

    public void selectInExplorer() {
        String nodeName = null;
        try {

            Exceptions.printStackTrace(e);
            return;
        }

        // find the Runtime panel top component
        // quite hacky, but it will be replaced by the Server Navigator

        TopComponent runtimePanel = null;
        ExplorerManager runtimeExplorer = null;
        Node runtimeNode = null;

        for (Iterator i = TopComponent.getRegistry().getOpened().iterator(); i.hasNext();) {
            TopComponent component = (TopComponent)i.next();
            Component[] children = component.getComponents();

                }
            }
        }

        if (runtimePanel == null) {
            return;
        }

        Node node = null;
        try {
            node = NodeOp.findPath(runtimeNode, new String[] { "Databases", nodeName }); // NOI18N

            Exceptions.printStackTrace(e);
            return;
        }

        try {
            runtimeExplorer.setSelectedNodes(new Node[] { node });
        } catch (PropertyVetoException e) {
            Exceptions.printStackTrace(e);
            return;
        }

        runtimePanel.requestActive();
    }

    public void showConnectionDialog() {
        try {
            final ConnectionNodeInfo cni = findConnectionNodeInfo(getName());

            Exceptions.printStackTrace(e);
        }
    }

    public Connection getJDBCConnection() {
        try {
            ConnectionNodeInfo cni = findConnectionNodeInfo(getName());

        }
        return null;
    }

    public void disconnect() throws DatabaseException {
        ConnectionNodeInfo cni = findConnectionNodeInfo(getName());
        if (cni != null && cni.getConnection() != null) {
            cni.disconnect();
        }
    }

    private ConnectionNodeInfo findConnectionNodeInfo(String connection) throws DatabaseException {
        assert connection != null;

        // We can't use the info classes here since surprisingly
        // the CNIs found in RootNode.getInstance().getInfo are different than
        // the ones the ConnectionNodes in the Databases tree listen to.

        // This will account for the "Please wait" node.
        Node[] nodes = RootNode.getInstance().getChildren().getNodes(true);

        for (int i = 0; i < nodes.length; i++) {
            // Skip nodes registered by node providers
            if ( ! (nodes[i] instanceof DatabaseNode) ) {
                continue;
            }

            DatabaseNodeInfo info = (DatabaseNodeInfo)nodes[i].getCookie(DatabaseNodeInfo.class);
            if (info == null) {
                continue;

        }
        return null;
    }

    private Object readResolve() throws ObjectStreamException {
        // sometimes deserialized objects have a null propertySuppport, not sure why
        if (propertySupport == null) {





                            try {
                                if (dbcon.getConnection() == null || dbcon.getConnection().isClosed())
                                    dbcon.connectAsync();
                                else {
                                    dbcon.setSchema(schemaPanel.getSchema());
                                    nfo.setSchema(schemaPanel.getSchema());

                                }
                            } catch (SQLException exc) {
                                //isClosed() method failed, try to connect
                                dbcon.connectAsync();
                            }
                            return;
                        }

                    failed = false;
                    
                    dbcon.addPropertyChangeListener(connectionListener);
                    dbcon.connectAsync();
                    
                    progress.start();
                    progress.switchToIndeterminate();

Lines 280-286 Link Here

(-)a/db/src/org/netbeans/modules/db/explorer/actions/ConnectUsingDriverAction.java (-2 / +2 lines)
280	basePanel.setConnectionInfo();	280	basePanel.setConnectionInfo();
281	try {	281	try {
282	if (cinfo.getConnection() == null \|\| cinfo.getConnection().isClosed())	282	if (cinfo.getConnection() == null \|\| cinfo.getConnection().isClosed())
283	cinfo.connect();	283	cinfo.connectAsync();
284	else {	284	else {
285	cinfo.setSchema(schemaPanel.getSchema());	285	cinfo.setSchema(schemaPanel.getSchema());
286	((RootNodeInfo)RootNode.getInstance().getInfo()).addConnection(cinfo);	286	((RootNodeInfo)RootNode.getInstance().getInfo()).addConnection(cinfo);
Lines 289-295 Link Here
289	}	289	}
290	} catch (SQLException exc) {	290	} catch (SQLException exc) {
291	//isClosed() method failed, try to connect	291	//isClosed() method failed, try to connect
292	cinfo.connect();	292	cinfo.connectAsync();
293	} catch (DatabaseException exc) {	293	} catch (DatabaseException exc) {
294	Logger.getLogger("global").log(Level.INFO, null, exc);	294	Logger.getLogger("global").log(Level.INFO, null, exc);
295	DbUtilities.reportError(bundle().getString("ERR_UnableToAddConnection"), exc.getMessage()); // NOI18N	295	DbUtilities.reportError(bundle().getString("ERR_UnableToAddConnection"), exc.getMessage()); // NOI18N

Lines 214-220 Link Here

(-)a/db/src/org/netbeans/modules/db/explorer/dlg/SchemaPanel.java (-2 / +2 lines)
214	Connection con = dbcon.getConnection();	214	Connection con = dbcon.getConnection();
215	try {	215	try {
216	if (con == null \|\| con.isClosed())	216	if (con == null \|\| con.isClosed())
217	dbcon.connect();	217	dbcon.connectAsync();
218	else {	218	else {
219	RequestProcessor.getDefault().post(new Runnable() {	219	RequestProcessor.getDefault().post(new Runnable() {
220	public void run() {	220	public void run() {
Lines 226-232 Link Here
226	}	226	}
227	} catch (SQLException exc) {	227	} catch (SQLException exc) {
228	//isClosed() method failed, try to connect	228	//isClosed() method failed, try to connect
229	dbcon.connect();	229	dbcon.connectAsync();
230	}	230	}
231	}//GEN-LAST:event_schemaButtonActionPerformed	231	}//GEN-LAST:event_schemaButtonActionPerformed
232		232





package org.netbeans.api.db.explorer;

import java.net.URL;
import org.netbeans.modules.db.test.TestBase;
import org.netbeans.modules.db.test.Util;
import org.netbeans.modules.db.util.DBTestBase;

/**
 *
 * @author Andrei Badea
 */
public class DatabaseConnectionTest extends DBTestBase {
    
    protected void setUp() throws Exception {
        super.setUp();

        assertEquals(dbconn, ConnectionManager.getDefault().getConnections()[0]);
    }

    public void testSyncConnection() throws Exception {
        DatabaseConnection dbconn = getDatabaseConnection();
        ConnectionManager.getDefault().connect(dbconn);
        assertTrue(dbconn.getJDBCConnection() != null);
        assertFalse(dbconn.getJDBCConnection().isClosed());
    }

    public void testDeleteConnection() throws Exception {
        Util.deleteConnectionFiles();
        Util.deleteDriverFiles();

Lines 27-34 Link Here

(-)a/db/test/unit/src/org/netbeans/api/db/sql/support/QuoterTest.java (-3 / +2 lines)
27	*/	27	*/
28	package org.netbeans.api.db.sql.support;	28	package org.netbeans.api.db.sql.support;
29		29
30	import org.netbeans.api.db.sql.support.SQLIdentifiers;	30	import org.netbeans.modules.db.util.DDLTestBase;
31	import org.netbeans.modules.db.util.DBTestBase;
32		31
33	/**	32	/**
34	* @author <a href="mailto:david@vancouvering.com">David Van Couvering</a>	33	* @author <a href="mailto:david@vancouvering.com">David Van Couvering</a>
Lines 36-42 Link Here
36	* This class is a set of tests to make sure we're quoting identifiers	35	* This class is a set of tests to make sure we're quoting identifiers
37	* correctly	36	* correctly
38	*/	37	*/
39	public class QuoterTest extends DBTestBase {	38	public class QuoterTest extends DDLTestBase {
40		39
41	private SQLIdentifiers.Quoter quoter;	40	private SQLIdentifiers.Quoter quoter;
42		41





import java.sql.Types;
import java.util.HashSet;
import org.netbeans.modules.db.util.DDLTestBase;

/**
 *
 * @author David
 */
public class AddToIndexDDLTest extends DDLTestBase {

    public AddToIndexDDLTest(String name) {
        super(name);




import org.netbeans.lib.ddl.impl.CreateTable;
import org.netbeans.lib.ddl.impl.TableColumn;
import org.netbeans.modules.db.explorer.infos.DatabaseNodeInfo;
import org.netbeans.modules.db.util.DDLTestBase;
import org.netbeans.modules.db.util.InfoHelper;

/**
 * @author David Van Couvering
 */
public class GrabTableHelperTest extends DDLTestBase {

    public GrabTableHelperTest(String name) {
        super(name);





import java.sql.Types;
import java.util.HashSet;
import org.netbeans.modules.db.util.DDLTestBase;

/**
 *
 * @author David
 */
public class AddIndexDDLTest extends DDLTestBase {

    public AddIndexDDLTest(String name) {
        super(name);




 */
package org.netbeans.modules.db.explorer.dlg;

import org.netbeans.modules.db.util.DDLTestBase;

/**
 *
 * @author David
 */
public class AddTableColumnDDLTest extends DDLTestBase {

    public AddTableColumnDDLTest(String name) {
        super(name);

Lines 27-35 Link Here

(-)a/db/test/unit/src/org/netbeans/modules/db/explorer/dlg/AddViewDDLTest.java (-2 / +2 lines)
27	*/	27	*/
28	package org.netbeans.modules.db.explorer.dlg;	28	package org.netbeans.modules.db.explorer.dlg;
29		29
30	import org.netbeans.modules.db.util.DBTestBase;	30	import org.netbeans.modules.db.util.DDLTestBase;
31		31
32	public class AddViewDDLTest extends DBTestBase {	32	public class AddViewDDLTest extends DDLTestBase {
33		33
34	public AddViewDDLTest(String name) {	34	public AddViewDDLTest(String name) {
35	super(name);	35	super(name);

Lines 28-36 Link Here

(-)a/db/test/unit/src/org/netbeans/modules/db/explorer/dlg/CreateTableDDLTest.java (-2 / +2 lines)
28	package org.netbeans.modules.db.explorer.dlg;	28	package org.netbeans.modules.db.explorer.dlg;
29		29
30	import java.util.Vector;	30	import java.util.Vector;
31	import org.netbeans.modules.db.util.DBTestBase;	31	import org.netbeans.modules.db.util.DDLTestBase;
32		32
33	public class CreateTableDDLTest extends DBTestBase {	33	public class CreateTableDDLTest extends DDLTestBase {
34		34
35	public CreateTableDDLTest(String name) {	35	public CreateTableDDLTest(String name) {
36	super(name);	36	super(name);




package org.netbeans.modules.db.explorer.infos;

import java.sql.Types;
import org.netbeans.modules.db.util.DDLTestBase;
import org.netbeans.modules.db.util.InfoHelper;

/**
 * @author <href="mailto:david@vancouvering.com">David Van Couvering</href>
 */
public class DDLHelperTest extends DDLTestBase {
    InfoHelper helper;

    public DDLHelperTest(String name) {




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

import java.net.URL;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;

import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.Iterator;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.api.db.explorer.ConnectionManager;
import org.netbeans.api.db.explorer.DatabaseConnection;
import org.netbeans.api.db.explorer.JDBCDriver;
import org.netbeans.api.db.explorer.JDBCDriverManager;
import org.netbeans.lib.ddl.impl.DriverSpecification;
import org.netbeans.lib.ddl.impl.Specification;
import org.netbeans.lib.ddl.impl.SpecificationFactory;
import org.netbeans.lib.ddl.impl.TableColumn;
import org.netbeans.modules.db.test.TestBase;

/**

    private static String password;
    private static String dbname;
    protected static String dblocation;
    private static URL driverJarUrl;
    
    private static String DRIVER_PROPERTY = "db.driverclass";
    private static String URL_PROPERTY = "db.url";
    private static String USERNAME_PROPERTY = "db.username";
    private static String PASSWORD_PROPERTY = "db.password";
    private static String DBDIR_PROPERTY = "db.dir";
    private static String DBNAME_PROPERTY = "db.name";

    private static String quoteString = null;
    
    // This defines what happens to identifiers when stored in db

    private static int    unquotedCaseRule = RULE_UNDEFINED;
    private static int    quotedCaseRule = RULE_UNDEFINED;

    private static JDBCDriver jdbcDriver;
    private static DatabaseConnection dbConnection;
    
    protected Connection conn;
    protected Specification spec;
    protected DriverSpecification drvSpec;

    static {
        try {
            specfactory = new SpecificationFactory();

            driverClass = System.getProperty(DRIVER_PROPERTY, 
                    "org.apache.derby.jdbc.EmbeddedDriver");
            dbname = System.getProperty(DBNAME_PROPERTY, "ddltestdb");

                            
            username = System.getProperty(USERNAME_PROPERTY, "testddl");
            password = System.getProperty(PASSWORD_PROPERTY, "testddl");

            driverJarUrl = Class.forName(driverClass).getProtectionDomain().getCodeSource().getLocation();

        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, null, e);
            throw new RuntimeException(e);

        super(name);
    }

    /**
     * Get the DatabaseConnection for the configured Java DB database.  This
     * method will create and register the connection the first time it is called
     */
    protected static DatabaseConnection getDatabaseConnection() throws Exception {
        if (dbConnection == null) {
            JDBCDriver driver = JDBCDriver.create("derbydriver", "derbydriver", driverClass, new URL[] {driverJarUrl});
            JDBCDriverManager.getDefault().addDriver(driver);

            dbConnection = DatabaseConnection.create(driver, dbUrl, username, "APP", password, false);
            ConnectionManager.getDefault().addConnection(dbConnection);
        }

        return dbConnection;
    }

    protected static String getDbUrl() {
        return dbUrl;
    }

    protected static String getDriverClass() {
        return driverClass;
    }

    protected static String getPassword() {
        return password;
    }

    public static String getUsername() {
        return username;
    }

    
    @Override
    protected void setUp() throws Exception {
        try {
            getConnection();
            createSchema();
            setSchema();
            initQuoteString();
            spec = (Specification)specfactory.createSpecification(conn);
            
            drvSpec = specfactory.createDriverSpecification(
                    spec.getMetaData().getDriverName().trim());
            if (spec.getMetaData().getDriverName().trim().equals(
                    "jConnect (TM) for JDBC (TM)")) //NOI18N
                //hack for Sybase ASE - copied from mainline code
                drvSpec.setMetaData(conn.getMetaData());
            else
                drvSpec.setMetaData(spec.getMetaData());
            
            drvSpec.setCatalog(conn.getCatalog());
            drvSpec.setSchema(SCHEMA);
        } catch ( SQLException e ) {
            SQLException original = e;
            while ( e != null ) {

        }
    }
    
    protected void initQuoteString() throws Exception {
        if ( quoteString != null  ) {
            return;
        }

        return numrows;
    }
    
    protected void createBasicTable(String tablename, String pkeyName) 
            throws Exception {
        dropTable(tablename);
        CreateTable cmd = spec.createCommandCreateTable(tablename);
        cmd.setObjectOwner(SCHEMA);
                
        // primary key
        TableColumn col = cmd.createPrimaryKeyColumn(pkeyName);
        col.setColumnType(Types.INTEGER);
        col.setNullAllowed(false);
        
        cmd.execute();
    }
    
    protected void createView(String viewName, String query) throws Exception {
        CreateView cmd = spec.createCommandCreateView(viewName);
        cmd.setQuery(query);
        cmd.setObjectOwner(SCHEMA);
        cmd.execute();
        
        assertFalse(cmd.wasException());        
    }

    protected void createSimpleIndex(String tablename, 
            String indexname, String colname) throws Exception {
        // Need to get identifier into correct case because we are
        // still quoting referred-to identifiers.
        tablename = fixIdentifier(tablename);
        CreateIndex xcmd = spec.createCommandCreateIndex(tablename);
        xcmd.setIndexName(indexname);

        // *not* unique
        xcmd.setIndexType(new String());

        xcmd.setObjectOwner(SCHEMA);
        xcmd.specifyColumn(fixIdentifier(colname));

        xcmd.execute();        
    }
    
    /**
     * Adds a basic column.  Non-unique, allows nulls.
     */
    protected void addBasicColumn(String tablename, String colname,
            int type, int size) throws Exception {
        // Need to get identifier into correct case because we are
        // still quoting referred-to identifiers.
        tablename = fixIdentifier(tablename);
        AddColumn cmd = spec.createCommandAddColumn(tablename);
        cmd.setObjectOwner(SCHEMA);
        TableColumn col = (TableColumn)cmd.createColumn(colname);
        col.setColumnType(type);
        col.setColumnSize(size);
        col.setNullAllowed(true);
        
        cmd.execute();
        if ( cmd.wasException() ) {
            throw new Exception("Unable to add column");
        }
    }
    
    protected void tearDown() throws Exception {
        if ( conn != null ) {
            try {




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
 *
 * 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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun 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 2008 Sun Microsystems, Inc.
 */

package org.netbeans.modules.db.util;

import java.sql.SQLException;
import java.sql.Types;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.lib.ddl.impl.AddColumn;
import org.netbeans.lib.ddl.impl.CreateIndex;
import org.netbeans.lib.ddl.impl.CreateTable;
import org.netbeans.lib.ddl.impl.CreateView;
import org.netbeans.lib.ddl.impl.DriverSpecification;
import org.netbeans.lib.ddl.impl.Specification;
import org.netbeans.lib.ddl.impl.SpecificationFactory;
import org.netbeans.lib.ddl.impl.TableColumn;

/**
 *
 * @author David
 */
public class DDLTestBase extends DBTestBase {
    private static Logger LOGGER = Logger.getLogger(DDLTestBase.class.getName());

    protected static SpecificationFactory specfactory;
    protected Specification spec;
    protected DriverSpecification drvSpec;

    static {
        try {
            specfactory = new SpecificationFactory();
        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, null, e);
            throw new RuntimeException(e);
        }
    }


    public DDLTestBase(String name) {
        super(name);
    }

    protected void setUp() throws Exception {
        super.setUp();

        try {
            spec = (Specification)specfactory.createSpecification(conn);

            drvSpec = specfactory.createDriverSpecification(
                    spec.getMetaData().getDriverName().trim());
            if (spec.getMetaData().getDriverName().trim().equals(
                    "jConnect (TM) for JDBC (TM)")) //NOI18N
                //hack for Sybase ASE - copied from mainline code
                drvSpec.setMetaData(conn.getMetaData());
            else
                drvSpec.setMetaData(spec.getMetaData());

            drvSpec.setCatalog(conn.getCatalog());
            drvSpec.setSchema(SCHEMA);
        } catch ( SQLException e ) {
            SQLException original = e;
            while ( e != null ) {
                LOGGER.log(Level.SEVERE, null, e);
                e = e.getNextException();
            }

            throw original;
        }
    }
    protected void createBasicTable(String tablename, String pkeyName)
            throws Exception {
        dropTable(tablename);
        CreateTable cmd = spec.createCommandCreateTable(tablename);
        cmd.setObjectOwner(SCHEMA);

        // primary key
        TableColumn col = cmd.createPrimaryKeyColumn(pkeyName);
        col.setColumnType(Types.INTEGER);
        col.setNullAllowed(false);

        cmd.execute();
    }

    protected void createView(String viewName, String query) throws Exception {
        CreateView cmd = spec.createCommandCreateView(viewName);
        cmd.setQuery(query);
        cmd.setObjectOwner(SCHEMA);
        cmd.execute();

        assertFalse(cmd.wasException());
    }

    protected void createSimpleIndex(String tablename,
            String indexname, String colname) throws Exception {
        // Need to get identifier into correct case because we are
        // still quoting referred-to identifiers.
        tablename = fixIdentifier(tablename);
        CreateIndex xcmd = spec.createCommandCreateIndex(tablename);
        xcmd.setIndexName(indexname);

        // *not* unique
        xcmd.setIndexType(new String());

        xcmd.setObjectOwner(SCHEMA);
        xcmd.specifyColumn(fixIdentifier(colname));

        xcmd.execute();
    }

    /**
     * Adds a basic column.  Non-unique, allows nulls.
     */
    protected void addBasicColumn(String tablename, String colname,
            int type, int size) throws Exception {
        // Need to get identifier into correct case because we are
        // still quoting referred-to identifiers.
        tablename = fixIdentifier(tablename);
        AddColumn cmd = spec.createCommandAddColumn(tablename);
        cmd.setObjectOwner(SCHEMA);
        TableColumn col = (TableColumn)cmd.createColumn(colname);
        col.setColumnType(type);
        col.setColumnSize(size);
        col.setNullAllowed(true);

        cmd.execute();
        if ( cmd.wasException() ) {
            throw new Exception("Unable to add column");
        }
    }
}

Return to bug 128546

Lines 105-110 Link Here

(-)a/db/apichanges.xml (+13 lines)
105	<!-- ACTUAL CHANGES BEGIN HERE: -->	105	<!-- ACTUAL CHANGES BEGIN HERE: -->
106		106
107	<changes>	107	<changes>
		108	<change>
		109	<api name="database_explorer_api"/>
		110	<summary>Add ability to connect a database connection directly with no UI</summary>
		111	<version major="1" minor="26"/>
		112	<date day="26" month="6" year="2008"/>
		113	<author login="davidvc"/>
		114	<compatibility addition="yes"/>
		115	<description>
		116	Add the ability to connect a database connection directly from the API
		117	without having any kind of UI pop up, be it a dialog or a progress window.
		118	</description>
		119	<issue number="128546"/>
		120	</change>
108	<change>	121	<change>
109	<api name="database_explorer_api"/>	122	<api name="database_explorer_api"/>
110	<summary>Add ability to remove a database connection</summary>	123	<summary>Add ability to remove a database connection</summary>

Lines 138-143 Link Here

(-)a/db/src/org/netbeans/api/db/explorer/ConnectionManager.java (+19 lines)
138	}	138	}
139	((RootNodeInfo)RootNode.getInstance().getInfo()).addConnectionNoConnect(dbconn.getDelegate());	139	((RootNodeInfo)RootNode.getInstance().getInfo()).addConnectionNoConnect(dbconn.getDelegate());
140	}	140	}
		141	/**
		142	* Connects this connection to the database <b>without opening any
		143	* dialog</b>. If not all the necessary parameters are set, this
		144	* method will throw an exception (versus prompting the user for input>
		145	* <p>
		146	* This method is called synchronously, and will throw an exception
		147	* if called on the AWT event thread
		148	*/
		149	public void connect(DatabaseConnection dbconn) throws DatabaseException {
		150	if (dbconn == null) {
		151	throw new NullPointerException();
		152	}
		153	if (!ConnectionList.getDefault().contains(dbconn.getDelegate())) {
		154	throw new IllegalStateException("This connection is not added to the ConnectionManager."); // NOI18N
		155	}
		156	dbconn.getDelegate().connectSync();
		157	}
		158
		159	/**
141		160
142	/**	161	/**
143	* Remove an existing connection from the Database Explorer. This method	162	* Remove an existing connection from the Database Explorer. This method

Lines 268-274 Link Here

(-)a/db/src/org/netbeans/modules/db/explorer/actions/ConnectAction.java (-3 / +3 lines)
268		268
269	try {	269	try {
270	if (dbcon.getConnection() == null \|\| dbcon.getConnection().isClosed())	270	if (dbcon.getConnection() == null \|\| dbcon.getConnection().isClosed())
271	dbcon.connect();	271	dbcon.connectAsync();
272	else {	272	else {
273	dbcon.setSchema(schemaPanel.getSchema());	273	dbcon.setSchema(schemaPanel.getSchema());
274	nfo.setSchema(schemaPanel.getSchema());	274	nfo.setSchema(schemaPanel.getSchema());
Lines 294-300 Link Here
294	}	294	}
295	} catch (SQLException exc) {	295	} catch (SQLException exc) {
296	//isClosed() method failed, try to connect	296	//isClosed() method failed, try to connect
297	dbcon.connect();	297	dbcon.connectAsync();
298	}	298	}
299	return;	299	return;
300	}	300	}
Lines 364-370 Link Here
364	failed = false;	364	failed = false;
365		365
366	dbcon.addPropertyChangeListener(connectionListener);	366	dbcon.addPropertyChangeListener(connectionListener);
367	dbcon.connect();	367	dbcon.connectAsync();
368		368
369	progress.start();	369	progress.start();
370	progress.switchToIndeterminate();	370	progress.switchToIndeterminate();

Lines 41-55 Link Here

(-)a/db/test/unit/src/org/netbeans/api/db/explorer/DatabaseConnectionTest.java (-3 / +9 lines)
41		41
42	package org.netbeans.api.db.explorer;	42	package org.netbeans.api.db.explorer;
43		43
44	import java.net.URL;
45	import org.netbeans.modules.db.test.TestBase;
46	import org.netbeans.modules.db.test.Util;	44	import org.netbeans.modules.db.test.Util;
		45	import org.netbeans.modules.db.util.DBTestBase;
47		46
48	/**	47	/**
49	*	48	*
50	* @author Andrei Badea	49	* @author Andrei Badea
51	*/	50	*/
52	public class DatabaseConnectionTest extends TestBase {	51	public class DatabaseConnectionTest extends DBTestBase {
53		52
54	protected void setUp() throws Exception {	53	protected void setUp() throws Exception {
55	super.setUp();	54	super.setUp();
Lines 92-97 Link Here
92	assertEquals(dbconn, ConnectionManager.getDefault().getConnections()[0]);	91	assertEquals(dbconn, ConnectionManager.getDefault().getConnections()[0]);
93	}	92	}
94		93
		94	public void testSyncConnection() throws Exception {
		95	DatabaseConnection dbconn = getDatabaseConnection();
		96	ConnectionManager.getDefault().connect(dbconn);
		97	assertTrue(dbconn.getJDBCConnection() != null);
		98	assertFalse(dbconn.getJDBCConnection().isClosed());
		99	}
		100
95	public void testDeleteConnection() throws Exception {	101	public void testDeleteConnection() throws Exception {
96	Util.deleteConnectionFiles();	102	Util.deleteConnectionFiles();
97	Util.deleteDriverFiles();	103	Util.deleteDriverFiles();

Lines 29-41 Link Here

(-)a/db/test/unit/src/org/netbeans/modules/db/explorer/actions/AddToIndexDDLTest.java (-2 / +2 lines)
29		29
30	import java.sql.Types;	30	import java.sql.Types;
31	import java.util.HashSet;	31	import java.util.HashSet;
32	import org.netbeans.modules.db.util.DBTestBase;	32	import org.netbeans.modules.db.util.DDLTestBase;
33		33
34	/**	34	/**
35	*	35	*
36	* @author David	36	* @author David
37	*/	37	*/
38	public class AddToIndexDDLTest extends DBTestBase {	38	public class AddToIndexDDLTest extends DDLTestBase {
39		39
40	public AddToIndexDDLTest(String name) {	40	public AddToIndexDDLTest(String name) {
41	super(name);	41	super(name);

Lines 36-48 Link Here

(-)a/db/test/unit/src/org/netbeans/modules/db/explorer/actions/GrabTableHelperTest.java (-2 / +2 lines)
36	import org.netbeans.lib.ddl.impl.CreateTable;	36	import org.netbeans.lib.ddl.impl.CreateTable;
37	import org.netbeans.lib.ddl.impl.TableColumn;	37	import org.netbeans.lib.ddl.impl.TableColumn;
38	import org.netbeans.modules.db.explorer.infos.DatabaseNodeInfo;	38	import org.netbeans.modules.db.explorer.infos.DatabaseNodeInfo;
39	import org.netbeans.modules.db.util.DBTestBase;	39	import org.netbeans.modules.db.util.DDLTestBase;
40	import org.netbeans.modules.db.util.InfoHelper;	40	import org.netbeans.modules.db.util.InfoHelper;
41		41
42	/**	42	/**
43	* @author David Van Couvering	43	* @author David Van Couvering
44	*/	44	*/
45	public class GrabTableHelperTest extends DBTestBase {	45	public class GrabTableHelperTest extends DDLTestBase {
46		46
47	public GrabTableHelperTest(String name) {	47	public GrabTableHelperTest(String name) {
48	super(name);	48	super(name);

Lines 27-32 Link Here

(-)a/db/test/unit/src/org/netbeans/modules/db/util/DBTestBase.java (-92 / +48 lines)
27	*/	27	*/
28	package org.netbeans.modules.db.util;	28	package org.netbeans.modules.db.util;
29		29
		30	import java.net.URL;
30	import java.sql.Connection;	31	import java.sql.Connection;
31	import java.sql.DatabaseMetaData;	32	import java.sql.DatabaseMetaData;
32	import java.sql.DriverManager;	33	import java.sql.DriverManager;
Lines 35-53 Link Here
35	import java.sql.ResultSetMetaData;	36	import java.sql.ResultSetMetaData;
36	import java.sql.SQLException;	37	import java.sql.SQLException;
37	import java.sql.Statement;	38	import java.sql.Statement;
38	import java.sql.Types;
39	import java.util.Iterator;	39	import java.util.Iterator;
40	import java.util.Vector;	40	import java.util.Vector;
41	import java.util.logging.Level;	41	import java.util.logging.Level;
42	import java.util.logging.Logger;	42	import java.util.logging.Logger;
43	import org.netbeans.lib.ddl.impl.AddColumn;	43	import org.netbeans.api.db.explorer.ConnectionManager;
44	import org.netbeans.lib.ddl.impl.CreateIndex;	44	import org.netbeans.api.db.explorer.DatabaseConnection;
45	import org.netbeans.lib.ddl.impl.CreateTable;	45	import org.netbeans.api.db.explorer.JDBCDriver;
46	import org.netbeans.lib.ddl.impl.CreateView;	46	import org.netbeans.api.db.explorer.JDBCDriverManager;
47	import org.netbeans.lib.ddl.impl.DriverSpecification;
48	import org.netbeans.lib.ddl.impl.Specification;
49	import org.netbeans.lib.ddl.impl.SpecificationFactory;
50	import org.netbeans.lib.ddl.impl.TableColumn;
51	import org.netbeans.modules.db.test.TestBase;	47	import org.netbeans.modules.db.test.TestBase;
52		48
53	/**	49	/**
Lines 72-85 Link Here
72	private static String password;	68	private static String password;
73	private static String dbname;	69	private static String dbname;
74	protected static String dblocation;	70	protected static String dblocation;
75		71	private static URL driverJarUrl;
		72
76	private static String DRIVER_PROPERTY = "db.driverclass";	73	private static String DRIVER_PROPERTY = "db.driverclass";
77	private static String URL_PROPERTY = "db.url";	74	private static String URL_PROPERTY = "db.url";
78	private static String USERNAME_PROPERTY = "db.username";	75	private static String USERNAME_PROPERTY = "db.username";
79	private static String PASSWORD_PROPERTY = "db.password";	76	private static String PASSWORD_PROPERTY = "db.password";
80	private static String DBDIR_PROPERTY = "db.dir";	77	private static String DBDIR_PROPERTY = "db.dir";
81	private static String DBNAME_PROPERTY = "db.name";	78	private static String DBNAME_PROPERTY = "db.name";
82		79
83	private static String quoteString = null;	80	private static String quoteString = null;
84		81
85	// This defines what happens to identifiers when stored in db	82	// This defines what happens to identifiers when stored in db
Lines 92-107 Link Here
92	private static int unquotedCaseRule = RULE_UNDEFINED;	89	private static int unquotedCaseRule = RULE_UNDEFINED;
93	private static int quotedCaseRule = RULE_UNDEFINED;	90	private static int quotedCaseRule = RULE_UNDEFINED;
94		91
95	protected static SpecificationFactory specfactory;	92	private static JDBCDriver jdbcDriver;
		93	private static DatabaseConnection dbConnection;
96		94
97	protected Connection conn;	95	protected Connection conn;
98	protected Specification spec;
99	protected DriverSpecification drvSpec;
100		96
101	static {	97	static {
102	try {	98	try {
103	specfactory = new SpecificationFactory();
104
105	driverClass = System.getProperty(DRIVER_PROPERTY,	99	driverClass = System.getProperty(DRIVER_PROPERTY,
106	"org.apache.derby.jdbc.EmbeddedDriver");	100	"org.apache.derby.jdbc.EmbeddedDriver");
107	dbname = System.getProperty(DBNAME_PROPERTY, "ddltestdb");	101	dbname = System.getProperty(DBNAME_PROPERTY, "ddltestdb");
Lines 123-128 Link Here
123		117
124	username = System.getProperty(USERNAME_PROPERTY, "testddl");	118	username = System.getProperty(USERNAME_PROPERTY, "testddl");
125	password = System.getProperty(PASSWORD_PROPERTY, "testddl");	119	password = System.getProperty(PASSWORD_PROPERTY, "testddl");
		120
		121	driverJarUrl = Class.forName(driverClass).getProtectionDomain().getCodeSource().getLocation();
		122
126	} catch (Exception e) {	123	} catch (Exception e) {
127	LOGGER.log(Level.SEVERE, null, e);	124	LOGGER.log(Level.SEVERE, null, e);
128	throw new RuntimeException(e);	125	throw new RuntimeException(e);
Lines 133-158 Link Here
133	super(name);	130	super(name);
134	}	131	}
135		132
		133	/**
		134	* Get the DatabaseConnection for the configured Java DB database. This
		135	* method will create and register the connection the first time it is called
		136	*/
		137	protected static DatabaseConnection getDatabaseConnection() throws Exception {
		138	if (dbConnection == null) {
		139	JDBCDriver driver = JDBCDriver.create("derbydriver", "derbydriver", driverClass, new URL[] {driverJarUrl});
		140	JDBCDriverManager.getDefault().addDriver(driver);
		141
		142	dbConnection = DatabaseConnection.create(driver, dbUrl, username, "APP", password, false);
		143	ConnectionManager.getDefault().addConnection(dbConnection);
		144	}
		145
		146	return dbConnection;
		147	}
		148
		149	protected static String getDbUrl() {
		150	return dbUrl;
		151	}
		152
		153	protected static String getDriverClass() {
		154	return driverClass;
		155	}
		156
		157	protected static String getPassword() {
		158	return password;
		159	}
		160
		161	public static String getUsername() {
		162	return username;
		163	}
		164
136		165
137	public void setUp() throws Exception {	166	@Override
		167	protected void setUp() throws Exception {
138	try {	168	try {
139	getConnection();	169	getConnection();
140	createSchema();	170	createSchema();
141	setSchema();	171	setSchema();
142	initQuoteString();	172	initQuoteString();
143	spec = (Specification)specfactory.createSpecification(conn);
144
145	drvSpec = specfactory.createDriverSpecification(
146	spec.getMetaData().getDriverName().trim());
147	if (spec.getMetaData().getDriverName().trim().equals(
148	"jConnect (TM) for JDBC (TM)")) //NOI18N
149	//hack for Sybase ASE - copied from mainline code
150	drvSpec.setMetaData(conn.getMetaData());
151	else
152	drvSpec.setMetaData(spec.getMetaData());
153
154	drvSpec.setCatalog(conn.getCatalog());
155	drvSpec.setSchema(SCHEMA);
156	} catch ( SQLException e ) {	173	} catch ( SQLException e ) {
157	SQLException original = e;	174	SQLException original = e;
158	while ( e != null ) {	175	while ( e != null ) {
Lines 296-302 Link Here
296	}	313	}
297	}	314	}
298		315
299	private void initQuoteString() throws Exception {	316	protected void initQuoteString() throws Exception {
300	if ( quoteString != null ) {	317	if ( quoteString != null ) {
301	return;	318	return;
302	}	319	}
Lines 579-645 Link Here
579	return numrows;	596	return numrows;
580	}	597	}
581		598
582	protected void createBasicTable(String tablename, String pkeyName)
583	throws Exception {
584	dropTable(tablename);
585	CreateTable cmd = spec.createCommandCreateTable(tablename);
586	cmd.setObjectOwner(SCHEMA);
587
588	// primary key
589	TableColumn col = cmd.createPrimaryKeyColumn(pkeyName);
590	col.setColumnType(Types.INTEGER);
591	col.setNullAllowed(false);
592
593	cmd.execute();
594	}
595
596	protected void createView(String viewName, String query) throws Exception {
597	CreateView cmd = spec.createCommandCreateView(viewName);
598	cmd.setQuery(query);
599	cmd.setObjectOwner(SCHEMA);
600	cmd.execute();
601
602	assertFalse(cmd.wasException());
603	}
604
605	protected void createSimpleIndex(String tablename,
606	String indexname, String colname) throws Exception {
607	// Need to get identifier into correct case because we are
608	// still quoting referred-to identifiers.
609	tablename = fixIdentifier(tablename);
610	CreateIndex xcmd = spec.createCommandCreateIndex(tablename);
611	xcmd.setIndexName(indexname);
612
613	// not unique
614	xcmd.setIndexType(new String());
615
616	xcmd.setObjectOwner(SCHEMA);
617	xcmd.specifyColumn(fixIdentifier(colname));
618
619	xcmd.execute();
620	}
621
622	/**
623	* Adds a basic column. Non-unique, allows nulls.
624	*/
625	protected void addBasicColumn(String tablename, String colname,
626	int type, int size) throws Exception {
627	// Need to get identifier into correct case because we are
628	// still quoting referred-to identifiers.
629	tablename = fixIdentifier(tablename);
630	AddColumn cmd = spec.createCommandAddColumn(tablename);
631	cmd.setObjectOwner(SCHEMA);
632	TableColumn col = (TableColumn)cmd.createColumn(colname);
633	col.setColumnType(type);
634	col.setColumnSize(size);
635	col.setNullAllowed(true);
636
637	cmd.execute();
638	if ( cmd.wasException() ) {
639	throw new Exception("Unable to add column");
640	}
641	}
642
643	protected void tearDown() throws Exception {	599	protected void tearDown() throws Exception {
644	if ( conn != null ) {	600	if ( conn != null ) {
645	try {	601	try {

Line 0 Link Here

(-)a/db/test/unit/src/org/netbeans/modules/db/util/DDLTestBase.java (+167 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
		5	*
		6	* The contents of this file are subject to the terms of either the GNU
		7	* General Public License Version 2 only ("GPL") or the Common
		8	* Development and Distribution License("CDDL") (collectively, the
		9	* "License"). You may not use this file except in compliance with the
		10	* License. You can obtain a copy of the License at
		11	* http://www.netbeans.org/cddl-gplv2.html
		12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		13	* specific language governing permissions and limitations under the
		14	* License. When distributing the software, include this License Header
		15	* Notice in each file and include the License file at
		16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
		17	* particular file as subject to the "Classpath" exception as provided
		18	* by Sun in the GPL Version 2 section of the License file that
		19	* accompanied this code. If applicable, add the following below the
		20	* License Header, with the fields enclosed by brackets [] replaced by
		21	* your own identifying information:
		22	* "Portions Copyrighted [year] [name of copyright owner]"
		23	*
		24	* If you wish your version of this file to be governed by only the CDDL
		25	* or only the GPL Version 2, indicate your decision by adding
		26	* "[Contributor] elects to include this software in this distribution
		27	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		28	* single choice of license, a recipient has the option to distribute
		29	* your version of this file under either the CDDL, the GPL Version 2 or
		30	* to extend the choice of license to its licensees as provided above.
		31	* However, if you add GPL Version 2 code and therefore, elected the GPL
		32	* Version 2 license, then the option applies only if the new code is
		33	* made subject to such option by the copyright holder.
		34	*
		35	* Contributor(s):
		36	*
		37	* Portions Copyrighted 2008 Sun Microsystems, Inc.
		38	*/
		39
		40	package org.netbeans.modules.db.util;
		41
		42	import java.sql.SQLException;
		43	import java.sql.Types;
		44	import java.util.logging.Level;
		45	import java.util.logging.Logger;
		46	import org.netbeans.lib.ddl.impl.AddColumn;
		47	import org.netbeans.lib.ddl.impl.CreateIndex;
		48	import org.netbeans.lib.ddl.impl.CreateTable;
		49	import org.netbeans.lib.ddl.impl.CreateView;
		50	import org.netbeans.lib.ddl.impl.DriverSpecification;
		51	import org.netbeans.lib.ddl.impl.Specification;
		52	import org.netbeans.lib.ddl.impl.SpecificationFactory;
		53	import org.netbeans.lib.ddl.impl.TableColumn;
		54
		55	/**
		56	*
		57	* @author David
		58	*/
		59	public class DDLTestBase extends DBTestBase {
		60	private static Logger LOGGER = Logger.getLogger(DDLTestBase.class.getName());
		61
		62	protected static SpecificationFactory specfactory;
		63	protected Specification spec;
		64	protected DriverSpecification drvSpec;
65
66	static {
67	try {
68	specfactory = new SpecificationFactory();
69	} catch (Exception e) {
70	LOGGER.log(Level.SEVERE, null, e);
71	throw new RuntimeException(e);
72	}
73	}
74
75
76	public DDLTestBase(String name) {
77	super(name);
78	}
79
80	protected void setUp() throws Exception {
81	super.setUp();
82
83	try {
84	spec = (Specification)specfactory.createSpecification(conn);
85
86	drvSpec = specfactory.createDriverSpecification(
87	spec.getMetaData().getDriverName().trim());
88	if (spec.getMetaData().getDriverName().trim().equals(
89	"jConnect (TM) for JDBC (TM)")) //NOI18N
90	//hack for Sybase ASE - copied from mainline code
91	drvSpec.setMetaData(conn.getMetaData());
92	else
93	drvSpec.setMetaData(spec.getMetaData());
94
95	drvSpec.setCatalog(conn.getCatalog());
96	drvSpec.setSchema(SCHEMA);
97	} catch ( SQLException e ) {
98	SQLException original = e;
99	while ( e != null ) {
100	LOGGER.log(Level.SEVERE, null, e);
101	e = e.getNextException();
102	}
103
104	throw original;
105	}
106	}
107	protected void createBasicTable(String tablename, String pkeyName)
108	throws Exception {
109	dropTable(tablename);
110	CreateTable cmd = spec.createCommandCreateTable(tablename);
111	cmd.setObjectOwner(SCHEMA);
112
113	// primary key
114	TableColumn col = cmd.createPrimaryKeyColumn(pkeyName);
115	col.setColumnType(Types.INTEGER);
116	col.setNullAllowed(false);
117
118	cmd.execute();
119	}
120
121	protected void createView(String viewName, String query) throws Exception {
122	CreateView cmd = spec.createCommandCreateView(viewName);
123	cmd.setQuery(query);
124	cmd.setObjectOwner(SCHEMA);
125	cmd.execute();
126
127	assertFalse(cmd.wasException());
128	}
129
130	protected void createSimpleIndex(String tablename,
131	String indexname, String colname) throws Exception {
132	// Need to get identifier into correct case because we are
133	// still quoting referred-to identifiers.
134	tablename = fixIdentifier(tablename);
135	CreateIndex xcmd = spec.createCommandCreateIndex(tablename);
136	xcmd.setIndexName(indexname);
137
138	// not unique
139	xcmd.setIndexType(new String());
140
141	xcmd.setObjectOwner(SCHEMA);
142	xcmd.specifyColumn(fixIdentifier(colname));
143
144	xcmd.execute();
145	}
146
147	/**
148	* Adds a basic column. Non-unique, allows nulls.
149	*/
150	protected void addBasicColumn(String tablename, String colname,
151	int type, int size) throws Exception {
152	// Need to get identifier into correct case because we are
153	// still quoting referred-to identifiers.
154	tablename = fixIdentifier(tablename);
155	AddColumn cmd = spec.createCommandAddColumn(tablename);
156	cmd.setObjectOwner(SCHEMA);
157	TableColumn col = (TableColumn)cmd.createColumn(colname);
158	col.setColumnType(type);
159	col.setColumnSize(size);
160	col.setNullAllowed(true);
161
162	cmd.execute();
163	if ( cmd.wasException() ) {
164	throw new Exception("Unable to add column");
165	}
166	}
167	}