View Javadoc
1 // 2 // Copyright 1998, 1999 CDS Networks, Inc., Medford Oregon 3 // 4 // All rights reserved. 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions are met: 8 // 1. Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // 2. Redistributions in binary form must reproduce the above copyright 11 // notice, this list of conditions and the following disclaimer in the 12 // documentation and/or other materials provided with the distribution. 13 // 3. All advertising materials mentioning features or use of this software 14 // must display the following acknowledgement: 15 // This product includes software developed by CDS Networks, Inc. 16 // 4. The name of CDS Networks, Inc. may not be used to endorse or promote 17 // products derived from this software without specific prior 18 // written permission. 19 // 20 // THIS SOFTWARE IS PROVIDED BY CDS NETWORKS, INC. ``AS IS'' AND 21 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 // ARE DISCLAIMED. IN NO EVENT SHALL CDS NETWORKS, INC. BE LIABLE 24 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 // SUCH DAMAGE. 31 // 32 33 34 package com.internetcds.jdbc.tds; 35 36 import java.sql.*; 37 import java.util.Properties; 38 import java.util.Vector; 39 40 class TdsInstance 41 { 42 public static final String cvsVersion = "$Id: Connection_base.java,v 1.6 2003/12/17 14:02:30 zoran Exp $"; 43 44 public boolean inUse = false; 45 public Tds tds = null; 46 47 public TdsInstance(Tds tds_) 48 { 49 tds = tds_; 50 inUse = false; 51 } 52 } 53 54 55 56 57 /*** 58 * <P>A Connection represents a session with a specific 59 * database. Within the context of a Connection, SQL statements are 60 * executed and results are returned. 61 * 62 * <P>A Connection's database is able to provide information 63 * describing its tables, its supported SQL grammar, its stored 64 * procedures, the capabilities of this connection, etc. This 65 * information is obtained with the getMetaData method. 66 * 67 * <P><B>Note:</B> By default the Connection automatically commits 68 * changes after executing each statement. If auto commit has been 69 * disabled, an explicit commit must be done or database changes will 70 * not be saved. 71 * 72 * @author Craig Spannring 73 * @author Igor Petrovski 74 * @author The FreeTDS project 75 * @version $Id: Connection_base.java,v 1.6 2003/12/17 14:02:30 zoran Exp $ 76 * 77 * @see DriverManager#getConnection 78 * @see Statement 79 * @see ResultSet 80 * @see DatabaseMetaData 81 */ 82 public class Connection_base implements ConnectionHelper 83 { 84 public static final String cvsVersion = "$Id: Connection_base.java,v 1.6 2003/12/17 14:02:30 zoran Exp $"; 85 86 87 String host = null; 88 int serverType = -1; // Can be either Driver.SYBASE or Driver.SQLSERVER 89 int port = -1; // Port numbers are _unsigned_ 16 bit, short is too small 90 String database = null; 91 Properties initialProps = null; 92 93 94 Vector tdsPool = null; 95 DatabaseMetaData databaseMetaData = null; 96 Vector allStatements = null; 97 // Tds tdsAll = null; 98 99 boolean autoCommit = true; 100 int transactionIsolationLevel = java.sql.Connection.TRANSACTION_READ_COMMITTED; 101 boolean isClosed = false; 102 103 private SQLWarningChain warningChain; 104 105 protected void NotImplemented() throws java.sql.SQLException 106 { 107 throw new java.sql.SQLException("Not Implemented"); 108 } 109 110 111 112 113 114 /*** 115 * Connect via TDS to a database server. 116 * 117 * @return a valid connection profile 118 * @exception SQLException if a database access error occurs 119 */ 120 public Connection_base( 121 Properties props_) 122 throws SQLException, com.internetcds.jdbc.tds.TdsException 123 { 124 host = props_.getProperty("HOST"); 125 serverType = Integer.parseInt(props_.getProperty("SERVERTYPE")); 126 port = Integer.parseInt(props_.getProperty("PORT")); 127 database = props_.getProperty("DBNAME"); 128 String user = props_.getProperty("user"); 129 String password = props_.getProperty("password"); 130 initialProps = props_; 131 132 warningChain = new SQLWarningChain(); 133 134 if (user == null) 135 { 136 user = props_.getProperty("USER"); 137 if (user == null) 138 { 139 throw new SQLException("Need a username."); 140 } 141 props_.put("user", user); 142 } 143 144 if (password == null) 145 { 146 password = props_.getProperty("PASSWORD"); 147 if (password == null) 148 { 149 throw new SQLException("Need a password."); 150 } 151 props_.put("password", password); 152 } 153 154 if (tdsPool == null) 155 { 156 tdsPool = new Vector(20); 157 } 158 159 if (allStatements == null) 160 { 161 allStatements = new Vector(2); 162 } 163 164 try 165 { 166 //sinisa 167 Tds tmpTds = this.allocateTds(); 168 // tdsAll = this.allocateTds(); 169 freeTds(tmpTds); 170 // freeTds(tdsAll); 171 } 172 catch (java.net.UnknownHostException e) 173 { 174 throw new SQLException("Unknown host"); 175 } 176 catch (java.io.IOException e) 177 { 178 throw new SQLException("Network error- " + e.getMessage()); 179 } 180 } 181 182 protected String sqlStatementToInitialize() 183 { 184 return serverType==Tds.SYBASE ? "set quoted_identifier on set textsize 50000" : ""; 185 } 186 187 protected String sqlStatementToSetTransactionIsolationLevel() 188 throws SQLException 189 { 190 String sql = "set transaction isolation level "; 191 192 if (serverType == Tds.SYBASE) 193 { 194 switch (transactionIsolationLevel) 195 { 196 case java.sql.Connection.TRANSACTION_READ_UNCOMMITTED: 197 { 198 throw new SQLException("Bad transaction level"); 199 } 200 case java.sql.Connection.TRANSACTION_READ_COMMITTED: 201 { 202 sql = sql + "1"; 203 break; 204 } 205 case java.sql.Connection.TRANSACTION_REPEATABLE_READ: 206 { 207 throw new SQLException("Bad transaction level"); 208 } 209 case java.sql.Connection.TRANSACTION_SERIALIZABLE: 210 { 211 sql = sql + "3"; 212 break; 213 } 214 case java.sql.Connection.TRANSACTION_NONE: 215 default: 216 { 217 throw new SQLException("Bad transaction level"); 218 } 219 } 220 } 221 else 222 { 223 switch (transactionIsolationLevel) 224 { 225 case java.sql.Connection.TRANSACTION_READ_UNCOMMITTED: 226 { 227 sql = sql + " read uncommitted "; 228 break; 229 } 230 case java.sql.Connection.TRANSACTION_READ_COMMITTED: 231 { 232 sql = sql + " read committed "; 233 break; 234 } 235 case java.sql.Connection.TRANSACTION_REPEATABLE_READ: 236 { 237 sql = sql + " repeatable read "; 238 break; 239 } 240 case java.sql.Connection.TRANSACTION_SERIALIZABLE: 241 { 242 throw new SQLException("SQLServer does not support " + 243 "TRANSACTION_SERIALIZABLE"); 244 } 245 case java.sql.Connection.TRANSACTION_NONE: 246 default: 247 { 248 throw new SQLException("Bad transaction level"); 249 } 250 } 251 } 252 return sql; 253 } 254 255 256 protected String sqlStatementToSetCommit() 257 { 258 String result; 259 260 if (serverType == Tds.SYBASE) 261 { 262 if (autoCommit) 263 { 264 result = "set CHAINED off "; 265 } 266 else 267 { 268 result = "set CHAINED on "; 269 } 270 } 271 else 272 { 273 if (autoCommit) 274 { 275 result = "set implicit_transactions off "; 276 } 277 else 278 { 279 result = "set implicit_transactions on "; 280 } 281 } 282 return result; 283 } 284 285 protected String sqlStatementForSettings() 286 throws SQLException 287 { 288 //zoran 289 return 290 sqlStatementToInitialize() + " " + 291 "set quoted_identifier,ansi_null_dflt_on,ansi_padding,ansi_warnings,ansi_nulls on set textsize 2147483647 "+ 292 sqlStatementToSetTransactionIsolationLevel() + " "; 293 // sqlStatementToSetCommit(); 294 } 295 296 297 public String getUrl() 298 { 299 // XXX Is it legal to return something that might not be 300 // exactly the URL used to connect? 301 return 302 ("jdbc:freetds:" 303 + (serverType==Tds.SYBASE?"sybase":"sqlserver") 304 + "://" + host + ":" + port + "/" + database); 305 } 306 307 /*** 308 * allocate a tds instance to the calling thread. 309 * <br> 310 * The routine tries to reuse an available tds instance. If there 311 * are no tds instances that aren't in use it will create a new 312 * instance. 313 * 314 * @exception java.sql.SQLException 315 * @exception java.net.UnknownHostException 316 * @exception com.internetcds.jdbc.tds.TdsException 317 * @exception java.io.IOException 318 * 319 * @return A tds instance to use for database communications. 320 */ 321 synchronized private Tds allocateTds() 322 throws java.sql.SQLException, java.net.UnknownHostException, 323 com.internetcds.jdbc.tds.TdsException, java.io.IOException 324 { 325 Tds result; 326 int i; 327 328 329 i = findAnAvailableTds(); 330 if (i == -1) 331 { 332 Tds tmpTds = null; 333 try 334 { 335 tmpTds = new Tds((java.sql.Connection)this, 336 initialProps, sqlStatementForSettings()); 337 } 338 catch (SQLException e) 339 { 340 throw new SQLException(e.getMessage() + "\n" + tdsPool.size() 341 + " connection are in use by this program"); 342 } 343 TdsInstance tmp = new TdsInstance(tmpTds); 344 tdsPool.addElement(tmp); 345 i = findAnAvailableTds(); 346 } 347 if (i == -1) 348 { 349 throw new TdsException("Internal Error. Couldn't get tds instance"); 350 } 351 if (((TdsInstance)tdsPool.elementAt(i)).inUse) 352 { 353 throw new TdsException("Internal Error. tds " + i 354 + " is already allocated"); 355 } 356 ((TdsInstance)tdsPool.elementAt(i)).inUse = true; 357 result = ((TdsInstance)(tdsPool.elementAt(i))).tds; 358 359 result.changeSettings(null, sqlStatementForSettings()); 360 361 return result; 362 } 363 364 /*** 365 * Find a tds in the TdsPool that is not in use. 366 * 367 * @return -1 if none were found, otherwise return the index a tds 368 */ 369 private int findAnAvailableTds() 370 { 371 int i; 372 373 for(i=tdsPool.size()-1; 374 i>=0 && ((TdsInstance)tdsPool.elementAt(i)).inUse; 375 i--) 376 { 377 // nop 378 } 379 return i; 380 } 381 382 383 384 public void markAsClosed(java.sql.Statement stmt) throws TdsException 385 { 386 if (!allStatements.removeElement((com.internetcds.jdbc.tds.Statement)stmt)) 387 { 388 //commented, if call close() more than once from application. 389 //throw new TdsException("Statement was not known by the connection"); 390 } 391 } 392 393 /*** 394 * return a tds instance back to the tds pool for reuse. 395 * 396 * @see allocateTds 397 */ 398 private void freeTds(Tds tds) 399 throws TdsException 400 { 401 int i; 402 403 i = -1; 404 do 405 { 406 i++; 407 } while(i<tdsPool.size() 408 && tds != ((TdsInstance)tdsPool.elementAt(i)).tds); 409 410 if (i<tdsPool.size()) 411 { 412 ((TdsInstance)tdsPool.elementAt(i)).inUse = false; 413 414 // XXX Should also send a cancel to the server and throw out any 415 // data that has already been sent. 416 } 417 else 418 { 419 throw new TdsException("Tried to free a tds that wasn't in use"); 420 } 421 } 422 423 /*** 424 * return a tds instance back to the tds pool for reuse. 425 * 426 * A thread that is using a tds instance should return the 427 * instance back to the tds pool when it is finished using it. 428 * 429 * @see allocateTds 430 */ 431 public void relinquish(Tds tds) 432 throws TdsException 433 { 434 freeTds(tds); 435 } 436 437 438 /*** 439 * SQL statements without parameters are normally executed using 440 * Statement objects. If the same SQL statement is executed many 441 * times, it is more efficient to use a PreparedStatement 442 * 443 * JDBC 2.0 444 * 445 * Result sets created using the returned Statement will have 446 * forward-only type, and read-only concurrency, by default. 447 * 448 * @return a new Statement object 449 * @exception SQLException passed through from the constructor 450 */ 451 public java.sql.Statement createStatement() throws SQLException 452 { 453 //sinisa 454 Tds tmpTds = null; 455 try 456 { 457 tmpTds = this.allocateTds(); 458 } 459 catch(com.internetcds.jdbc.tds.TdsException e) 460 { 461 throw new SQLException(e.getMessage()); 462 } 463 catch(java.io.IOException e) 464 { 465 throw new SQLException(e.getMessage()); 466 } 467 //sinisa 468 com.internetcds.jdbc.tds.Statement result; 469 result = new com.internetcds.jdbc.tds.Statement(this, tmpTds); 470 // result = new com.internetcds.jdbc.tds.Statement(this, tdsAll); 471 472 allStatements.addElement(result); 473 return result; 474 } 475 476 477 478 /*** 479 * A SQL statement with or without IN parameters can be 480 * pre-compiled and stored in a PreparedStatement object. This 481 * object can then be used to efficiently execute this statement 482 * multiple times. 483 * 484 * <P><B>Note:</B> This method is optimized for handling 485 * parametric SQL statements that benefit from precompilation. If 486 * the driver supports precompilation, prepareStatement will send 487 * the statement to the database for precompilation. Some drivers 488 * may not support precompilation. In this case, the statement may 489 * not be sent to the database until the PreparedStatement is 490 * executed. This has no direct affect on users; however, it does 491 * affect which method throws certain SQLExceptions. 492 * 493 * JDBC 2.0 494 * 495 * Result sets created using the returned PreparedStatement will have 496 * forward-only type and read-only concurrency, by default. 497 * 498 * @param sql a SQL statement that may contain one or more '?' IN 499 * parameter placeholders 500 * @return a new PreparedStatement object containing the 501 * pre-compiled statement 502 * @exception SQLException if a database-access error occurs. 503 */ 504 public java.sql.PreparedStatement prepareStatement(String sql) 505 throws SQLException 506 { 507 java.sql.PreparedStatement result; 508 509 //sinisa 510 Tds tmpTds = null; 511 try 512 { 513 tmpTds = this.allocateTds(); 514 } 515 catch (java.io.IOException e) 516 { 517 throw new SQLException(e.getMessage()); 518 } 519 catch (com.internetcds.jdbc.tds.TdsException e) 520 { 521 throw new SQLException(e.getMessage()); 522 } 523 524 result = Constructors.newPreparedStatement(this, tmpTds, sql); 525 // result = Constructors.newPreparedStatement(this, tdsAll, sql); 526 527 allStatements.addElement(result); 528 529 return result; 530 } 531 532 /*** 533 * A SQL stored procedure call statement is handled by creating a 534 * CallableStatement for it. The CallableStatement provides methods 535 * for setting up its IN and OUT parameters and methods for executing 536 * it. 537 * 538 * <B>Note:</B> This method is optimised for handling stored procedure 539 * call statements. Some drivers may send the call statement to the 540 * database when the prepareCall is done; others may wait until the 541 * CallableStatement is executed. This has no direct effect on users; 542 * however, it does affect which method throws certain SQLExceptions 543 * 544 * JDBC 2.0 545 * 546 * Result sets created using the returned CallableStatement will have 547 * forward-only type and read-only concurrency, by default. 548 * 549 * @param sql a SQL statement that may contain one or more '?' parameter 550 * placeholders. Typically this statement is a JDBC function call 551 * escape string. 552 * @return a new CallableStatement object containing the pre-compiled 553 * SQL statement 554 * @exception SQLException if a database access error occurs 555 */ 556 public java.sql.CallableStatement prepareCall(String sql) throws SQLException 557 { 558 java.sql.CallableStatement result; 559 560 //sinisa 561 Tds tmpTds = null; 562 try 563 { 564 tmpTds = this.allocateTds(); 565 } 566 catch (java.io.IOException e) 567 { 568 throw new SQLException(e.getMessage()); 569 } 570 catch (com.internetcds.jdbc.tds.TdsException e) 571 { 572 throw new SQLException(e.getMessage()); 573 } 574 575 result = Constructors.newCallableStatement(this, tmpTds, sql); 576 // result = Constructors.newCallableStatement(this, tdsAll, sql); 577 allStatements.addElement(result); 578 579 return result; 580 } 581 582 /*** 583 * A driver may convert the JDBC sql grammar into its system's 584 * native SQL grammar prior to sending it; nativeSQL returns the 585 * native form of the statement that the driver would have sent. 586 * 587 * @param sql a SQL statement that may contain one or more '?' 588 * parameter placeholders 589 * @return the native form of this statement 590 * @exception SQLException if a database access error occurs 591 */ 592 593 public String nativeSQL(String sql) throws SQLException 594 { 595 return Tds.toNativeSql(sql, serverType); 596 } 597 598 599 /*** 600 * If a connection is in auto-commit mode, then all its SQL 601 * statements will be executed and committed as individual 602 * transactions. Otherwise, its SQL statements are grouped into 603 * transactions that are terminated by either commit() or 604 * rollback(). By default, new connections are in auto-commit 605 * mode. 606 * 607 * The commit occurs when the statement completes or the next 608 * execute occurs, whichever comes first. In the case of 609 * statements returning a ResultSet, the statement completes when 610 * the last row of the ResultSet has been retrieved or the 611 * ResultSet has been closed. In advanced cases, a single 612 * statement may return multiple results as well as output 613 * parameter values. Here the commit occurs when all results and 614 * output param values have been retrieved. 615 * 616 * @param value true enables auto-commit; false disables 617 * auto-commit. 618 * @exception SQLException if a database-access error occurs. 619 */ 620 public void setAutoCommit(boolean value) throws SQLException 621 { 622 int i; 623 String sql = null; 624 625 autoCommit = value; 626 sql = sqlStatementToSetCommit(); 627 //sinisa 628 for(i=0; i<allStatements.size(); i++) 629 { 630 Statement stmt = (Statement)allStatements.elementAt(i); 631 // Statement stmt = (com.internetcds.jdbc.tds.Statement)this.createStatement(); 632 633 { 634 // Note- stmt.execute implicitly eats the END_TOKEN 635 // that will come back from the commit command 636 stmt.execute(sql); 637 stmt.execute("BEGIN TRAN"); 638 } 639 } 640 } 641 642 643 /*** 644 * Get the current auto-commit state. 645 * 646 * @return Current state of auto-commit mode. 647 * @exception SQLException if a database-access error occurs. 648 * @see #setAutoCommit 649 */ 650 public boolean getAutoCommit() throws SQLException 651 { 652 return autoCommit; 653 } 654 655 656 /*** 657 * Commit makes all changes made since the previous 658 * commit/rollback permanent and releases any database locks 659 * currently held by the Connection. This method should only be 660 * used when auto commit has been disabled. 661 * 662 * @exception SQLException if a database-access error occurs. 663 * @see #setAutoCommit 664 */ 665 public void commit() throws SQLException 666 { 667 commitOrRollback(true); 668 } 669 670 671 /*** 672 * Rollback drops all changes made since the previous 673 * commit/rollback and releases any database locks currently held 674 * by the Connection. This method should only be used when auto 675 * commit has been disabled. 676 * 677 * @exception SQLException if a database-access error occurs. 678 * @see #setAutoCommit 679 */ 680 public void rollback() throws SQLException 681 { 682 commitOrRollback(false); 683 } 684 685 private void commitOrRollback(boolean commit) 686 throws SQLException 687 { 688 int i; 689 SQLException exception = null; 690 691 if (autoCommit) 692 { 693 throw new SQLException("This method should only be " + 694 " used when auto commit has been disabled."); 695 } 696 697 698 // XXX race condition here. It is possible that a statement could 699 // close while running this for loop. 700 //sinisa 701 for(i=0; i<allStatements.size(); i++) 702 { 703 Statement stmt = (Statement)allStatements.elementAt(i); 704 //String sql = "IF @@TRANCOUNT > 0 COMMIT TRAN"; 705 //String sqlRollback = "IF @@TRANCOUNT > 0 ROLLBACK TRAN "; 706 //Statement stmt = (com.internetcds.jdbc.tds.Statement)this.createStatement(); 707 708 try 709 { 710 if (commit) 711 { 712 stmt.commit(); 713 // stmt.executeQuery(sql); 714 } 715 else 716 { 717 stmt.rollback(); 718 // stmt.executeQuery(sqlRollback); 719 } 720 } 721 // XXX need to put all of these into the warning chain. 722 // 723 // Don't think so, the warnings would belong to Statement anyway -- SB 724 catch (java.sql.SQLException e) 725 { 726 exception = e; 727 } 728 catch (java.io.IOException e) 729 { 730 exception = new SQLException(e.getMessage()); 731 } 732 catch (com.internetcds.jdbc.tds.TdsException e) 733 { 734 exception = new SQLException(e.getMessage()); 735 } 736 737 /* if (stmt instanceof CallableStatement) 738 { 739 ((PreparedStatementHelper)stmt).dropAllProcedures(); 740 throw new SQLException("Not implemented"); 741 } 742 else if (stmt instanceof PreparedStatement) 743 { 744 ((PreparedStatementHelper)stmt).dropAllProcedures(); 745 } 746 */ 747 } 748 if (exception != null) 749 { 750 throw exception; 751 } 752 } 753 754 /*** 755 * In some cases, it is desirable to immediately release a 756 * Connection's database and JDBC resources instead of waiting for 757 * them to be automatically released; the close method provides this 758 * immediate release. 759 * 760 * <P><B>Note:</B> A Connection is automatically closed when it is 761 * garbage collected. Certain fatal errors also result in a closed 762 * Connection. 763 * 764 * @exception SQLException if a database-access error occurs. 765 */ 766 public void close() throws SQLException 767 { 768 int i; 769 770 771 for(i=0; i<allStatements.size(); i++) 772 { 773 Statement stmt = (Statement)allStatements.elementAt(i); 774 775 { 776 if( !stmt.isClosed() ) 777 stmt.close(); 778 } 779 } 780 781 for(i=0; i<tdsPool.size(); i++) 782 { 783 ((TdsInstance)tdsPool.elementAt(i)).tds.close(); 784 } 785 786 clearWarnings(); 787 isClosed = true; 788 } 789 790 /*** 791 * Tests to see if a Connection is closed. 792 * 793 * @return true if the connection is closed; false if it's still open 794 * @exception SQLException if a database-access error occurs. 795 */ 796 public boolean isClosed() throws SQLException 797 { 798 return isClosed; 799 } 800 801 /*** 802 * A connection's database is able to provide information describing 803 * its tables, its supported SQL grammar, its stored procedures, the 804 * capabilities of this connection, etc. This information is made 805 * available through a DatabaseMetaData object. 806 * 807 * @return a DatabaseMetaData object for this connection 808 * @exception SQLException if a database access error occurs 809 */ 810 public java.sql.DatabaseMetaData getMetaData() throws SQLException 811 { 812 try 813 { 814 if (databaseMetaData == null) 815 { 816 // The DatabaseMetaData may need the tds connection 817 // at some later time. Therefore we shouldn't relinquish the 818 // tds. 819 Tds tds = this.allocateTds(); 820 databaseMetaData = new com.internetcds.jdbc.tds.DatabaseMetaData(this, tds); 821 } 822 return databaseMetaData; 823 } 824 catch(java.io.IOException e) 825 { 826 throw new SQLException(e.getMessage()); 827 } 828 catch(com.internetcds.jdbc.tds.TdsException e) 829 { 830 throw new SQLException(e.getMessage()); 831 } 832 // catch(java.net.UnknownHostException e) 833 // { 834 // throw new SQLException(e.getMessage()); 835 // } 836 } 837 838 /*** 839 * You can put a connection in read-only mode as a hint to enable 840 * database optimizations 841 * 842 * <B>Note:</B> setReadOnly cannot be called while in the middle 843 * of a transaction 844 * 845 * @param readOnly - true enables read-only mode; false disables it 846 * @exception SQLException if a database access error occurs 847 */ 848 public void setReadOnly (boolean readOnly) throws SQLException 849 { 850 throw new SQLException("Not implemented (setReadOnly)"); 851 } 852 853 /*** 854 * Tests to see if the connection is in read-only mode. 855 * 856 * @return true if connection is read-only 857 * @exception SQLException if a database-access error occurs. 858 */ 859 public boolean isReadOnly() throws SQLException 860 { 861 throw new SQLException("Not implemented (isReadOnly)"); 862 } 863 864 865 866 /*** 867 * A sub-space of this Connection's database may be selected by setting a 868 * catalog name. If the driver does not support catalogs it will 869 * silently ignore this request. 870 * 871 * @exception SQLException if a database-access error occurs. 872 */ 873 public void setCatalog(String catalog) throws SQLException 874 { 875 throw new SQLException("Not implemented (setCatalog)"); 876 } 877 878 /*** 879 * Return the Connection's current catalog name. 880 * 881 * @return the current catalog name or null 882 * @exception SQLException if a database-access error occurs. 883 */ 884 public String getCatalog() throws SQLException 885 { 886 throw new SQLException("Not implemented (getCatalog)"); 887 } 888 889 890 /*** 891 * You can call this method to try to change the transaction 892 * isolation level using one of the TRANSACTION_* values. 893 * 894 * <P><B>Note:</B> setTransactionIsolation cannot be called while 895 * in the middle of a transaction. 896 * 897 * @param level one of the TRANSACTION_* isolation values with the 898 * exception of TRANSACTION_NONE; some databases may not support 899 * other values 900 * @exception SQLException if a database-access error occurs. 901 * @see DatabaseMetaData#supportsTransactionIsolationLevel 902 */ 903 public void setTransactionIsolation(int level) 904 throws SQLException 905 { 906 int i; 907 String sql; 908 909 transactionIsolationLevel = level; 910 911 sql = sqlStatementToSetTransactionIsolationLevel(); 912 913 for(i=0; i<allStatements.size(); i++) 914 { 915 Statement stmt = (Statement)allStatements.elementAt(i); 916 917 { 918 // Note- stmt.execute implicitly eats the END_TOKEN 919 // that will come back from the commit command 920 stmt.execute(sql); 921 } 922 } 923 } 924 925 926 927 /*** 928 * Get this Connection's current transaction isolation mode. 929 * 930 * @return the current TRANSACTION_* mode value 931 * @exception SQLException if a database-access error occurs. 932 */ 933 public int getTransactionIsolation() throws SQLException 934 { 935 return transactionIsolationLevel; 936 } 937 938 939 /*** 940 * The first warning reported by calls on this Connection is 941 * returned. 942 * 943 * <P><B>Note:</B> Subsequent warnings will be chained to this 944 * SQLWarning. 945 * 946 * @return the first SQLWarning or null 947 * @exception SQLException if a database-access error occurs. 948 */ 949 public SQLWarning getWarnings() throws SQLException 950 { 951 return warningChain.getWarnings(); 952 } 953 954 /*** 955 * After this call, getWarnings returns null until a new warning 956 * is reported for this connection. 957 * 958 * @exception SQLException if a database access error occurs 959 */ 960 public void clearWarnings() throws SQLException 961 { 962 warningChain.clearWarnings(); 963 } 964 965 //--------------------------JDBC 2.0----------------------------- 966 967 /*** 968 * JDBC 2.0 969 * 970 * Creates a <code>Statement</code> object that will generate 971 * <code>ResultSet</code> objects with the given type and concurrency. 972 * This method is the same as the <code>createStatement</code> method 973 * above, but it allows the default result set 974 * type and result set concurrency type to be overridden. 975 * 976 * @param resultSetType a result set type; see ResultSet.TYPE_XXX 977 * @param resultSetConcurrency a concurrency type; see ResultSet.CONCUR_XXX 978 * @return a new Statement object 979 * @exception SQLException if a database access error occurs 980 */ 981 public java.sql.Statement createStatement( 982 int resultSetType, 983 int resultSetConcurrency) 984 throws SQLException 985 { 986 987 Tds tmpTds = null; 988 try 989 { 990 tmpTds = this.allocateTds(); 991 } 992 catch(com.internetcds.jdbc.tds.TdsException e) 993 { 994 throw new SQLException(e.getMessage()); 995 } 996 catch(java.io.IOException e) 997 { 998 throw new SQLException(e.getMessage()); 999 } 1000 com.internetcds.jdbc.tds.Statement result; 1001 result = new com.internetcds.jdbc.tds.Statement(this, tmpTds); 1002 1003 allStatements.addElement(result); 1004 1005 return result; 1006 } 1007 1008 1009 /*** 1010 * JDBC 2.0 1011 * 1012 * Creates a <code>PreparedStatement</code> object that will generate 1013 * <code>ResultSet</code> objects with the given type and concurrency. 1014 * This method is the same as the <code>prepareStatement</code> method 1015 * above, but it allows the default result set 1016 * type and result set concurrency type to be overridden. 1017 * 1018 * @param resultSetType a result set type; see ResultSet.TYPE_XXX 1019 * @param resultSetConcurrency a concurrency type; see ResultSet.CONCUR_XXX 1020 * @return a new PreparedStatement object containing the 1021 * pre-compiled SQL statement 1022 * @exception SQLException if a database access error occurs 1023 */ 1024 public java.sql.PreparedStatement prepareStatement( 1025 String sql, 1026 int resultSetType, 1027 int resultSetConcurrency) 1028 throws SQLException 1029 { 1030 NotImplemented(); 1031 return null; 1032 } 1033 1034 1035 /*** 1036 * JDBC 2.0 1037 * 1038 * Creates a <code>CallableStatement</code> object that will generate 1039 * <code>ResultSet</code> objects with the given type and concurrency. 1040 * This method is the same as the <code>prepareCall</code> method 1041 * above, but it allows the default result set 1042 * type and result set concurrency type to be overridden. 1043 * 1044 * @param resultSetType a result set type; see ResultSet.TYPE_XXX 1045 * @param resultSetConcurrency a concurrency type; see ResultSet.CONCUR_XXX 1046 * @return a new CallableStatement object containing the 1047 * pre-compiled SQL statement 1048 * @exception SQLException if a database access error occurs 1049 */ 1050 public java.sql.CallableStatement prepareCall( 1051 String sql, 1052 int resultSetType, 1053 int resultSetConcurrency) throws SQLException 1054 { 1055 NotImplemented(); 1056 return null; 1057 } 1058 1059 1060 } 1061 1062

This page was automatically generated by Maven