test/performance/wisc/JDBCBench.java

   1 import java.sql.*;
   2 import java.util.Random;
   3 public class JDBCBench
   4 {
   5    public static Random generator = new Random();
   6    public static int getRandom(int end)
   7    {
   8        double val = generator.nextDouble();
   9        val *=end;
  10        return (int)(val);
  11    }
  12
  13    public static int singleTuple(Connection con, boolean flag)throws Exception
  14    {
  15         PreparedStatement stmt = null ;
  16         String stmtStr;
  17         if (flag) {
  18             String buf = "SELECT unique1, unique2, stringu1, stringu2 from big1 where unique1=?";
  19             stmtStr = buf;
  20         }else {
  21             String buf = "SELECT unique1, unique2, stringu1, stringu2 from big1 where stringu1=?";
  22             stmtStr = buf;
  23         }
  24
  25         stmt = con.prepareStatement(stmtStr);
  26         int count=0, recordCount=0;
  27         int ret =0;
  28         long start=0, end=0, curr=0;
  29         long tot=0;
  30         ResultSet  rs;
  31         int searchVal[] = {1, 10, 100, 500, 1000, 5000 ,7500, 8000, 9000, 9999};
  32
  33         for(int i=0; i<10; i++) {
  34                 start = System.nanoTime();
  35                 if (flag)
  36                     stmt.setInt(1, searchVal[i]);
  37                 else
  38                     stmt.setString(1, "Value" +searchVal[i]);
  39                 rs = stmt.executeQuery();
  40                 recordCount=0;
  41                 if(rs.next())
  42                 {
  43                    recordCount++;
  44                 }
  45                 rs.close();
  46                 con.commit();
  47                 end = System.nanoTime();
  48                 if(recordCount != 1)
  49                 {
  50                    System.out.println("No of records for:"+ stmtStr +""+ recordCount );
  51                    return 0;
  52                 }
  53
  54                 curr = end - start;
  55                 tot = tot + curr;
  56                 count++;
  57         }
  58
  59         stmt.close();
  60         return (int)tot/10/1000;
  61    }
  62
  63
  64
  65 public static int onePerSel(Connection con) throws Exception
  66    {
  67           PreparedStatement stmt = null;
  68
  69           String stmtStr;
  70           String buf= "SELECT unique1, unique2, stringu1 from big1 where unique1 between ? and ?";
  71           stmtStr= buf;
  72           stmt = con.prepareStatement(stmtStr);
  73           int count =0, recordCount=0;
  74           int ret =0;
  75           long start =0, end =0, curr =0;
  76           long tot =0;
  77           ResultSet rs;
  78           int searchVal[] = {1, 5, 10, 50, 100, 500, 1000, 5000 ,7500, 9500};
  79           for (int i =0 ; i< 10 ; i++) {
  80              start = System.nanoTime();
  81              stmt.setInt(1, searchVal[i]);
  82              stmt.setInt(2, searchVal[i] +99);
  83              rs = stmt.executeQuery();
  84              recordCount=0;
  85              while (rs.next())
  86              {
  87                  recordCount++;
  88              }
  89
  90              rs.close();
  91              con.commit();
  92              end = System.nanoTime();
  93
  94
  95              if (recordCount!= 100)
  96              {
  97                  System.out.println("No. of records for:"+ stmtStr +" "+recordCount);
  98                  return 0;
  99              }
 100              curr = end-start;
 101              tot = tot + curr;
 102              count++;
 103
 104          }
 105          stmt.close();
 106          return (int)tot/10/1000;
 107    }
 108
 109 //Order By
 110 public static int orderby(Connection con) throws Exception
 111    {
 112           PreparedStatement stmt = null;
 113           String stmtStr="";
 114           String buf= "SELECT two, four, ten, twenty, onepercent, string4 from big1 where unique1 between ? and ? order by unique1";
 115           stmtStr= buf;
 116
 117           stmt = con.prepareStatement(stmtStr);
 118           int count =0, recordCount=0;
 119           int ret =0;
 120           long start =0, end =0, curr =0;
 121           long tot =0;
 122           ResultSet rs;
 123           int searchVal[] = {1, 5, 10, 50, 100, 500, 1000, 5000 ,7500, 9500};
 124           for (int i =0 ; i< 10 ; i++) {
 125              start = System.nanoTime();
 126              stmt.setInt(1, searchVal[i]);
 127              stmt.setInt(2, searchVal[i] +99);
 128              rs = stmt.executeQuery();
 129              recordCount=0;
 130              while (rs.next())
 131              {
 132                  recordCount++;
 133              }
 134
 135              rs.close();
 136              con.commit();
 137              end = System.nanoTime();
 138
 139
 140              if (recordCount!= 100)
 141              {
 142                  System.out.println("No. of records for"+ stmtStr +" "+recordCount);
 143                  return 0;
 144              }
 145              curr = end-start;
 146              tot = tot + curr;
 147              count++;
 148
 149          }
 150          stmt.close();
 151          return (int)tot/10/1000;
 152    }
 153
 154
 155 //DISTINCT
 156 public static int distinct(Connection con) throws Exception
 157    {
 158           PreparedStatement stmt = null;
 159           String stmtStr="";
 160           //String buf = "SELECT DISTINCT two, four, ten, twenty, onepercent, string4 FROM big1;";
 161           String buf = "SELECT DISTINCT onepercent FROM big1";
 162           stmtStr=buf;
 163           stmt = con.prepareStatement(stmtStr);
 164           int count =0, recordCount=0;
 165           int ret =0;
 166           long start =0, end =0, curr =0;
 167           long tot =0;
 168           ResultSet rs;
 169           for (int i =0 ; i< 10 ; i++) {
 170              start = System.nanoTime();
 171              rs = stmt.executeQuery();
 172              recordCount=0;
 173              while(rs.next())
 174              {
 175                  recordCount++;
 176              }
 177
 178              rs.close();
 179              con.commit();
 180              end = System.nanoTime();
 181
 182              if (recordCount!= 100)
 183              {
 184                  System.out.println("No. of records for" + stmtStr + " "+recordCount);
 185                  return 0;
 186              }
 187              curr = end-start;
 188              tot = tot + curr;
 189              count++;
 190
 191          }
 192          stmt.close();
 193          return (int)tot/10/1000;
 194    }
 195
 196
 197 // aggregate
 198 public static int aggregate(Connection con, int val,boolean flag)throws Exception
 199 {
 200         PreparedStatement stmt = null;
 201         String stmtStr="";
 202         if(val==1 && !flag)
 203         {
 204             String buf = "SELECT MIN(unique1) from big1";
 205             stmtStr = buf;
 206         }
 207         else if(val==1 && flag)
 208         {
 209
 210             String buf = "SELECT MIN(unique1) from big1 group by onepercent";
 211             stmtStr = buf;
 212
 213         }
 214
 215         if(val==2 && !flag)
 216         {
 217             String buf = "SELECT MAX(unique1) from big1";
 218             stmtStr = buf;
 219         }
 220         else if(val==2 && flag)
 221         {
 222
 223             String buf = "SELECT MAX(unique1) from big1 group by onepercent";
 224             stmtStr = buf;
 225
 226         }
 227         else if(val==3 && !flag)
 228         {
 229
 230             String buf = "SELECT SUM(unique1) from big1";
 231             stmtStr = buf;
 232         }
 233         else if (val==3 && flag)
 234         {
 235
 236             String buf = "SELECT SUM(unique1) from big1 group by onepercent";
 237             stmtStr = buf;
 238         }
 239         stmt = con.prepareStatement(stmtStr);
 240         int count = 0, recordCount;
 241         int ret = 0;
 242         long start = 0,end = 0,curr = 0;
 243         long tot = 0;
 244         ResultSet rs;
 245
 246         for(int i=0;i<10;i++){
 247                 start = System.nanoTime();
 248                 rs = stmt.executeQuery();
 249                 recordCount = 0;
 250                 while(rs.next())
 251                 {
 252                     recordCount++;
 253                 }
 254
 255                 rs.close();
 256                 con.commit();
 257                 end = System.nanoTime();
 258
 259                 if(!flag && recordCount !=1)
 260                 {
 261                     System.out.println("No. of records for "+ stmtStr + " "+recordCount);
 262                     return 0;
 263                 }else if (flag && recordCount !=100)
 264                 {
 265                     System.out.println("No. of records for "+ stmtStr + " "+  recordCount);
 266                     return 0;
 267                 }
 268                 curr = end - start;
 269                 tot = tot + curr;
 270                 count++;
 271         }
 272         stmt.close();
 273         return (int)tot/10/1000;
 274    }
 275
 276
 277   // DML statement
 278   public static int dmlstatement(Connection con, int val)throws Exception
 279   {
 280         PreparedStatement stmt = null;
 281         String stmtStr="";
 282         if(val==1)
 283         {
 284                 String buf = "insert into big1 values(?,?,0,2,0,10,50,688,1950,4950,9950,1,100,'MXXXXXXXXXXXXXXXXXXXXXXXXXGXXXXXXXXXXXXXXXXXXXXXXXXC','GXXXXXXXXXXXXXXXXXXXXXXXXXCXXXXXXXXXXXXXXXXXXXXXXXXA','OXXXXXXXXXXXXXXXXXXXXXXXXXOXXXXXXXXXXXXXXXXXXXXXXXXO')";
 285                 stmtStr = buf;
 286         }
 287         else if(val==2)
 288         {
 289             String buf = "UPDATE big1 SET two=1 WHERE unique1=?";
 290             stmtStr = buf;
 291         }
 292         else
 293         {
 294             String buf = "DELETE FROM big1 WHERE unique1=?";
 295             stmtStr = buf;
 296         }
 297
 298         stmt = con.prepareStatement(stmtStr);
 299         int count = 0, recordCount=0;
 300         int ret = 0;
 301         long start = 0,end = 0,curr = 0;
 302         long tot = 0;
 303         for(int i=0; i<100; i++){
 304                 stmt.setInt(1, 10000+i);
 305                 if (val ==1) stmt.setInt(2, 10000+i);
 306                 start = System.nanoTime();
 307                 ret = stmt.executeUpdate();
 308                 if(ret!=1) return 1;
 309
 310                 con.commit();
 311                 end = System.nanoTime();
 312                 curr = end - start;
 313                 tot = tot + curr;
 314                 count++;
 315         }
 316         stmt.close();
 317         return (int)tot/100/1000;
 318   }
 319
 320
 321 // Joining
 322 public static int joining(Connection con,int val)throws Exception
 323 {
 324         PreparedStatement stmt = null;
 325         String stmtStr= null;
 326         if(val==1 )
 327         {
 328             String buf = "SELECT big1.unique1, big1.unique2, small.unique1, small.stringu1 FROM big1,small WHERE big1.unique2=small.unique1 AND big1.unique1=?";
 329             stmtStr = buf;
 330         }
 331         else if(val==2)
 332         {
 333             String buf = "SELECT small.unique1, big1.unique1, big2.unique1, small.stringu1, big1.unique2, big2.unique2 FROM big1, big2, small WHERE big1.unique2 = small.unique1 AND big1.unique2=big2.unique1 AND big1.unique1 = ?";
 334             stmtStr=buf;
 335         }
 336
 337         stmt  = con.prepareStatement(stmtStr);
 338         int count=0,recordCount=0,ret=0;
 339         long start=0,end=0,curr=0;
 340         long tot=0;
 341         ResultSet rs;
 342         int searchVal[] = {1, 5, 10, 50, 100, 250, 500, 750, 900, 999};
 343         for(int i=0;i<10;i++)
 344         {
 345                 recordCount =0;
 346                 start = System.nanoTime();
 347                 stmt.setInt(1, searchVal[i]);
 348                 rs = stmt.executeQuery();
 349                 while(rs.next())
 350                 {
 351                   //  System.out.println("Record:"+ rs.getInt(1)+ " "+ rs.getInt(2)+" " +rs.getInt(3)+ " "+ rs.getString(4));
 352                     recordCount++;
 353                 }
 354                 rs.close();
 355                 con.commit();
 356                 end=System.nanoTime();
 357                 if(recordCount!=1)
 358                 {
 359                    System.out.println("No. of records in"+ stmtStr +" "+ recordCount);
 360                    return 0;
 361                 }
 362
 363                 curr = end - start;
 364                 tot = tot + curr;
 365                 count++;
 366         }
 367         stmt.close();
 368         return (int)tot/10/1000;
 369 }
 370
 371 static long joinCondition(Connection con,int val)throws Exception
 372
 373 {
 374         PreparedStatement stmt = null;
 375         String stmtStr= null;
 376         if(val==1 )
 377         {
 378            String buf = "SELECT big1.unique1, big1.unique2, small.unique1, small.stringu1 FROM big1,small WHERE big1.unique2=small.unique1 AND big1.unique1 > ? AND big1.unique1 <= ?";
 379             stmtStr = buf;
 380         }
 381         else if(val==2)
 382         {
 383             String buf = "SELECT small.unique1, big1.unique1, big2.unique1, small.stringu1, big1.unique2, big2.unique2 FROM big1, big2, small WHERE big1.unique2=small.unique1 AND big1.unique2=big2.unique1 AND big1.unique1 > ? and big1.unique1 <= ?";
 384             stmtStr=buf;
 385         }
 386
 387         stmt  = con.prepareStatement(stmtStr);
 388         int count=0,recordCount=0,ret=0;
 389         long  start=0,end=0,curr=0;
 390         long  tot=0;
 391         ResultSet rs;
 392         int searchVal[] = {1, 5, 10, 50, 100, 200, 250, 500, 750, 800};
 393         for(int i=0;i<10;i++)
 394         {
 395                 recordCount =0;
 396                 start = System.nanoTime();
 397                 stmt.setInt(1, searchVal[i]);
 398                 stmt.setInt(2, searchVal[i]+100);
 399                 rs = stmt.executeQuery();
 400                 while(rs.next())
 401                 {
 402                     //System.out.println("Record:"+ rs.getInt(1)+ " "+ rs.getInt(2)+" " +rs.getInt(3)+ " "+ rs.getString(4));
 403                     recordCount++;
 404                 }
 405                 rs.close();
 406                 con.commit();
 407                 end=System.nanoTime();
 408                 if(recordCount!=100)
 409                 {
 410                    System.out.println("No. of records in"+ stmtStr +" "+ recordCount);
 411                    return 0;
 412                 }
 413
 414                 curr = end - start;
 415                 tot = tot + curr;
 416                 count++;
 417         }
 418         stmt.close();
 419         return tot/10/1000;
 420 }
 421
 422
 423
 424 //*****************************************************
 425 public static void main(String[] args)
 426
 427    {
 428      int flag=1;
 429      if (args.length == 3)
 430      {
 431          if (args[0].equals("csql")) flag=1;
 432          else if (args[0].equals("mysql")) flag=2;
 433          else if (args[0].equals("postgres")) flag=3;
 434          else if (args[0].equals("oracle")) flag=4;
 435          else if (args[0].equals("sybase")) flag=5;
 436      }
 437      else {
 438          System.out.println("Usage: java JDBCBench <DBNAME> <username> <password>");
 439          return;
 440      }
 441      try
 442      {
 443           Connection con = null;
 444           if (flag == 1) {
 445               Class.forName("csql.jdbc.JdbcSqlDriver");
 446               con = DriverManager.getConnection("jdbc:csql", args[1], args[2]);
 447           } else if (flag == 2) {
 448               Class.forName("com.mysql.jdbc.Driver");
 449               con = DriverManager.getConnection("jdbc:mysql://localhost/test", args[1], args[2]);
 450           } else if (flag == 3) {
 451               Class.forName("org.postgresql.Driver");
 452               con = DriverManager.getConnection("jdbc:postgresql://localhost/test", args[1], args[2]);
 453           } else if (flag == 4) {
 454               Class.forName("oracle.jdbc.driver.OracleDriver");
 455               con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", args[1], args[2]);
 456           } else if (flag == 5) {
 457               Class.forName("com.sybase.jdbc3.jdbc.SybDataSource");
 458               con = DriverManager.getConnection("jdbc:sybase:Tds:localhost:4112", args[1], args[2]);
 459           }
 460           con.setAutoCommit(false);
 461           con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
 462           Statement cStmt = con.createStatement();
 463
 464           long timeTaken[][] = new long[20][3];
 465           int ins=1,upd=2,del=3;// function parameter
 466           int min=1, max=2,sum=3;// function parameter
 467
 468
 469           timeTaken[0][0] = singleTuple(con, true);
 470           timeTaken[1][0] = singleTuple(con, false);
 471
 472           timeTaken[2][0] = onePerSel(con);
 473           timeTaken[3][0] = aggregate(con,min,false);
 474           timeTaken[4][0] = aggregate(con,min,true);
 475           timeTaken[5][0] = aggregate(con,max,false);
 476           timeTaken[6][0] = aggregate(con,max,true);
 477
 478           timeTaken[7][0] = aggregate(con,sum,false);
 479           timeTaken[8][0] = aggregate(con,sum,true);
 480           timeTaken[9][0] = distinct(con);
 481           timeTaken[10][0] = orderby(con);
 482
 483           timeTaken[11][0] = dmlstatement(con,ins);
 484           timeTaken[12][0] = dmlstatement(con,upd);
 485           timeTaken[13][0] = dmlstatement(con,del);
 486           timeTaken[14][0] = joining(con,1);
 487           timeTaken[15][0] = joining(con,2);
 488           timeTaken[16][0] = joinCondition(con,1);
 489           timeTaken[17][0] = joinCondition(con,2);
 490           System.out.println("Finished no index queries");
 491           try{
 492               if(flag == 1)
 493               {
 494                  cStmt.execute("FLUSH CACHE");
 495                  con.commit();
 496               }
 497            }catch(Exception e ){e.printStackTrace(); System.out.println("Error creating index");}
 498           //create index
 499           try{
 500             if (flag ==1) {
 501               cStmt.execute("CREATE INDEX idx1 ON big1(unique1) HASH");
 502               cStmt.close();
 503               cStmt.execute("CREATE INDEX idx2 ON big2(unique1) HASH");
 504               cStmt.close();
 505               cStmt.execute("CREATE INDEX idx3 ON small(unique1) HASH");
 506               cStmt.close();
 507               cStmt.execute("CREATE INDEX idx4 ON big1(stringu1) HASH");
 508               cStmt.close();
 509               con.commit();
 510             }else if (flag ==2) {
 511               cStmt.execute("CREATE INDEX mysqld1 USING HASH ON big1(unique1)");
 512               cStmt.execute("CREATE INDEX mysqld2 USING HASH ON big2(unique1)");
 513               cStmt.execute("CREATE INDEX mysqld3 USING HASH ON small(unique1)");
 514               cStmt.execute("CREATE INDEX mysqld4 USING HASH ON big1(stringu1)");
 515               con.commit();
 516             } else if (flag == 3) {
 517           cStmt.execute("CREATE INDEX psqld1 on big1 USING HASH (unique1)");
 518           cStmt.execute("CREATE INDEX psqld2 on big2 USING HASH (unique1)");
 519           cStmt.execute("CREATE INDEX psqld3 on small USING HASH (unique1)");
 520           cStmt.execute("CREATE INDEX psqld4 on big1 USING HASH (stringu1)");
 521           }
 522       }
 523           catch(Exception e ){e.printStackTrace(); System.out.println("Error creating index");}
 524           timeTaken[0][1] = singleTuple(con, true);
 525           timeTaken[1][1] = singleTuple(con, false);
 526           timeTaken[2][1] = 0;
 527           timeTaken[3][1] = 0;
 528           timeTaken[4][1] = 0;
 529           timeTaken[5][1] = 0;
 530           timeTaken[6][1] = 0;
 531           timeTaken[7][1] = 0;
 532           timeTaken[8][1] = 0;
 533           timeTaken[9][1] = 0;
 534           timeTaken[10][1] = orderby(con);
 535
 536           timeTaken[11][1] = dmlstatement(con,ins);
 537           timeTaken[12][1] = dmlstatement(con,upd);
 538           timeTaken[13][1] = dmlstatement(con,del);
 539           timeTaken[14][1] = joining(con,1);
 540           timeTaken[15][1] = joining(con,2);
 541           timeTaken[16][1] = joinCondition(con,1);
 542           timeTaken[17][1] = joinCondition(con,2);
 543           System.out.println("Finished hash index queries");
 544
 545           try{
 546               if(flag == 1)
 547               {
 548                  cStmt.execute("FLUSH CACHE");
 549                  con.commit();
 550               }
 551            }catch(Exception e ){e.printStackTrace(); System.out.println("Error creating index");}
 552
 553
 554           try{
 555             if (flag ==1) {
 556               cStmt.execute("DROP INDEX idx1");
 557               cStmt.close();
 558               cStmt.execute("DROP INDEX idx2");
 559               cStmt.close();
 560               cStmt.execute("DROP INDEX idx3");
 561               cStmt.close();
 562               cStmt.execute("DROP INDEX idx4");
 563               cStmt.close();
 564               cStmt.execute("CREATE INDEX idx5 ON big1(unique1) TREE");
 565               cStmt.execute("CREATE INDEX idx6 ON big2(unique1) TREE");
 566               cStmt.execute("CREATE INDEX idx7 ON small(unique1) TREE");
 567               cStmt.execute("CREATE INDEX idx8 ON big1(stringu1) TREE");
 568               con.commit();
 569             }else if (flag ==2) {
 570               cStmt.execute("DROP INDEX mysqld1 on big1");
 571               cStmt.execute("DROP INDEX mysqld2 on big2");
 572               cStmt.execute("DROP INDEX mysqld3 on small");
 573               cStmt.execute("DROP INDEX mysqld4 on big1");
 574               cStmt.execute("CREATE INDEX mysqld5 USING BTREE ON big1(unique1)");
 575               cStmt.execute("CREATE INDEX mysqld6 USING BTREE ON big2(unique1)");
 576               cStmt.execute("CREATE INDEX mysqld7 USING BTREE ON small(unique1)");
 577               cStmt.execute("CREATE INDEX mysqld8 USING BTREE ON big1(stringu1)");
 578               con.commit();
 579             } else if (flag == 3) {
 580           cStmt.execute("DROP INDEX psqld1");
 581           cStmt.execute("DROP INDEX psqld2");
 582           cStmt.execute("DROP INDEX psqld3");
 583           cStmt.execute("DROP INDEX psqld4");
 584           cStmt.execute("CREATE INDEX psqld5 on big1 USING BTREE (unique1)");
 585           cStmt.execute("CREATE INDEX psqld6 on big2 USING BTREE (unique1)");
 586           cStmt.execute("CREATE INDEX psqld7 on small USING BTREE (unique1)");
 587           cStmt.execute("CREATE INDEX psqld8 on big1 USING BTREE (stringu1)");
 588               con.commit();
 589             }
 590           }catch(Exception e ){e.printStackTrace(); System.out.println("Error creating index");}
 591
 592           timeTaken[0][2] = singleTuple(con, true);
 593           timeTaken[1][2] = singleTuple(con, false);
 594           timeTaken[2][2] = onePerSel(con);
 595           timeTaken[3][2] = aggregate(con,min,false);
 596           timeTaken[4][2] = aggregate(con,min,true);
 597           timeTaken[5][2] = aggregate(con,max,false);
 598           timeTaken[6][2] = aggregate(con,max,true);
 599           timeTaken[7][2] = 0;
 600           timeTaken[8][2] = 0;
 601           timeTaken[9][2] = 0;
 602           timeTaken[10][2] = orderby(con);
 603           timeTaken[11][2] = dmlstatement(con,ins);
 604           timeTaken[12][2] = dmlstatement(con,upd);
 605           timeTaken[13][2] = dmlstatement(con,del);
 606           timeTaken[14][2] = joining(con,1);
 607           timeTaken[15][2] = joining(con,2);
 608           timeTaken[16][2] = joinCondition(con,1);
 609           timeTaken[17][2] = joinCondition(con,2);
 610           System.out.println("Finished tree index queries");
 611
 612
 613
 614           try{
 615             if (flag ==1) {
 616               cStmt.execute("DROP INDEX idx5");
 617               cStmt.close();
 618               cStmt.execute("DROP INDEX idx6");
 619               cStmt.close();
 620               cStmt.execute("DROP INDEX idx7");
 621               cStmt.close();
 622               cStmt.execute("DROP INDEX idx8");
 623               cStmt.close();
 624               con.commit();
 625             } else if (flag ==2) {
 626               cStmt.execute("DROP INDEX mysqld5 on big1");
 627               cStmt.execute("DROP INDEX mysqld6 on big2");
 628               cStmt.execute("DROP INDEX mysqld7 on small");
 629               cStmt.execute("DROP INDEX mysqld8 on big1");
 630               con.commit();
 631             } else if (flag ==3) {
 632               cStmt.execute("DROP INDEX psqld5");
 633               cStmt.execute("DROP INDEX psqld6");
 634               cStmt.execute("DROP INDEX psqld7");
 635               cStmt.execute("DROP INDEX psqld8");
 636               con.commit();
 637             }
 638           }catch(Exception e ){System.out.println("Error dropping indexes");}
 639
 640           System.out.println("Wisconsin Benchmark Report:");
 641
 642           System.out.println("**********************************************************");
 643           System.out.println(" Statement       \t NoIndex\tHash \tTree");
 644           System.out.println("**********************************************************");
 645           System.out.println(" SelectInt 1     \t "+timeTaken[0][0] +" \t \t"+ timeTaken[0][1]+ "   \t"+ timeTaken[0][2]);
 646           System.out.println(" SelectStr 1     \t "+timeTaken[1][0] +" \t \t"+ timeTaken[1][1]+ "   \t"+ timeTaken[1][2]);
 647           System.out.println(" 1% Sel          \t "+timeTaken[2][0] +" \t \t-   \t"+ timeTaken[2][2]);
 648
 649           System.out.println(" Min      1      \t "+timeTaken[3][0] +" \t \t-   \t"+ timeTaken[3][2]);
 650           System.out.println(" Min_GrBy 1%     \t "+timeTaken[4][0] +" \t \t-   \t-");
 651
 652           System.out.println(" Max      1      \t "+timeTaken[5][0] +" \t \t-   \t"+ timeTaken[5][2]);
 653           System.out.println(" Max_GrBy 1%     \t "+timeTaken[6][0] +" \t \t-   \t-");
 654
 655           System.out.println(" Sum      1      \t "+timeTaken[7][0] +" \t \t-   \t-");
 656           System.out.println(" Sum_GrBy 1%     \t "+timeTaken[8][0] +" \t \t-   \t-");
 657
 658           System.out.println(" Distinct 1%     \t "+timeTaken[9][0] +" \t \t-   \t-");
 659           System.out.println(" OrderBy 1%      \t "+timeTaken[10][0] +" \t \t"+ timeTaken[10][1]+ "   \t"+ timeTaken[10][2]);
 660
 661           System.out.println(" Insert 1        \t "+timeTaken[11][0] +" \t \t"+ timeTaken[11][1]+ "   \t"+ timeTaken[11][2]);
 662           System.out.println(" Update 1        \t "+timeTaken[12][0] +" \t \t"+ timeTaken[12][1]+ "   \t"+ timeTaken[12][2]);
 663           System.out.println(" Delete 1        \t "+timeTaken[13][0] +" \t \t"+ timeTaken[13][1]+ "   \t"+ timeTaken[13][2]);
 664           System.out.println(" Join(10K*1K)1   \t "+timeTaken[14][0] +" \t \t"+ timeTaken[14][1]+ "\t"+ timeTaken[14][2]);
 665           System.out.println(" Join(10K*10K*1K)1\t "+timeTaken[15][0] +"\t  \t"+ timeTaken[15][1]+ "\t"+ timeTaken[15][2]);
 666
 667           System.out.println(" Join(10K*1K)100 \t "+timeTaken[16][0]+"\t \t"+ timeTaken[16][1]+ "\t"+ timeTaken[16][2]);
 668           System.out.println(" Join(10K*10K*1K)100\t "+timeTaken[17][0] +"\t  \t"+ timeTaken[17][1]+ "\t"+ timeTaken[17][2]);
 669
 670           System.out.println("**********************************************************");
 671           con.close();
 672         }
 673         catch(Exception e) {
 674             System.out.println("Exception in Test: "+e);
 675             e.printStackTrace();
 676         }
 677
 678     }
 679 }