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.*; 023 import java.util.Calendar; 024 import java.util.Map; 025 026 /** 027 * Wraps a ResultSet and reports method calls, returns and exceptions. 028 * 029 * JDBC 4 version. 030 * 031 * @author Arthur Blake 032 */ 033 public class ResultSetSpy implements ResultSet, Spy 034 { 035 private final SpyLogDelegator log; 036 037 /** 038 * Report an exception to be logged. 039 * 040 * @param methodCall description of method call and arguments passed to it that generated the exception. 041 * @param exception exception that was generated 042 */ 043 protected void reportException(String methodCall, SQLException exception) 044 { 045 log.exceptionOccured(this, methodCall, exception, null, -1L); 046 } 047 048 /** 049 * Report (for logging) that a method returned. All the other reportReturn methods are conveniance methods that call 050 * this method. 051 * 052 * @param methodCall description of method call and arguments passed to it that returned. 053 * @param msg description of what the return value that was returned. may be an empty String for void return types. 054 */ 055 protected void reportAllReturns(String methodCall, String msg) 056 { 057 log.methodReturned(this, methodCall, msg); 058 } 059 060 private ResultSet realResultSet; 061 private StatementSpy parent; 062 063 /** 064 * Create a new ResultSetSpy that wraps another ResultSet object, that logs all method calls, expceptions, etc. 065 * 066 * @param parent Statement that generated this ResultSet. 067 * @param realResultSet real underlying ResultSet that is being wrapped. 068 */ 069 public ResultSetSpy(StatementSpy parent, ResultSet realResultSet) 070 { 071 if (realResultSet == null) 072 { 073 throw new IllegalArgumentException("Must provide a non null real ResultSet"); 074 } 075 this.realResultSet = realResultSet; 076 this.parent = parent; 077 log = SpyLogFactory.getSpyLogDelegator(); 078 } 079 080 /** 081 * Description for ResultSet class type. 082 */ 083 public static final String classTypeDescription = "ResultSet"; 084 085 public String getClassType() 086 { 087 return classTypeDescription; 088 } 089 090 public int getConnectionNumber() 091 { 092 return parent.getConnectionNumber(); 093 } 094 095 /** 096 * Conveniance method to report (for logging) that a method returned a boolean value. 097 * 098 * @param methodCall description of method call and arguments passed to it that returned. 099 * @param value boolean return value. 100 * @return the boolean return value as passed in. 101 */ 102 protected boolean reportReturn(String methodCall, boolean value) 103 { 104 reportAllReturns(methodCall, "" + value); 105 return value; 106 } 107 108 /** 109 * Conveniance method to report (for logging) that a method returned a byte value. 110 * 111 * @param methodCall description of method call and arguments passed to it that returned. 112 * @param value byte return value. 113 * @return the byte return value as passed in. 114 */ 115 protected byte reportReturn(String methodCall, byte value) 116 { 117 reportAllReturns(methodCall, "" + value); 118 return value; 119 } 120 121 /** 122 * Conveniance method to report (for logging) that a method returned a int value. 123 * 124 * @param methodCall description of method call and arguments passed to it that returned. 125 * @param value int return value. 126 * @return the int return value as passed in. 127 */ 128 protected int reportReturn(String methodCall, int value) 129 { 130 reportAllReturns(methodCall, "" + value); 131 return value; 132 } 133 134 /** 135 * Conveniance method to report (for logging) that a method returned a double value. 136 * 137 * @param methodCall description of method call and arguments passed to it that returned. 138 * @param value double return value. 139 * @return the double return value as passed in. 140 */ 141 protected double reportReturn(String methodCall, double value) 142 { 143 reportAllReturns(methodCall, "" + value); 144 return value; 145 } 146 147 /** 148 * Conveniance method to report (for logging) that a method returned a short value. 149 * 150 * @param methodCall description of method call and arguments passed to it that returned. 151 * @param value short return value. 152 * @return the short return value as passed in. 153 */ 154 protected short reportReturn(String methodCall, short value) 155 { 156 reportAllReturns(methodCall, "" + value); 157 return value; 158 } 159 160 /** 161 * Conveniance method to report (for logging) that a method returned a long value. 162 * 163 * @param methodCall description of method call and arguments passed to it that returned. 164 * @param value long return value. 165 * @return the long return value as passed in. 166 */ 167 protected long reportReturn(String methodCall, long value) 168 { 169 reportAllReturns(methodCall, "" + value); 170 return value; 171 } 172 173 /** 174 * Conveniance method to report (for logging) that a method returned a float value. 175 * 176 * @param methodCall description of method call and arguments passed to it that returned. 177 * @param value float return value. 178 * @return the float return value as passed in. 179 */ 180 protected float reportReturn(String methodCall, float value) 181 { 182 reportAllReturns(methodCall, "" + value); 183 return value; 184 } 185 186 /** 187 * Conveniance method to report (for logging) that a method returned an Object. 188 * 189 * @param methodCall description of method call and arguments passed to it that returned. 190 * @param value return Object. 191 * @return the return Object as passed in. 192 */ 193 protected Object reportReturn(String methodCall, Object value) 194 { 195 reportAllReturns(methodCall, "" + value); 196 return value; 197 } 198 199 /** 200 * Conveniance method to report (for logging) that a method returned (void return type). 201 * 202 * @param methodCall description of method call and arguments passed to it that returned. 203 */ 204 protected void reportReturn(String methodCall) 205 { 206 reportAllReturns(methodCall, ""); 207 } 208 209 // forwarding methods 210 211 public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException 212 { 213 String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ", " + length + ")"; 214 try 215 { 216 realResultSet.updateAsciiStream(columnIndex, x, length); 217 } 218 catch (SQLException s) 219 { 220 reportException(methodCall, s); 221 throw s; 222 } 223 reportReturn(methodCall); 224 } 225 226 public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException 227 { 228 String methodCall = "updateAsciiStream(" + columnName + ", " + x + ", " + length + ")"; 229 try 230 { 231 realResultSet.updateAsciiStream(columnName, x, length); 232 } 233 catch (SQLException s) 234 { 235 reportException(methodCall, s); 236 throw s; 237 } 238 reportReturn(methodCall); 239 } 240 241 public int getRow() throws SQLException 242 { 243 String methodCall = "getRow()"; 244 try 245 { 246 return reportReturn(methodCall, realResultSet.getRow()); 247 } 248 catch (SQLException s) 249 { 250 reportException(methodCall, s); 251 throw s; 252 } 253 } 254 255 public void cancelRowUpdates() throws SQLException 256 { 257 String methodCall = "cancelRowUpdates()"; 258 try 259 { 260 realResultSet.cancelRowUpdates(); 261 } 262 catch (SQLException s) 263 { 264 reportException(methodCall, s); 265 throw s; 266 } 267 reportReturn(methodCall); 268 } 269 270 public Time getTime(int columnIndex) throws SQLException 271 { 272 String methodCall = "getTime(" + columnIndex + ")"; 273 try 274 { 275 return (Time) reportReturn(methodCall, realResultSet.getTime(columnIndex)); 276 } 277 catch (SQLException s) 278 { 279 reportException(methodCall, s); 280 throw s; 281 } 282 } 283 284 public Time getTime(String columnName) throws SQLException 285 { 286 String methodCall = "getTime(" + columnName + ")"; 287 try 288 { 289 return (Time) reportReturn(methodCall, realResultSet.getTime(columnName)); 290 } 291 catch (SQLException s) 292 { 293 reportException(methodCall, s); 294 throw s; 295 } 296 } 297 298 public Time getTime(int columnIndex, Calendar cal) throws SQLException 299 { 300 String methodCall = "getTime(" + columnIndex + ", " + cal + ")"; 301 try 302 { 303 return (Time) reportReturn(methodCall, realResultSet.getTime(columnIndex, cal)); 304 } 305 catch (SQLException s) 306 { 307 reportException(methodCall, s); 308 throw s; 309 } 310 } 311 312 public Time getTime(String columnName, Calendar cal) throws SQLException 313 { 314 String methodCall = "getTime(" + columnName + ", " + cal + ")"; 315 try 316 { 317 return (Time) reportReturn(methodCall, realResultSet.getTime(columnName, cal)); 318 } 319 catch (SQLException s) 320 { 321 reportException(methodCall, s); 322 throw s; 323 } 324 } 325 326 public boolean absolute(int row) throws SQLException 327 { 328 String methodCall = "absolute(" + row + ")"; 329 try 330 { 331 return reportReturn(methodCall, realResultSet.absolute(row)); 332 } 333 catch (SQLException s) 334 { 335 reportException(methodCall, s); 336 throw s; 337 } 338 } 339 340 public Timestamp getTimestamp(int columnIndex) throws SQLException 341 { 342 String methodCall = "getTimestamp(" + columnIndex + ")"; 343 try 344 { 345 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnIndex)); 346 } 347 catch (SQLException s) 348 { 349 reportException(methodCall, s); 350 throw s; 351 } 352 } 353 354 public Timestamp getTimestamp(String columnName) throws SQLException 355 { 356 String methodCall = "getTimestamp(" + columnName + ")"; 357 try 358 { 359 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnName)); 360 } 361 catch (SQLException s) 362 { 363 reportException(methodCall, s); 364 throw s; 365 } 366 367 } 368 369 public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException 370 { 371 String methodCall = "getTimestamp(" + columnIndex + ", " + cal + ")"; 372 try 373 { 374 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnIndex, cal)); 375 } 376 catch (SQLException s) 377 { 378 reportException(methodCall, s); 379 throw s; 380 } 381 382 } 383 384 public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException 385 { 386 String methodCall = "getTimestamp(" + columnName + ", " + cal + ")"; 387 try 388 { 389 return (Timestamp) reportReturn(methodCall, realResultSet.getTimestamp(columnName, cal)); 390 } 391 catch (SQLException s) 392 { 393 reportException(methodCall, s); 394 throw s; 395 } 396 } 397 398 public void moveToInsertRow() throws SQLException 399 { 400 String methodCall = "moveToInsertRow()"; 401 try 402 { 403 realResultSet.moveToInsertRow(); 404 } 405 catch (SQLException s) 406 { 407 reportException(methodCall, s); 408 throw s; 409 } 410 reportReturn(methodCall); 411 } 412 413 public boolean relative(int rows) throws SQLException 414 { 415 String methodCall = "relative(" + rows + ")"; 416 try 417 { 418 return reportReturn(methodCall, realResultSet.relative(rows)); 419 } 420 catch (SQLException s) 421 { 422 reportException(methodCall, s); 423 throw s; 424 } 425 } 426 427 public boolean previous() throws SQLException 428 { 429 String methodCall = "previous()"; 430 try 431 { 432 return reportReturn(methodCall, realResultSet.previous()); 433 } 434 catch (SQLException s) 435 { 436 reportException(methodCall, s); 437 throw s; 438 } 439 } 440 441 public void moveToCurrentRow() throws SQLException 442 { 443 String methodCall = "moveToCurrentRow()"; 444 try 445 { 446 realResultSet.moveToCurrentRow(); 447 } 448 catch (SQLException s) 449 { 450 reportException(methodCall, s); 451 throw s; 452 } 453 reportReturn(methodCall); 454 } 455 456 public Ref getRef(int i) throws SQLException 457 { 458 String methodCall = "getRef(" + i + ")"; 459 try 460 { 461 return (Ref) reportReturn(methodCall, realResultSet.getRef(i)); 462 } 463 catch (SQLException s) 464 { 465 reportException(methodCall, s); 466 throw s; 467 } 468 } 469 470 public void updateRef(int columnIndex, Ref x) throws SQLException 471 { 472 String methodCall = "updateRef(" + columnIndex + ", " + x + ")"; 473 try 474 { 475 realResultSet.updateRef(columnIndex, x); 476 } 477 catch (SQLException s) 478 { 479 reportException(methodCall, s); 480 throw s; 481 } 482 reportReturn(methodCall); 483 } 484 485 public Ref getRef(String colName) throws SQLException 486 { 487 String methodCall = "getRef(" + colName + ")"; 488 try 489 { 490 return (Ref) reportReturn(methodCall, realResultSet.getRef(colName)); 491 } 492 catch (SQLException s) 493 { 494 reportException(methodCall, s); 495 throw s; 496 } 497 } 498 499 public void updateRef(String columnName, Ref x) throws SQLException 500 { 501 String methodCall = "updateRef(" + columnName + ", " + x + ")"; 502 try 503 { 504 realResultSet.updateRef(columnName, x); 505 } 506 catch (SQLException s) 507 { 508 reportException(methodCall, s); 509 throw s; 510 } 511 reportReturn(methodCall); 512 } 513 514 public Blob getBlob(int i) throws SQLException 515 { 516 String methodCall = "getBlob(" + i + ")"; 517 try 518 { 519 return (Blob) reportReturn(methodCall, realResultSet.getBlob(i)); 520 } 521 catch (SQLException s) 522 { 523 reportException(methodCall, s); 524 throw s; 525 } 526 } 527 528 public void updateBlob(int columnIndex, Blob x) throws SQLException 529 { 530 String methodCall = "updateBlob(" + columnIndex + ", " + x + ")"; 531 try 532 { 533 realResultSet.updateBlob(columnIndex, x); 534 } 535 catch (SQLException s) 536 { 537 reportException(methodCall, s); 538 throw s; 539 } 540 reportReturn(methodCall); 541 } 542 543 public Blob getBlob(String colName) throws SQLException 544 { 545 String methodCall = "getBlob(" + colName + ")"; 546 try 547 { 548 return (Blob) reportReturn(methodCall, realResultSet.getBlob(colName)); 549 } 550 catch (SQLException s) 551 { 552 reportException(methodCall, s); 553 throw s; 554 } 555 } 556 557 public void updateBlob(String columnName, Blob x) throws SQLException 558 { 559 String methodCall = "updateBlob(" + columnName + ", " + x + ")"; 560 try 561 { 562 realResultSet.updateBlob(columnName, x); 563 } 564 catch (SQLException s) 565 { 566 reportException(methodCall, s); 567 throw s; 568 } 569 reportReturn(methodCall); 570 } 571 572 public Clob getClob(int i) throws SQLException 573 { 574 String methodCall = "getClob(" + i + ")"; 575 try 576 { 577 return (Clob) reportReturn(methodCall, realResultSet.getClob(i)); 578 } 579 catch (SQLException s) 580 { 581 reportException(methodCall, s); 582 throw s; 583 } 584 } 585 586 public void updateClob(int columnIndex, Clob x) throws SQLException 587 { 588 String methodCall = "updateClob(" + columnIndex + ", " + x + ")"; 589 try 590 { 591 realResultSet.updateClob(columnIndex, x); 592 } 593 catch (SQLException s) 594 { 595 reportException(methodCall, s); 596 throw s; 597 } 598 reportReturn(methodCall); 599 } 600 601 public Clob getClob(String colName) throws SQLException 602 { 603 String methodCall = "getClob(" + colName + ")"; 604 try 605 { 606 return (Clob) reportReturn(methodCall, realResultSet.getClob(colName)); 607 } 608 catch (SQLException s) 609 { 610 reportException(methodCall, s); 611 throw s; 612 } 613 } 614 615 public void updateClob(String columnName, Clob x) throws SQLException 616 { 617 String methodCall = "updateClob(" + columnName + ", " + x + ")"; 618 try 619 { 620 realResultSet.updateClob(columnName, x); 621 } 622 catch (SQLException s) 623 { 624 reportException(methodCall, s); 625 throw s; 626 } 627 reportReturn(methodCall); 628 } 629 630 public boolean getBoolean(int columnIndex) throws SQLException 631 { 632 String methodCall = "getBoolean(" + columnIndex + ")"; 633 try 634 { 635 return reportReturn(methodCall, realResultSet.getBoolean(columnIndex)); 636 } 637 catch (SQLException s) 638 { 639 reportException(methodCall, s); 640 throw s; 641 } 642 } 643 644 public boolean getBoolean(String columnName) throws SQLException 645 { 646 String methodCall = "getBoolean(" + columnName + ")"; 647 try 648 { 649 return reportReturn(methodCall, realResultSet.getBoolean(columnName)); 650 } 651 catch (SQLException s) 652 { 653 reportException(methodCall, s); 654 throw s; 655 } 656 } 657 658 public Array getArray(int i) throws SQLException 659 { 660 String methodCall = "getArray(" + i + ")"; 661 try 662 { 663 return (Array) reportReturn(methodCall, realResultSet.getArray(i)); 664 } 665 catch (SQLException s) 666 { 667 reportException(methodCall, s); 668 throw s; 669 } 670 } 671 672 public void updateArray(int columnIndex, Array x) throws SQLException 673 { 674 String methodCall = "updateArray(" + columnIndex + ", " + x + ")"; 675 try 676 { 677 realResultSet.updateArray(columnIndex, x); 678 } 679 catch (SQLException s) 680 { 681 reportException(methodCall, s); 682 throw s; 683 } 684 reportReturn(methodCall); 685 } 686 687 public Array getArray(String colName) throws SQLException 688 { 689 String methodCall = "getArray(" + colName + ")"; 690 try 691 { 692 return (Array) reportReturn(methodCall, realResultSet.getArray(colName)); 693 } 694 catch (SQLException s) 695 { 696 reportException(methodCall, s); 697 throw s; 698 } 699 } 700 701 public void updateArray(String columnName, Array x) throws SQLException 702 { 703 String methodCall = "updateArray(" + columnName + ", " + x + ")"; 704 try 705 { 706 realResultSet.updateArray(columnName, x); 707 } 708 catch (SQLException s) 709 { 710 reportException(methodCall, s); 711 throw s; 712 } 713 reportReturn(methodCall); 714 } 715 716 public RowId getRowId(int columnIndex) throws SQLException { 717 String methodCall = "getRowId(" + columnIndex + ")"; 718 try 719 { 720 return (RowId) reportReturn(methodCall, realResultSet.getRowId(columnIndex)); 721 } 722 catch (SQLException s) 723 { 724 reportException(methodCall, s); 725 throw s; 726 } 727 } 728 729 public RowId getRowId(String columnLabel) throws SQLException { 730 String methodCall = "getRowId(" + columnLabel + ")"; 731 try 732 { 733 return (RowId) reportReturn(methodCall, realResultSet.getRowId(columnLabel)); 734 } 735 catch (SQLException s) 736 { 737 reportException(methodCall, s); 738 throw s; 739 } 740 } 741 742 public void updateRowId(int columnIndex, RowId x) throws SQLException { 743 String methodCall = "updateRowId(" + columnIndex + ", " + x + ")"; 744 try 745 { 746 realResultSet.updateRowId(columnIndex, x); 747 } 748 catch (SQLException s) 749 { 750 reportException(methodCall, s); 751 throw s; 752 } 753 reportReturn(methodCall); 754 } 755 756 public void updateRowId(String columnLabel, RowId x) throws SQLException { 757 String methodCall = "updateRowId(" + columnLabel + ", " + x + ")"; 758 try 759 { 760 realResultSet.updateRowId(columnLabel, x); 761 } 762 catch (SQLException s) 763 { 764 reportException(methodCall, s); 765 throw s; 766 } 767 reportReturn(methodCall); 768 } 769 770 public int getHoldability() throws SQLException { 771 String methodCall = "getHoldability()"; 772 try 773 { 774 return reportReturn(methodCall, realResultSet.getHoldability()); 775 } 776 catch (SQLException s) 777 { 778 reportException(methodCall, s); 779 throw s; 780 } 781 } 782 783 public boolean isClosed() throws SQLException { 784 String methodCall = "isClosed()"; 785 try 786 { 787 return reportReturn(methodCall, realResultSet.isClosed()); 788 } 789 catch (SQLException s) 790 { 791 reportException(methodCall, s); 792 throw s; 793 } 794 } 795 796 public void updateNString(int columnIndex, String nString) throws SQLException { 797 String methodCall = "updateNString(" + columnIndex + ", " + nString + ")"; 798 try 799 { 800 realResultSet.updateNString(columnIndex, nString); 801 } 802 catch (SQLException s) 803 { 804 reportException(methodCall, s); 805 throw s; 806 } 807 reportReturn(methodCall); 808 } 809 810 public void updateNString(String columnLabel, String nString) throws SQLException { 811 String methodCall = "updateNString(" + columnLabel + ", " + nString + ")"; 812 try 813 { 814 realResultSet.updateNString(columnLabel, nString); 815 } 816 catch (SQLException s) 817 { 818 reportException(methodCall, s); 819 throw s; 820 } 821 reportReturn(methodCall); 822 } 823 824 public void updateNClob(int columnIndex, NClob nClob) throws SQLException { 825 String methodCall = "updateNClob(" + columnIndex + ", " + nClob + ")"; 826 try 827 { 828 realResultSet.updateNClob(columnIndex, nClob); 829 } 830 catch (SQLException s) 831 { 832 reportException(methodCall, s); 833 throw s; 834 } 835 reportReturn(methodCall); 836 } 837 838 public void updateNClob(String columnLabel, NClob nClob) throws SQLException { 839 String methodCall = "updateNClob(" + columnLabel + ", " + nClob + ")"; 840 try 841 { 842 realResultSet.updateNClob(columnLabel, nClob); 843 } 844 catch (SQLException s) 845 { 846 reportException(methodCall, s); 847 throw s; 848 } 849 reportReturn(methodCall); 850 } 851 852 public NClob getNClob(int columnIndex) throws SQLException { 853 String methodCall = "getNClob(" + columnIndex + ")"; 854 try 855 { 856 return (NClob) reportReturn(methodCall, realResultSet.getNClob(columnIndex)); 857 } 858 catch (SQLException s) 859 { 860 reportException(methodCall, s); 861 throw s; 862 } 863 } 864 865 public NClob getNClob(String columnLabel) throws SQLException { 866 String methodCall = "getNClob(" + columnLabel + ")"; 867 try 868 { 869 return (NClob) reportReturn(methodCall, realResultSet.getNClob(columnLabel)); 870 } 871 catch (SQLException s) 872 { 873 reportException(methodCall, s); 874 throw s; 875 } 876 } 877 878 public SQLXML getSQLXML(int columnIndex) throws SQLException { 879 String methodCall = "getSQLXML(" + columnIndex + ")"; 880 try 881 { 882 return (SQLXML) reportReturn(methodCall, realResultSet.getSQLXML(columnIndex)); 883 } 884 catch (SQLException s) 885 { 886 reportException(methodCall, s); 887 throw s; 888 } 889 } 890 891 public SQLXML getSQLXML(String columnLabel) throws SQLException { 892 String methodCall = "getSQLXML(" + columnLabel + ")"; 893 try 894 { 895 return (SQLXML) reportReturn(methodCall, realResultSet.getSQLXML(columnLabel)); 896 } 897 catch (SQLException s) 898 { 899 reportException(methodCall, s); 900 throw s; 901 } 902 } 903 904 public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException { 905 String methodCall = "updateSQLXML(" + columnIndex + ", " + xmlObject + ")"; 906 try 907 { 908 realResultSet.updateSQLXML(columnIndex, xmlObject); 909 } 910 catch (SQLException s) 911 { 912 reportException(methodCall, s); 913 throw s; 914 } 915 reportReturn(methodCall); 916 } 917 918 public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException { 919 String methodCall = "updateSQLXML(" + columnLabel + ", " + xmlObject + ")"; 920 try 921 { 922 realResultSet.updateSQLXML(columnLabel, xmlObject); 923 } 924 catch (SQLException s) 925 { 926 reportException(methodCall, s); 927 throw s; 928 } 929 reportReturn(methodCall); 930 } 931 932 public String getNString(int columnIndex) throws SQLException { 933 String methodCall = "getNString(" + columnIndex + ")"; 934 try 935 { 936 return (String) reportReturn(methodCall, realResultSet.getNString(columnIndex)); 937 } 938 catch (SQLException s) 939 { 940 reportException(methodCall, s); 941 throw s; 942 } 943 } 944 945 public String getNString(String columnLabel) throws SQLException { 946 String methodCall = "getNString(" + columnLabel + ")"; 947 try 948 { 949 return (String) reportReturn(methodCall, realResultSet.getNString(columnLabel)); 950 } 951 catch (SQLException s) 952 { 953 reportException(methodCall, s); 954 throw s; 955 } 956 } 957 958 public Reader getNCharacterStream(int columnIndex) throws SQLException { 959 String methodCall = "getNCharacterStream(" + columnIndex + ")"; 960 try 961 { 962 return (Reader) reportReturn(methodCall, realResultSet.getNCharacterStream(columnIndex)); 963 } 964 catch (SQLException s) 965 { 966 reportException(methodCall, s); 967 throw s; 968 } 969 } 970 971 public Reader getNCharacterStream(String columnLabel) throws SQLException { 972 String methodCall = "getNCharacterStream(" + columnLabel + ")"; 973 try 974 { 975 return (Reader) reportReturn(methodCall, realResultSet.getNCharacterStream(columnLabel)); 976 } 977 catch (SQLException s) 978 { 979 reportException(methodCall, s); 980 throw s; 981 } 982 } 983 984 public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException { 985 String methodCall = "updateNCharacterStream(" + columnIndex + ", " + x + ", " + length + ")"; 986 try 987 { 988 realResultSet.updateNCharacterStream(columnIndex, x, length); 989 } 990 catch (SQLException s) 991 { 992 reportException(methodCall, s); 993 throw s; 994 } 995 reportReturn(methodCall); 996 } 997 998 public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException { 999 String methodCall = "updateNCharacterStream(" + columnLabel + ", " + reader + ", " + length + ")"; 1000 try 1001 { 1002 realResultSet.updateNCharacterStream(columnLabel, reader, length); 1003 } 1004 catch (SQLException s) 1005 { 1006 reportException(methodCall, s); 1007 throw s; 1008 } 1009 reportReturn(methodCall); 1010 } 1011 1012 public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException { 1013 String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ", " + length + ")"; 1014 try 1015 { 1016 realResultSet.updateAsciiStream(columnIndex, x, length); 1017 } 1018 catch (SQLException s) 1019 { 1020 reportException(methodCall, s); 1021 throw s; 1022 } 1023 reportReturn(methodCall); 1024 } 1025 1026 public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException { 1027 String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ", " + length + ")"; 1028 try 1029 { 1030 realResultSet.updateBinaryStream(columnIndex, x, length); 1031 } 1032 catch (SQLException s) 1033 { 1034 reportException(methodCall, s); 1035 throw s; 1036 } 1037 reportReturn(methodCall); 1038 } 1039 1040 public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException { 1041 String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ", " + length + ")"; 1042 try 1043 { 1044 realResultSet.updateCharacterStream(columnIndex, x, length); 1045 } 1046 catch (SQLException s) 1047 { 1048 reportException(methodCall, s); 1049 throw s; 1050 } 1051 reportReturn(methodCall); 1052 } 1053 1054 public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException { 1055 String methodCall = "updateAsciiStream(" + columnLabel + ", " + x + ", " + length + ")"; 1056 try 1057 { 1058 realResultSet.updateAsciiStream(columnLabel, x, length); 1059 } 1060 catch (SQLException s) 1061 { 1062 reportException(methodCall, s); 1063 throw s; 1064 } 1065 reportReturn(methodCall); 1066 } 1067 1068 public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException { 1069 String methodCall = "updateBinaryStream(" + columnLabel + ", " + x + ", " + length + ")"; 1070 try 1071 { 1072 realResultSet.updateBinaryStream(columnLabel, x, length); 1073 } 1074 catch (SQLException s) 1075 { 1076 reportException(methodCall, s); 1077 throw s; 1078 } 1079 reportReturn(methodCall); 1080 } 1081 1082 public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException { 1083 String methodCall = "updateCharacterStream(" + columnLabel + ", " + reader + ", " + length + ")"; 1084 try 1085 { 1086 realResultSet.updateCharacterStream(columnLabel, reader, length); 1087 } 1088 catch (SQLException s) 1089 { 1090 reportException(methodCall, s); 1091 throw s; 1092 } 1093 reportReturn(methodCall); 1094 } 1095 1096 public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException { 1097 String methodCall = "updateBlob(" + columnIndex + ", " + inputStream + ", " + length + ")"; 1098 try 1099 { 1100 realResultSet.updateBlob(columnIndex, inputStream, length); 1101 } 1102 catch (SQLException s) 1103 { 1104 reportException(methodCall, s); 1105 throw s; 1106 } 1107 reportReturn(methodCall); 1108 } 1109 1110 public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException { 1111 String methodCall = "updateBlob(" + columnLabel + ", " + inputStream + ", " + length + ")"; 1112 try 1113 { 1114 realResultSet.updateBlob(columnLabel, inputStream, length); 1115 } 1116 catch (SQLException s) 1117 { 1118 reportException(methodCall, s); 1119 throw s; 1120 } 1121 reportReturn(methodCall); 1122 } 1123 1124 public void updateClob(int columnIndex, Reader reader, long length) throws SQLException { 1125 String methodCall = "updateClob(" + columnIndex + ", " + reader + ", " + length + ")"; 1126 try 1127 { 1128 realResultSet.updateClob(columnIndex, reader, length); 1129 } 1130 catch (SQLException s) 1131 { 1132 reportException(methodCall, s); 1133 throw s; 1134 } 1135 reportReturn(methodCall); 1136 } 1137 1138 public void updateClob(String columnLabel, Reader reader, long length) throws SQLException { 1139 String methodCall = "updateClob(" + columnLabel + ", " + reader + ", " + length + ")"; 1140 try 1141 { 1142 realResultSet.updateClob(columnLabel, reader, length); 1143 } 1144 catch (SQLException s) 1145 { 1146 reportException(methodCall, s); 1147 throw s; 1148 } 1149 reportReturn(methodCall); 1150 } 1151 1152 public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException { 1153 String methodCall = "updateNClob(" + columnIndex + ", " + reader + ", " + length + ")"; 1154 try 1155 { 1156 realResultSet.updateNClob(columnIndex, reader, length); 1157 } 1158 catch (SQLException s) 1159 { 1160 reportException(methodCall, s); 1161 throw s; 1162 } 1163 reportReturn(methodCall); 1164 } 1165 1166 public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException { 1167 String methodCall = "updateNClob(" + columnLabel + ", " + reader + ", " + length + ")"; 1168 try 1169 { 1170 realResultSet.updateNClob(columnLabel, reader, length); 1171 } 1172 catch (SQLException s) 1173 { 1174 reportException(methodCall, s); 1175 throw s; 1176 } 1177 reportReturn(methodCall); 1178 } 1179 1180 public void updateNCharacterStream(int columnIndex, Reader reader) throws SQLException { 1181 String methodCall = "updateNCharacterStream(" + columnIndex + ", " + reader + ")"; 1182 try 1183 { 1184 realResultSet.updateNCharacterStream(columnIndex, reader); 1185 } 1186 catch (SQLException s) 1187 { 1188 reportException(methodCall, s); 1189 throw s; 1190 } 1191 reportReturn(methodCall); 1192 } 1193 1194 public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException { 1195 String methodCall = "updateNCharacterStream(" + columnLabel + ", " + reader + ")"; 1196 try 1197 { 1198 realResultSet.updateNCharacterStream(columnLabel, reader); 1199 } 1200 catch (SQLException s) 1201 { 1202 reportException(methodCall, s); 1203 throw s; 1204 } 1205 reportReturn(methodCall); 1206 } 1207 1208 public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException { 1209 String methodCall = "updateAsciiStream(" + columnIndex + ", " + x + ")"; 1210 try 1211 { 1212 realResultSet.updateAsciiStream(columnIndex, x); 1213 } 1214 catch (SQLException s) 1215 { 1216 reportException(methodCall, s); 1217 throw s; 1218 } 1219 reportReturn(methodCall); 1220 } 1221 1222 public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException { 1223 String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ")"; 1224 try 1225 { 1226 realResultSet.updateBinaryStream(columnIndex, x); 1227 } 1228 catch (SQLException s) 1229 { 1230 reportException(methodCall, s); 1231 throw s; 1232 } 1233 reportReturn(methodCall); 1234 } 1235 1236 public void updateCharacterStream(int columnIndex, Reader x) throws SQLException { 1237 String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ")"; 1238 try 1239 { 1240 realResultSet.updateCharacterStream(columnIndex, x); 1241 } 1242 catch (SQLException s) 1243 { 1244 reportException(methodCall, s); 1245 throw s; 1246 } 1247 reportReturn(methodCall); 1248 } 1249 1250 public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException { 1251 String methodCall = "updateAsciiStream(" + columnLabel + ", " + x + ")"; 1252 try 1253 { 1254 realResultSet.updateAsciiStream(columnLabel, x); 1255 } 1256 catch (SQLException s) 1257 { 1258 reportException(methodCall, s); 1259 throw s; 1260 } 1261 reportReturn(methodCall); 1262 } 1263 1264 public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException { 1265 String methodCall = "updateBinaryStream(" + columnLabel + ", " + x + ")"; 1266 try 1267 { 1268 realResultSet.updateBinaryStream(columnLabel, x); 1269 } 1270 catch (SQLException s) 1271 { 1272 reportException(methodCall, s); 1273 throw s; 1274 } 1275 reportReturn(methodCall); 1276 } 1277 1278 public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException { 1279 String methodCall = "updateCharacterStream(" + columnLabel + ", " + reader + ")"; 1280 try 1281 { 1282 realResultSet.updateCharacterStream(columnLabel, reader); 1283 } 1284 catch (SQLException s) 1285 { 1286 reportException(methodCall, s); 1287 throw s; 1288 } 1289 reportReturn(methodCall); 1290 } 1291 1292 public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException { 1293 String methodCall = "updateBlob(" + columnIndex + ", " + inputStream + ")"; 1294 try 1295 { 1296 realResultSet.updateBlob(columnIndex, inputStream); 1297 } 1298 catch (SQLException s) 1299 { 1300 reportException(methodCall, s); 1301 throw s; 1302 } 1303 reportReturn(methodCall); 1304 } 1305 1306 public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException { 1307 String methodCall = "updateBlob(" + columnLabel + ", " + inputStream + ")"; 1308 try 1309 { 1310 realResultSet.updateBlob(columnLabel, inputStream); 1311 } 1312 catch (SQLException s) 1313 { 1314 reportException(methodCall, s); 1315 throw s; 1316 } 1317 reportReturn(methodCall); 1318 } 1319 1320 public void updateClob(int columnIndex, Reader reader) throws SQLException { 1321 String methodCall = "updateClob(" + columnIndex + ", " + reader + ")"; 1322 try 1323 { 1324 realResultSet.updateClob(columnIndex, reader); 1325 } 1326 catch (SQLException s) 1327 { 1328 reportException(methodCall, s); 1329 throw s; 1330 } 1331 reportReturn(methodCall); 1332 } 1333 1334 public void updateClob(String columnLabel, Reader reader) throws SQLException { 1335 String methodCall = "updateClob(" + columnLabel + ", " + reader + ")"; 1336 try 1337 { 1338 realResultSet.updateClob(columnLabel, reader); 1339 } 1340 catch (SQLException s) 1341 { 1342 reportException(methodCall, s); 1343 throw s; 1344 } 1345 reportReturn(methodCall); 1346 } 1347 1348 public void updateNClob(int columnIndex, Reader reader) throws SQLException { 1349 String methodCall = "updateNClob(" + columnIndex + ", " + reader + ")"; 1350 try 1351 { 1352 realResultSet.updateNClob(columnIndex, reader); 1353 } 1354 catch (SQLException s) 1355 { 1356 reportException(methodCall, s); 1357 throw s; 1358 } 1359 reportReturn(methodCall); 1360 } 1361 1362 public void updateNClob(String columnLabel, Reader reader) throws SQLException { 1363 String methodCall = "updateNClob(" + columnLabel + ", " + reader + ")"; 1364 try 1365 { 1366 realResultSet.updateNClob(columnLabel, reader); 1367 } 1368 catch (SQLException s) 1369 { 1370 reportException(methodCall, s); 1371 throw s; 1372 } 1373 reportReturn(methodCall); 1374 } 1375 1376 public boolean isBeforeFirst() throws SQLException 1377 { 1378 String methodCall = "isBeforeFirst()"; 1379 try 1380 { 1381 return reportReturn(methodCall, realResultSet.isBeforeFirst()); 1382 } 1383 catch (SQLException s) 1384 { 1385 reportException(methodCall, s); 1386 throw s; 1387 } 1388 } 1389 1390 public short getShort(int columnIndex) throws SQLException 1391 { 1392 String methodCall = "getShort(" + columnIndex + ")"; 1393 try 1394 { 1395 return reportReturn(methodCall, realResultSet.getShort(columnIndex)); 1396 } 1397 catch (SQLException s) 1398 { 1399 reportException(methodCall, s); 1400 throw s; 1401 } 1402 } 1403 1404 public short getShort(String columnName) throws SQLException 1405 { 1406 String methodCall = "getShort(" + columnName + ")"; 1407 try 1408 { 1409 return reportReturn(methodCall, realResultSet.getShort(columnName)); 1410 } 1411 catch (SQLException s) 1412 { 1413 reportException(methodCall, s); 1414 throw s; 1415 } 1416 } 1417 1418 public int getInt(int columnIndex) throws SQLException 1419 { 1420 String methodCall = "getInt(" + columnIndex + ")"; 1421 try 1422 { 1423 return reportReturn(methodCall, realResultSet.getInt(columnIndex)); 1424 } 1425 catch (SQLException s) 1426 { 1427 reportException(methodCall, s); 1428 throw s; 1429 } 1430 } 1431 1432 public int getInt(String columnName) throws SQLException 1433 { 1434 String methodCall = "getInt(" + columnName + ")"; 1435 try 1436 { 1437 return reportReturn(methodCall, realResultSet.getInt(columnName)); 1438 } 1439 catch (SQLException s) 1440 { 1441 reportException(methodCall, s); 1442 throw s; 1443 } 1444 } 1445 1446 public void close() throws SQLException 1447 { 1448 String methodCall = "close()"; 1449 try 1450 { 1451 realResultSet.close(); 1452 } 1453 catch (SQLException s) 1454 { 1455 reportException(methodCall, s); 1456 throw s; 1457 } 1458 reportReturn(methodCall); 1459 } 1460 1461 public ResultSetMetaData getMetaData() throws SQLException 1462 { 1463 String methodCall = "getMetaData()"; 1464 try 1465 { 1466 return (ResultSetMetaData) reportReturn(methodCall, realResultSet.getMetaData()); 1467 } 1468 catch (SQLException s) 1469 { 1470 reportException(methodCall, s); 1471 throw s; 1472 } 1473 } 1474 1475 public int getType() throws SQLException 1476 { 1477 String methodCall = "getType()"; 1478 try 1479 { 1480 return reportReturn(methodCall, realResultSet.getType()); 1481 } 1482 catch (SQLException s) 1483 { 1484 reportException(methodCall, s); 1485 throw s; 1486 } 1487 } 1488 1489 public double getDouble(int columnIndex) throws SQLException 1490 { 1491 String methodCall = "getDouble(" + columnIndex + ")"; 1492 try 1493 { 1494 return reportReturn(methodCall, realResultSet.getDouble(columnIndex)); 1495 } 1496 catch (SQLException s) 1497 { 1498 reportException(methodCall, s); 1499 throw s; 1500 } 1501 } 1502 1503 public double getDouble(String columnName) throws SQLException 1504 { 1505 String methodCall = "getDouble(" + columnName + ")"; 1506 try 1507 { 1508 return reportReturn(methodCall, realResultSet.getDouble(columnName)); 1509 } 1510 catch (SQLException s) 1511 { 1512 reportException(methodCall, s); 1513 throw s; 1514 } 1515 } 1516 1517 public void deleteRow() throws SQLException 1518 { 1519 String methodCall = "deleteRow()"; 1520 try 1521 { 1522 realResultSet.deleteRow(); 1523 } 1524 catch (SQLException s) 1525 { 1526 reportException(methodCall, s); 1527 throw s; 1528 } 1529 reportReturn(methodCall); 1530 } 1531 1532 public int getConcurrency() throws SQLException 1533 { 1534 String methodCall = "getConcurrency()"; 1535 try 1536 { 1537 return reportReturn(methodCall, realResultSet.getConcurrency()); 1538 } 1539 catch (SQLException s) 1540 { 1541 reportException(methodCall, s); 1542 throw s; 1543 } 1544 } 1545 1546 public boolean rowUpdated() throws SQLException 1547 { 1548 String methodCall = "rowUpdated()"; 1549 try 1550 { 1551 return reportReturn(methodCall, realResultSet.rowUpdated()); 1552 } 1553 catch (SQLException s) 1554 { 1555 reportException(methodCall, s); 1556 throw s; 1557 } 1558 } 1559 1560 public Date getDate(int columnIndex) throws SQLException 1561 { 1562 String methodCall = "getDate(" + columnIndex + ")"; 1563 try 1564 { 1565 return (Date) reportReturn(methodCall, realResultSet.getDate(columnIndex)); 1566 } 1567 catch (SQLException s) 1568 { 1569 reportException(methodCall, s); 1570 throw s; 1571 } 1572 } 1573 1574 public Date getDate(String columnName) throws SQLException 1575 { 1576 String methodCall = "getDate(" + columnName + ")"; 1577 try 1578 { 1579 return (Date) reportReturn(methodCall, realResultSet.getDate(columnName)); 1580 } 1581 catch (SQLException s) 1582 { 1583 reportException(methodCall, s); 1584 throw s; 1585 } 1586 } 1587 1588 public Date getDate(int columnIndex, Calendar cal) throws SQLException 1589 { 1590 String methodCall = "getDate(" + columnIndex + ", " + cal + ")"; 1591 try 1592 { 1593 return (Date) reportReturn(methodCall, realResultSet.getDate(columnIndex, cal)); 1594 } 1595 catch (SQLException s) 1596 { 1597 reportException(methodCall, s); 1598 throw s; 1599 } 1600 1601 } 1602 1603 public Date getDate(String columnName, Calendar cal) throws SQLException 1604 { 1605 String methodCall = "getDate(" + columnName + ", " + cal + ")"; 1606 try 1607 { 1608 return (Date) reportReturn(methodCall, realResultSet.getDate(columnName, cal)); 1609 } 1610 catch (SQLException s) 1611 { 1612 reportException(methodCall, s); 1613 throw s; 1614 } 1615 } 1616 1617 public boolean last() throws SQLException 1618 { 1619 String methodCall = "last()"; 1620 try 1621 { 1622 return reportReturn(methodCall, realResultSet.last()); 1623 } 1624 catch (SQLException s) 1625 { 1626 reportException(methodCall, s); 1627 throw s; 1628 } 1629 } 1630 1631 public boolean rowInserted() throws SQLException 1632 { 1633 String methodCall = "rowInserted()"; 1634 try 1635 { 1636 return reportReturn(methodCall, realResultSet.rowInserted()); 1637 } 1638 catch (SQLException s) 1639 { 1640 reportException(methodCall, s); 1641 throw s; 1642 } 1643 } 1644 1645 public boolean rowDeleted() throws SQLException 1646 { 1647 String methodCall = "rowDeleted()"; 1648 try 1649 { 1650 return reportReturn(methodCall, realResultSet.rowDeleted()); 1651 } 1652 catch (SQLException s) 1653 { 1654 reportException(methodCall, s); 1655 throw s; 1656 } 1657 } 1658 1659 public void updateNull(int columnIndex) throws SQLException 1660 { 1661 String methodCall = "updateNull(" + columnIndex + ")"; 1662 try 1663 { 1664 realResultSet.updateNull(columnIndex); 1665 } 1666 catch (SQLException s) 1667 { 1668 reportException(methodCall, s); 1669 throw s; 1670 } 1671 reportReturn(methodCall); 1672 } 1673 1674 public void updateNull(String columnName) throws SQLException 1675 { 1676 String methodCall = "updateNull(" + columnName + ")"; 1677 try 1678 { 1679 realResultSet.updateNull(columnName); 1680 } 1681 catch (SQLException s) 1682 { 1683 reportException(methodCall, s); 1684 throw s; 1685 } 1686 reportReturn(methodCall); 1687 } 1688 1689 public void updateShort(int columnIndex, short x) throws SQLException 1690 { 1691 String methodCall = "updateShort(" + columnIndex + ", " + x + ")"; 1692 try 1693 { 1694 realResultSet.updateShort(columnIndex, x); 1695 } 1696 catch (SQLException s) 1697 { 1698 reportException(methodCall, s); 1699 throw s; 1700 } 1701 reportReturn(methodCall); 1702 } 1703 1704 public void updateShort(String columnName, short x) throws SQLException 1705 { 1706 String methodCall = "updateShort(" + columnName + ", " + x + ")"; 1707 try 1708 { 1709 realResultSet.updateShort(columnName, x); 1710 } 1711 catch (SQLException s) 1712 { 1713 reportException(methodCall, s); 1714 throw s; 1715 } 1716 reportReturn(methodCall); 1717 } 1718 1719 public void updateBoolean(int columnIndex, boolean x) throws SQLException 1720 { 1721 String methodCall = "updateBoolean(" + columnIndex + ", " + x + ")"; 1722 try 1723 { 1724 realResultSet.updateBoolean(columnIndex, x); 1725 } 1726 catch (SQLException s) 1727 { 1728 reportException(methodCall, s); 1729 throw s; 1730 } 1731 reportReturn(methodCall); 1732 } 1733 1734 public void updateBoolean(String columnName, boolean x) throws SQLException 1735 { 1736 String methodCall = "updateBoolean(" + columnName + ", " + x + ")"; 1737 try 1738 { 1739 realResultSet.updateBoolean(columnName, x); 1740 } 1741 catch (SQLException s) 1742 { 1743 reportException(methodCall, s); 1744 throw s; 1745 } 1746 reportReturn(methodCall); 1747 } 1748 1749 public void updateByte(int columnIndex, byte x) throws SQLException 1750 { 1751 String methodCall = "updateByte(" + columnIndex + ", " + x + ")"; 1752 try 1753 { 1754 realResultSet.updateByte(columnIndex, x); 1755 } 1756 catch (SQLException s) 1757 { 1758 reportException(methodCall, s); 1759 throw s; 1760 } 1761 reportReturn(methodCall); 1762 } 1763 1764 public void updateByte(String columnName, byte x) throws SQLException 1765 { 1766 String methodCall = "updateByte(" + columnName + ", " + x + ")"; 1767 try 1768 { 1769 realResultSet.updateByte(columnName, x); 1770 } 1771 catch (SQLException s) 1772 { 1773 reportException(methodCall, s); 1774 throw s; 1775 } 1776 reportReturn(methodCall); 1777 } 1778 1779 public void updateInt(int columnIndex, int x) throws SQLException 1780 { 1781 String methodCall = "updateInt(" + columnIndex + ", " + x + ")"; 1782 try 1783 { 1784 realResultSet.updateInt(columnIndex, x); 1785 } 1786 catch (SQLException s) 1787 { 1788 reportException(methodCall, s); 1789 throw s; 1790 } 1791 reportReturn(methodCall); 1792 } 1793 1794 public void updateInt(String columnName, int x) throws SQLException 1795 { 1796 String methodCall = "updateInt(" + columnName + ", " + x + ")"; 1797 try 1798 { 1799 realResultSet.updateInt(columnName, x); 1800 } 1801 catch (SQLException s) 1802 { 1803 reportException(methodCall, s); 1804 throw s; 1805 } 1806 reportReturn(methodCall); 1807 } 1808 1809 public Object getObject(int columnIndex) throws SQLException 1810 { 1811 String methodCall = "getObject(" + columnIndex + ")"; 1812 try 1813 { 1814 return reportReturn(methodCall, realResultSet.getObject(columnIndex)); 1815 } 1816 catch (SQLException s) 1817 { 1818 reportException(methodCall, s); 1819 throw s; 1820 } 1821 } 1822 1823 public Object getObject(String columnName) throws SQLException 1824 { 1825 String methodCall = "getObject(" + columnName + ")"; 1826 try 1827 { 1828 return reportReturn(methodCall, realResultSet.getObject(columnName)); 1829 } 1830 catch (SQLException s) 1831 { 1832 reportException(methodCall, s); 1833 throw s; 1834 } 1835 } 1836 1837 public Object getObject(String colName, Map map) throws SQLException 1838 { 1839 String methodCall = "getObject(" + colName + ", " + map + ")"; 1840 try 1841 { 1842 return reportReturn(methodCall, realResultSet.getObject(colName, map)); 1843 } 1844 catch (SQLException s) 1845 { 1846 reportException(methodCall, s); 1847 throw s; 1848 } 1849 } 1850 1851 public boolean next() throws SQLException 1852 { 1853 String methodCall = "next()"; 1854 try 1855 { 1856 return reportReturn(methodCall, realResultSet.next()); 1857 } 1858 catch (SQLException s) 1859 { 1860 reportException(methodCall, s); 1861 throw s; 1862 } 1863 } 1864 1865 public void updateLong(int columnIndex, long x) throws SQLException 1866 { 1867 String methodCall = "updateLong(" + columnIndex + ", " + x + ")"; 1868 try 1869 { 1870 realResultSet.updateLong(columnIndex, x); 1871 } 1872 catch (SQLException s) 1873 { 1874 reportException(methodCall, s); 1875 throw s; 1876 } 1877 reportReturn(methodCall); 1878 } 1879 1880 public void updateLong(String columnName, long x) throws SQLException 1881 { 1882 String methodCall = "updateLong(" + columnName + ", " + x + ")"; 1883 try 1884 { 1885 realResultSet.updateLong(columnName, x); 1886 } 1887 catch (SQLException s) 1888 { 1889 reportException(methodCall, s); 1890 throw s; 1891 } 1892 reportReturn(methodCall); 1893 } 1894 1895 public void updateFloat(int columnIndex, float x) throws SQLException 1896 { 1897 String methodCall = "updateFloat(" + columnIndex + ", " + x + ")"; 1898 try 1899 { 1900 realResultSet.updateFloat(columnIndex, x); 1901 } 1902 catch (SQLException s) 1903 { 1904 reportException(methodCall, s); 1905 throw s; 1906 } 1907 reportReturn(methodCall); 1908 1909 } 1910 1911 public void updateFloat(String columnName, float x) throws SQLException 1912 { 1913 String methodCall = "updateFloat(" + columnName + ", " + x + ")"; 1914 try 1915 { 1916 realResultSet.updateFloat(columnName, x); 1917 } 1918 catch (SQLException s) 1919 { 1920 reportException(methodCall, s); 1921 throw s; 1922 } 1923 reportReturn(methodCall); 1924 } 1925 1926 public void updateDouble(int columnIndex, double x) throws SQLException 1927 { 1928 String methodCall = "updateDouble(" + columnIndex + ", " + x + ")"; 1929 try 1930 { 1931 realResultSet.updateDouble(columnIndex, x); 1932 } 1933 catch (SQLException s) 1934 { 1935 reportException(methodCall, s); 1936 throw s; 1937 } 1938 reportReturn(methodCall); 1939 } 1940 1941 public void updateDouble(String columnName, double x) throws SQLException 1942 { 1943 String methodCall = "updateDouble(" + columnName + ", " + x + ")"; 1944 try 1945 { 1946 realResultSet.updateDouble(columnName, x); 1947 } 1948 catch (SQLException s) 1949 { 1950 reportException(methodCall, s); 1951 throw s; 1952 } 1953 reportReturn(methodCall); 1954 } 1955 1956 public Statement getStatement() throws SQLException 1957 { 1958 String methodCall = "getStatement()"; 1959 try 1960 { 1961 Statement s = realResultSet.getStatement(); 1962 if (s == null) 1963 { 1964 return (Statement) reportReturn(methodCall, s); 1965 } 1966 else 1967 { 1968 //todo: what's going on here? 1969 return (Statement) reportReturn(methodCall, new StatementSpy(new ConnectionSpy(s.getConnection()), s)); 1970 } 1971 } 1972 catch (SQLException s) 1973 { 1974 reportException(methodCall, s); 1975 throw s; 1976 } 1977 } 1978 1979 public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException 1980 { 1981 String methodCall = "getObject(" + columnIndex + ", " + map + ")"; 1982 try 1983 { 1984 return reportReturn(methodCall, realResultSet.getObject(columnIndex, map)); 1985 } 1986 catch (SQLException s) 1987 { 1988 reportException(methodCall, s); 1989 throw s; 1990 } 1991 } 1992 1993 public void updateString(int columnIndex, String x) throws SQLException 1994 { 1995 String methodCall = "updateString(" + columnIndex + ", " + x + ")"; 1996 try 1997 { 1998 realResultSet.updateString(columnIndex, x); 1999 } 2000 catch (SQLException s) 2001 { 2002 reportException(methodCall, s); 2003 throw s; 2004 } 2005 reportReturn(methodCall); 2006 } 2007 2008 public void updateString(String columnName, String x) throws SQLException 2009 { 2010 String methodCall = "updateString(" + columnName + ", " + x + ")"; 2011 try 2012 { 2013 realResultSet.updateString(columnName, x); 2014 } 2015 catch (SQLException s) 2016 { 2017 reportException(methodCall, s); 2018 throw s; 2019 } 2020 reportReturn(methodCall); 2021 } 2022 2023 public InputStream getAsciiStream(int columnIndex) throws SQLException 2024 { 2025 String methodCall = "getAsciiStream(" + columnIndex + ")"; 2026 try 2027 { 2028 return (InputStream) reportReturn(methodCall, realResultSet.getAsciiStream(columnIndex)); 2029 } 2030 catch (SQLException s) 2031 { 2032 reportException(methodCall, s); 2033 throw s; 2034 } 2035 } 2036 2037 public InputStream getAsciiStream(String columnName) throws SQLException 2038 { 2039 String methodCall = "getAsciiStream(" + columnName + ")"; 2040 try 2041 { 2042 return (InputStream) reportReturn(methodCall, realResultSet.getAsciiStream(columnName)); 2043 } 2044 catch (SQLException s) 2045 { 2046 reportException(methodCall, s); 2047 throw s; 2048 } 2049 } 2050 2051 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException 2052 { 2053 String methodCall = "updateBigDecimal(" + columnIndex + ", " + x + ")"; 2054 try 2055 { 2056 realResultSet.updateBigDecimal(columnIndex, x); 2057 } 2058 catch (SQLException s) 2059 { 2060 reportException(methodCall, s); 2061 throw s; 2062 } 2063 reportReturn(methodCall); 2064 } 2065 2066 public URL getURL(int columnIndex) throws SQLException 2067 { 2068 String methodCall = "getURL(" + columnIndex + ")"; 2069 try 2070 { 2071 return (URL) reportReturn(methodCall, realResultSet.getURL(columnIndex)); 2072 } 2073 catch (SQLException s) 2074 { 2075 reportException(methodCall, s); 2076 throw s; 2077 } 2078 } 2079 2080 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException 2081 { 2082 String methodCall = "updateBigDecimal(" + columnName + ", " + x + ")"; 2083 try 2084 { 2085 realResultSet.updateBigDecimal(columnName, x); 2086 } 2087 catch (SQLException s) 2088 { 2089 reportException(methodCall, s); 2090 throw s; 2091 } 2092 reportReturn(methodCall); 2093 } 2094 2095 public URL getURL(String columnName) throws SQLException 2096 { 2097 String methodCall = "getURL(" + columnName + ")"; 2098 try 2099 { 2100 return (URL) reportReturn(methodCall, realResultSet.getURL(columnName)); 2101 } 2102 catch (SQLException s) 2103 { 2104 reportException(methodCall, s); 2105 throw s; 2106 } 2107 } 2108 2109 public void updateBytes(int columnIndex, byte[] x) throws SQLException 2110 { 2111 // todo: dump array? 2112 String methodCall = "updateBytes(" + columnIndex + ", " + x + ")"; 2113 try 2114 { 2115 realResultSet.updateBytes(columnIndex, x); 2116 } 2117 catch (SQLException s) 2118 { 2119 reportException(methodCall, s); 2120 throw s; 2121 } 2122 reportReturn(methodCall); 2123 } 2124 2125 public void updateBytes(String columnName, byte[] x) throws SQLException 2126 { 2127 // todo: dump array? 2128 String methodCall = "updateBytes(" + columnName + ", " + x + ")"; 2129 try 2130 { 2131 realResultSet.updateBytes(columnName, x); 2132 } 2133 catch (SQLException s) 2134 { 2135 reportException(methodCall, s); 2136 throw s; 2137 } 2138 reportReturn(methodCall); 2139 } 2140 2141 /** 2142 * @deprecated 2143 */ 2144 public InputStream getUnicodeStream(int columnIndex) throws SQLException 2145 { 2146 String methodCall = "getUnicodeStream(" + columnIndex + ")"; 2147 try 2148 { 2149 return (InputStream) reportReturn(methodCall, realResultSet.getUnicodeStream(columnIndex)); 2150 } 2151 catch (SQLException s) 2152 { 2153 reportException(methodCall, s); 2154 throw s; 2155 } 2156 } 2157 2158 /** 2159 * @deprecated 2160 */ 2161 public InputStream getUnicodeStream(String columnName) throws SQLException 2162 { 2163 String methodCall = "getUnicodeStream(" + columnName + ")"; 2164 try 2165 { 2166 return (InputStream) reportReturn(methodCall, realResultSet.getUnicodeStream(columnName)); 2167 } 2168 catch (SQLException s) 2169 { 2170 reportException(methodCall, s); 2171 throw s; 2172 } 2173 } 2174 2175 public void updateDate(int columnIndex, Date x) throws SQLException 2176 { 2177 String methodCall = "updateDate(" + columnIndex + ", " + x + ")"; 2178 try 2179 { 2180 realResultSet.updateDate(columnIndex, x); 2181 } 2182 catch (SQLException s) 2183 { 2184 reportException(methodCall, s); 2185 throw s; 2186 } 2187 } 2188 2189 public void updateDate(String columnName, Date x) throws SQLException 2190 { 2191 String methodCall = "updateDate(" + columnName + ", " + x + ")"; 2192 try 2193 { 2194 realResultSet.updateDate(columnName, x); 2195 } 2196 catch (SQLException s) 2197 { 2198 reportException(methodCall, s); 2199 throw s; 2200 } 2201 reportReturn(methodCall); 2202 } 2203 2204 public int getFetchSize() throws SQLException 2205 { 2206 String methodCall = "getFetchSize()"; 2207 try 2208 { 2209 return reportReturn(methodCall, realResultSet.getFetchSize()); 2210 } 2211 catch (SQLException s) 2212 { 2213 reportException(methodCall, s); 2214 throw s; 2215 } 2216 } 2217 2218 public SQLWarning getWarnings() throws SQLException 2219 { 2220 String methodCall = "getWarnings()"; 2221 try 2222 { 2223 return (SQLWarning) reportReturn(methodCall, realResultSet.getWarnings()); 2224 } 2225 catch (SQLException s) 2226 { 2227 reportException(methodCall, s); 2228 throw s; 2229 } 2230 } 2231 2232 public InputStream getBinaryStream(int columnIndex) throws SQLException 2233 { 2234 String methodCall = "getBinaryStream(" + columnIndex + ")"; 2235 try 2236 { 2237 return (InputStream) reportReturn(methodCall, realResultSet.getBinaryStream(columnIndex)); 2238 } 2239 catch (SQLException s) 2240 { 2241 reportException(methodCall, s); 2242 throw s; 2243 } 2244 } 2245 2246 public InputStream getBinaryStream(String columnName) throws SQLException 2247 { 2248 String methodCall = "getBinaryStream(" + columnName + ")"; 2249 try 2250 { 2251 return (InputStream) reportReturn(methodCall, realResultSet.getBinaryStream(columnName)); 2252 } 2253 catch (SQLException s) 2254 { 2255 reportException(methodCall, s); 2256 throw s; 2257 } 2258 } 2259 2260 public void clearWarnings() throws SQLException 2261 { 2262 String methodCall = "clearWarnings()"; 2263 try 2264 { 2265 realResultSet.clearWarnings(); 2266 } 2267 catch (SQLException s) 2268 { 2269 reportException(methodCall, s); 2270 throw s; 2271 } 2272 reportReturn(methodCall); 2273 } 2274 2275 public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException 2276 { 2277 String methodCall = "updateTimestamp(" + columnIndex + ", " + x + ")"; 2278 try 2279 { 2280 realResultSet.updateTimestamp(columnIndex, x); 2281 } 2282 catch (SQLException s) 2283 { 2284 reportException(methodCall, s); 2285 throw s; 2286 } 2287 reportReturn(methodCall); 2288 } 2289 2290 public void updateTimestamp(String columnName, Timestamp x) throws SQLException 2291 { 2292 String methodCall = "updateTimestamp(" + columnName + ", " + x + ")"; 2293 try 2294 { 2295 realResultSet.updateTimestamp(columnName, x); 2296 } 2297 catch (SQLException s) 2298 { 2299 reportException(methodCall, s); 2300 throw s; 2301 } 2302 reportReturn(methodCall); 2303 } 2304 2305 public boolean first() throws SQLException 2306 { 2307 String methodCall = "first()"; 2308 try 2309 { 2310 return reportReturn(methodCall, realResultSet.first()); 2311 } 2312 catch (SQLException s) 2313 { 2314 reportException(methodCall, s); 2315 throw s; 2316 } 2317 } 2318 2319 public String getCursorName() throws SQLException 2320 { 2321 String methodCall = "getCursorName()"; 2322 try 2323 { 2324 return (String) reportReturn(methodCall, realResultSet.getCursorName()); 2325 } 2326 catch (SQLException s) 2327 { 2328 reportException(methodCall, s); 2329 throw s; 2330 } 2331 } 2332 2333 public int findColumn(String columnName) throws SQLException 2334 { 2335 String methodCall = "findColumn(" + columnName + ")"; 2336 try 2337 { 2338 return reportReturn(methodCall, realResultSet.findColumn(columnName)); 2339 } 2340 catch (SQLException s) 2341 { 2342 reportException(methodCall, s); 2343 throw s; 2344 } 2345 } 2346 2347 public boolean wasNull() throws SQLException 2348 { 2349 String methodCall = "wasNull()"; 2350 try 2351 { 2352 return reportReturn(methodCall, realResultSet.wasNull()); 2353 } 2354 catch (SQLException s) 2355 { 2356 reportException(methodCall, s); 2357 throw s; 2358 } 2359 } 2360 2361 public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException 2362 { 2363 String methodCall = "updateBinaryStream(" + columnIndex + ", " + x + ", " + length + ")"; 2364 try 2365 { 2366 realResultSet.updateBinaryStream(columnIndex, x, length); 2367 } 2368 catch (SQLException s) 2369 { 2370 reportException(methodCall, s); 2371 throw s; 2372 } 2373 reportReturn(methodCall); 2374 } 2375 2376 public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException 2377 { 2378 String methodCall = "updateBinaryStream(" + columnName + ", " + x + ", " + length + ")"; 2379 try 2380 { 2381 realResultSet.updateBinaryStream(columnName, x, length); 2382 } 2383 catch (SQLException s) 2384 { 2385 reportException(methodCall, s); 2386 throw s; 2387 } 2388 reportReturn(methodCall); 2389 } 2390 2391 public String getString(int columnIndex) throws SQLException 2392 { 2393 String methodCall = "getString(" + columnIndex + ")"; 2394 try 2395 { 2396 return (String) reportReturn(methodCall, realResultSet.getString(columnIndex)); 2397 } 2398 catch (SQLException s) 2399 { 2400 reportException(methodCall, s); 2401 throw s; 2402 } 2403 } 2404 2405 public String getString(String columnName) throws SQLException 2406 { 2407 String methodCall = "getString(" + columnName + ")"; 2408 try 2409 { 2410 return (String) reportReturn(methodCall, realResultSet.getString(columnName)); 2411 } 2412 catch (SQLException s) 2413 { 2414 reportException(methodCall, s); 2415 throw s; 2416 } 2417 } 2418 2419 public Reader getCharacterStream(int columnIndex) throws SQLException 2420 { 2421 String methodCall = "getCharacterStream(" + columnIndex + ")"; 2422 try 2423 { 2424 return (Reader) reportReturn(methodCall, realResultSet.getCharacterStream(columnIndex)); 2425 } 2426 catch (SQLException s) 2427 { 2428 reportException(methodCall, s); 2429 throw s; 2430 } 2431 } 2432 2433 public Reader getCharacterStream(String columnName) throws SQLException 2434 { 2435 String methodCall = "getCharacterStream(" + columnName + ")"; 2436 try 2437 { 2438 return (Reader) reportReturn(methodCall, realResultSet.getCharacterStream(columnName)); 2439 } 2440 catch (SQLException s) 2441 { 2442 reportException(methodCall, s); 2443 throw s; 2444 } 2445 } 2446 2447 public void setFetchDirection(int direction) throws SQLException 2448 { 2449 String methodCall = "setFetchDirection(" + direction + ")"; 2450 try 2451 { 2452 realResultSet.setFetchDirection(direction); 2453 } 2454 catch (SQLException s) 2455 { 2456 reportException(methodCall, s); 2457 throw s; 2458 } 2459 reportReturn(methodCall); 2460 } 2461 2462 public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException 2463 { 2464 String methodCall = "updateCharacterStream(" + columnIndex + ", " + x + ", " + length + ")"; 2465 try 2466 { 2467 realResultSet.updateCharacterStream(columnIndex, x, length); 2468 } 2469 catch (SQLException s) 2470 { 2471 reportException(methodCall, s); 2472 throw s; 2473 } 2474 reportReturn(methodCall); 2475 } 2476 2477 public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException 2478 { 2479 String methodCall = "updateCharacterStream(" + columnName + ", " + reader + ", " + length + ")"; 2480 try 2481 { 2482 realResultSet.updateCharacterStream(columnName, reader, length); 2483 } 2484 catch (SQLException s) 2485 { 2486 reportException(methodCall, s); 2487 throw s; 2488 } 2489 reportReturn(methodCall); 2490 } 2491 2492 public byte getByte(int columnIndex) throws SQLException 2493 { 2494 String methodCall = "getByte(" + columnIndex + ")"; 2495 try 2496 { 2497 return reportReturn(methodCall, realResultSet.getByte(columnIndex)); 2498 } 2499 catch (SQLException s) 2500 { 2501 reportException(methodCall, s); 2502 throw s; 2503 } 2504 } 2505 2506 public byte getByte(String columnName) throws SQLException 2507 { 2508 String methodCall = "getByte(" + columnName + ")"; 2509 try 2510 { 2511 return reportReturn(methodCall, realResultSet.getByte(columnName)); 2512 } 2513 catch (SQLException s) 2514 { 2515 reportException(methodCall, s); 2516 throw s; 2517 } 2518 } 2519 2520 public void updateTime(int columnIndex, Time x) throws SQLException 2521 { 2522 String methodCall = "updateTime(" + columnIndex + ", " + x + ")"; 2523 try 2524 { 2525 realResultSet.updateTime(columnIndex, x); 2526 } 2527 catch (SQLException s) 2528 { 2529 reportException(methodCall, s); 2530 throw s; 2531 } 2532 reportReturn(methodCall); 2533 } 2534 2535 public void updateTime(String columnName, Time x) throws SQLException 2536 { 2537 String methodCall = "updateTime(" + columnName + ", " + x + ")"; 2538 try 2539 { 2540 realResultSet.updateTime(columnName, x); 2541 } 2542 catch (SQLException s) 2543 { 2544 reportException(methodCall, s); 2545 throw s; 2546 } 2547 reportReturn(methodCall); 2548 } 2549 2550 public byte[] getBytes(int columnIndex) throws SQLException 2551 { 2552 String methodCall = "getBytes(" + columnIndex + ")"; 2553 try 2554 { 2555 return (byte[]) reportReturn(methodCall, realResultSet.getBytes(columnIndex)); 2556 } 2557 catch (SQLException s) 2558 { 2559 reportException(methodCall, s); 2560 throw s; 2561 } 2562 } 2563 2564 public byte[] getBytes(String columnName) throws SQLException 2565 { 2566 String methodCall = "getBytes(" + columnName + ")"; 2567 try 2568 { 2569 return (byte[]) reportReturn(methodCall, realResultSet.getBytes(columnName)); 2570 } 2571 catch (SQLException s) 2572 { 2573 reportException(methodCall, s); 2574 throw s; 2575 } 2576 } 2577 2578 public boolean isAfterLast() throws SQLException 2579 { 2580 String methodCall = "isAfterLast()"; 2581 try 2582 { 2583 return reportReturn(methodCall, realResultSet.isAfterLast()); 2584 } 2585 catch (SQLException s) 2586 { 2587 reportException(methodCall, s); 2588 throw s; 2589 } 2590 } 2591 2592 public void updateObject(int columnIndex, Object x, int scale) throws SQLException 2593 { 2594 String methodCall = "updateObject(" + columnIndex + ", " + x + ", " + scale + ")"; 2595 try 2596 { 2597 realResultSet.updateObject(columnIndex, x, scale); 2598 } 2599 catch (SQLException s) 2600 { 2601 reportException(methodCall, s); 2602 throw s; 2603 } 2604 reportReturn(methodCall); 2605 } 2606 2607 public void updateObject(int columnIndex, Object x) throws SQLException 2608 { 2609 String methodCall = "updateObject(" + columnIndex + ", " + x + ")"; 2610 try 2611 { 2612 realResultSet.updateObject(columnIndex, x); 2613 } 2614 catch (SQLException s) 2615 { 2616 reportException(methodCall, s); 2617 throw s; 2618 } 2619 reportReturn(methodCall); 2620 } 2621 2622 public void updateObject(String columnName, Object x, int scale) throws SQLException 2623 { 2624 String methodCall = "updateObject(" + columnName + ", " + x + ", " + scale + ")"; 2625 try 2626 { 2627 realResultSet.updateObject(columnName, x, scale); 2628 } 2629 catch (SQLException s) 2630 { 2631 reportException(methodCall, s); 2632 throw s; 2633 } 2634 reportReturn(methodCall); 2635 } 2636 2637 public void updateObject(String columnName, Object x) throws SQLException 2638 { 2639 String methodCall = "updateObject(" + columnName + ", " + x + ")"; 2640 try 2641 { 2642 realResultSet.updateObject(columnName, x); 2643 } 2644 catch (SQLException s) 2645 { 2646 reportException(methodCall, s); 2647 throw s; 2648 } 2649 reportReturn(methodCall); 2650 } 2651 2652 public int getFetchDirection() throws SQLException 2653 { 2654 String methodCall = "getFetchDirection()"; 2655 try 2656 { 2657 return reportReturn(methodCall, realResultSet.getFetchDirection()); 2658 } 2659 catch (SQLException s) 2660 { 2661 reportException(methodCall, s); 2662 throw s; 2663 } 2664 } 2665 2666 public long getLong(int columnIndex) throws SQLException 2667 { 2668 String methodCall = "getLong(" + columnIndex + ")"; 2669 try 2670 { 2671 return reportReturn(methodCall, realResultSet.getLong(columnIndex)); 2672 } 2673 catch (SQLException s) 2674 { 2675 reportException(methodCall, s); 2676 throw s; 2677 } 2678 } 2679 2680 public long getLong(String columnName) throws SQLException 2681 { 2682 String methodCall = "getLong(" + columnName + ")"; 2683 try 2684 { 2685 return reportReturn(methodCall, realResultSet.getLong(columnName)); 2686 } 2687 catch (SQLException s) 2688 { 2689 reportException(methodCall, s); 2690 throw s; 2691 } 2692 } 2693 2694 public boolean isFirst() throws SQLException 2695 { 2696 String methodCall = "isFirst()"; 2697 try 2698 { 2699 return reportReturn(methodCall, realResultSet.isFirst()); 2700 } 2701 catch (SQLException s) 2702 { 2703 reportException(methodCall, s); 2704 throw s; 2705 } 2706 } 2707 2708 public void insertRow() throws SQLException 2709 { 2710 String methodCall = "insertRow()"; 2711 try 2712 { 2713 realResultSet.insertRow(); 2714 } 2715 catch (SQLException s) 2716 { 2717 reportException(methodCall, s); 2718 throw s; 2719 } 2720 } 2721 2722 public float getFloat(int columnIndex) throws SQLException 2723 { 2724 String methodCall = "getFloat(" + columnIndex + ")"; 2725 try 2726 { 2727 return reportReturn(methodCall, realResultSet.getFloat(columnIndex)); 2728 } 2729 catch (SQLException s) 2730 { 2731 reportException(methodCall, s); 2732 throw s; 2733 } 2734 } 2735 2736 public float getFloat(String columnName) throws SQLException 2737 { 2738 String methodCall = "getFloat(" + columnName + ")"; 2739 try 2740 { 2741 return reportReturn(methodCall, realResultSet.getFloat(columnName)); 2742 } 2743 catch (SQLException s) 2744 { 2745 reportException(methodCall, s); 2746 throw s; 2747 } 2748 } 2749 2750 public boolean isLast() throws SQLException 2751 { 2752 String methodCall = "isLast()"; 2753 try 2754 { 2755 return reportReturn(methodCall, realResultSet.isLast()); 2756 } 2757 catch (SQLException s) 2758 { 2759 reportException(methodCall, s); 2760 throw s; 2761 } 2762 } 2763 2764 public void setFetchSize(int rows) throws SQLException 2765 { 2766 String methodCall = "setFetchSize(" + rows + ")"; 2767 try 2768 { 2769 realResultSet.setFetchSize(rows); 2770 } 2771 catch (SQLException s) 2772 { 2773 reportException(methodCall, s); 2774 throw s; 2775 } 2776 reportReturn(methodCall); 2777 } 2778 2779 public void updateRow() throws SQLException 2780 { 2781 String methodCall = "updateRow()"; 2782 try 2783 { 2784 realResultSet.updateRow(); 2785 } 2786 catch (SQLException s) 2787 { 2788 reportException(methodCall, s); 2789 throw s; 2790 } 2791 reportReturn(methodCall); 2792 } 2793 2794 public void beforeFirst() throws SQLException 2795 { 2796 String methodCall = "beforeFirst()"; 2797 try 2798 { 2799 realResultSet.beforeFirst(); 2800 } 2801 catch (SQLException s) 2802 { 2803 reportException(methodCall, s); 2804 throw s; 2805 } 2806 reportReturn(methodCall); 2807 } 2808 2809 /** 2810 * @deprecated 2811 */ 2812 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException 2813 { 2814 String methodCall = "getBigDecimal(" + columnIndex + ", " + scale + ")"; 2815 try 2816 { 2817 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnIndex, scale)); 2818 } 2819 catch (SQLException s) 2820 { 2821 reportException(methodCall, s); 2822 throw s; 2823 } 2824 } 2825 2826 /** 2827 * @deprecated 2828 */ 2829 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException 2830 { 2831 String methodCall = "getBigDecimal(" + columnName + ", " + scale + ")"; 2832 try 2833 { 2834 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnName, scale)); 2835 } 2836 catch (SQLException s) 2837 { 2838 reportException(methodCall, s); 2839 throw s; 2840 } 2841 } 2842 2843 public BigDecimal getBigDecimal(int columnIndex) throws SQLException 2844 { 2845 String methodCall = "getBigDecimal(" + columnIndex + ")"; 2846 try 2847 { 2848 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnIndex)); 2849 } 2850 catch (SQLException s) 2851 { 2852 reportException(methodCall, s); 2853 throw s; 2854 } 2855 } 2856 2857 public BigDecimal getBigDecimal(String columnName) throws SQLException 2858 { 2859 String methodCall = "getBigDecimal(" + columnName + ")"; 2860 try 2861 { 2862 return (BigDecimal) reportReturn(methodCall, realResultSet.getBigDecimal(columnName)); 2863 } 2864 catch (SQLException s) 2865 { 2866 reportException(methodCall, s); 2867 throw s; 2868 } 2869 } 2870 2871 public void afterLast() throws SQLException 2872 { 2873 String methodCall = "afterLast()"; 2874 try 2875 { 2876 realResultSet.afterLast(); 2877 } 2878 catch (SQLException s) 2879 { 2880 reportException(methodCall, s); 2881 throw s; 2882 } 2883 reportReturn(methodCall); 2884 } 2885 2886 public void refreshRow() throws SQLException 2887 { 2888 String methodCall = "refreshRow()"; 2889 try 2890 { 2891 realResultSet.refreshRow(); 2892 } 2893 catch (SQLException s) 2894 { 2895 reportException(methodCall, s); 2896 throw s; 2897 } 2898 } 2899 2900 public <T> T unwrap(Class<T> iface) throws SQLException { 2901 String methodCall = "unwrap(" + (iface==null?"null":iface.getName()) + ")"; 2902 try 2903 { 2904 //todo: double check this logic 2905 return (T)reportReturn(methodCall, (iface != null && (iface == ResultSet.class || iface == Spy.class))?(T)this:realResultSet.unwrap(iface)); 2906 } 2907 catch (SQLException s) 2908 { 2909 reportException(methodCall,s); 2910 throw s; 2911 } 2912 } 2913 2914 public boolean isWrapperFor(Class<?> iface) throws SQLException 2915 { 2916 String methodCall = "isWrapperFor(" + (iface==null?"null":iface.getName()) + ")"; 2917 try 2918 { 2919 return reportReturn(methodCall, (iface != null && (iface == ResultSet.class || iface == Spy.class)) || 2920 realResultSet.isWrapperFor(iface)); 2921 } 2922 catch (SQLException s) 2923 { 2924 reportException(methodCall,s); 2925 throw s; 2926 } 2927 } 2928 }