001 /** 002 * Copyright 2007-2008 Arthur Blake 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 package net.sf.log4jdbc; 017 018 import java.io.InputStream; 019 import java.io.Reader; 020 import java.math.BigDecimal; 021 import java.net.URL; 022 import java.sql.Array; 023 import java.sql.Blob; 024 import java.sql.Clob; 025 import java.sql.Date; 026 import java.sql.Ref; 027 import java.sql.ResultSet; 028 import java.sql.ResultSetMetaData; 029 import java.sql.SQLException; 030 import java.sql.SQLWarning; 031 import java.sql.Statement; 032 import java.sql.Time; 033 import java.sql.Timestamp; 034 import java.util.Calendar; 035 import java.util.Map; 036 037 /** 038 * Wraps a ResultSet and reports method calls, returns and exceptions. 039 * 040 * @author Arthur Blake 041 */ 042 public class ResultSetSpy implements ResultSet, Spy 043 { 044 private final SpyLogDelegator log; 045 046 /** 047 * Report an exception to be logged. 048 * 049 * @param methodCall description of method call and arguments passed to it that generated the exception. 050 * @param exception exception that was generated 051 */ 052 protected void reportException(String methodCall, SQLException exception) 053 { 054 log.exceptionOccured(this, methodCall, exception, null, -1L); 055 } 056 057 /** 058 * Report (for logging) that a method returned. All the other reportReturn methods are conveniance methods that call 059 * this method. 060 * 061 * @param methodCall description of method call and arguments passed to it that returned. 062 * @param msg description of what the return value that was returned. may be an empty String for void return types. 063 */ 064 protected void reportAllReturns(String methodCall, String msg) 065 { 066 log.methodReturned(this, methodCall, msg); 067 } 068 069 private ResultSet realResultSet; 070 private StatementSpy parent; 071 072 /** 073 * Create a new ResultSetSpy that wraps another ResultSet object, that logs all method calls, expceptions, etc. 074 * 075 * @param parent Statement that generated this ResultSet. 076 * @param realResultSet real underlying ResultSet that is being wrapped. 077 */ 078 public ResultSetSpy(StatementSpy parent, ResultSet realResultSet) 079 { 080 if (realResultSet == null) 081 { 082 throw new IllegalArgumentException("Must provide a non null real ResultSet"); 083 } 084 this.realResultSet = realResultSet; 085 this.parent = parent; 086 log = SpyLogFactory.getSpyLogDelegator(); 087 } 088 089 /** 090 * Description for ResultSet class type. 091 */ 092 public static final String classTypeDescription = "ResultSet"; 093 094 public String getClassType() 095 { 096 return classTypeDescription; 097 } 098 099 public int getConnectionNumber() 100 { 101 return parent.getConnectionNumber(); 102 } 103 104 /** 105 * Conveniance method to report (for logging) that a method returned a boolean value. 106 * 107 * @param methodCall description of method call and arguments passed to it that returned. 108 * @param value boolean return value. 109 * @return the boolean return value as passed in. 110 */ 111 protected boolean reportReturn(String methodCall, boolean value) 112 { 113 reportAllReturns(methodCall, "" + value); 114 return value; 115 } 116 117 /** 118 * Conveniance method to report (for logging) that a method returned a byte value. 119 * 120 * @param methodCall description of method call and arguments passed to it that returned. 121 * @param value byte return value. 122 * @return the byte return value as passed in. 123 */ 124 protected byte reportReturn(String methodCall, byte value) 125 { 126 reportAllReturns(methodCall, "" + value); 127 return value; 128 } 129 130 /** 131 * Conveniance method to report (for logging) that a method returned a int value. 132 * 133 * @param methodCall description of method call and arguments passed to it that returned. 134 * @param value int return value. 135 * @return the int return value as passed in. 136 */ 137 protected int reportReturn(String methodCall, int value) 138 { 139 reportAllReturns(methodCall, "" + value); 140 return value; 141 } 142 143 /** 144 * Conveniance method to report (for logging) that a method returned a double value. 145 * 146 * @param methodCall description of method call and arguments passed to it that returned. 147 * @param value double return value. 148 * @return the double return value as passed in. 149 */ 150 protected double reportReturn(String methodCall, double value) 151 { 152 reportAllReturns(methodCall, "" + value); 153 return value; 154 } 155 156 /** 157 * Conveniance method to report (for logging) that a method returned a short value. 158 * 159 * @param methodCall description of method call and arguments passed to it that returned. 160 * @param value short return value. 161 * @return the short return value as passed in. 162 */ 163 protected short reportReturn(String methodCall, short value) 164 { 165 reportAllReturns(methodCall, "" + value); 166 return value; 167 } 168 169 /** 170 * Conveniance method to report (for logging) that a method returned a long value. 171 * 172 * @param methodCall description of method call and arguments passed to it that returned. 173 * @param value long return value. 174 * @return the long return value as passed in. 175 */ 176 protected long reportReturn(String methodCall, long value) 177 { 178 reportAllReturns(methodCall, "" + value); 179 return value; 180 } 181 182 /** 183 * Conveniance method to report (for logging) that a method returned a float value. 184 * 185 * @param methodCall description of method call and arguments passed to it that returned. 186 * @param value float return value. 187 * @return the float return value as passed in. 188 */ 189 protected float reportReturn(String methodCall, float value) 190 { 191 reportAllReturns(methodCall, "" + value); 192 return value; 193 } 194 195 /** 196 * Conveniance method to report (for logging) that a method returned an Object. 197 * 198 * @param methodCall description of method call and arguments passed to it that returned. 199 * @param value return Object. 200 * @return the return Object as passed in. 201 */ 202 protected Object reportReturn(String methodCall, Object value) 203 { 204 reportAllReturns(methodCall, "" + value); 205 return value; 206 } 207 208 /** 209 * Conveniance method to report (for logging) that a method returned (void return type). 210 * 211 * @param methodCall description of method call and arguments passed to it that returned. 212 */ 213 protected void reportReturn(String methodCall) 214 { 215 reportAllReturns(methodCall, ""); 216 } 217 218 // forwarding methods 219 220 public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException 221 { 222 String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ", " + length + ")"; 223 try 224 { 225 realResultSet.updateAsciiStream(columnIndex, x, length); 226 } 227 catch (SQLException s) 228 { 229 reportException(methodCall, s); 230 throw s; 231 } 232 reportReturn(methodCall); 233 } 234 235 public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException 236 { 237 String methodCall = "updateAsciiStream(" + columnName + ", " + x + ", " + length + ")"; 238 try 239 { 240 realResultSet.updateAsciiStream(columnName, x, length); 241 } 242 catch (SQLException s) 243 { 244 reportException(methodCall, s); 245 throw s; 246 } 247 reportReturn(methodCall); 248 } 249 250 public int getRow() throws SQLException 251 { 252 String methodCall = "getRow()"; 253 try 254 { 255 return reportReturn(methodCall, realResultSet.getRow()); 256 } 257 catch (SQLException s) 258 { 259 reportException(methodCall, s); 260 throw s; 261 } 262 } 263 264 public void cancelRowUpdates() throws SQLException 265 { 266 String methodCall = "cancelRowUpdates()"; 267 try 268 { 269 realResultSet.cancelRowUpdates(); 270 } 271 catch (SQLException s) 272 { 273 reportException(methodCall, s); 274 throw s; 275 } 276 reportReturn(methodCall); 277 } 278 279 public Time getTime(int columnIndex) throws SQLException 280 { 281 String methodCall = "getTime(" + columnIndex + ")"; 282 try 283 { 284 return (Time) reportReturn(methodCall, realResultSet.getTime(columnIndex)); 285 } 286 catch (SQLException s) 287 { 288 reportException(methodCall, s); 289 throw s; 290 } 291 } 292 293 public Time getTime(String columnName) throws SQLException 294 { 295 String methodCall = "getTime(" + columnName + ")"; 296 try 297 { 298 return (Time) reportReturn(methodCall, realResultSet.getTime(columnName)); 299 } 300 catch (SQLException s) 301 { 302 reportException(methodCall, s); 303 throw s; 304 } 305 } 306 307 public Time getTime(int columnIndex, Calendar cal) throws SQLException 308 { 309 String methodCall = "getTime(" + columnIndex + ", " + cal + ")"; 310 try 311 { 312 return (Time) reportReturn(methodCall, realResultSet.getTime(columnIndex, cal)); 313 } 314 catch (SQLException s) 315 { 316 reportException(methodCall, s); 317 throw s; 318 } 319 } 320 321 public Time getTime(String columnName, Calendar cal) throws SQLException 322 { 323 String methodCall = "getTime(" + columnName + ", " + cal + ")"; 324 try 325 { 326 return (Time) reportReturn(methodCall, realResultSet.getTime(columnName, cal)); 327 } 328 catch (SQLException s) 329 { 330 reportException(methodCall, s); 331 throw s; 332 } 333 } 334 335 public boolean absolute(int row) throws SQLException 336 { 337 String methodCall = "absolute(" + row + ")"; 338 try 339 { 340 return reportReturn(methodCall, realResultSet.absolute(row)); 341 } 342 catch (SQLException s) 343 { 344 reportException(methodCall, s); 345 throw s; 346 } 347 } 348 349 public Timestamp getTimestamp(int columnIndex) throws SQLException 350 { 351 String methodCall = "getTimestamp(" + columnIndex + ")"; 352 try 353 { 354 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnIndex)); 355 } 356 catch (SQLException s) 357 { 358 reportException(methodCall, s); 359 throw s; 360 } 361 } 362 363 public Timestamp getTimestamp(String columnName) throws SQLException 364 { 365 String methodCall = "getTimestamp(" + columnName + ")"; 366 try 367 { 368 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnName)); 369 } 370 catch (SQLException s) 371 { 372 reportException(methodCall, s); 373 throw s; 374 } 375 376 } 377 378 public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException 379 { 380 String methodCall = "getTimestamp(" + columnIndex + ", " + cal + ")"; 381 try 382 { 383 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnIndex, cal)); 384 } 385 catch (SQLException s) 386 { 387 reportException(methodCall, s); 388 throw s; 389 } 390 391 } 392 393 public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException 394 { 395 String methodCall = "getTimestamp(" + columnName + ", " + cal + ")"; 396 try 397 { 398 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnName, cal)); 399 } 400 catch (SQLException s) 401 { 402 reportException(methodCall, s); 403 throw s; 404 } 405 } 406 407 public void moveToInsertRow() throws SQLException 408 { 409 String methodCall = "moveToInsertRow()"; 410 try 411 { 412 realResultSet.moveToInsertRow(); 413 } 414 catch (SQLException s) 415 { 416 reportException(methodCall, s); 417 throw s; 418 } 419 reportReturn(methodCall); 420 } 421 422 public boolean relative(int rows) throws SQLException 423 { 424 String methodCall = "relative(" + rows + ")"; 425 try 426 { 427 return reportReturn(methodCall, realResultSet.relative(rows)); 428 } 429 catch (SQLException s) 430 { 431 reportException(methodCall, s); 432 throw s; 433 } 434 } 435 436 public boolean previous() throws SQLException 437 { 438 String methodCall = "previous()"; 439 try 440 { 441 return reportReturn(methodCall, realResultSet.previous()); 442 } 443 catch (SQLException s) 444 { 445 reportException(methodCall, s); 446 throw s; 447 } 448 } 449 450 public void moveToCurrentRow() throws SQLException 451 { 452 String methodCall = "moveToCurrentRow()"; 453 try 454 { 455 realResultSet.moveToCurrentRow(); 456 } 457 catch (SQLException s) 458 { 459 reportException(methodCall, s); 460 throw s; 461 } 462 reportReturn(methodCall); 463 } 464 465 public Ref getRef(int i) throws SQLException 466 { 467 String methodCall = "getRef(" + i + ")"; 468 try 469 { 470 return (Ref) reportReturn(methodCall, realResultSet.getRef(i)); 471 } 472 catch (SQLException s) 473 { 474 reportException(methodCall, s); 475 throw s; 476 } 477 } 478 479 public void updateRef(int columnIndex, Ref x) throws SQLException 480 { 481 String methodCall = "updateRef(" + columnIndex + ", " + x + ")"; 482 try 483 { 484 realResultSet.updateRef(columnIndex, x); 485 } 486 catch (SQLException s) 487 { 488 reportException(methodCall, s); 489 throw s; 490 } 491 reportReturn(methodCall); 492 } 493 494 public Ref getRef(String colName) throws SQLException 495 { 496 String methodCall = "getRef(" + colName + ")"; 497 try 498 { 499 return (Ref) reportReturn(methodCall, realResultSet.getRef(colName)); 500 } 501 catch (SQLException s) 502 { 503 reportException(methodCall, s); 504 throw s; 505 } 506 } 507 508 public void updateRef(String columnName, Ref x) throws SQLException 509 { 510 String methodCall = "updateRef(" + columnName + ", " + x + ")"; 511 try 512 { 513 realResultSet.updateRef(columnName, x); 514 } 515 catch (SQLException s) 516 { 517 reportException(methodCall, s); 518 throw s; 519 } 520 reportReturn(methodCall); 521 } 522 523 public Blob getBlob(int i) throws SQLException 524 { 525 String methodCall = "getBlob(" + i + ")"; 526 try 527 { 528 return (Blob) reportReturn(methodCall, realResultSet.getBlob(i)); 529 } 530 catch (SQLException s) 531 { 532 reportException(methodCall, s); 533 throw s; 534 } 535 } 536 537 public void updateBlob(int columnIndex, Blob x) throws SQLException 538 { 539 String methodCall = "updateBlob(" + columnIndex + ", " + x + ")"; 540 try 541 { 542 realResultSet.updateBlob(columnIndex, x); 543 } 544 catch (SQLException s) 545 { 546 reportException(methodCall, s); 547 throw s; 548 } 549 reportReturn(methodCall); 550 } 551 552 public Blob getBlob(String colName) throws SQLException 553 { 554 String methodCall = "getBlob(" + colName + ")"; 555 try 556 { 557 return (Blob) reportReturn(methodCall, realResultSet.getBlob(colName)); 558 } 559 catch (SQLException s) 560 { 561 reportException(methodCall, s); 562 throw s; 563 } 564 } 565 566 public void updateBlob(String columnName, Blob x) throws SQLException 567 { 568 String methodCall = "updateBlob(" + columnName + ", " + x + ")"; 569 try 570 { 571 realResultSet.updateBlob(columnName, x); 572 } 573 catch (SQLException s) 574 { 575 reportException(methodCall, s); 576 throw s; 577 } 578 reportReturn(methodCall); 579 } 580 581 public Clob getClob(int i) throws SQLException 582 { 583 String methodCall = "getClob(" + i + ")"; 584 try 585 { 586 return (Clob) reportReturn(methodCall, realResultSet.getClob(i)); 587 } 588 catch (SQLException s) 589 { 590 reportException(methodCall, s); 591 throw s; 592 } 593 } 594 595 public void updateClob(int columnIndex, Clob x) throws SQLException 596 { 597 String methodCall = "updateClob(" + columnIndex + ", " + x + ")"; 598 try 599 { 600 realResultSet.updateClob(columnIndex, x); 601 } 602 catch (SQLException s) 603 { 604 reportException(methodCall, s); 605 throw s; 606 } 607 reportReturn(methodCall); 608 } 609 610 public Clob getClob(String colName) throws SQLException 611 { 612 String methodCall = "getClob(" + colName + ")"; 613 try 614 { 615 return (Clob) reportReturn(methodCall, realResultSet.getClob(colName)); 616 } 617 catch (SQLException s) 618 { 619 reportException(methodCall, s); 620 throw s; 621 } 622 } 623 624 public void updateClob(String columnName, Clob x) throws SQLException 625 { 626 String methodCall = "updateClob(" + columnName + ", " + x + ")"; 627 try 628 { 629 realResultSet.updateClob(columnName, x); 630 } 631 catch (SQLException s) 632 { 633 reportException(methodCall, s); 634 throw s; 635 } 636 reportReturn(methodCall); 637 } 638 639 public boolean getBoolean(int columnIndex) throws SQLException 640 { 641 String methodCall = "getBoolean(" + columnIndex + ")"; 642 try 643 { 644 return reportReturn(methodCall, realResultSet.getBoolean(columnIndex)); 645 } 646 catch (SQLException s) 647 { 648 reportException(methodCall, s); 649 throw s; 650 } 651 } 652 653 public boolean getBoolean(String columnName) throws SQLException 654 { 655 String methodCall = "getBoolean(" + columnName + ")"; 656 try 657 { 658 return reportReturn(methodCall, realResultSet.getBoolean(columnName)); 659 } 660 catch (SQLException s) 661 { 662 reportException(methodCall, s); 663 throw s; 664 } 665 } 666 667 public Array getArray(int i) throws SQLException 668 { 669 String methodCall = "getArray(" + i + ")"; 670 try 671 { 672 return (Array) reportReturn(methodCall, realResultSet.getArray(i)); 673 } 674 catch (SQLException s) 675 { 676 reportException(methodCall, s); 677 throw s; 678 } 679 } 680 681 public void updateArray(int columnIndex, Array x) throws SQLException 682 { 683 String methodCall = "updateArray(" + columnIndex + ", " + x + ")"; 684 try 685 { 686 realResultSet.updateArray(columnIndex, x); 687 } 688 catch (SQLException s) 689 { 690 reportException(methodCall, s); 691 throw s; 692 } 693 reportReturn(methodCall); 694 } 695 696 public Array getArray(String colName) throws SQLException 697 { 698 String methodCall = "getArray(" + colName + ")"; 699 try 700 { 701 return (Array) reportReturn(methodCall, realResultSet.getArray(colName)); 702 } 703 catch (SQLException s) 704 { 705 reportException(methodCall, s); 706 throw s; 707 } 708 } 709 710 public void updateArray(String columnName, Array x) throws SQLException 711 { 712 String methodCall = "updateArray(" + columnName + ", " + x + ")"; 713 try 714 { 715 realResultSet.updateArray(columnName, x); 716 } 717 catch (SQLException s) 718 { 719 reportException(methodCall, s); 720 throw s; 721 } 722 reportReturn(methodCall); 723 } 724 725 public boolean isBeforeFirst() throws SQLException 726 { 727 String methodCall = "isBeforeFirst()"; 728 try 729 { 730 return reportReturn(methodCall, realResultSet.isBeforeFirst()); 731 } 732 catch (SQLException s) 733 { 734 reportException(methodCall, s); 735 throw s; 736 } 737 } 738 739 public short getShort(int columnIndex) throws SQLException 740 { 741 String methodCall = "getShort(" + columnIndex + ")"; 742 try 743 { 744 return reportReturn(methodCall, realResultSet.getShort(columnIndex)); 745 } 746 catch (SQLException s) 747 { 748 reportException(methodCall, s); 749 throw s; 750 } 751 } 752 753 public short getShort(String columnName) throws SQLException 754 { 755 String methodCall = "getShort(" + columnName + ")"; 756 try 757 { 758 return reportReturn(methodCall, realResultSet.getShort(columnName)); 759 } 760 catch (SQLException s) 761 { 762 reportException(methodCall, s); 763 throw s; 764 } 765 } 766 767 public int getInt(int columnIndex) throws SQLException 768 { 769 String methodCall = "getInt(" + columnIndex + ")"; 770 try 771 { 772 return reportReturn(methodCall, realResultSet.getInt(columnIndex)); 773 } 774 catch (SQLException s) 775 { 776 reportException(methodCall, s); 777 throw s; 778 } 779 } 780 781 public int getInt(String columnName) throws SQLException 782 { 783 String methodCall = "getInt(" + columnName + ")"; 784 try 785 { 786 return reportReturn(methodCall, realResultSet.getInt(columnName)); 787 } 788 catch (SQLException s) 789 { 790 reportException(methodCall, s); 791 throw s; 792 } 793 } 794 795 public void close() throws SQLException 796 { 797 String methodCall = "close()"; 798 try 799 { 800 realResultSet.close(); 801 } 802 catch (SQLException s) 803 { 804 reportException(methodCall, s); 805 throw s; 806 } 807 reportReturn(methodCall); 808 } 809 810 public ResultSetMetaData getMetaData() throws SQLException 811 { 812 String methodCall = "getMetaData()"; 813 try 814 { 815 return (ResultSetMetaData) reportReturn(methodCall, realResultSet.getMetaData()); 816 } 817 catch (SQLException s) 818 { 819 reportException(methodCall, s); 820 throw s; 821 } 822 } 823 824 public int getType() throws SQLException 825 { 826 String methodCall = "getType()"; 827 try 828 { 829 return reportReturn(methodCall, realResultSet.getType()); 830 } 831 catch (SQLException s) 832 { 833 reportException(methodCall, s); 834 throw s; 835 } 836 } 837 838 public double getDouble(int columnIndex) throws SQLException 839 { 840 String methodCall = "getDouble(" + columnIndex + ")"; 841 try 842 { 843 return reportReturn(methodCall, realResultSet.getDouble(columnIndex)); 844 } 845 catch (SQLException s) 846 { 847 reportException(methodCall, s); 848 throw s; 849 } 850 } 851 852 public double getDouble(String columnName) throws SQLException 853 { 854 String methodCall = "getDouble(" + columnName + ")"; 855 try 856 { 857 return reportReturn(methodCall, realResultSet.getDouble(columnName)); 858 } 859 catch (SQLException s) 860 { 861 reportException(methodCall, s); 862 throw s; 863 } 864 } 865 866 public void deleteRow() throws SQLException 867 { 868 String methodCall = "deleteRow()"; 869 try 870 { 871 realResultSet.deleteRow(); 872 } 873 catch (SQLException s) 874 { 875 reportException(methodCall, s); 876 throw s; 877 } 878 reportReturn(methodCall); 879 } 880 881 public int getConcurrency() throws SQLException 882 { 883 String methodCall = "getConcurrency()"; 884 try 885 { 886 return reportReturn(methodCall, realResultSet.getConcurrency()); 887 } 888 catch (SQLException s) 889 { 890 reportException(methodCall, s); 891 throw s; 892 } 893 } 894 895 public boolean rowUpdated() throws SQLException 896 { 897 String methodCall = "rowUpdated()"; 898 try 899 { 900 return reportReturn(methodCall, realResultSet.rowUpdated()); 901 } 902 catch (SQLException s) 903 { 904 reportException(methodCall, s); 905 throw s; 906 } 907 } 908 909 public Date getDate(int columnIndex) throws SQLException 910 { 911 String methodCall = "getDate(" + columnIndex + ")"; 912 try 913 { 914 return (Date) reportReturn(methodCall, realResultSet.getDate(columnIndex)); 915 } 916 catch (SQLException s) 917 { 918 reportException(methodCall, s); 919 throw s; 920 } 921 } 922 923 public Date getDate(String columnName) throws SQLException 924 { 925 String methodCall = "getDate(" + columnName + ")"; 926 try 927 { 928 return (Date) reportReturn(methodCall, realResultSet.getDate(columnName)); 929 } 930 catch (SQLException s) 931 { 932 reportException(methodCall, s); 933 throw s; 934 } 935 } 936 937 public Date getDate(int columnIndex, Calendar cal) throws SQLException 938 { 939 String methodCall = "getDate(" + columnIndex + ", " + cal + ")"; 940 try 941 { 942 return (Date) reportReturn(methodCall, realResultSet.getDate(columnIndex, cal)); 943 } 944 catch (SQLException s) 945 { 946 reportException(methodCall, s); 947 throw s; 948 } 949 950 } 951 952 public Date getDate(String columnName, Calendar cal) throws SQLException 953 { 954 String methodCall = "getDate(" + columnName + ", " + cal + ")"; 955 try 956 { 957 return (Date) reportReturn(methodCall, realResultSet.getDate(columnName, cal)); 958 } 959 catch (SQLException s) 960 { 961 reportException(methodCall, s); 962 throw s; 963 } 964 } 965 966 public boolean last() throws SQLException 967 { 968 String methodCall = "last()"; 969 try 970 { 971 return reportReturn(methodCall, realResultSet.last()); 972 } 973 catch (SQLException s) 974 { 975 reportException(methodCall, s); 976 throw s; 977 } 978 } 979 980 public boolean rowInserted() throws SQLException 981 { 982 String methodCall = "rowInserted()"; 983 try 984 { 985 return reportReturn(methodCall, realResultSet.rowInserted()); 986 } 987 catch (SQLException s) 988 { 989 reportException(methodCall, s); 990 throw s; 991 } 992 } 993 994 public boolean rowDeleted() throws SQLException 995 { 996 String methodCall = "rowDeleted()"; 997 try 998 { 999 return reportReturn(methodCall, realResultSet.rowDeleted()); 1000 } 1001 catch (SQLException s) 1002 { 1003 reportException(methodCall, s); 1004 throw s; 1005 } 1006 } 1007 1008 public void updateNull(int columnIndex) throws SQLException 1009 { 1010 String methodCall = "updateNull(" + columnIndex + ")"; 1011 try 1012 { 1013 realResultSet.updateNull(columnIndex); 1014 } 1015 catch (SQLException s) 1016 { 1017 reportException(methodCall, s); 1018 throw s; 1019 } 1020 reportReturn(methodCall); 1021 } 1022 1023 public void updateNull(String columnName) throws SQLException 1024 { 1025 String methodCall = "updateNull(" + columnName + ")"; 1026 try 1027 { 1028 realResultSet.updateNull(columnName); 1029 } 1030 catch (SQLException s) 1031 { 1032 reportException(methodCall, s); 1033 throw s; 1034 } 1035 reportReturn(methodCall); 1036 } 1037 1038 public void updateShort(int columnIndex, short x) throws SQLException 1039 { 1040 String methodCall = "updateShort(" + columnIndex + ", " + x + ")"; 1041 try 1042 { 1043 realResultSet.updateShort(columnIndex, x); 1044 } 1045 catch (SQLException s) 1046 { 1047 reportException(methodCall, s); 1048 throw s; 1049 } 1050 reportReturn(methodCall); 1051 } 1052 1053 public void updateShort(String columnName, short x) throws SQLException 1054 { 1055 String methodCall = "updateShort(" + columnName + ", " + x + ")"; 1056 try 1057 { 1058 realResultSet.updateShort(columnName, x); 1059 } 1060 catch (SQLException s) 1061 { 1062 reportException(methodCall, s); 1063 throw s; 1064 } 1065 reportReturn(methodCall); 1066 } 1067 1068 public void updateBoolean(int columnIndex, boolean x) throws SQLException 1069 { 1070 String methodCall = "updateBoolean(" + columnIndex + ", " + x + ")"; 1071 try 1072 { 1073 realResultSet.updateBoolean(columnIndex, x); 1074 } 1075 catch (SQLException s) 1076 { 1077 reportException(methodCall, s); 1078 throw s; 1079 } 1080 reportReturn(methodCall); 1081 } 1082 1083 public void updateBoolean(String columnName, boolean x) throws SQLException 1084 { 1085 String methodCall = "updateBoolean(" + columnName + ", " + x + ")"; 1086 try 1087 { 1088 realResultSet.updateBoolean(columnName, x); 1089 } 1090 catch (SQLException s) 1091 { 1092 reportException(methodCall, s); 1093 throw s; 1094 } 1095 reportReturn(methodCall); 1096 } 1097 1098 public void updateByte(int columnIndex, byte x) throws SQLException 1099 { 1100 String methodCall = "updateByte(" + columnIndex + ", " + x + ")"; 1101 try 1102 { 1103 realResultSet.updateByte(columnIndex, x); 1104 } 1105 catch (SQLException s) 1106 { 1107 reportException(methodCall, s); 1108 throw s; 1109 } 1110 reportReturn(methodCall); 1111 } 1112 1113 public void updateByte(String columnName, byte x) throws SQLException 1114 { 1115 String methodCall = "updateByte(" + columnName + ", " + x + ")"; 1116 try 1117 { 1118 realResultSet.updateByte(columnName, x); 1119 } 1120 catch (SQLException s) 1121 { 1122 reportException(methodCall, s); 1123 throw s; 1124 } 1125 reportReturn(methodCall); 1126 } 1127 1128 public void updateInt(int columnIndex, int x) throws SQLException 1129 { 1130 String methodCall = "updateInt(" + columnIndex + ", " + x + ")"; 1131 try 1132 { 1133 realResultSet.updateInt(columnIndex, x); 1134 } 1135 catch (SQLException s) 1136 { 1137 reportException(methodCall, s); 1138 throw s; 1139 } 1140 reportReturn(methodCall); 1141 } 1142 1143 public void updateInt(String columnName, int x) throws SQLException 1144 { 1145 String methodCall = "updateInt(" + columnName + ", " + x + ")"; 1146 try 1147 { 1148 realResultSet.updateInt(columnName, x); 1149 } 1150 catch (SQLException s) 1151 { 1152 reportException(methodCall, s); 1153 throw s; 1154 } 1155 reportReturn(methodCall); 1156 } 1157 1158 public Object getObject(int columnIndex) throws SQLException 1159 { 1160 String methodCall = "getObject(" + columnIndex + ")"; 1161 try 1162 { 1163 return reportReturn(methodCall, realResultSet.getObject(columnIndex)); 1164 } 1165 catch (SQLException s) 1166 { 1167 reportException(methodCall, s); 1168 throw s; 1169 } 1170 } 1171 1172 public Object getObject(String columnName) throws SQLException 1173 { 1174 String methodCall = "getObject(" + columnName + ")"; 1175 try 1176 { 1177 return reportReturn(methodCall, realResultSet.getObject(columnName)); 1178 } 1179 catch (SQLException s) 1180 { 1181 reportException(methodCall, s); 1182 throw s; 1183 } 1184 } 1185 1186 public Object getObject(int i, Map map) throws SQLException 1187 { 1188 String methodCall = "getObject(" + i + ", " + map + ")"; 1189 try 1190 { 1191 return reportReturn(methodCall, realResultSet.getObject(i, map)); 1192 } 1193 catch (SQLException s) 1194 { 1195 reportException(methodCall, s); 1196 throw s; 1197 } 1198 } 1199 1200 public Object getObject(String colName, Map map) throws SQLException 1201 { 1202 String methodCall = "getObject(" + colName + ", " + map + ")"; 1203 try 1204 { 1205 return reportReturn(methodCall, realResultSet.getObject(colName, map)); 1206 } 1207 catch (SQLException s) 1208 { 1209 reportException(methodCall, s); 1210 throw s; 1211 } 1212 } 1213 1214 public boolean next() throws SQLException 1215 { 1216 String methodCall = "next()"; 1217 try 1218 { 1219 return reportReturn(methodCall, realResultSet.next()); 1220 } 1221 catch (SQLException s) 1222 { 1223 reportException(methodCall, s); 1224 throw s; 1225 } 1226 } 1227 1228 public void updateLong(int columnIndex, long x) throws SQLException 1229 { 1230 String methodCall = "updateLong(" + columnIndex + ", " + x + ")"; 1231 try 1232 { 1233 realResultSet.updateLong(columnIndex, x); 1234 } 1235 catch (SQLException s) 1236 { 1237 reportException(methodCall, s); 1238 throw s; 1239 } 1240 reportReturn(methodCall); 1241 } 1242 1243 public void updateLong(String columnName, long x) throws SQLException 1244 { 1245 String methodCall = "updateLong(" + columnName + ", " + x + ")"; 1246 try 1247 { 1248 realResultSet.updateLong(columnName, x); 1249 } 1250 catch (SQLException s) 1251 { 1252 reportException(methodCall, s); 1253 throw s; 1254 } 1255 reportReturn(methodCall); 1256 } 1257 1258 public void updateFloat(int columnIndex, float x) throws SQLException 1259 { 1260 String methodCall = "updateFloat(" + columnIndex + ", " + x + ")"; 1261 try 1262 { 1263 realResultSet.updateFloat(columnIndex, x); 1264 } 1265 catch (SQLException s) 1266 { 1267 reportException(methodCall, s); 1268 throw s; 1269 } 1270 reportReturn(methodCall); 1271 1272 } 1273 1274 public void updateFloat(String columnName, float x) throws SQLException 1275 { 1276 String methodCall = "updateFloat(" + columnName + ", " + x + ")"; 1277 try 1278 { 1279 realResultSet.updateFloat(columnName, x); 1280 } 1281 catch (SQLException s) 1282 { 1283 reportException(methodCall, s); 1284 throw s; 1285 } 1286 reportReturn(methodCall); 1287 } 1288 1289 public void updateDouble(int columnIndex, double x) throws SQLException 1290 { 1291 String methodCall = "updateDouble(" + columnIndex + ", " + x + ")"; 1292 try 1293 { 1294 realResultSet.updateDouble(columnIndex, x); 1295 } 1296 catch (SQLException s) 1297 { 1298 reportException(methodCall, s); 1299 throw s; 1300 } 1301 reportReturn(methodCall); 1302 } 1303 1304 public void updateDouble(String columnName, double x) throws SQLException 1305 { 1306 String methodCall = "updateDouble(" + columnName + ", " + x + ")"; 1307 try 1308 { 1309 realResultSet.updateDouble(columnName, x); 1310 } 1311 catch (SQLException s) 1312 { 1313 reportException(methodCall, s); 1314 throw s; 1315 } 1316 reportReturn(methodCall); 1317 } 1318 1319 public Statement getStatement() throws SQLException 1320 { 1321 String methodCall = "getStatement()"; 1322 try 1323 { 1324 Statement s = realResultSet.getStatement(); 1325 if (s == null) 1326 { 1327 return (Statement) reportReturn(methodCall, s); 1328 } 1329 else 1330 { 1331 return (Statement) reportReturn(methodCall, new StatementSpy(new ConnectionSpy(s.getConnection()), s)); 1332 } 1333 } 1334 catch (SQLException s) 1335 { 1336 reportException(methodCall, s); 1337 throw s; 1338 } 1339 } 1340 1341 public void updateString(int columnIndex, String x) throws SQLException 1342 { 1343 String methodCall = "updateString(" + columnIndex + ", " + x + ")"; 1344 try 1345 { 1346 realResultSet.updateString(columnIndex, x); 1347 } 1348 catch (SQLException s) 1349 { 1350 reportException(methodCall, s); 1351 throw s; 1352 } 1353 reportReturn(methodCall); 1354 } 1355 1356 public void updateString(String columnName, String x) throws SQLException 1357 { 1358 String methodCall = "updateString(" + columnName + ", " + x + ")"; 1359 try 1360 { 1361 realResultSet.updateString(columnName, x); 1362 } 1363 catch (SQLException s) 1364 { 1365 reportException(methodCall, s); 1366 throw s; 1367 } 1368 reportReturn(methodCall); 1369 } 1370 1371 public InputStream getAsciiStream(int columnIndex) throws SQLException 1372 { 1373 String methodCall = "getAsciiStream(" + columnIndex + ")"; 1374 try 1375 { 1376 return (InputStream) reportReturn(methodCall, realResultSet.getAsciiStream(columnIndex)); 1377 } 1378 catch (SQLException s) 1379 { 1380 reportException(methodCall, s); 1381 throw s; 1382 } 1383 } 1384 1385 public InputStream getAsciiStream(String columnName) throws SQLException 1386 { 1387 String methodCall = "getAsciiStream(" + columnName + ")"; 1388 try 1389 { 1390 return (InputStream) reportReturn(methodCall, realResultSet.getAsciiStream(columnName)); 1391 } 1392 catch (SQLException s) 1393 { 1394 reportException(methodCall, s); 1395 throw s; 1396 } 1397 } 1398 1399 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException 1400 { 1401 String methodCall = "updateBigDecimal(" + columnIndex + ", " + x + ")"; 1402 try 1403 { 1404 realResultSet.updateBigDecimal(columnIndex, x); 1405 } 1406 catch (SQLException s) 1407 { 1408 reportException(methodCall, s); 1409 throw s; 1410 } 1411 reportReturn(methodCall); 1412 } 1413 1414 public URL getURL(int columnIndex) throws SQLException 1415 { 1416 String methodCall = "getURL(" + columnIndex + ")"; 1417 try 1418 { 1419 return (URL) reportReturn(methodCall, realResultSet.getURL(columnIndex)); 1420 } 1421 catch (SQLException s) 1422 { 1423 reportException(methodCall, s); 1424 throw s; 1425 } 1426 } 1427 1428 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException 1429 { 1430 String methodCall = "updateBigDecimal(" + columnName + ", " + x + ")"; 1431 try 1432 { 1433 realResultSet.updateBigDecimal(columnName, x); 1434 } 1435 catch (SQLException s) 1436 { 1437 reportException(methodCall, s); 1438 throw s; 1439 } 1440 reportReturn(methodCall); 1441 } 1442 1443 public URL getURL(String columnName) throws SQLException 1444 { 1445 String methodCall = "getURL(" + columnName + ")"; 1446 try 1447 { 1448 return (URL) reportReturn(methodCall, realResultSet.getURL(columnName)); 1449 } 1450 catch (SQLException s) 1451 { 1452 reportException(methodCall, s); 1453 throw s; 1454 } 1455 } 1456 1457 public void updateBytes(int columnIndex, byte[] x) throws SQLException 1458 { 1459 String methodCall = "updateBytes(" + columnIndex + ", " + x + ")"; 1460 try 1461 { 1462 realResultSet.updateBytes(columnIndex, x); 1463 } 1464 catch (SQLException s) 1465 { 1466 reportException(methodCall, s); 1467 throw s; 1468 } 1469 reportReturn(methodCall); 1470 } 1471 1472 public void updateBytes(String columnName, byte[] x) throws SQLException 1473 { 1474 String methodCall = "updateBytes(" + columnName + ", " + x + ")"; 1475 try 1476 { 1477 realResultSet.updateBytes(columnName, x); 1478 } 1479 catch (SQLException s) 1480 { 1481 reportException(methodCall, s); 1482 throw s; 1483 } 1484 reportReturn(methodCall); 1485 } 1486 1487 /** 1488 * @deprecated 1489 */ 1490 public InputStream getUnicodeStream(int columnIndex) throws SQLException 1491 { 1492 String methodCall = "getUnicodeStream(" + columnIndex + ")"; 1493 try 1494 { 1495 return (InputStream) reportReturn(methodCall, realResultSet.getUnicodeStream(columnIndex)); 1496 } 1497 catch (SQLException s) 1498 { 1499 reportException(methodCall, s); 1500 throw s; 1501 } 1502 } 1503 1504 /** 1505 * @deprecated 1506 */ 1507 public InputStream getUnicodeStream(String columnName) throws SQLException 1508 { 1509 String methodCall = "getUnicodeStream(" + columnName + ")"; 1510 try 1511 { 1512 return (InputStream) reportReturn(methodCall, realResultSet.getUnicodeStream(columnName)); 1513 } 1514 catch (SQLException s) 1515 { 1516 reportException(methodCall, s); 1517 throw s; 1518 } 1519 } 1520 1521 public void updateDate(int columnIndex, Date x) throws SQLException 1522 { 1523 String methodCall = "updateDate(" + columnIndex + ", " + x + ")"; 1524 try 1525 { 1526 realResultSet.updateDate(columnIndex, x); 1527 } 1528 catch (SQLException s) 1529 { 1530 reportException(methodCall, s); 1531 throw s; 1532 } 1533 } 1534 1535 public void updateDate(String columnName, Date x) throws SQLException 1536 { 1537 String methodCall = "updateDate(" + columnName + ", " + x + ")"; 1538 try 1539 { 1540 realResultSet.updateDate(columnName, x); 1541 } 1542 catch (SQLException s) 1543 { 1544 reportException(methodCall, s); 1545 throw s; 1546 } 1547 reportReturn(methodCall); 1548 } 1549 1550 public int getFetchSize() throws SQLException 1551 { 1552 String methodCall = "getFetchSize()"; 1553 try 1554 { 1555 return reportReturn(methodCall, realResultSet.getFetchSize()); 1556 } 1557 catch (SQLException s) 1558 { 1559 reportException(methodCall, s); 1560 throw s; 1561 } 1562 } 1563 1564 public SQLWarning getWarnings() throws SQLException 1565 { 1566 String methodCall = "getWarnings()"; 1567 try 1568 { 1569 return (SQLWarning) reportReturn(methodCall, realResultSet.getWarnings()); 1570 } 1571 catch (SQLException s) 1572 { 1573 reportException(methodCall, s); 1574 throw s; 1575 } 1576 } 1577 1578 public InputStream getBinaryStream(int columnIndex) throws SQLException 1579 { 1580 String methodCall = "getBinaryStream(" + columnIndex + ")"; 1581 try 1582 { 1583 return (InputStream) reportReturn(methodCall, realResultSet.getBinaryStream(columnIndex)); 1584 } 1585 catch (SQLException s) 1586 { 1587 reportException(methodCall, s); 1588 throw s; 1589 } 1590 } 1591 1592 public InputStream getBinaryStream(String columnName) throws SQLException 1593 { 1594 String methodCall = "getBinaryStream(" + columnName + ")"; 1595 try 1596 { 1597 return (InputStream) reportReturn(methodCall, realResultSet.getBinaryStream(columnName)); 1598 } 1599 catch (SQLException s) 1600 { 1601 reportException(methodCall, s); 1602 throw s; 1603 } 1604 } 1605 1606 public void clearWarnings() throws SQLException 1607 { 1608 String methodCall = "clearWarnings()"; 1609 try 1610 { 1611 realResultSet.clearWarnings(); 1612 } 1613 catch (SQLException s) 1614 { 1615 reportException(methodCall, s); 1616 throw s; 1617 } 1618 reportReturn(methodCall); 1619 } 1620 1621 public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException 1622 { 1623 String methodCall = "updateTimestamp(" + columnIndex + ", " + x + ")"; 1624 try 1625 { 1626 realResultSet.updateTimestamp(columnIndex, x); 1627 } 1628 catch (SQLException s) 1629 { 1630 reportException(methodCall, s); 1631 throw s; 1632 } 1633 reportReturn(methodCall); 1634 } 1635 1636 public void updateTimestamp(String columnName, Timestamp x) throws SQLException 1637 { 1638 String methodCall = "updateTimestamp(" + columnName + ", " + x + ")"; 1639 try 1640 { 1641 realResultSet.updateTimestamp(columnName, x); 1642 } 1643 catch (SQLException s) 1644 { 1645 reportException(methodCall, s); 1646 throw s; 1647 } 1648 reportReturn(methodCall); 1649 } 1650 1651 public boolean first() throws SQLException 1652 { 1653 String methodCall = "first()"; 1654 try 1655 { 1656 return reportReturn(methodCall, realResultSet.first()); 1657 } 1658 catch (SQLException s) 1659 { 1660 reportException(methodCall, s); 1661 throw s; 1662 } 1663 } 1664 1665 public String getCursorName() throws SQLException 1666 { 1667 String methodCall = "getCursorName()"; 1668 try 1669 { 1670 return (String) reportReturn(methodCall, realResultSet.getCursorName()); 1671 } 1672 catch (SQLException s) 1673 { 1674 reportException(methodCall, s); 1675 throw s; 1676 } 1677 } 1678 1679 public int findColumn(String columnName) throws SQLException 1680 { 1681 String methodCall = "findColumn(" + columnName + ")"; 1682 try 1683 { 1684 return reportReturn(methodCall, realResultSet.findColumn(columnName)); 1685 } 1686 catch (SQLException s) 1687 { 1688 reportException(methodCall, s); 1689 throw s; 1690 } 1691 } 1692 1693 public boolean wasNull() throws SQLException 1694 { 1695 String methodCall = "wasNull()"; 1696 try 1697 { 1698 return reportReturn(methodCall, realResultSet.wasNull()); 1699 } 1700 catch (SQLException s) 1701 { 1702 reportException(methodCall, s); 1703 throw s; 1704 } 1705 } 1706 1707 public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException 1708 { 1709 String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ", " + length + ")"; 1710 try 1711 { 1712 realResultSet.updateBinaryStream(columnIndex, x, length); 1713 } 1714 catch (SQLException s) 1715 { 1716 reportException(methodCall, s); 1717 throw s; 1718 } 1719 reportReturn(methodCall); 1720 } 1721 1722 public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException 1723 { 1724 String methodCall = "updateBinaryStream(" + columnName + ", " + x + ", " + length + ")"; 1725 try 1726 { 1727 realResultSet.updateBinaryStream(columnName, x, length); 1728 } 1729 catch (SQLException s) 1730 { 1731 reportException(methodCall, s); 1732 throw s; 1733 } 1734 reportReturn(methodCall); 1735 } 1736 1737 public String getString(int columnIndex) throws SQLException 1738 { 1739 String methodCall = "getString(" + columnIndex + ")"; 1740 try 1741 { 1742 return (String) reportReturn(methodCall, realResultSet.getString(columnIndex)); 1743 } 1744 catch (SQLException s) 1745 { 1746 reportException(methodCall, s); 1747 throw s; 1748 } 1749 } 1750 1751 public String getString(String columnName) throws SQLException 1752 { 1753 String methodCall = "getString(" + columnName + ")"; 1754 try 1755 { 1756 return (String) reportReturn(methodCall, realResultSet.getString(columnName)); 1757 } 1758 catch (SQLException s) 1759 { 1760 reportException(methodCall, s); 1761 throw s; 1762 } 1763 } 1764 1765 public Reader getCharacterStream(int columnIndex) throws SQLException 1766 { 1767 String methodCall = "getCharacterStream(" + columnIndex + ")"; 1768 try 1769 { 1770 return (Reader) reportReturn(methodCall, realResultSet.getCharacterStream(columnIndex)); 1771 } 1772 catch (SQLException s) 1773 { 1774 reportException(methodCall, s); 1775 throw s; 1776 } 1777 } 1778 1779 public Reader getCharacterStream(String columnName) throws SQLException 1780 { 1781 String methodCall = "getCharacterStream(" + columnName + ")"; 1782 try 1783 { 1784 return (Reader) reportReturn(methodCall, realResultSet.getCharacterStream(columnName)); 1785 } 1786 catch (SQLException s) 1787 { 1788 reportException(methodCall, s); 1789 throw s; 1790 } 1791 } 1792 1793 public void setFetchDirection(int direction) throws SQLException 1794 { 1795 String methodCall = "setFetchDirection(" + direction + ")"; 1796 try 1797 { 1798 realResultSet.setFetchDirection(direction); 1799 } 1800 catch (SQLException s) 1801 { 1802 reportException(methodCall, s); 1803 throw s; 1804 } 1805 reportReturn(methodCall); 1806 } 1807 1808 public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException 1809 { 1810 String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ", " + length + ")"; 1811 try 1812 { 1813 realResultSet.updateCharacterStream(columnIndex, x, length); 1814 } 1815 catch (SQLException s) 1816 { 1817 reportException(methodCall, s); 1818 throw s; 1819 } 1820 reportReturn(methodCall); 1821 } 1822 1823 public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException 1824 { 1825 String methodCall = "updateCharacterStream(" + columnName + ", " + reader + ", " + length + ")"; 1826 try 1827 { 1828 realResultSet.updateCharacterStream(columnName, reader, length); 1829 } 1830 catch (SQLException s) 1831 { 1832 reportException(methodCall, s); 1833 throw s; 1834 } 1835 reportReturn(methodCall); 1836 } 1837 1838 public byte getByte(int columnIndex) throws SQLException 1839 { 1840 String methodCall = "getByte(" + columnIndex + ")"; 1841 try 1842 { 1843 return reportReturn(methodCall, realResultSet.getByte(columnIndex)); 1844 } 1845 catch (SQLException s) 1846 { 1847 reportException(methodCall, s); 1848 throw s; 1849 } 1850 } 1851 1852 public byte getByte(String columnName) throws SQLException 1853 { 1854 String methodCall = "getByte(" + columnName + ")"; 1855 try 1856 { 1857 return reportReturn(methodCall, realResultSet.getByte(columnName)); 1858 } 1859 catch (SQLException s) 1860 { 1861 reportException(methodCall, s); 1862 throw s; 1863 } 1864 } 1865 1866 public void updateTime(int columnIndex, Time x) throws SQLException 1867 { 1868 String methodCall = "updateTime(" + columnIndex + ", " + x + ")"; 1869 try 1870 { 1871 realResultSet.updateTime(columnIndex, x); 1872 } 1873 catch (SQLException s) 1874 { 1875 reportException(methodCall, s); 1876 throw s; 1877 } 1878 reportReturn(methodCall); 1879 } 1880 1881 public void updateTime(String columnName, Time x) throws SQLException 1882 { 1883 String methodCall = "updateTime(" + columnName + ", " + x + ")"; 1884 try 1885 { 1886 realResultSet.updateTime(columnName, x); 1887 } 1888 catch (SQLException s) 1889 { 1890 reportException(methodCall, s); 1891 throw s; 1892 } 1893 reportReturn(methodCall); 1894 } 1895 1896 public byte[] getBytes(int columnIndex) throws SQLException 1897 { 1898 String methodCall = "getBytes(" + columnIndex + ")"; 1899 try 1900 { 1901 return (byte[]) reportReturn(methodCall, realResultSet.getBytes(columnIndex)); 1902 } 1903 catch (SQLException s) 1904 { 1905 reportException(methodCall, s); 1906 throw s; 1907 } 1908 } 1909 1910 public byte[] getBytes(String columnName) throws SQLException 1911 { 1912 String methodCall = "getBytes(" + columnName + ")"; 1913 try 1914 { 1915 return (byte[]) reportReturn(methodCall, realResultSet.getBytes(columnName)); 1916 } 1917 catch (SQLException s) 1918 { 1919 reportException(methodCall, s); 1920 throw s; 1921 } 1922 } 1923 1924 public boolean isAfterLast() throws SQLException 1925 { 1926 String methodCall = "isAfterLast()"; 1927 try 1928 { 1929 return reportReturn(methodCall, realResultSet.isAfterLast()); 1930 } 1931 catch (SQLException s) 1932 { 1933 reportException(methodCall, s); 1934 throw s; 1935 } 1936 } 1937 1938 public void updateObject(int columnIndex, Object x, int scale) throws SQLException 1939 { 1940 String methodCall = "updateObject(" + columnIndex + ", " + x + ", " + scale + ")"; 1941 try 1942 { 1943 realResultSet.updateObject(columnIndex, x, scale); 1944 } 1945 catch (SQLException s) 1946 { 1947 reportException(methodCall, s); 1948 throw s; 1949 } 1950 reportReturn(methodCall); 1951 } 1952 1953 public void updateObject(int columnIndex, Object x) throws SQLException 1954 { 1955 String methodCall = "updateObject(" + columnIndex + ", " + x + ")"; 1956 try 1957 { 1958 realResultSet.updateObject(columnIndex, x); 1959 } 1960 catch (SQLException s) 1961 { 1962 reportException(methodCall, s); 1963 throw s; 1964 } 1965 reportReturn(methodCall); 1966 } 1967 1968 public void updateObject(String columnName, Object x, int scale) throws SQLException 1969 { 1970 String methodCall = "updateObject(" + columnName + ", " + x + ", " + scale + ")"; 1971 try 1972 { 1973 realResultSet.updateObject(columnName, x, scale); 1974 } 1975 catch (SQLException s) 1976 { 1977 reportException(methodCall, s); 1978 throw s; 1979 } 1980 reportReturn(methodCall); 1981 } 1982 1983 public void updateObject(String columnName, Object x) throws SQLException 1984 { 1985 String methodCall = "updateObject(" + columnName + ", " + x + ")"; 1986 try 1987 { 1988 realResultSet.updateObject(columnName, x); 1989 } 1990 catch (SQLException s) 1991 { 1992 reportException(methodCall, s); 1993 throw s; 1994 } 1995 reportReturn(methodCall); 1996 } 1997 1998 public int getFetchDirection() throws SQLException 1999 { 2000 String methodCall = "getFetchDirection()"; 2001 try 2002 { 2003 return reportReturn(methodCall, realResultSet.getFetchDirection()); 2004 } 2005 catch (SQLException s) 2006 { 2007 reportException(methodCall, s); 2008 throw s; 2009 } 2010 } 2011 2012 public long getLong(int columnIndex) throws SQLException 2013 { 2014 String methodCall = "getLong(" + columnIndex + ")"; 2015 try 2016 { 2017 return reportReturn(methodCall, realResultSet.getLong(columnIndex)); 2018 } 2019 catch (SQLException s) 2020 { 2021 reportException(methodCall, s); 2022 throw s; 2023 } 2024 } 2025 2026 public long getLong(String columnName) throws SQLException 2027 { 2028 String methodCall = "getLong(" + columnName + ")"; 2029 try 2030 { 2031 return reportReturn(methodCall, realResultSet.getLong(columnName)); 2032 } 2033 catch (SQLException s) 2034 { 2035 reportException(methodCall, s); 2036 throw s; 2037 } 2038 } 2039 2040 public boolean isFirst() throws SQLException 2041 { 2042 String methodCall = "isFirst()"; 2043 try 2044 { 2045 return reportReturn(methodCall, realResultSet.isFirst()); 2046 } 2047 catch (SQLException s) 2048 { 2049 reportException(methodCall, s); 2050 throw s; 2051 } 2052 } 2053 2054 public void insertRow() throws SQLException 2055 { 2056 String methodCall = "insertRow()"; 2057 try 2058 { 2059 realResultSet.insertRow(); 2060 } 2061 catch (SQLException s) 2062 { 2063 reportException(methodCall, s); 2064 throw s; 2065 } 2066 } 2067 2068 public float getFloat(int columnIndex) throws SQLException 2069 { 2070 String methodCall = "getFloat(" + columnIndex + ")"; 2071 try 2072 { 2073 return reportReturn(methodCall, realResultSet.getFloat(columnIndex)); 2074 } 2075 catch (SQLException s) 2076 { 2077 reportException(methodCall, s); 2078 throw s; 2079 } 2080 } 2081 2082 public float getFloat(String columnName) throws SQLException 2083 { 2084 String methodCall = "getFloat(" + columnName + ")"; 2085 try 2086 { 2087 return reportReturn(methodCall, realResultSet.getFloat(columnName)); 2088 } 2089 catch (SQLException s) 2090 { 2091 reportException(methodCall, s); 2092 throw s; 2093 } 2094 } 2095 2096 public boolean isLast() throws SQLException 2097 { 2098 String methodCall = "isLast()"; 2099 try 2100 { 2101 return reportReturn(methodCall, realResultSet.isLast()); 2102 } 2103 catch (SQLException s) 2104 { 2105 reportException(methodCall, s); 2106 throw s; 2107 } 2108 } 2109 2110 public void setFetchSize(int rows) throws SQLException 2111 { 2112 String methodCall = "setFetchSize(" + rows + ")"; 2113 try 2114 { 2115 realResultSet.setFetchSize(rows); 2116 } 2117 catch (SQLException s) 2118 { 2119 reportException(methodCall, s); 2120 throw s; 2121 } 2122 reportReturn(methodCall); 2123 } 2124 2125 public void updateRow() throws SQLException 2126 { 2127 String methodCall = "updateRow()"; 2128 try 2129 { 2130 realResultSet.updateRow(); 2131 } 2132 catch (SQLException s) 2133 { 2134 reportException(methodCall, s); 2135 throw s; 2136 } 2137 reportReturn(methodCall); 2138 } 2139 2140 public void beforeFirst() throws SQLException 2141 { 2142 String methodCall = "beforeFirst()"; 2143 try 2144 { 2145 realResultSet.beforeFirst(); 2146 } 2147 catch (SQLException s) 2148 { 2149 reportException(methodCall, s); 2150 throw s; 2151 } 2152 reportReturn(methodCall); 2153 } 2154 2155 /** 2156 * @deprecated 2157 */ 2158 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException 2159 { 2160 String methodCall = "getBigDecimal(" + columnIndex + ", " + scale + ")"; 2161 try 2162 { 2163 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnIndex, scale)); 2164 } 2165 catch (SQLException s) 2166 { 2167 reportException(methodCall, s); 2168 throw s; 2169 } 2170 } 2171 2172 /** 2173 * @deprecated 2174 */ 2175 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException 2176 { 2177 String methodCall = "getBigDecimal(" + columnName + ", " + scale + ")"; 2178 try 2179 { 2180 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnName, scale)); 2181 } 2182 catch (SQLException s) 2183 { 2184 reportException(methodCall, s); 2185 throw s; 2186 } 2187 } 2188 2189 public BigDecimal getBigDecimal(int columnIndex) throws SQLException 2190 { 2191 String methodCall = "getBigDecimal(" + columnIndex + ")"; 2192 try 2193 { 2194 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnIndex)); 2195 } 2196 catch (SQLException s) 2197 { 2198 reportException(methodCall, s); 2199 throw s; 2200 } 2201 } 2202 2203 public BigDecimal getBigDecimal(String columnName) throws SQLException 2204 { 2205 String methodCall = "getBigDecimal(" + columnName + ")"; 2206 try 2207 { 2208 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnName)); 2209 } 2210 catch (SQLException s) 2211 { 2212 reportException(methodCall, s); 2213 throw s; 2214 } 2215 } 2216 2217 public void afterLast() throws SQLException 2218 { 2219 String methodCall = "afterLast()"; 2220 try 2221 { 2222 realResultSet.afterLast(); 2223 } 2224 catch (SQLException s) 2225 { 2226 reportException(methodCall, s); 2227 throw s; 2228 } 2229 reportReturn(methodCall); 2230 } 2231 2232 public void refreshRow() throws SQLException 2233 { 2234 String methodCall = "refreshRow()"; 2235 try 2236 { 2237 realResultSet.refreshRow(); 2238 } 2239 catch (SQLException s) 2240 { 2241 reportException(methodCall, s); 2242 throw s; 2243 } 2244 } 2245 }