home *** CD-ROM | disk | FTP | other *** search
/ PC World 1999 May / PCWorld_1999-05_cd.bin / software / Vyzkuste / inprise / INTRCLNT_15 / DATA.Z / PerformanceTests.txt < prev    next >
Text File  |  1998-09-21  |  48KB  |  1,151 lines
  1. // Copyright InterBase Software Corporation, 1998.
  2. // Written by inprise.interbase.interclient.r&d.PaulOstler :-)
  3.  
  4. /**   
  5.  * Portable performance test suite for InterClient or any other JDBC driver.
  6.  * <p>
  7.  * <b>IMPORTANT STEPS BEFORE RUNNING THIS TEST</b>
  8.  * <ol>
  9.  * <li> 
  10.  * Create an empty test database file to be used for performance tests.
  11.  * Metadata is created automatically by the test program,
  12.  * but a test database must be created manually before running tests.
  13.  * <p>                       
  14.  * For InterBase, manually create test.gdb in the directory of your choice as follows:
  15.  * <ul>      
  16.  * <li> isql
  17.  * <li> create database "test.gdb" [user "sysdba" password "masterkey"];
  18.  * <li> quit;  
  19.  * </ul>
  20.  * The brackets ([]) indicate an optional user/password, only required
  21.  * if system environment variables ISC_USER and ISC_PASSWORD are not set.
  22.  * <p>
  23.  * Some database products, like Oracle, manage their own filespace
  24.  * so skip this step for such products.
  25.  * <li>    Tailor configuration variables.
  26.  *         This is done programmatically by setting the public configuration
  27.  *         variables of this class programmatically in an application program
  28.  *         (with a <code>main()</code>) external to this
  29.  *         <code>PerformanceTests</code> library.
  30.  *         Do <i>not</i> edit the default values in the
  31.  *         <code>PerformanceTest</code> source.
  32.  *         Rather, edit a copy of class <code>interbase.interclient.tests.ExampleTests</code>.
  33.  *         or copy the <code>ExampleTests</code> program and modify its source.
  34.  *         You may want to change the package name (interbase.interclient.tests)
  35.  *         on the first line of your copy of the <code>ExampleTests</code>
  36.  *         source file to the name
  37.  *         of your choice, making sure
  38.  *         the package name matches the new directory location of your test
  39.  *         program relative to your class path,
  40.  *         then compile the new program source.
  41.  *         <p>
  42.  *         Configure variables for the
  43.  *         URLs, drivers, and test control switches in <code>ExampleTests</code> .
  44.  *         <p>
  45.  *         You must manually configure ODBC and BDE
  46.  *         data-source names for test.gdb using the ODBC or BDE
  47.  *         configuration utilities.  For consistency, use
  48.  *         ODBC and BDE alias names as suggested by the defaults
  49.  *         of the various configuration variables in <code>ExampleTests</code>.
  50.  *         The ODBC configuration utiltity
  51.  *         can usually be found in the NT control panel.
  52.  *         The BDE Administrator can be found in the DataGateway program group.
  53.  * <li>    Be sure to start InterServer, DataGateway, InterBase, Sybase Open Server,
  54.  *         dbANYWHERE, or any other servers tested before running <code>ExampleTests</code>.
  55.  *         Also, make sure DataGateway.zip, InterClient.jar,
  56.  *         and any other driver to test are in a library class path for your project.
  57.  * <li>    Discard the performance results of the first test run in order
  58.  *         to factor out the overhead in initial class loading, and
  59.  *         the initial database page allocation for an originally
  60.  *         empty test.gdb.  In other words, run the test twice
  61.  *         so that Java classes are pre-loaded, and take
  62.  *         the results of the second test only.
  63.  * <li>    Look for results and/or errors in the specified output file
  64.  *         as configured.
  65.  * </ol>
  66.  * @author Paul Ostler
  67.  **/
  68. public class PerformanceTests
  69. {
  70.   // *******************************************
  71.   // *** Default public configurables.
  72.   // *** Do not modify the default values in this file.
  73.   // *** Modify publics programmatically via an external class
  74.   // *** such as ExampleTests rather than hardwiring
  75.   // *** values in this class.
  76.   // *******************************************
  77.  
  78.   /**
  79.    * Output file to write the performance test results.
  80.    * This is where you'll want to look after running a test.
  81.    * <p>
  82.    * The default value is null, which means output will be written to System.out.
  83.    **/
  84.   public static String outputFileName = null;
  85.  
  86.   /**
  87.    * An array of database engines, usernames, passwords, URLs, and drivers you wish to test.
  88.    * <p>
  89.    * Each element in the array consists of a tuple
  90.    * <code>{ engineName, username, password, URL, driverClassName }</code>.
  91.    * The engine name is needed
  92.    * to construct dbms-dependent SQL.  Valid engine names are
  93.    * "interbase", "oracle", etc...
  94.    * Some drivers, such as DataGateway, can be used against
  95.    * different engines (known as category 3 drivers).
  96.    * <p>
  97.    * Here are some example client/server tuples that could be tested
  98.    * The remote hostname may be set to localhost to test client/server in loopback mode.
  99.    * <pre>
  100.    * PerformanceTests.driversToTest = new String[][] {
  101.    * // *** Client/server URLs ***
  102.    * // JDBC-ODBC bridge used remotely (uses native dbms client api and dbms net protocol)
  103.    *  { "interbase",
  104.    *    "sysdba",
  105.    *    "masterkey",
  106.    *    "jdbc:odbc:clientServerTest",
  107.    *    "sun.jdbc.odbc.JdbcOdbcDriver" }
  108.    * // InterClient (uses custom client api and remote protocol (RP))
  109.    * ,{ "interbase",
  110.    *    "sysdba",
  111.    *    "masterkey",
  112.    *    "jdbc:interbase://hostname/d:/databases/test.gdb",
  113.    *    "interbase.interclient.Driver" }
  114.    * // Datagateway Broker  (uses custom client api and remote protocol (RP))
  115.    * ,{ "interbase",
  116.    *    "sysdba",
  117.    *    "masterkey",
  118.    *    "jdbc:BorlandBroker://hostname/localTest",
  119.    *    "borland.jdbc.Broker.RemoteDriver" }
  120.    * // Datagateway bridge used remotely (uses native dbms client api and RP)
  121.    * ,{ "interbase",
  122.    *    "sysdba",
  123.    *    "masterkey",
  124.    *    "jdbc:BorlandBridge:clientServerTest",
  125.    *    "borland.jdbc.Bridge.LocalDriver" }
  126.    * // Sybase jConnect (uses custom client api, but uses TDS remote protocol)
  127.    * ,{ "sqlanywhere",
  128.    *    "dba",
  129.    *    "sql",
  130.    *    "jdbc:sybase:Tds:hostname:4444/d:\\sqlany50\\sademo.db",
  131.    *    "com.sybase.jdbc.SybDriver" }
  132.    * // Symantec dbAnywhere
  133.    * ,{ "sqlanywhere",
  134.    *    "dba",
  135.    *    "sql",
  136.    *    "jdbc:dbaw://hostname:8889/Sybase_SQLANY/Sademo/Sademo",
  137.    *    "symantec.itools.db.jdbc.Driver" }
  138.    * // Oracle Thin Driver (uses custom client api, but uses Oracle remote protocol?)
  139.    * ,{ "oracle",
  140.    *    "user",
  141.    *    "password",
  142.    *    "jdbc:oracle:thin:@hostname:1521:ORCL",
  143.    *    "oracle.jdbc.driver.OracleDriver" }
  144.    * // Solid Driver uses Solid protocol
  145.    * ,{ "solid",
  146.    *    "sysdba",
  147.    *    "masterkey",
  148.    *    "jdbc:solid://hostname:1313/sysdba/masterkey",
  149.    *    "solid.jdbc.SolidDriver" }
  150.    * //
  151.    * // *** Local URLs follow (not client/server) ***
  152.    * // Datagateway bridge used locally
  153.    * ,{ "interbase",
  154.    *    "sysdba",
  155.    *    "masterkey",
  156.    *    "jdbc:BorlandBridge:localTest",
  157.    *    "borland.jdbc.Bridge.LocalDriver" }
  158.    * // JDBC-ODBC bridge used locally
  159.    * ,{ "interbase",
  160.    *    "sysdba",
  161.    *    "masterkey",
  162.    *    "jdbc:odbc:localTest"
  163.    *    "sun.jdbc.odbc.JdbcOdbcDriver" }
  164.    * };
  165.    * </pre>
  166.    **/
  167.   public static String[][] driversToTest = null;
  168.  
  169.   // *************************************************
  170.   // *** Configurable test control switches follow ***
  171.   // *** (ie. what to test and what not to test).  ***
  172.   // *** Modify values thru an external application rather than ***
  173.   // *** modifying the default values as set here. ***
  174.   // *************************************************
  175.  
  176.   // *** Toggles for performance suites ***
  177.   public static boolean testMetaData = false;   // exhaustive database metadata extraction
  178.   public static boolean testStrings = false;    // various CHAR(n) tests
  179.   public static boolean testBLObs = false;      // various BLOb tests
  180.   public static boolean testNumbers = false;    // various numeric data
  181.   public static boolean testDates = false;      // Dates, Times, and Timestamps
  182.   public static boolean testProcedures = false; // Stored procedures
  183.  
  184.   public static boolean test1ByteBlobs = false;      // uses dataSize/1 rows
  185.   public static boolean test10ByteBlobs = false;     // uses dataSize/10 rows
  186.   public static boolean test100ByteBlobs = false;    // uses dataSize/100 rows
  187.   public static boolean test1000ByteBlobs = false;   // uses dataSize/1000 rows
  188.   public static boolean test10000ByteBlobs = false;  // uses dataSize/10000 rows
  189.   public static boolean test100000ByteBlobs = false; // uses dataSize/100000 rows
  190.  
  191.   public static boolean test1CharStrings = false;  // most time consuming
  192.   public static boolean test10CharStrings = false;
  193.   public static boolean test100CharStrings = false;
  194.   public static boolean test1000CharStrings = false;
  195.   public static boolean test10000CharStrings = false; // least time consuming
  196.  
  197.   /**
  198.    * Size of bulk data loads for testing.
  199.    * <p>
  200.    * <code>testDataSize</code> indicates how many bytes are inserted or selected for each test.
  201.    * For example, if the <code>testDataSize</code> = 100,000, then the 1-byte blob test will
  202.    * insert 100,00 rows of 1-byte blobs, but the 100,000-byte blob test will
  203.    * insert only a single row.  Decreasing <code>dataSize</code> will decrease the time
  204.    * required to run the performance tests.
  205.    * <p>
  206.    * Default value is 1,000.
  207.    * It is recommended to always make dataSize divisible by 1,000.
  208.    **/
  209.   public static int testDataSize = 1000; // make it divisible by 1,000
  210.  
  211.   /**
  212.    * See InterClient API reference for <code>Connection.setAutoCommit()</code>.
  213.    * <p>
  214.    * Default is false.
  215.    * @see interbase.interclient.Connection#setAutoCommit
  216.    **/
  217.   public static boolean enableAutoCommit = false;
  218.  
  219.   /**
  220.    * Direct the driver manager log stream to <code>ouputFileName</code>.
  221.    * See JavaSoft API reference for <code>DriverManager.setLogStream()</code>.
  222.    * <p>
  223.    * Default is false.
  224.    * @see java.sql.DriverManager#setLogStream
  225.    **/
  226.   public static boolean enableDriverManagerLogStream = false;
  227.  
  228.   /**
  229.    * Character set name, see InterClient API reference for class
  230.    * <code>interbase.interclient.ConnectionProperties</code> for mappings
  231.    * to InterBase character sets.
  232.    * <p>
  233.    * Default is null which means to use the driver defaults.
  234.    * @see interbase.interclient.ConnectionProperties
  235.    **/
  236.   public static String characterSet = null;
  237.  
  238.   /**
  239.    * This is the character to use to construct test strings.
  240.    * For example, if test100chars is enabled, then a test string
  241.    * of 100 characters will be created using this character.
  242.    * <p>
  243.    * Default is 'X'.
  244.    * @see #characterSet
  245.    **/
  246.   public static char character = 'X';
  247.   
  248.   // **********************************************
  249.   // *** End of Configurables *********************
  250.   // **********************************************
  251.  
  252.   // *** specifies the number of bytes per row in NUMBER_TABLE ***
  253.   // *** set below with table declaration for number tests ***
  254.   private static int numberBytesPerRecord__;
  255.  
  256.   // *** String data to be inserted and selected from test database ***
  257.   private static String s1char__ = null;
  258.   private static String s10chars__ = null;
  259.   private static String s100chars__ = null;
  260.   private static String s1000chars__ = null;
  261.   private static String s10000chars__ = null;
  262.  
  263.   // *** Blob data to be inserted and selected from test database ***
  264.   private static byte[] b1byte__ = null;
  265.   private static byte[] b10bytes__ = null;
  266.   private static byte[] b100bytes__ = null;
  267.   private static byte[] b1000bytes__ = null;
  268.   private static byte[] b10000bytes__ = null;
  269.   private static byte[] b100000bytes__ = null;
  270.  
  271.   // *** Performance metric variables ***
  272.   private static long startTime__, endTime__, elapsedTime__;
  273.  
  274.   // *** The engine currently being tested, this is used to determine
  275.   // *** the variant of SQL to use.
  276.   // *** Engine names are passed in as part of the urlsToTest array.
  277.   private static String engine__;
  278.  
  279.   // *** JDBC global object declarations ***
  280.   private static java.sql.Driver d__ = null;
  281.   private static java.sql.Connection c__ = null;
  282.   private static java.sql.Statement s__ = null;
  283.   private static java.sql.PreparedStatement ps__ = null;
  284.   private static java.sql.ResultSet rs__ = null;
  285.   private static java.util.Properties properties__ = null;
  286.   private static String user__ = null;
  287.   private static String password__ = null;
  288.   private static String url__ = null;
  289.  
  290.   // *** Print stream for writing results ***
  291.   private static java.io.PrintStream printStream__ = null;
  292.   
  293.   /**
  294.    * Run the performance tests under the configuration as set
  295.    * by the public configuration variables.
  296.    * Results are written to <code>outputFileFile</code>.
  297.    **/
  298.   synchronized static public void run ()
  299.   {
  300.     // this forces jdbc objects to be closed before
  301.     // this java application exits.
  302.     System.runFinalizersOnExit (true);
  303.  
  304.     if (outputFileName == null) {
  305.       printStream__ = System.out; // System.out is the default
  306.     }
  307.     else {
  308.       try {
  309.         printStream__ =
  310.           new java.io.PrintStream (new java.io.FileOutputStream (outputFileName),
  311.                                    true);  // auto-flush
  312.       }
  313.       catch (java.io.IOException e) {
  314.         System.out.println  ("Couldn't open print stream to " + outputFileName +
  315.                              "Aborting tests...");
  316.         System.exit (1);
  317.       }
  318.     }
  319.  
  320.     showPerformanceTuningVariables ();
  321.  
  322.     try {
  323.       int i;
  324.       
  325.       populateStaticData ();
  326.  
  327.       if (enableDriverManagerLogStream)
  328.         java.sql.DriverManager.setLogStream (printStream__);
  329.  
  330.       // *** Load all available drivers from your class path ***
  331.       for (i=0; i<driversToTest.length; i++) {
  332.         try {
  333.           Class.forName (driversToTest[i][4]);
  334.         }
  335.         catch (ClassNotFoundException e) {
  336.       printStream__.println ("Driver " +
  337.                                driversToTest[i][4] +
  338.                                " not found in classpath.");
  339.         }
  340.       }
  341.  
  342.       printStream__.println ("******************************************************************************");
  343.       printStream__.println ("*** Beginning performance tests ***");
  344.       printStream__.println ("*** The number of rows and bytes selected should match the number inserted ***");
  345.       printStream__.println ("******************************************************************************");
  346.  
  347.       // *** Test all urls specified in driversToTest ***
  348.       for (i=0; i<driversToTest.length; i++) {
  349.         engine__ = driversToTest[i][0];
  350.         user__ = driversToTest[i][1];
  351.         password__ = driversToTest[i][2];
  352.         url__ = driversToTest[i][3];
  353.         printStream__.println ();
  354.         printStream__.println ("*** Testing " + url__ + " ***");
  355.         test ();
  356.         printStream__.println ("*** Finished testing " + url__ + " ***");
  357.       }
  358.  
  359.       printStream__.println ();
  360.       printStream__.println ("*** End Of Tests ***");
  361.       // If you're using the JBuilder debugger,
  362.       // check for errors under JBuilder | View | Execution Log.
  363.     }
  364.     catch (java.sql.SQLException e) {
  365.       showException (e);
  366.     }
  367.     finally {
  368.       printStream__.close ();
  369.     }
  370.   }
  371.  
  372.   private static void showPerformanceTuningVariables ()
  373.   {
  374.     printStream__.println ("*** Running interbase.interclient.PerformanceTests.run() ***");
  375.     printStream__.println ("driversToTest:");
  376.     for (int i=0; i<driversToTest.length; i++) {
  377.       printStream__.print (driversToTest[i][0]);
  378.       printStream__.print (", ");
  379.       printStream__.print (driversToTest[i][1]);
  380.       printStream__.print (", ");
  381.       printStream__.print (driversToTest[i][2]);
  382.       printStream__.print (", ");
  383.       printStream__.print (driversToTest[i][3]);
  384.       printStream__.print (", ");
  385.       printStream__.print (driversToTest[i][4]);
  386.       printStream__.println ();
  387.     }
  388.  
  389.     printStream__.println ("testMetaData: " + testMetaData);
  390.     printStream__.println ("testStrings: " + testStrings);
  391.     printStream__.println ("testBLObs: " + testBLObs);
  392.     printStream__.println ("testNumbers: " + testNumbers);
  393.     printStream__.println ("testDates: " + testDates);
  394.     printStream__.println ("testProcedures: " + testProcedures);
  395.  
  396.     printStream__.println ("test1ByteBlobs: " + test1ByteBlobs);
  397.     printStream__.println ("test10ByteBlobs: " + test10ByteBlobs);
  398.     printStream__.println ("test100ByteBlobs: " + test100ByteBlobs);
  399.     printStream__.println ("test1000ByteBlobs: " + test1000ByteBlobs);
  400.     printStream__.println ("test10000ByteBlobs: " + test10000ByteBlobs);
  401.     printStream__.println ("test100000ByteBlobs: " + test100000ByteBlobs);
  402.  
  403.     printStream__.println ("test1CharStrings: " + test1CharStrings);
  404.     printStream__.println ("test10CharStrings: " + test10CharStrings);
  405.     printStream__.println ("test100CharStrings: " + test100CharStrings);
  406.     printStream__.println ("test1000CharStrings: " + test1000CharStrings);
  407.     printStream__.println ("test10000CharStrings: " + test10000CharStrings);
  408.  
  409.     printStream__.println ("testDataSize: " + testDataSize);
  410.  
  411.     printStream__.println ("enableAutoCommit: " + enableAutoCommit);
  412.     printStream__.println ("enableDriverManagerLogStream: " + enableDriverManagerLogStream);
  413.  
  414.     printStream__.println ("characterSet: " + characterSet);
  415.     printStream__.println ("character: " + character);
  416.   }
  417.  
  418.   private static void populateStaticData ()
  419.   {
  420.     int i;
  421.     
  422.     // *** Populate java strings for inserting into database CHAR fields ***
  423.     // !!! had to lower this to please JBuilder, up to 10,000 later.
  424.     StringBuffer tempBuffer = new StringBuffer (10000); //!!!1,000 when debugging
  425.     for (i=0; i<10000; i++) // !!!10,000 or  1,000 when debugging
  426.       tempBuffer.append (character);
  427.     // !!! comment out next two when debugging
  428.     s10000chars__ = tempBuffer.toString ();
  429.     tempBuffer.setLength (1000);
  430.     s1000chars__ = tempBuffer.toString ();
  431.     tempBuffer.setLength (100);
  432.     s100chars__ = tempBuffer.toString ();
  433.     tempBuffer.setLength (10);
  434.     s10chars__ = tempBuffer.toString ();
  435.     tempBuffer.setLength (1);
  436.     s1char__ = tempBuffer.toString ();
  437.  
  438.     // !!! comment out next two when debugging
  439.     b100000bytes__ = new byte [100000];
  440.     b10000bytes__ = new byte [10000];
  441.     b1000bytes__ = new byte [1000];
  442.     b100bytes__ = new byte [100];
  443.     b10bytes__ = new byte [10];
  444.     b1byte__ = new byte [1];
  445.     for (i=0; i<100000; i++) // !!! up to 100,000, 1,000 when debugging
  446.       b100000bytes__[i] = 56; // !!! up to 100,000, 1,000 when debugging
  447.     // !!!comment out next two when debugging
  448.     System.arraycopy (b100000bytes__, 0, b10000bytes__, 0, 10000);
  449.     System.arraycopy (b10000bytes__, 0, b1000bytes__, 0, 1000);
  450.     System.arraycopy (b1000bytes__, 0, b100bytes__, 0, 100);
  451.     System.arraycopy (b100bytes__, 0, b10bytes__, 0, 10);
  452.     System.arraycopy (b10bytes__, 0, b1byte__, 0, 1);
  453.   }
  454.  
  455.   // url__ and engine__ must be previously set.
  456.   private static void test () throws java.sql.SQLException
  457.   {
  458.     try {
  459.       // *** Get a connection to the url ***
  460.       d__ = java.sql.DriverManager.getDriver (url__);
  461.       printStream__.println ("*** using driver version: " + d__.getMajorVersion() + "." + d__.getMinorVersion() + " ***");
  462.       
  463.       properties__ = new java.util.Properties ();
  464.       properties__.put ("user", user__);
  465.       properties__.put ("password", password__);
  466.       if (characterSet != null)
  467.         properties__.put ("charset", characterSet); // need to resource "charSet"
  468.       c__ = d__.connect (url__, properties__);
  469.  
  470.       // *** Create the metadata needed ***
  471.       c__.setAutoCommit (false);  // Run DDL with autocommit off
  472.       dropTestTables ();
  473.       createTestTables ();
  474.       c__.commit (); // Commit the DDL
  475.       c__.setAutoCommit (enableAutoCommit);
  476.  
  477.       if (testMetaData)
  478.         testMetaData ();
  479.  
  480.       if (testStrings) {
  481.         printStream__.println ("** Beginning string tests **");
  482.     testStringInsertPerformance ();
  483.     testStringSelectPerformance ();
  484.       }
  485.       if (testBLObs) {
  486.         printStream__.println ("** Beginning BLOb tests **");
  487.     testBLObInsertPerformance ();
  488.     testBLObSelectPerformance ();
  489.       }
  490.       if (testNumbers) {
  491.         printStream__.println ("** Beginning number tests **");
  492.     testNumberInsertPerformance ();
  493.     testNumberSelectPerformance ();
  494.       }
  495.       if (testDates) {
  496.         printStream__.println ("** Beginning date tests **");
  497.     testDateInsertPerformance ();
  498.     testDateSelectPerformance ();
  499.       }
  500.       if (testProcedures) {
  501.         printStream__.println ("** Beginning procedure tests **");
  502.     testProcedureInsertPerformance ();
  503.     testProcedureSelectPerformance ();
  504.       }
  505.     }
  506.     catch (java.sql.SQLException e) {
  507.       showException (e);
  508.       throw e;
  509.     }
  510.     finally {
  511.       // The jdbc/odbc bridge needs the commit before close can be called
  512.       if ((c__ != null) && !c__.isClosed()) {
  513.         c__.commit();
  514.         c__.close ();
  515.       }
  516.       c__ = null;
  517.     }
  518.   }
  519.  
  520.   private static void showException (java.sql.SQLException e)
  521.   {
  522.     java.sql.SQLException next = e;
  523.     while (next != null) {
  524.       printStream__.println ("SQL State: " + next.getSQLState () + "");
  525.       printStream__.println ("Error Code: " + next.getErrorCode () + "");
  526.       printStream__.println ("Message: " + next.getMessage () + "");
  527.       next = next.getNextException ();
  528.     }
  529.   }
  530.  
  531.   private static void dropTestTables () throws java.sql.SQLException
  532.   {
  533.     s__ = c__.createStatement();
  534.     try { s__.executeUpdate ("drop table CHAR1_TABLE"); } catch (java.sql.SQLException e) {}
  535.     try { s__.executeUpdate ("drop table CHAR10_TABLE"); } catch (java.sql.SQLException e) {}
  536.     try { s__.executeUpdate ("drop table CHAR100_TABLE"); } catch (java.sql.SQLException e) {}
  537.     try { s__.executeUpdate ("drop table CHAR1000_TABLE"); } catch (java.sql.SQLException e) {}
  538.     try { s__.executeUpdate ("drop table CHAR10000_TABLE"); } catch (java.sql.SQLException e) {}
  539.     try { s__.executeUpdate ("drop table BLOB1_TABLE"); } catch (java.sql.SQLException e) {}
  540.     try { s__.executeUpdate ("drop table BLOB10_TABLE"); } catch (java.sql.SQLException e) {}
  541.     try { s__.executeUpdate ("drop table BLOB100_TABLE"); } catch (java.sql.SQLException e) {}
  542.     try { s__.executeUpdate ("drop table BLOB1000_TABLE"); } catch (java.sql.SQLException e) {}
  543.     try { s__.executeUpdate ("drop table BLOB10000_TABLE"); } catch (java.sql.SQLException e) {}
  544.     try { s__.executeUpdate ("drop table BLOB100000_TABLE"); } catch (java.sql.SQLException e) {}
  545.     try { s__.executeUpdate ("drop table NUMBER_TABLE"); } catch (java.sql.SQLException e) {}
  546.     try { s__.executeUpdate ("drop table DATE_TABLE"); } catch (java.sql.SQLException e) {}
  547.     try { s__.executeUpdate ("drop procedure INSERT_PROC"); } catch (java.sql.SQLException e) {}
  548.     try { s__.executeUpdate ("drop procedure SELECT_PROC"); } catch (java.sql.SQLException e) {}
  549.     try { s__.executeUpdate ("drop procedure EXECUTE_PROC"); } catch (java.sql.SQLException e) {}
  550.     try { s__.executeUpdate ("drop table PROC_CHAR100_TABLE"); } catch (java.sql.SQLException e) {}
  551.     s__.close();
  552.     c__.commit (); // Some drivers don't force commit on DDL
  553.   }
  554.  
  555.   private static void createTestTables () throws java.sql.SQLException
  556.   {
  557.     s__ = c__.createStatement();
  558.     // Could provide SQL in a resource bundle for each engine__
  559.     String charset = (engine__.equals ("interbase") && (characterSet != null))
  560.                      ? (" character set " +
  561.                         interbase.interclient.CharacterEncodings.getInterBaseCharacterSetName (characterSet))
  562.                      : "";
  563.     if (testStrings) {
  564.       if (test1CharStrings)
  565.     s__.executeUpdate ("create table CHAR1_TABLE (S char(1)" + charset + ")");
  566.       if (test10CharStrings)
  567.     s__.executeUpdate ("create table CHAR10_TABLE (S char(10)" + charset + ")");
  568.       if (test100CharStrings)
  569.     s__.executeUpdate ("create table CHAR100_TABLE (S char(100)" + charset + ")");
  570.       if (test1000CharStrings)
  571.     s__.executeUpdate ("create table CHAR1000_TABLE (S char(1000)" + charset + ")");
  572.       if (test10000CharStrings)
  573.     s__.executeUpdate ("create table CHAR10000_TABLE (S char(10000)" + charset + ")");
  574.     }
  575.     if (testBLObs) {
  576.       String longVarBinary;
  577.       if (engine__.equals ("solid"))
  578.     longVarBinary = "long varbinary";
  579.       else if (engine__.equals ("sqlanywhere"))
  580.         longVarBinary = "Image";
  581.       else
  582.     longVarBinary = "blob";
  583.  
  584.       if (test1ByteBlobs)
  585.     s__.executeUpdate ("create table BLOB1_TABLE (B " + longVarBinary + ")");
  586.       if (test10ByteBlobs)
  587.     s__.executeUpdate ("create table BLOB10_TABLE (B " + longVarBinary + ")");
  588.       if (test100ByteBlobs)
  589.     s__.executeUpdate ("create table BLOB100_TABLE (B " + longVarBinary + ")");
  590.       if (test1000ByteBlobs)
  591.     s__.executeUpdate ("create table BLOB1000_TABLE (B " + longVarBinary + ")");
  592.       if (test10000ByteBlobs)
  593.     s__.executeUpdate ("create table BLOB10000_TABLE (B " + longVarBinary + ")");
  594.       if (test100000ByteBlobs)
  595.     s__.executeUpdate ("create table BLOB100000_TABLE (B " + longVarBinary + ")");
  596.     }
  597.     if (testNumbers) {
  598.       numberBytesPerRecord__ = 32; // number of bytes per row in NUMBER_TABLE
  599.       s__.executeUpdate ("create table NUMBER_TABLE (aSmallint        SMALLINT," +
  600.              "                           anInteger        INTEGER," +
  601.              "                           aDouble          DOUBLE PRECISION," +
  602.              "                           aFloat           FLOAT," +
  603.              "                           aNumericSmallint NUMERIC(4,2)," + // SMALLINT
  604.              "                           aNumericInteger  NUMERIC(9,3)," + // INTEGER
  605.              "                           aNumericDouble   NUMERIC(10,4))");// DOUBLE
  606.     }
  607.     if (testDates) {
  608.       s__.executeUpdate ("create table DATE_TABLE (aDate      DATE," +
  609.              "                         aTime      DATE," +
  610.              "                         aTimestamp DATE)");
  611.     }
  612.     if (testProcedures) {
  613.       s__.executeUpdate ("create table PROC_CHAR100_TABLE (S char(100)" + charset + ")");
  614.       s__.executeUpdate ("create procedure INSERT_PROC" +
  615.                          " as begin insert into PROC_CHAR100_TABLE (S) values ('" +
  616.                          s100chars__ + "'); end");
  617.       s__.executeUpdate ("create procedure SELECT_PROC" +
  618.                          " returns (RETURN_VALUE char(100)" + charset + ")" +
  619.                          " as begin for select S from PROC_CHAR100_TABLE into :RETURN_VALUE" +
  620.                          " do suspend; end");
  621.       s__.executeUpdate ("create procedure EXECUTE_PROC" +
  622.                          " returns (RETURN_VALUE char(100)" + charset + ")" +
  623.                          " as begin RETURN_VALUE = USER; end");
  624.     }
  625.     s__.close();
  626.     c__.commit (); // Some drivers don't force commit on DDL
  627.   }
  628.  
  629.   private static void testMetaData () throws java.sql.SQLException
  630.   {
  631.     java.util.Vector tableVector = new java.util.Vector ();
  632.     java.util.Enumeration tableEnum;
  633.     String table;
  634.  
  635.     startTime__ = System.currentTimeMillis ();
  636.     java.sql.DatabaseMetaData dbmd = c__.getMetaData ();
  637.  
  638.     // First collect a vector of table names
  639.     java.sql.ResultSet tempRS =
  640.       dbmd.getTables ("", "", "%", new String[] {"TABLE", "SYSTEM TABLE", "VIEW"});
  641.     while (tempRS.next ()) {
  642.       tableVector.addElement (tempRS.getString ("TABLE_NAME"));
  643.     }
  644.  
  645.     // Tables
  646.     printStream__.println ("*** Tables ***");
  647.     showResultSet (dbmd.getTables ("", "", "%", new String[] {"TABLE", "SYSTEM TABLE", "VIEW"}));
  648.  
  649.     // Table Privileges
  650.     printStream__.println ("*** Table Privileges ***");
  651.     showResultSet (dbmd.getTablePrivileges ("", "", "%"));
  652.  
  653.     // Columns
  654.     printStream__.println ("*** Columns ***");
  655.     showResultSet (dbmd.getColumns ("", "", "%", "%"));
  656.  
  657.     // Column Privileges
  658.     tableEnum = tableVector.elements ();
  659.     while (tableEnum.hasMoreElements ()) {
  660.       table = (String) tableEnum.nextElement ();
  661.       printStream__.println ("*** Column Privileges for table " + table + " ***");
  662.       showResultSet (dbmd.getColumnPrivileges ("", "", table, "%"));
  663.     }
  664.  
  665.     // Best Row Identifier
  666.     int scope = java.sql.DatabaseMetaData.bestRowSession;
  667.     boolean nullable = false;
  668.     tableEnum = tableVector.elements ();
  669.     while (tableEnum.hasMoreElements ()) {
  670.       table = (String) tableEnum.nextElement ();
  671.       printStream__.println ("*** Best Row Identifier for table " + table + " ***");
  672.       showResultSet (dbmd.getBestRowIdentifier ("", "", table, scope, nullable));
  673.     }
  674.  
  675.     // Version Columns
  676.     tableEnum = tableVector.elements ();
  677.     while (tableEnum.hasMoreElements ()) {
  678.       table = (String) tableEnum.nextElement ();
  679.       printStream__.println ("*** Version Columns for table " + table + " ***");
  680.       showResultSet (dbmd.getVersionColumns ("", "", table));
  681.     }
  682.  
  683.     // Primary Keys
  684.     tableEnum = tableVector.elements ();
  685.     while (tableEnum.hasMoreElements ()) {
  686.       table = (String) tableEnum.nextElement ();
  687.       printStream__.println ("*** Primary Keys for table " + table + " ***");
  688.       showResultSet (dbmd.getPrimaryKeys ("", "", table));
  689.     }
  690.  
  691.     // Imported Keys
  692.     tableEnum = tableVector.elements ();
  693.     while (tableEnum.hasMoreElements ()) {
  694.       table = (String) tableEnum.nextElement ();
  695.       printStream__.println ("*** Imported Keys for table " + table + " ***");
  696.       showResultSet (dbmd.getImportedKeys ("", "", table));
  697.     }
  698.  
  699.     // Exported Keys
  700.     tableEnum = tableVector.elements ();
  701.     while (tableEnum.hasMoreElements ()) {
  702.       table = (String) tableEnum.nextElement ();
  703.       printStream__.println ("*** Exported Keys for table " + table + " ***");
  704.       showResultSet (dbmd.getExportedKeys ("", "", table));
  705.     }
  706.  
  707.     // Cross Reference
  708.     java.util.Enumeration primaryTableEnum = tableVector.elements ();
  709.     java.util.Enumeration foreignTableEnum = tableVector.elements ();
  710.     while (primaryTableEnum.hasMoreElements ()) {
  711.       String primaryTable = (String) primaryTableEnum.nextElement ();
  712.       while (foreignTableEnum.hasMoreElements ()) {
  713.         String foreignTable = (String) foreignTableEnum.nextElement ();
  714.         printStream__.println ("*** Cross Reference for primary table " + primaryTable + " and foreign table " + foreignTable + " ***");
  715.         showResultSet (dbmd.getCrossReference ("", "", primaryTable, "", "", foreignTable));
  716.       }
  717.     }
  718.  
  719.     // Procedures
  720.     printStream__.println ("*** Procedures ***");
  721.     showResultSet (dbmd.getProcedures ("", "", "%"));
  722.  
  723.     // Procedure Columns
  724.     printStream__.println ("*** Procedure Columns ***");
  725.     showResultSet (dbmd.getProcedureColumns ("", "", "%", "%"));
  726.  
  727.     // Table Types
  728.     printStream__.println ("*** Table Types ***");
  729.     showResultSet (dbmd.getTableTypes ());
  730.  
  731.     // Type Info
  732.     printStream__.println ("*** Type Info ***");
  733.     showResultSet (dbmd.getTypeInfo ());
  734.  
  735.     // Index Info
  736.     boolean unique = false;
  737.     boolean approximate = true;
  738.     tableEnum = tableVector.elements ();
  739.     while (tableEnum.hasMoreElements ()) {
  740.       table = (String) tableEnum.nextElement ();
  741.       printStream__.println ("*** Index Info for table " + table + " ***");
  742.       showResultSet (dbmd.getIndexInfo ("", "", table, unique, approximate));
  743.     }
  744.  
  745.     endTime__ = System.currentTimeMillis ();
  746.     elapsedTime__ = endTime__ - startTime__;
  747.     printStream__.println ("database metadata extracted in: " + elapsedTime__ + " milliseconds");
  748.   }
  749.  
  750.   private static void showResultSet (java.sql.ResultSet resultSet) throws java.sql.SQLException
  751.   {
  752.     java.sql.ResultSetMetaData metaData = resultSet.getMetaData();
  753.     int[] displaySizes = new int[metaData.getColumnCount ()];
  754.     for (int col=1; col <= metaData.getColumnCount (); col++) {
  755.       displaySizes[col-1] = Math.max (metaData.getColumnName (col).length(),
  756.                                       metaData.getColumnDisplaySize (col)) + 1;
  757.     }
  758.  
  759.     for (int col=1; col <= metaData.getColumnCount (); col++) {
  760.       writeColumnData (metaData.getColumnName (col), col, displaySizes);
  761.     }
  762.     printStream__.println ();
  763.     for (int col=1; col <= metaData.getColumnCount (); col++) {
  764.       writeColumnData (metaData.getTableName (col), col, displaySizes);
  765.     }
  766.     printStream__.println ();
  767.     for (int col=1; col <= metaData.getColumnCount (); col++) {
  768.       writeColumnData (metaData.getColumnLabel (col), col, displaySizes);
  769.     }
  770.     printStream__.println ();
  771.     for (int col=1; col <= metaData.getColumnCount (); col++) {
  772.       writeColumnData (metaData.getColumnTypeName (col), col, displaySizes);
  773.     }
  774.     printStream__.println ();
  775.     for (int col=1; col <= metaData.getColumnCount (); col++) {
  776.       writeColumnData (String.valueOf (metaData.isWritable (col)), col, displaySizes);
  777.     }
  778.     printStream__.println ();
  779.     while (resultSet.next ()) {
  780.       for (int col=1; col <= metaData.getColumnCount (); col++) {
  781.     writeColumnData (resultSet.getString (col), col, displaySizes);
  782.       }
  783.       printStream__.println ();
  784.     }
  785.     printStream__.println ();
  786.     resultSet.close ();
  787.   }
  788.  
  789.   private static void writeColumnData (String string,
  790.                                        int column,
  791.                                        int[] displaySizes)
  792.   {
  793.      printStream__.print (string);
  794.  
  795.      int strLength;
  796.      if (string == null)
  797.        strLength = 4;
  798.      else
  799.        strLength = string.length ();
  800.  
  801.      for (int i=strLength; i < displaySizes[column-1]; i++)
  802.        printStream__.print (' ');
  803.   }
  804.  
  805.   private static void testStringInsertPerformance () throws java.sql.SQLException
  806.   {
  807.     if (test1CharStrings)
  808.       try { insertStrings (s1char__); } catch (java.sql.SQLException e) { showException (e); }
  809.  
  810.     if (test10CharStrings)
  811.       try { insertStrings (s10chars__); } catch (java.sql.SQLException e) { showException (e); }
  812.  
  813.     if (test100CharStrings)
  814.       try { insertStrings (s100chars__); } catch (java.sql.SQLException e) { showException (e); }
  815.  
  816.     if (test1000CharStrings)
  817.       try { insertStrings (s1000chars__); } catch (java.sql.SQLException e) { showException (e); }
  818.  
  819.     if (test10000CharStrings)
  820.       try { insertStrings (s10000chars__); } catch (java.sql.SQLException e) { showException (e); }
  821.   }
  822.  
  823.   private static void insertStrings (String str) throws java.sql.SQLException
  824.   {
  825.     int numRows = Math.max (1, testDataSize/str.length ());
  826.     int numChars = 0;
  827.  
  828.     startTime__ = System.currentTimeMillis ();
  829.     ps__ = c__.prepareStatement ("insert into CHAR" + str.length() + "_TABLE (S) values (?)"); // Network
  830.     for (int row = 0; row < numRows; row++) {
  831.       numChars += str.length();
  832.       ps__.setString (1, str);
  833.       ps__.executeUpdate (); // Network
  834.     }
  835.     ps__.close ();
  836.     endTime__ = System.currentTimeMillis ();
  837.     elapsedTime__ = endTime__ - startTime__;
  838.     printStream__.println ("inserted " + numRows + " rows of " + str.length() + " char strings in: " +
  839.                  elapsedTime__ + " milliseconds (" + numChars + " chars inserted)");
  840.   }
  841.  
  842.   private static void testStringSelectPerformance () throws java.sql.SQLException
  843.   {
  844.     if (test1CharStrings)
  845.       try { selectStrings (s1char__.length()); } catch (java.sql.SQLException e) { showException (e); }
  846.  
  847.     if (test10CharStrings)
  848.       try { selectStrings (s10chars__.length ()); } catch (java.sql.SQLException e) { showException (e); }
  849.  
  850.     if (test100CharStrings)
  851.       try { selectStrings (s100chars__.length ()); } catch (java.sql.SQLException e) { showException (e); }
  852.  
  853.     if (test1000CharStrings)
  854.       try { selectStrings (s1000chars__.length ()); } catch (java.sql.SQLException e) { showException (e); }
  855.  
  856.     if (test10000CharStrings)
  857.       try { selectStrings (s10000chars__.length ()); } catch (java.sql.SQLException e) { showException (e); }
  858.   }
  859.  
  860.   private static void selectStrings (int length) throws java.sql.SQLException
  861.   {
  862.     int numRows = 0;
  863.     int numChars = 0;
  864.     String temp;
  865.  
  866.     startTime__ = System.currentTimeMillis ();
  867.     s__ = c__.createStatement ();
  868.     rs__ = s__.executeQuery ("select S from CHAR" + length + "_TABLE"); // Network
  869.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  870.       temp = rs__.getString(1);
  871.       numRows++;
  872.       numChars += temp.length();
  873.     }
  874.     s__.close ();
  875.     endTime__ = System.currentTimeMillis ();
  876.     elapsedTime__ = endTime__ - startTime__;
  877.     printStream__.println ("selected " + numRows + " rows of " + length + " char strings in: " +
  878.                  elapsedTime__ + " milliseconds (" + numChars  + " chars selected)");
  879.   }
  880.  
  881.   private static void testBLObInsertPerformance () throws java.sql.SQLException
  882.   {
  883.     if (test1ByteBlobs)
  884.       try { insertBLObs (b1byte__); } catch (java.sql.SQLException e) { showException (e); }
  885.  
  886.     if (test10ByteBlobs)
  887.       try { insertBLObs (b10bytes__);  } catch (java.sql.SQLException e) { showException (e); }
  888.  
  889.     if (test100ByteBlobs)
  890.       try { insertBLObs (b100bytes__);  } catch (java.sql.SQLException e) { showException (e); }
  891.  
  892.     if (test1000ByteBlobs)
  893.       try { insertBLObs (b1000bytes__); } catch (java.sql.SQLException e) { showException (e); }
  894.  
  895.     if (test10000ByteBlobs)
  896.       try { insertBLObs (b10000bytes__);  } catch (java.sql.SQLException e) { showException (e); }
  897.  
  898.     if (test100000ByteBlobs)
  899.       try { insertBLObs (b100000bytes__);  } catch (java.sql.SQLException e) { showException (e); }
  900.   }
  901.  
  902.   private static void insertBLObs (byte[] bytes) throws java.sql.SQLException
  903.   {
  904.     java.io.ByteArrayInputStream stream = null;
  905.     int numRows = Math.max (1, testDataSize/bytes.length);
  906.     int numBytes = 0;
  907.  
  908.     startTime__ = System.currentTimeMillis ();
  909.     ps__ = c__.prepareStatement ("insert into BLOB" + bytes.length + "_TABLE (B) values (?)"); // Network
  910.     for (int row = 0; row < numRows; row++) {
  911.       numBytes += bytes.length;
  912.       stream = new java.io.ByteArrayInputStream (bytes);
  913.       ps__.setBinaryStream (1, stream, bytes.length);
  914.       ps__.executeUpdate (); // Network
  915.     }
  916.     ps__.close ();
  917.     endTime__ = System.currentTimeMillis ();
  918.     elapsedTime__ = endTime__ - startTime__;
  919.     printStream__.println ("inserted " + numRows + " rows of " + bytes.length + " byte blobs in: " +
  920.                  elapsedTime__ + " milliseconds (" + numBytes + " bytes inserted)");
  921.   }
  922.  
  923.   private static void testBLObSelectPerformance () throws java.sql.SQLException
  924.   {
  925.     if (test1ByteBlobs)
  926.       try { selectBLObs (b1byte__.length);  } catch (java.sql.SQLException e) { showException (e); }
  927.  
  928.     if (test10ByteBlobs)
  929.       try { selectBLObs (b10bytes__.length); } catch (java.sql.SQLException e) { showException (e); }
  930.  
  931.     if (test100ByteBlobs)
  932.       try { selectBLObs (b100bytes__.length);  } catch (java.sql.SQLException e) { showException (e); }
  933.  
  934.     if (test1000ByteBlobs)
  935.       try { selectBLObs (b1000bytes__.length); } catch (java.sql.SQLException e) { showException (e); }
  936.  
  937.     if (test10000ByteBlobs)
  938.       try { selectBLObs (b10000bytes__.length); } catch (java.sql.SQLException e) { showException (e); }
  939.  
  940.     if (test100000ByteBlobs)
  941.       try { selectBLObs (b100000bytes__.length); } catch (java.sql.SQLException e) { showException (e); }
  942.   }
  943.  
  944.   private static void selectBLObs (int length) throws java.sql.SQLException
  945.   {
  946.     java.io.InputStream stream;
  947.     byte[] readBuffer = new byte[testDataSize]; // More than adequate
  948.     int numRows = 0;
  949.     int bytesRead;
  950.     int numBytes = 0;
  951.  
  952.     try {
  953.       startTime__ = System.currentTimeMillis ();
  954.       s__ = c__.createStatement ();
  955.       rs__ = s__.executeQuery ("select B from BLOB" + length + "_TABLE"); // Network
  956.       while (rs__.next ()) {
  957.     stream = rs__.getBinaryStream (1);
  958.         numRows++;
  959.         while ((bytesRead = stream.read (readBuffer)) != -1) { // Network
  960.           numBytes += bytesRead;
  961.         }
  962.       }
  963.       s__.close ();
  964.       endTime__ = System.currentTimeMillis ();
  965.       elapsedTime__ = endTime__ - startTime__;
  966.       printStream__.println ("selected " + numRows + " rows of " + length + " byte blobs in: " +
  967.              elapsedTime__ + " milliseconds (" + numBytes + " bytes selected)");
  968.     }
  969.     catch (java.io.IOException e) {
  970.       throw new java.sql.SQLException ("IOException: " + e.getMessage ());
  971.     }
  972.   }
  973.  
  974.   private static void testNumberInsertPerformance () throws java.sql.SQLException
  975.   {
  976.     try { insertNumbers (); } catch (java.sql.SQLException e) { showException (e); }
  977.   }
  978.  
  979.   private static void insertNumbers () throws java.sql.SQLException
  980.   {
  981.     int numRows = Math.max (1, testDataSize/numberBytesPerRecord__);
  982.  
  983.     startTime__ = System.currentTimeMillis ();
  984.     ps__ = c__.prepareStatement ("insert into NUMBER_TABLE (aSmallint," +
  985.                  "                          anInteger," +
  986.                  "                          aDouble," +
  987.                  "                          aFloat," +
  988.                  "                          aNumericSmallint," +
  989.                  "                          aNumericInteger," +
  990.                  "                          aNumericDouble)" +
  991.                  " values (?, ?, ?, ?, ?, ?, ?)"); // Network
  992.     for (int row = 0; row < numRows; row++) {
  993.       ps__.setShort (1, (short) 1);
  994.       ps__.setInt (2, 2);
  995.       ps__.setDouble (3, (double) 3);
  996.       ps__.setFloat (4, (float) 4);
  997.       ps__.setInt (5, 5);
  998.       ps__.setInt (6, 6);
  999.       ps__.setDouble (7, (double) 7);
  1000.       ps__.executeUpdate (); // Network
  1001.     }
  1002.     ps__.close ();
  1003.     endTime__ = System.currentTimeMillis ();
  1004.     elapsedTime__ = endTime__ - startTime__;
  1005.     printStream__.println ("inserted " + numRows + " rows of " + numberBytesPerRecord__ + " byte number records in: " +
  1006.            elapsedTime__ + " milliseconds (" + numRows*numberBytesPerRecord__ + " bytes inserted)");
  1007.   }
  1008.  
  1009.   private static void testNumberSelectPerformance () throws java.sql.SQLException
  1010.   {
  1011.     try { selectNumbers ();  } catch (java.sql.SQLException e) { showException (e); }
  1012.   }
  1013.  
  1014.   private static void selectNumbers () throws java.sql.SQLException
  1015.   {
  1016.     int numRows = 0;
  1017.  
  1018.     s__ = c__.createStatement ();
  1019.     startTime__ = System.currentTimeMillis ();
  1020.     rs__ = s__.executeQuery ("select aSmallint," +
  1021.                  "       anInteger," +
  1022.                  "       aDouble," +
  1023.                  "       aFloat," +
  1024.                  "       aNumericSmallint," +
  1025.                  "       aNumericInteger," +
  1026.                  "       aNumericDouble" +
  1027.                  " from NUMBER_TABLE"); // Network
  1028.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  1029.       numRows++;
  1030.       rs__.getString (1);
  1031.       rs__.getString (2);
  1032.       rs__.getString (3);
  1033.       rs__.getString (4);
  1034.       rs__.getString (5);
  1035.       rs__.getString (6);
  1036.       rs__.getString (7);
  1037.     }
  1038.     s__.close ();
  1039.     endTime__ = System.currentTimeMillis ();
  1040.     elapsedTime__ = endTime__ - startTime__;
  1041.     printStream__.println ("selected " + numRows + " rows of " + numberBytesPerRecord__ + " byte number records in: " +
  1042.            elapsedTime__ + " milliseconds (" + numRows*numberBytesPerRecord__  + " bytes selected)");
  1043.   }
  1044.  
  1045.   private static void testDateInsertPerformance () throws java.sql.SQLException
  1046.   {
  1047.     try { insertDates ();  } catch (java.sql.SQLException e) { showException (e); }
  1048.   }
  1049.  
  1050.   private static void insertDates () throws java.sql.SQLException
  1051.   {
  1052.     int numRows = Math.max (1, testDataSize/(3*8)); // 3 64-bit fields
  1053.  
  1054.     startTime__ = System.currentTimeMillis ();
  1055.     ps__ = c__.prepareStatement ("insert into DATE_TABLE (aDate," +
  1056.                  "                        aTime," +
  1057.                  "                        aTimestamp)" +
  1058.                  " values (?, ?, ?)"); // Network
  1059.     for (int row = 0; row < numRows; row++) {
  1060.       ps__.setDate (1, new java.sql.Date (98, 1, 3));
  1061.       ps__.setTime (2, new java.sql.Time (0, 0, 0));
  1062.       ps__.setTimestamp (3, new java.sql.Timestamp (98, 1, 3, 0, 0, 0, 0));
  1063.       ps__.executeUpdate (); // Network
  1064.     }
  1065.     ps__.close ();
  1066.     endTime__ = System.currentTimeMillis ();
  1067.     elapsedTime__ = endTime__ - startTime__;
  1068.     printStream__.println ("inserted " + numRows + " rows of 3 field (date, time, timestamp) records in: " +
  1069.                  elapsedTime__ + " milliseconds (" + numRows*3*8 + " bytes inserted)");
  1070.   }
  1071.  
  1072.   private static void testDateSelectPerformance () throws java.sql.SQLException
  1073.   {
  1074.     try { selectDates (); } catch (java.sql.SQLException e) { showException (e); }
  1075.   }
  1076.  
  1077.   private static void selectDates () throws java.sql.SQLException
  1078.   {
  1079.     int numRows = 0;
  1080.  
  1081.     s__ = c__.createStatement ();
  1082.     startTime__ = System.currentTimeMillis ();
  1083.     rs__ = s__.executeQuery ("select aDate," +
  1084.                  "       aTime," +
  1085.                  "       aTimestamp" +
  1086.                  " from DATE_TABLE"); // Network
  1087.  
  1088.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  1089.       numRows++;
  1090.       rs__.getString (1);
  1091.       rs__.getString (2);
  1092.       rs__.getString (3);
  1093.     }
  1094.     s__.close ();
  1095.     endTime__ = System.currentTimeMillis ();
  1096.     elapsedTime__ = endTime__ - startTime__;
  1097.     printStream__.println ("selected " + numRows + " rows of 3 field (date, time, timestamp) records in: " +
  1098.                  elapsedTime__ + " milliseconds (" + numRows*3*8 + " bytes selected)");
  1099.   }
  1100.  
  1101.   private static void testProcedureInsertPerformance () throws java.sql.SQLException
  1102.   {
  1103.     startTime__ = System.currentTimeMillis ();
  1104.     s__ = c__.createStatement ();
  1105.     s__.executeUpdate ("execute procedure INSERT_PROC"); // Network
  1106.     s__.close ();
  1107.     endTime__ = System.currentTimeMillis ();
  1108.     elapsedTime__ = endTime__ - startTime__;
  1109.     printStream__.println ("executed procedure INSERT_PROC in: " +
  1110.                  elapsedTime__ + " milliseconds");
  1111.   }
  1112.  
  1113.   private static void testProcedureSelectPerformance () throws java.sql.SQLException
  1114.   {
  1115.     int numRows = 0;
  1116.  
  1117.     startTime__ = System.currentTimeMillis ();
  1118.     s__ = c__.createStatement ();
  1119.     s__.execute ("execute procedure SELECT_PROC"); // Network
  1120.     rs__ = s__.getResultSet ();
  1121.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  1122.       numRows++;
  1123.       rs__.getString (1);
  1124.     }
  1125.  
  1126.     rs__ = s__.executeQuery ("execute procedure EXECUTE_PROC"); // Network
  1127.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  1128.       numRows++;
  1129.       rs__.getString (1);
  1130.     }
  1131.  
  1132.     rs__ = s__.executeQuery ("select * from SELECT_PROC"); // Network
  1133.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  1134.       numRows++;
  1135.       rs__.getString (1);
  1136.     }
  1137.  
  1138.     rs__ = s__.executeQuery ("select * from EXECUTE_PROC"); // Network
  1139.     while (rs__.next ()) { // Networks only when local row cache is exhausted
  1140.       numRows++;
  1141.       rs__.getString (1);
  1142.     }
  1143.  
  1144.     s__.close ();
  1145.     endTime__ = System.currentTimeMillis ();
  1146.     elapsedTime__ = endTime__ - startTime__;
  1147.     printStream__.println ("executed various procedures in: " +
  1148.                  elapsedTime__ + " milliseconds");
  1149.   }
  1150. }
  1151.