home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / sun / jdbc / odbc / JdbcOdbcConnection.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  9.2 KB  |  459 lines
  1. package sun.jdbc.odbc;
  2.  
  3. import java.sql.CallableStatement;
  4. import java.sql.DatabaseMetaData;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.SQLWarning;
  9. import java.sql.Statement;
  10. import java.util.Enumeration;
  11. import java.util.Hashtable;
  12. import java.util.Properties;
  13.  
  14. public class JdbcOdbcConnection extends JdbcOdbcObject implements JdbcOdbcConnectionInterface {
  15.    protected JdbcOdbc OdbcApi;
  16.    protected JdbcOdbcDriverInterface myDriver;
  17.    protected int hEnv;
  18.    protected int hDbc;
  19.    protected SQLWarning lastWarning;
  20.    protected boolean closed;
  21.    protected String URL;
  22.    protected int odbcVer;
  23.    protected Hashtable typeInfo;
  24.    protected Hashtable statements;
  25.  
  26.    public JdbcOdbcConnection(JdbcOdbc var1, int var2, JdbcOdbcDriverInterface var3) {
  27.       this.OdbcApi = var1;
  28.       this.myDriver = var3;
  29.       this.hEnv = var2;
  30.       this.hDbc = 0;
  31.       this.URL = null;
  32.       this.lastWarning = null;
  33.       this.closed = true;
  34.    }
  35.  
  36.    protected void finalize() {
  37.       if (JdbcOdbcObject.isTracing()) {
  38.          JdbcOdbcObject.trace("Connection.finalize " + this);
  39.       }
  40.  
  41.       try {
  42.          this.close();
  43.       } catch (SQLException var1) {
  44.       }
  45.    }
  46.  
  47.    public void initialize(String var1, Properties var2, int var3) throws SQLException {
  48.       String var6 = "";
  49.       if (this.closed) {
  50.          this.hDbc = this.myDriver.allocConnection(this.hEnv);
  51.       }
  52.  
  53.       if (var3 > 0) {
  54.          this.setLoginTimeout(var3);
  55.       }
  56.  
  57.       String var4 = var2.getProperty("user", "");
  58.       String var5 = var2.getProperty("password", "");
  59.       var6 = "DSN=" + var1;
  60.       if (var4 != null) {
  61.          var6 = var6 + ";UID=" + var4;
  62.       }
  63.  
  64.       if (var5 != null) {
  65.          var6 = var6 + ";PWD=" + var5;
  66.       }
  67.  
  68.       try {
  69.          this.OdbcApi.SQLDriverConnect(this.hDbc, var6);
  70.       } catch (SQLWarning var8) {
  71.          this.lastWarning = var8;
  72.       } catch (SQLException var9) {
  73.          this.myDriver.closeConnection(this.hDbc);
  74.          throw var9;
  75.       }
  76.  
  77.       this.closed = false;
  78.       this.statements = new Hashtable();
  79.       if (JdbcOdbcObject.isTracing()) {
  80.          DatabaseMetaData var7 = this.getMetaData();
  81.          JdbcOdbcObject.trace("Driver name:    " + var7.getDriverName());
  82.          JdbcOdbcObject.trace("Driver version: " + var7.getDriverVersion());
  83.       }
  84.  
  85.       this.buildTypeInfo();
  86.    }
  87.  
  88.    public Statement createStatement() throws SQLException {
  89.       if (JdbcOdbcObject.isTracing()) {
  90.          JdbcOdbcObject.trace("*Connection.createStatement");
  91.       }
  92.  
  93.       JdbcOdbcStatement var1 = new JdbcOdbcStatement(this);
  94.       var1.initialize(this.OdbcApi, this.hDbc);
  95.       this.registerStatement(var1);
  96.       return var1;
  97.    }
  98.  
  99.    public PreparedStatement prepareStatement(String var1) throws SQLException {
  100.       if (JdbcOdbcObject.isTracing()) {
  101.          JdbcOdbcObject.trace("*Connection.prepareStatement (" + var1 + ")");
  102.       }
  103.  
  104.       Object var3 = null;
  105.       SQLWarning var4 = null;
  106.       int var2 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  107.  
  108.       try {
  109.          this.OdbcApi.SQLPrepare(var2, var1);
  110.       } catch (SQLWarning var6) {
  111.          var4 = var6;
  112.       } catch (SQLException var7) {
  113.          this.OdbcApi.SQLFreeStmt(var2, 1);
  114.          throw var7;
  115.       }
  116.  
  117.       JdbcOdbcPreparedStatement var8 = new JdbcOdbcPreparedStatement(this);
  118.       var8.initialize(this.OdbcApi, this.hDbc, var2, this.typeInfo);
  119.       ((JdbcOdbcStatement)var8).setWarning(var4);
  120.       this.registerStatement(var8);
  121.       return var8;
  122.    }
  123.  
  124.    public CallableStatement prepareCall(String var1) throws SQLException {
  125.       if (JdbcOdbcObject.isTracing()) {
  126.          JdbcOdbcObject.trace("*Connection.prepareCall (" + var1 + ")");
  127.       }
  128.  
  129.       Object var3 = null;
  130.       SQLWarning var4 = null;
  131.       int var2 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  132.  
  133.       try {
  134.          this.OdbcApi.SQLPrepare(var2, var1);
  135.       } catch (SQLWarning var6) {
  136.          var4 = var6;
  137.       } catch (SQLException var7) {
  138.          this.OdbcApi.SQLFreeStmt(var2, 1);
  139.          throw var7;
  140.       }
  141.  
  142.       JdbcOdbcCallableStatement var8 = new JdbcOdbcCallableStatement(this);
  143.       ((JdbcOdbcPreparedStatement)var8).initialize(this.OdbcApi, this.hDbc, var2, this.typeInfo);
  144.       ((JdbcOdbcStatement)var8).setWarning(var4);
  145.       this.registerStatement(var8);
  146.       return var8;
  147.    }
  148.  
  149.    public String nativeSQL(String var1) throws SQLException {
  150.       if (JdbcOdbcObject.isTracing()) {
  151.          JdbcOdbcObject.trace("*Connection.nativeSQL (" + var1 + ")");
  152.       }
  153.  
  154.       String var2;
  155.       try {
  156.          var2 = this.OdbcApi.SQLNativeSql(this.hDbc, var1);
  157.       } catch (SQLException var3) {
  158.          var2 = var1;
  159.       }
  160.  
  161.       return var2;
  162.    }
  163.  
  164.    public void setAutoCommit(boolean var1) throws SQLException {
  165.       if (JdbcOdbcObject.isTracing()) {
  166.          JdbcOdbcObject.trace("*Connection.setAutoCommit (" + var1 + ")");
  167.       }
  168.  
  169.       byte var2 = 1;
  170.       this.validateConnection();
  171.       if (!var1) {
  172.          var2 = 0;
  173.       }
  174.  
  175.       this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)102, var2);
  176.    }
  177.  
  178.    public boolean getAutoCommit() throws SQLException {
  179.       if (JdbcOdbcObject.isTracing()) {
  180.          JdbcOdbcObject.trace("*Connection.getAutoCommit");
  181.       }
  182.  
  183.       boolean var2 = false;
  184.       this.validateConnection();
  185.       int var1 = this.OdbcApi.SQLGetConnectOption(this.hDbc, (short)102);
  186.       if (var1 == 1) {
  187.          var2 = true;
  188.       }
  189.  
  190.       return var2;
  191.    }
  192.  
  193.    public void commit() throws SQLException {
  194.       if (JdbcOdbcObject.isTracing()) {
  195.          JdbcOdbcObject.trace("*Connection.commit");
  196.       }
  197.  
  198.       this.OdbcApi.SQLTransact(this.hEnv, this.hDbc, (short)0);
  199.    }
  200.  
  201.    public void rollback() throws SQLException {
  202.       if (JdbcOdbcObject.isTracing()) {
  203.          JdbcOdbcObject.trace("*Connection.rollback");
  204.       }
  205.  
  206.       this.OdbcApi.SQLTransact(this.hEnv, this.hDbc, (short)1);
  207.    }
  208.  
  209.    public void close() throws SQLException {
  210.       if (JdbcOdbcObject.isTracing()) {
  211.          JdbcOdbcObject.trace("*Connection.close");
  212.       }
  213.  
  214.       this.closeAllStatements();
  215.       if (!this.closed) {
  216.          this.myDriver.disconnect(this.hDbc);
  217.          this.myDriver.closeConnection(this.hDbc);
  218.       }
  219.  
  220.       this.closed = true;
  221.       this.URL = null;
  222.    }
  223.  
  224.    public boolean isClosed() throws SQLException {
  225.       return this.closed;
  226.    }
  227.  
  228.    public DatabaseMetaData getMetaData() throws SQLException {
  229.       if (JdbcOdbcObject.isTracing()) {
  230.          JdbcOdbcObject.trace("*Connection.getMetaData");
  231.       }
  232.  
  233.       this.validateConnection();
  234.       JdbcOdbcDatabaseMetaData var1 = new JdbcOdbcDatabaseMetaData(this.OdbcApi, this);
  235.       return var1;
  236.    }
  237.  
  238.    public void setReadOnly(boolean var1) throws SQLException {
  239.       if (JdbcOdbcObject.isTracing()) {
  240.          JdbcOdbcObject.trace("*Connection.setReadOnly (" + var1 + ")");
  241.       }
  242.  
  243.       byte var2 = 0;
  244.       this.validateConnection();
  245.       if (var1) {
  246.          var2 = 1;
  247.       }
  248.  
  249.       try {
  250.          this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)101, var2);
  251.       } catch (SQLException var3) {
  252.          if (JdbcOdbcObject.isTracing()) {
  253.             JdbcOdbcObject.trace("setReadOnly exception ignored");
  254.          }
  255.  
  256.       }
  257.    }
  258.  
  259.    public boolean isReadOnly() throws SQLException {
  260.       if (JdbcOdbcObject.isTracing()) {
  261.          JdbcOdbcObject.trace("*Connection.isReadOnly");
  262.       }
  263.  
  264.       boolean var2 = false;
  265.       this.validateConnection();
  266.       int var1 = this.OdbcApi.SQLGetConnectOption(this.hDbc, (short)101);
  267.       if (var1 == 1) {
  268.          var2 = true;
  269.       }
  270.  
  271.       return var2;
  272.    }
  273.  
  274.    public void setCatalog(String var1) throws SQLException {
  275.       if (JdbcOdbcObject.isTracing()) {
  276.          JdbcOdbcObject.trace("*Connection.setCatalog (" + var1 + ")");
  277.       }
  278.  
  279.       this.validateConnection();
  280.       this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)109, var1);
  281.    }
  282.  
  283.    public String getCatalog() throws SQLException {
  284.       if (JdbcOdbcObject.isTracing()) {
  285.          JdbcOdbcObject.trace("*Connection.getCatalog");
  286.       }
  287.  
  288.       this.validateConnection();
  289.       return this.OdbcApi.SQLGetInfoString(this.hDbc, (short)16);
  290.    }
  291.  
  292.    public void setTransactionIsolation(int var1) throws SQLException {
  293.       if (JdbcOdbcObject.isTracing()) {
  294.          JdbcOdbcObject.trace("*Connection.setTransactionIsolation (" + var1 + ")");
  295.       }
  296.  
  297.       this.validateConnection();
  298.       switch (var1) {
  299.          case 0:
  300.             this.setAutoCommit(true);
  301.             return;
  302.          case 1:
  303.             this.setAutoCommit(false);
  304.             this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)108, 1);
  305.             return;
  306.          case 2:
  307.             this.setAutoCommit(false);
  308.             this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)108, 2);
  309.             return;
  310.          case 4:
  311.             this.setAutoCommit(false);
  312.             this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)108, 4);
  313.             return;
  314.          case 8:
  315.             this.setAutoCommit(false);
  316.             this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)108, 8);
  317.             return;
  318.          default:
  319.             this.setAutoCommit(false);
  320.             this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)108, var1);
  321.       }
  322.    }
  323.  
  324.    public int getTransactionIsolation() throws SQLException {
  325.       if (JdbcOdbcObject.isTracing()) {
  326.          JdbcOdbcObject.trace("*Connection.getTransactionIsolation");
  327.       }
  328.  
  329.       int var1 = 0;
  330.       this.validateConnection();
  331.       int var2 = this.OdbcApi.SQLGetConnectOption(this.hDbc, (short)108);
  332.       switch (var2) {
  333.          case 1:
  334.             var1 = 1;
  335.             break;
  336.          case 2:
  337.             var1 = 2;
  338.             break;
  339.          case 4:
  340.             var1 = 4;
  341.             break;
  342.          case 8:
  343.             var1 = 8;
  344.             break;
  345.          default:
  346.             var1 = var2;
  347.       }
  348.  
  349.       return var1;
  350.    }
  351.  
  352.    public SQLWarning getWarnings() throws SQLException {
  353.       if (JdbcOdbcObject.isTracing()) {
  354.          JdbcOdbcObject.trace("*Connection.getWarnings");
  355.       }
  356.  
  357.       return this.lastWarning;
  358.    }
  359.  
  360.    public void clearWarnings() throws SQLException {
  361.       this.lastWarning = null;
  362.    }
  363.  
  364.    public void validateConnection() throws SQLException {
  365.       if (this.isClosed()) {
  366.          throw new SQLException("Connection is closed");
  367.       }
  368.    }
  369.  
  370.    public int getHDBC() {
  371.       return this.hDbc;
  372.    }
  373.  
  374.    public void setURL(String var1) {
  375.       this.URL = var1;
  376.    }
  377.  
  378.    public String getURL() {
  379.       return this.URL;
  380.    }
  381.  
  382.    protected void setLoginTimeout(int var1) throws SQLException {
  383.       this.OdbcApi.SQLSetConnectOption(this.hDbc, (short)103, var1);
  384.    }
  385.  
  386.    public int getODBCVer() {
  387.       if (this.odbcVer == 0) {
  388.          String var1;
  389.          try {
  390.             var1 = this.OdbcApi.SQLGetInfoString(this.hDbc, (short)10);
  391.          } catch (SQLException var3) {
  392.             var1 = "-1";
  393.          }
  394.  
  395.          Integer var2 = new Integer(var1.substring(0, 2));
  396.          this.odbcVer = var2;
  397.       }
  398.  
  399.       return this.odbcVer;
  400.    }
  401.  
  402.    protected void buildTypeInfo() throws SQLException {
  403.       this.typeInfo = new Hashtable();
  404.       if (JdbcOdbcObject.isTracing()) {
  405.          JdbcOdbcObject.trace("Caching SQL type information");
  406.       }
  407.  
  408.       ResultSet var1 = this.getMetaData().getTypeInfo();
  409.  
  410.       for(boolean var4 = var1.next(); var4; var4 = var1.next()) {
  411.          String var5 = var1.getString(1);
  412.          int var3 = var1.getInt(2);
  413.          if (this.typeInfo.get(new Integer(var3)) == null) {
  414.             JdbcOdbcTypeInfo var2 = new JdbcOdbcTypeInfo();
  415.             var2.setName(var5);
  416.             var2.setPrec(var1.getInt(3));
  417.             this.typeInfo.put(new Integer(var3), var2);
  418.          }
  419.       }
  420.  
  421.       var1.close();
  422.    }
  423.  
  424.    protected void registerStatement(Statement var1) {
  425.       if (JdbcOdbcObject.isTracing()) {
  426.          JdbcOdbcObject.trace("Registering Statement " + var1);
  427.       }
  428.  
  429.       this.statements.put(var1, "");
  430.    }
  431.  
  432.    public void deregisterStatement(Statement var1) {
  433.       if (this.statements.get(var1) != null) {
  434.          if (JdbcOdbcObject.isTracing()) {
  435.             JdbcOdbcObject.trace("deregistering Statement " + var1);
  436.          }
  437.  
  438.          this.statements.remove(var1);
  439.       }
  440.  
  441.    }
  442.  
  443.    public synchronized void closeAllStatements() throws SQLException {
  444.       if (JdbcOdbcObject.isTracing()) {
  445.          JdbcOdbcObject.trace(this.statements.size() + " Statement(s) to close");
  446.       }
  447.  
  448.       if (this.statements.size() != 0) {
  449.          Enumeration var1 = this.statements.keys();
  450.  
  451.          while(var1.hasMoreElements()) {
  452.             Statement var2 = (Statement)var1.nextElement();
  453.             var2.close();
  454.          }
  455.  
  456.       }
  457.    }
  458. }
  459.