1 /*
 2  Derby - Class SimpleApp
 3  */
 4 
 5 import java.sql.Connection;
 6 import java.sql.DriverManager;
 7 import java.sql.ResultSet;
 8 import java.sql.SQLException;
 9 import java.sql.Statement;
 10 
 11 import java.util.Properties;
 12 
 13 
 14 /**
 15  * This sample program is a minimal JDBC application showing
 16  * JDBC access to Derby.
 17  *
 18  * Instructions for how to run this program are
 19  * given in <A HREF=example.html>example.html</A>.
 20  *
 21  * Derby applications can run against Derby running in an embedded
 22  * or a client/server framework. When Derby runs in an embedded framework,
 23  * the Derby application and Derby run in the same JVM. The application
 24  * starts up the Derby engine. When Derby runs in a client/server framework,
 25  * the application runs in a different JVM from Derby. The application only needs
 26  * to start the client driver, and the connectivity framework provides network connections.
 27  * (The server must already be running.)
 28  *
 29  * <p>When you run this application, give one of the following arguments:
 30  * * embedded (default, if none specified)
 31  * * derbyclient (will use the Net client driver to access Network Server)
 32  * * jccjdbcclient (if Derby is running embedded in the JCC Server framework)
 33  *
 34  */
 35 public class SimpleApp
 36 {
 37  /* the default framework is embedded*/
 38  public String framework = "embedded";
 39  public String driver = "org.apache.derby.jdbc.EmbeddedDriver";
 40  public String protocol = "jdbc:derby:";
 41  
 42  public String username = "user1";
 43  public String password = "user1";
 44 
 45  public static void main(String[] args)
 46  {
 47  new SimpleApp().go(args);
 48  }
 49 
 50  void go(String[] args)
 51  {
 52  /* parse the arguments to determine which framework is desired*/
 53  parseArguments(args);
 54 
 55  /* check for J2ME specification - J2ME must use a DataSource further on */
 56  String javaspec = System.getProperty( "java.specification.name" );
 57  boolean java2me = false;
 58  if( javaspec.indexOf( "J2ME" ) > -1 )
 59  {
 60  java2me = true;
 61  }
 62  System.out.println(java2me);
 63  System.out.println("SimpleApp starting in " + framework + " mode.");
 64 
 65  try
 66  {
 67  /*
 68  The driver is installed by loading its class.
 69  In an embedded environment, this will start up Derby, since it is not already running.
 70  */
 71  org.apache.derby.jdbc.EmbeddedSimpleDataSource ds = null;
 72  Connection conn = null;
 73  Properties props = new Properties();
 74  props.put("user", username);
 75  props.put("password", password);
 76 
 77  /* If we are using a J2ME jvm, we need to use a DataSource, otherwise
 78  * we can use java.sql.DriverManager to get the connection, or
 79  * a Datasource. This example program uses a DataSource with J2ME
 80  * but uses DriverManager otherwise.
 81  * If we were to use a DataSource for J2SE, we could use
 82  * the org.apache.derby.jdbc.EmbeddedDataSource, rather than the
 83  * org.apache.derby.jdbc.EmbeddedSimpleDataSource we need to use for J2ME.
 84  */
 85  
 86  if( java2me )
 87  {
 88  /*
 89  The connection specifies create in the DataSource settings for
 90  the database to be created. To remove the database,
 91  remove the directory derbyDB and its contents.
 92  The directory derbyDB will be created under
 93  the directory that the system property
 94  derby.system.home points to, or the current
 95  directory if derby.system.home is not set.
 96  */
 97  
 98  ds = new org.apache.derby.jdbc.EmbeddedSimpleDataSource();
 99  ds.setDatabaseName("derbyDB");
 100  ds.setCreateDatabase("create");
 101  conn = ds.getConnection(username, password);
 102  
 103  System.out.println("this is Java2Me");
 104  }
 105  else
 106  {
 107  System.out.println("this is NOT Java2Me");
 108  /*
 109  The connection specifies create=true in the url to cause
 110  the database to be created. To remove the database,
 111  remove the directory derbyDB and its contents.
 112  The directory derbyDB will be created under
 113  the directory that the system property
 114  derby.system.home points to, or the current
 115  directory if derby.system.home is not set.
 116  */
 117  
 118  Class.forName(driver).newInstance();
 119  System.out.println("Loaded the appropriate driver.");
 120  
 121  conn = DriverManager.getConnection(protocol +
 122  "derbyDB;create=true", props);
 123  }
 124  System.out.println("Connected to and created database derbyDB");
 125 
 126  conn.setAutoCommit(false);
 127 
 128  /*
 129  Creating a statement lets us issue commands against
 130  the connection.
 131  */
 132  Statement s = conn.createStatement();
 133 
 134  /*
 135  We create a table, add a few rows, and update one.
 136  */
 137  s.execute("create table derbyDB(num int, addr varchar(40))");
 138  System.out.println("Created table derbyDB");
 139  s.execute("insert into derbyDB values (1956,'Webster St.')");
 140  System.out.println("Inserted 1956 Webster");
 141  s.execute("insert into derbyDB values (1910,'Union St.')");
 142  System.out.println("Inserted 1910 Union");
 143  s.execute(
 144  "update derbyDB set num=180, addr='Grand Ave.' where num=1956");
 145  System.out.println("Updated 1956 Webster to 180 Grand");
 146 
 147  s.execute(
 148  "update derbyDB set num=300, addr='Lakeshore Ave.' where num=180");
 149  System.out.println("Updated 180 Grand to 300 Lakeshore");
 150 
 151  /*
 152  We select the rows and verify the results.
 153  */
 154  ResultSet rs = s.executeQuery(
 155  "SELECT num, addr FROM derbyDB ORDER BY num");
 156 
 157  if (!rs.next())
 158  {
 159  throw new Exception("Wrong number of rows");
 160  }
 161 
 162  if (rs.getInt(1) != 300)
 163  {
 164  throw new Exception("Wrong row returned");
 165  }
 166 
 167  if (!rs.next())
 168  {
 169  throw new Exception("Wrong number of rows");
 170  }
 171 
 172  if (rs.getInt(1) != 1910)
 173  {
 174  throw new Exception("Wrong row returned");
 175  }
 176 
 177  if (rs.next())
 178  {
 179  throw new Exception("Wrong number of rows");
 180  }
 181 
 182  System.out.println("Verified the rows");
 183 
 184  s.execute("drop table derbyDB");
 185  System.out.println("Dropped table derbyDB");
 186 
 187  /*
 188  We release the result and statement resources.
 189  */
 190  rs.close();
 191  s.close();
 192  System.out.println("Closed result set and statement");
 193 
 194  /*
 195  We end the transaction and the connection.
 196  */
 197  conn.commit();
 198  conn.close();
 199  System.out.println("Committed transaction and closed connection");
 200 
 201  /*
 202  In embedded mode, an application should shut down Derby.
 203  If the application fails to shut down Derby explicitly,
 204  the Derby does not perform a checkpoint when the JVM shuts down, which means
 205  that the next connection will be slower.
 206  Explicitly shutting down Derby with the URL is preferred.
 207  This style of shutdown will always throw an "exception".
 208  */
 209  boolean gotSQLExc = false;
 210 
 211  if (framework.equals("embedded"))
 212  {
 213  /* again, with J2ME, we need to use a datasource to get the connection */
 214  if( java2me )
 215  {
 216  try
 217  {
 218  ds.setShutdownDatabase( "shutdown" );
 219  conn = ds.getConnection(username, password);
 220  }
 221  catch (SQLException se)
 222  {
 223  if( se.getErrorCode() == 45000 )
 224  {
 225  gotSQLExc = true;
 226  }
 227  }
 228  }
 229  else 
 230  { 
 231  try
 232  {
 233  DriverManager.getConnection("jdbc:derby:;shutdown=true");
 234  }
 235  catch (SQLException se)
 236  {
 237  gotSQLExc = true;
 238  }
 239  }
 240 
 241  if (!gotSQLExc)
 242  {
 243  System.out.println("Database did not shut down normally");
 244  }
 245  else
 246  {
 247  System.out.println("Database shut down normally");
 248  }
 249  }
 250  }
 251  catch (Throwable e)
 252  {
 253  System.out.println("exception thrown:");
 254 
 255  if (e instanceof SQLException)
 256  {
 257  printSQLError((SQLException) e);
 258  }
 259  else
 260  {
 261  e.printStackTrace();
 262  }
 263  }
 264 
 265  System.out.println("SimpleApp finished");
 266  }
 267 
 268  static void printSQLError(SQLException e)
 269  {
 270  while (e != null)
 271  {
 272  System.out.println(e.toString());
 273  e = e.getNextException();
 274  }
 275  }
 276 
 277  private void parseArguments(String[] args)
 278  {
 279  int length = args.length;
 280 
 281  for (int index = 0; index < length; index++)
 282  {
 283  if (args[index].equalsIgnoreCase("jccjdbcclient"))
 284  {
 285  framework = "jccjdbc";
 286  driver = "com.ibm.db2.jcc.DB2Driver";
 287  protocol = "jdbc:derby:net://localhost:1527/";
 288  }
 289  if (args[index].equalsIgnoreCase("derbyclient"))
 290  {
 291  framework = "derbyclient";
 292  driver = "org.apache.derby.jdbc.ClientDriver";
 293  protocol = "jdbc:derby://localhost:1527/";
 294  }
 295  }
 296  }
 297 }