src/com/lavans/luz2/sql/cluster/ClusterConnection.java

   1 /* $Id: ClusterConnection.java 94 2008-12-18 11:07:17Z dobashi $\r
   2  * create: 2004/09/17\r
   3  * (c)2004 Lavans Networks Inc. All Rights Reserved.\r
   4  */\r
   5 package com.lavans.luz2.sql.cluster;\r
   6 \r
   7 import java.sql.Array;\r
   8 import java.sql.Blob;\r
   9 import java.sql.CallableStatement;\r
  10 import java.sql.Clob;\r
  11 import java.sql.Connection;\r
  12 import java.sql.DatabaseMetaData;\r
  13 import java.sql.NClob;\r
  14 import java.sql.PreparedStatement;\r
  15 import java.sql.ResultSet;\r
  16 import java.sql.SQLClientInfoException;\r
  17 import java.sql.SQLException;\r
  18 import java.sql.SQLWarning;\r
  19 import java.sql.SQLXML;\r
  20 import java.sql.Savepoint;\r
  21 import java.sql.Statement;\r
  22 import java.sql.Struct;\r
  23 import java.util.ArrayList;\r
  24 import java.util.HashMap;\r
  25 import java.util.List;\r
  26 import java.util.Map;\r
  27 import java.util.Properties;\r
  28 \r
  29 import org.apache.commons.logging.Log;\r
  30 import org.apache.commons.logging.LogFactory;\r
  31 \r
  32 \r
  33 /**\r
  34  * クラスタ接続用Connectionクラス。\r
  35  *\r
  36  * Connectionクラスに対して行う設定処理(setAutoCommit()等)は、\r
  37  * 更新処理を行う前に実行しておくこと。DB切替が発生した際に、\r
  38  * AutoCommitがTrueの時に作成したStatementは再実行されない。\r
  39  *\r
  40  * 制限事項\r
  41  * クラスタ接続ではセーブポイントの管理は行わない。\r
  42  * SQLWarningsはDB切替時に引き継がれない。\r
  43  *\r
  44  * @author dobashi\r
  45  * @version 1.00\r
  46  */\r
  47 public class ClusterConnection implements Connection {\r
  48         /** Messageクラスに移動? */\r
  49         private static final String MSG_WARN_SWITCH_DB="障害が出たので接続先を切り替えます。";\r
  50 //      private static final String MSG_ERR_RECREATE="Statementの再生成に失敗。";\r
  51         /** 処理委譲先 */\r
  52         private Connection con=null;\r
  53 \r
  54         /**\r
  55          * コネクションプール。障害時に別のコネクションを取得するため、\r
  56          * インスタンス変数として参照しておく必要がある。\r
  57          */\r
  58         private ClusterConnectionPool pool = null;\r
  59 \r
  60         /**\r
  61          * setAutoCommit実行フラグ。\r
  62          * setAutoCommit()を明示的に呼ばないでクラスタの切り替えが起こった際に、\r
  63          * 新しいConnectionでsetAutoCommit()を実行しないようにする。\r
  64          * executeBatch内でSET TRANSACTIONしている時などにこの判断が必要。\r
  65          * TODO 判定処理未実装\r
  66          */\r
  67 //      private boolean setAutoCommitFlag = false; //\r
  68 \r
  69         /**\r
  70          * 保存しておくConnectionの状態。\r
  71          * 障害が発生した場合、Connectionに対する操作(setAutoCommit()等)を\r
  72          * 再実行するために保持しておく。\r
  73          */\r
  74         private boolean isAutoCommit = true;\r
  75         private String catalog = null;\r
  76         private int holdability = ResultSet.CLOSE_CURSORS_AT_COMMIT;\r
  77         private boolean isReadOnly = false;\r
  78         private int transactionIsolation = TRANSACTION_READ_COMMITTED;\r
  79         private Map<String, Class<?>> typeMap = null;\r
  80 \r
  81         /**\r
  82          * Statement/PreparedStatement保存用リスト。\r
  83          * 作成した順序を保存しておかなければならないので\r
  84          * List型にて保存する。各Statementを作成したときの引数は\r
  85          * 別途Mapにて保存。\r
  86          */\r
  87         private List<ClusterStatement> statementList = null;\r
  88 \r
  89         /**\r
  90          * Statement/PreparedStatementを作成したときの引数保存用。\r
  91          * 障害時にStatementを再作成するのに必要。\r
  92          * キーはStatement,値が作成時の引数を入れたCalledMethod。\r
  93          * 障害時にはまだclose()されていないStatementに対して\r
  94          * 再更新処理を行う。\r
  95          */\r
  96         private Map<ClusterStatement, CalledMethod> statementMap = null;\r
  97 \r
  98         /** ロガー。debug用 */\r
  99         private static Log logger = LogFactory.getLog(ClusterConnection.class);\r
 100 \r
 101         /**\r
 102          * コンストラクタ。\r
 103          * @throws SQLException\r
 104          */\r
 105         public ClusterConnection(Connection con, ClusterConnectionPool pool) throws SQLException{\r
 106                 this.con = con;\r
 107                 this.pool = pool;\r
 108 //              methodList = new ArrayList();\r
 109                 statementList = new ArrayList<ClusterStatement> ();\r
 110                 statementMap = new HashMap<ClusterStatement, CalledMethod> ();\r
 111 //              prepareMap = new HashMap();\r
 112 \r
 113                 // 障害時にコネクションに対して行った操作を再実行できるように保持しておく。\r
 114                 isAutoCommit = con.getAutoCommit();\r
 115                 catalog = con.getCatalog();\r
 116                 // Oracle9が未サポートのためコメントアウト\r
 117                 //holdability = con.getHoldability();\r
 118                 isReadOnly = con.isReadOnly();\r
 119                 transactionIsolation = con.getTransactionIsolation();\r
 120                 typeMap = con.getTypeMap();\r
 121 \r
 122         }\r
 123 \r
 124         /**\r
 125          * 過去の実行履歴のクリア処理。\r
 126          * ClusterConnectionPoolから取得するときに呼ばれる。\r
 127          *\r
 128          */\r
 129 //      public void init(){\r
 130 //              methodList.clear();\r
 131 //              statementList.clear();\r
 132 //              statementMap.clear();\r
 133 //      }\r
 134 \r
 135         /**\r
 136          * クラスタリング対応のメソッド実行処理。\r
 137          * @param methodName\r
 138          * @param args\r
 139          * @return\r
 140          * @throws SQLException\r
 141          */\r
 142         private Object clusterCall(String methodName, Object[] args, Class<?>[] parameterTypes) throws SQLException{\r
 143                 return clusterCall(new CalledMethod(methodName, args, parameterTypes));\r
 144         }\r
 145 \r
 146         /**\r
 147          * クラスタリング対応のメソッド実行処理。\r
 148          * @param calledMethod\r
 149          * @return\r
 150          * @throws SQLException\r
 151          */\r
 152         private Object clusterCall(CalledMethod calledMethod) throws SQLException{\r
 153                 logger.debug( calledMethod.toString());\r
 154 \r
 155                 Object result = null;\r
 156                 try{\r
 157                         result = calledMethod.invoke(con);\r
 158                 }catch (Exception e) {\r
 159                         try{\r
 160                                 logger.error(MSG_WARN_SWITCH_DB, e.getCause());\r
 161                         }catch (Exception e2) {\r
 162                                 // getCause()に失敗した時用\r
 163                                 logger.error(MSG_WARN_SWITCH_DB, e);\r
 164                         }\r
 165                         try { con.close(); } catch (SQLException se) {}\r
 166                         con = pool.getAnotherConnection(this);\r
 167                         try{\r
 168                                 // コネクションに対して行った操作を再実行する。\r
 169                                 con.setAutoCommit(isAutoCommit);\r
 170                                 con.setCatalog(catalog);\r
 171                                 con.setHoldability(holdability);\r
 172                                 con.setReadOnly(isReadOnly);\r
 173                                 con.setTransactionIsolation(transactionIsolation);\r
 174                                 con.setTypeMap(typeMap);\r
 175 \r
 176                                 // 過去に作成したStatementへ再更新処理を依頼する。\r
 177                                 for(int i=0; i<statementList.size(); i++){\r
 178                                         ClusterStatement cst = statementList.get(i);\r
 179                                         CalledMethod method = statementMap.get(cst);\r
 180                                         Statement st = (Statement)method.invoke(con);           // Statementを再生成\r
 181                                         cst.reupdateStatement(st);\r
 182                                 }\r
 183 \r
 184                                 // エラーの起きたメソッドの再実行\r
 185                                 result = calledMethod.invoke(con);\r
 186                         }catch (Exception e2) {\r
 187                                 // 再度実行。ここでもさらにエラーがでるならSQLExceptionにラップする。\r
 188                                 throw new SQLException(e2.getMessage());\r
 189                         }\r
 190                 }\r
 191 \r
 192                 return result;\r
 193         }\r
 194 \r
 195 \r
 196         /**\r
 197          * 再実行キューからの取り外し。\r
 198          * Statement#close()でこれを呼ぶ必要がある。\r
 199          */\r
 200         public void remove(Statement st){\r
 201                 statementList.remove(st);\r
 202                 statementMap.remove(st);\r
 203         }\r
 204         /**\r
 205          * 再実行キューからの取り外し。\r
 206          * PrepareStatement#close()でこれを呼ぶ必要がある。\r
 207          */\r
 208 //      public void remove(PreparedStatement st){\r
 209 //              prepareMap.remove(st);\r
 210 //      }\r
 211 \r
 212         /**\r
 213          * 接続先切替。\r
 214          * ClusterStatementから呼ばれる。エラーを通知してきたStatementに対しては\r
 215          * autoCommitの状態にかかわらずネイティブなStatementを返す。\r
 216          *\r
 217          * 保存してあるすべてのStatementに対して、過去に実行した\r
 218          * sqlを再実行する。\r
 219          */\r
 220         public void notifyError(ClusterStatement src) throws SQLException{\r
 221                 // 既存のconを破棄してみる。\r
 222                 try{ con.rollback(); con.close(); }catch (SQLException e) {}\r
 223 \r
 224                 try{\r
 225                         con = pool.getAnotherConnection(this);\r
 226                         // コネクションに対して行った操作を再実行する。\r
 227                         con.setAutoCommit(isAutoCommit);\r
 228                         con.setTransactionIsolation(transactionIsolation);\r
 229                         con.setCatalog(catalog);\r
 230                         // Oracle9iが対応していないので削除\r
 231                         //con.setHoldability(holdability);\r
 232                         con.setReadOnly(isReadOnly);\r
 233                         con.setTypeMap(typeMap);\r
 234 \r
 235                         // 過去に作成したStatementへ再更新処理を依頼する。\r
 236                         for(int i=0; i<statementList.size(); i++){\r
 237                                 ClusterStatement cst = statementList.get(i);\r
 238                                 if(src==cst){                   // エラーの通知元にはstatementListに無くてもStatementを渡す。\r
 239                                         continue;\r
 240                                 }\r
 241                                 CalledMethod method = statementMap.get(cst);\r
 242                                 Statement st = (Statement)method.invoke(con);           // Statementを再生成\r
 243                                 cst.reupdateStatement(st);\r
 244                         }\r
 245 \r
 246                         // エラーの通知元にはstatementListに無くてもStatementを渡す。\r
 247                         CalledMethod method = statementMap.get(src);\r
 248                         Statement st = (Statement)method.invoke(con);           // Statementを再生成\r
 249                         src.reupdateStatement(st);\r
 250 \r
 251                 }catch (SQLException e) {\r
 252                         throw e;\r
 253                 }catch (Exception e) {\r
 254                         // それ以外のエラーが出た場合はSQLExceptionとしてスローする。\r
 255                         throw new SQLException(e.getMessage());\r
 256                 }\r
 257 \r
 258         }\r
 259 \r
 260         /**\r
 261          * 接続先切替。\r
 262          * ClusterPreparedStatementから呼ばれる。\r
 263          * ClusterPrStatementのインスタンスは消滅せずに、内部で持っている\r
 264          * Statementへの参照を切り替えるだけなので、ネイティブなStatementを返す。\r
 265          */\r
 266 //      public PreparedStatement getAnotherPreparedStatement(PreparedStatement pst) throws SQLException{\r
 267 //              // 既存のconを破棄してみる。\r
 268 //              try{ con.close(); }catch (SQLException e) {}\r
 269 //\r
 270 //              con = pool.getAnotherConnection(this);\r
 271 //\r
 272 //              // 前にPreparedStatementを作ったときの引数を取得。\r
 273 //              Object[] objs = (Object[])prepareMap.get(pst);\r
 274 //              Class<?>[] cls = null;\r
 275 //              if(objs!=null){         // objsがnull(=引数無し)の時はclsもnullで良い。prepareStatementではあり得ないはず。\r
 276 //                      cls = new Class[objs.length];\r
 277 //                      for(int i=0; i<objs.length; i++){\r
 278 //                              cls[i] = objs[i].getClass();\r
 279 //                      }\r
 280 //              }\r
 281 //\r
 282 //              // 新しいPreparedStatementの取得。\r
 283 //              // 失敗したらSQLExceptionでスローする。\r
 284 //              PreparedStatement st = null;\r
 285 //              try{\r
 286 //                      Method method = con.getClass().getMethod("prepareStatement",cls);\r
 287 //                      st = (PreparedStatement)method.invoke(con, objs);\r
 288 //              }catch (Exception e) {\r
 289 //                      throw new  SQLException(MSG_ERR_RECREATE+e.getMessage());\r
 290 //              }\r
 291 //              return st;\r
 292 //      }\r
 293 //\r
 294         /**\r
 295          * @see java.sql.Connection#createStatement()\r
 296          */\r
 297         public Statement createStatement() throws SQLException {\r
 298                 CalledMethod method = new CalledMethod("createStatement", null, null);\r
 299 \r
 300                 Statement st = (Statement)clusterCall(method);\r
 301                 ClusterStatement cst = new ClusterStatement(this, st);\r
 302                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 303                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 304                         statementMap.put(cst, method);\r
 305                 }\r
 306                 return cst;\r
 307         }\r
 308 \r
 309         /**\r
 310          * @see java.sql.Connection#createStatement(int, int)\r
 311          */\r
 312         public Statement createStatement(\r
 313                 int resultSetType,\r
 314                 int resultSetConcurrency)\r
 315                 throws SQLException {\r
 316                 Object[] args = new Object[]{\r
 317                         new Integer(resultSetType),\r
 318                         new Integer(resultSetConcurrency)\r
 319                 };\r
 320                 Class<?>[] types = new Class<?>[]{\r
 321                         Integer.TYPE,\r
 322                         Integer.TYPE\r
 323                 };\r
 324                 CalledMethod method = new CalledMethod("createStatement", args, types);\r
 325 \r
 326                 Statement st = (Statement)clusterCall(method);\r
 327                 ClusterStatement cst = new ClusterStatement(this, st);\r
 328                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 329                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 330                         statementMap.put(cst, method);\r
 331                 }\r
 332                 return cst;\r
 333         }\r
 334 \r
 335         /**\r
 336          * Holdability指定付きStatement生成。\r
 337          * ただしOracleは無条件で例外をスローする。\r
 338          * @see java.sql.Connection#createStatement(int, int, int)\r
 339          */\r
 340         public Statement createStatement(\r
 341                 int resultSetType,\r
 342                 int resultSetConcurrency,\r
 343                 int resultSetHoldability)\r
 344                 throws SQLException {\r
 345                 Object[] args = new Object[]{\r
 346                         new Integer(resultSetType),\r
 347                         new Integer(resultSetConcurrency),\r
 348                         new Integer(resultSetHoldability)\r
 349                 };\r
 350                 Class<?>[] types = new Class<?>[]{\r
 351                         Integer.TYPE,\r
 352                         Integer.TYPE,\r
 353                         Integer.TYPE\r
 354                 };\r
 355                 CalledMethod method = new CalledMethod("createStatement", args, types);\r
 356 \r
 357                 Statement st = (Statement)clusterCall(method);\r
 358                 ClusterStatement cst = new ClusterStatement(this, st);\r
 359                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 360                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 361                         statementMap.put(cst, method);\r
 362                 }\r
 363                 return cst;\r
 364         }\r
 365 \r
 366         /**\r
 367          * @see java.sql.Connection#prepareCall(java.lang.String)\r
 368          */\r
 369         public CallableStatement prepareCall(String sql) throws SQLException {\r
 370                 ClusterCallableStatement cst = new ClusterCallableStatement(this, con.prepareCall(sql));\r
 371                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 372                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 373                 }\r
 374                 return cst;\r
 375         }\r
 376 \r
 377         /**\r
 378          * @see java.sql.Connection#prepareCall(java.lang.String, int, int)\r
 379          */\r
 380         public CallableStatement prepareCall(\r
 381                 String sql,\r
 382                 int resultSetType,\r
 383                 int resultSetConcurrency)\r
 384                 throws SQLException {\r
 385                 ClusterCallableStatement cst = new ClusterCallableStatement(this, con.prepareCall(sql,resultSetType,resultSetConcurrency));\r
 386                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 387                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 388                 }\r
 389                 return cst;\r
 390         }\r
 391 \r
 392         /**\r
 393          * @see java.sql.Connection#prepareCall(java.lang.String, int, int, int)\r
 394          */\r
 395         public CallableStatement prepareCall(\r
 396                 String sql,\r
 397                 int resultSetType,\r
 398                 int resultSetConcurrency,\r
 399                 int resultSetHoldability)\r
 400                 throws SQLException {\r
 401                 ClusterCallableStatement cst = new ClusterCallableStatement(this, con.prepareCall(sql,resultSetType,resultSetConcurrency,resultSetHoldability));\r
 402                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 403                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 404                 }\r
 405                 return cst;\r
 406         }\r
 407 \r
 408         /**\r
 409          * @see java.sql.Connection#prepareStatement(java.lang.String)\r
 410          */\r
 411         public PreparedStatement prepareStatement(String sql) throws SQLException {\r
 412                 Object[] args = new Object[]{\r
 413                         sql\r
 414                 };\r
 415                 Class<?>[] types = new Class<?>[]{\r
 416                         String.class\r
 417                 };\r
 418                 CalledMethod method = new CalledMethod("prepareStatement", args, types);\r
 419 \r
 420                 PreparedStatement st = (PreparedStatement)clusterCall(method);\r
 421                 ClusterPreparedStatement cst = new ClusterPreparedStatement(this, st);\r
 422                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 423                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 424                         statementMap.put(cst, method);\r
 425                 }\r
 426                 return cst;\r
 427         }\r
 428 \r
 429         /**\r
 430          * @see java.sql.Connection#prepareStatement(java.lang.String, int)\r
 431          */\r
 432         public PreparedStatement prepareStatement(\r
 433                 String sql,\r
 434                 int autoGeneratedKeys)\r
 435                 throws SQLException {\r
 436                 Object[] args = new Object[]{\r
 437                         sql,\r
 438                         new Integer(autoGeneratedKeys)\r
 439                 };\r
 440                 Class<?>[] types = new Class<?>[]{\r
 441                         String.class,\r
 442                         Integer.TYPE\r
 443                 };\r
 444                 CalledMethod method = new CalledMethod("prepareStatement", args, types);\r
 445 \r
 446                 PreparedStatement st = (PreparedStatement)clusterCall(method);\r
 447                 ClusterPreparedStatement cst = new ClusterPreparedStatement(this, st);\r
 448                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 449                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 450                         statementMap.put(cst, method);\r
 451                 }\r
 452                 return cst;\r
 453         }\r
 454 \r
 455         /**\r
 456          * @see java.sql.Connection#prepareStatement(java.lang.String, int, int)\r
 457          */\r
 458         public PreparedStatement prepareStatement(\r
 459                 String sql,\r
 460                 int resultSetType,\r
 461                 int resultSetConcurrency)\r
 462                 throws SQLException {\r
 463                 Object[] args = new Object[]{\r
 464                         sql,\r
 465                         new Integer(resultSetType),\r
 466                         new Integer(resultSetConcurrency)\r
 467                 };\r
 468                 Class<?>[] types = new Class<?>[]{\r
 469                         String.class,\r
 470                         Integer.TYPE,\r
 471                         Integer.TYPE\r
 472                 };\r
 473                 CalledMethod method = new CalledMethod("prepareStatement", args, types);\r
 474 \r
 475                 PreparedStatement st = (PreparedStatement)clusterCall(method);\r
 476                 ClusterPreparedStatement cst = new ClusterPreparedStatement(this, st);\r
 477                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 478                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 479                         statementMap.put(cst, method);\r
 480                 }\r
 481                 return cst;\r
 482         }\r
 483 \r
 484         /**\r
 485          * @see java.sql.Connection#prepareStatement(java.lang.String, int, int, int)\r
 486          */\r
 487         public PreparedStatement prepareStatement(\r
 488                 String sql,\r
 489                 int resultSetType,\r
 490                 int resultSetConcurrency,\r
 491                 int resultSetHoldability)\r
 492                 throws SQLException {\r
 493                 Object[] args = new Object[]{\r
 494                         sql,\r
 495                         new Integer(resultSetType),\r
 496                         new Integer(resultSetConcurrency),\r
 497                         new Integer(resultSetHoldability)\r
 498                 };\r
 499                 Class<?>[] types = new Class<?>[]{\r
 500                         String.class,\r
 501                         Integer.TYPE,\r
 502                         Integer.TYPE,\r
 503                         Integer.TYPE\r
 504                 };\r
 505                 CalledMethod method = new CalledMethod("prepareStatement", args, types);\r
 506 \r
 507                 PreparedStatement st = (PreparedStatement)clusterCall(method);\r
 508                 ClusterPreparedStatement cst = new ClusterPreparedStatement(this, st);\r
 509                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 510                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 511                         statementMap.put(cst, method);\r
 512                 }\r
 513                 return cst;\r
 514         }\r
 515 \r
 516         /**\r
 517          * @see java.sql.Connection#prepareStatement(java.lang.String, int[])\r
 518          */\r
 519         public PreparedStatement prepareStatement(String sql, int[] columnIndexes)\r
 520                 throws SQLException {\r
 521                 Object[] args = new Object[]{sql, columnIndexes};\r
 522                 Class<?>[] types = new Class<?>[]{\r
 523                                 String.class,\r
 524                                 int[].class\r
 525                 };\r
 526                 CalledMethod method = new CalledMethod("prepareStatement", args, types);\r
 527 \r
 528                 PreparedStatement st = (PreparedStatement)clusterCall(method);\r
 529                 ClusterPreparedStatement cst = new ClusterPreparedStatement(this, st);\r
 530                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 531                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 532                         statementMap.put(cst, method);\r
 533                 }\r
 534                 return cst;\r
 535         }\r
 536 \r
 537         /**\r
 538          * @see java.sql.Connection#prepareStatement(java.lang.String, java.lang.String[])\r
 539          */\r
 540         public PreparedStatement prepareStatement(String sql, String[] columnNames)\r
 541                 throws SQLException {\r
 542                 Object[] args = new Object[]{sql,columnNames};\r
 543                 Class<?>[] types = new Class<?>[]{\r
 544                         String.class,\r
 545                         String[].class\r
 546                 };\r
 547                 CalledMethod method = new CalledMethod("prepareStatement", args, types);\r
 548 \r
 549                 PreparedStatement st = (PreparedStatement)clusterCall(method);\r
 550                 ClusterPreparedStatement cst = new ClusterPreparedStatement(this, st);\r
 551                 if(!getAutoCommit()){                           // 自動コミットじゃない場合だけ\r
 552                         statementList.add(cst);         // 再実行に備えてとっておく。\r
 553                         statementMap.put(cst, method);\r
 554                 }\r
 555                 return cst;\r
 556         }\r
 557 \r
 558         /* (非 Javadoc)\r
 559          * @see java.sql.Connection#getHoldability()\r
 560          */\r
 561         public int getHoldability() throws SQLException {\r
 562                 return holdability;\r
 563 //              return ((Integer)clusterCall("getHoldability", null, null)).intValue();\r
 564         }\r
 565 \r
 566         /* (非 Javadoc)\r
 567          * @see java.sql.Connection#getTransactionIsolation()\r
 568          */\r
 569         public int getTransactionIsolation() throws SQLException {\r
 570                 return transactionIsolation;\r
 571 //              return ((Integer)clusterCall("getTransactionIsolation", null, null)).intValue();\r
 572         }\r
 573 \r
 574         /* (非 Javadoc)\r
 575          * @see java.sql.Connection#clearWarnings()\r
 576          */\r
 577         public void clearWarnings() throws SQLException {\r
 578                 clusterCall("clearWarnings", null, null);\r
 579         }\r
 580 \r
 581         /* (非 Javadoc)\r
 582          * @see java.sql.Connection#close()\r
 583          */\r
 584         public void close() throws SQLException {\r
 585                 clusterCall("close", null, null);\r
 586                 // コネクションを閉じてしまったので以前のメソッドは再実行する必要なし。\r
 587                 statementList.clear();\r
 588                 statementMap.clear();\r
 589         }\r
 590 \r
 591         /* (非 Javadoc)\r
 592          * @see java.sql.Connection#commit()\r
 593          */\r
 594         public void commit() throws SQLException {\r
 595                 clusterCall("commit", null, null);\r
 596                 // 過去の更新処理は再実行する必要なし。\r
 597                 statementList.clear();\r
 598                 statementMap.clear();\r
 599 \r
 600         }\r
 601 \r
 602         /* (非 Javadoc)\r
 603          * @see java.sql.Connection#rollback()\r
 604          */\r
 605         public void rollback() throws SQLException {\r
 606                 clusterCall("rollback", null, null);\r
 607                 // 過去の更新処理は再実行する必要なし。\r
 608                 statementList.clear();\r
 609                 statementMap.clear();\r
 610 \r
 611         }\r
 612 \r
 613         /* (非 Javadoc)\r
 614          * @see java.sql.Connection#getAutoCommit()\r
 615          */\r
 616         public boolean getAutoCommit() throws SQLException {\r
 617                 return isAutoCommit;\r
 618 //              return ((Boolean)clusterCall("getAutoCommit", null, null)).booleanValue();\r
 619         }\r
 620 \r
 621         /* (非 Javadoc)\r
 622          * @see java.sql.Connection#isClosed()\r
 623          */\r
 624         public boolean isClosed() throws SQLException {\r
 625                 return ((Boolean)clusterCall("isClosed", null, null)).booleanValue();\r
 626         }\r
 627 \r
 628         /* (非 Javadoc)\r
 629          * @see java.sql.Connection#isReadOnly()\r
 630          */\r
 631         public boolean isReadOnly() throws SQLException {\r
 632                 return isReadOnly;\r
 633 //              return ((Boolean)clusterCall("isReadOnly", null, null)).booleanValue();\r
 634         }\r
 635 \r
 636         /* (非 Javadoc)\r
 637          * @see java.sql.Connection#setHoldability(int)\r
 638          */\r
 639         public void setHoldability(int holdability) throws SQLException {\r
 640                 clusterCall("setHoldability", new Object[]{new Integer(holdability)},\r
 641                                 new Class<?>[]{Integer.TYPE});\r
 642                 this.holdability = holdability;\r
 643         }\r
 644 \r
 645         /* (非 Javadoc)\r
 646          * @see java.sql.Connection#setTransactionIsolation(int)\r
 647          */\r
 648         public void setTransactionIsolation(int level) throws SQLException {\r
 649                 clusterCall("setTransactionIsolation", new Object[]{new Integer(level)},\r
 650                                 new Class<?>[]{Integer.TYPE});\r
 651                 transactionIsolation = level;\r
 652 \r
 653         }\r
 654 \r
 655         /* (非 Javadoc)\r
 656          * @see java.sql.Connection#setAutoCommit(boolean)\r
 657          */\r
 658         public void setAutoCommit(boolean autoCommit) throws SQLException {\r
 659                 clusterCall("setAutoCommit", new Object[]{new Boolean(autoCommit)},\r
 660                                 new Class<?>[]{Boolean.TYPE});\r
 661                 isAutoCommit = autoCommit;\r
 662 \r
 663                 // この時点でコミットが行われるので、過去の更新処理はクリアする。\r
 664                 statementList.clear();\r
 665                 statementMap.clear();\r
 666         }\r
 667 \r
 668         /* (非 Javadoc)\r
 669          * @see java.sql.Connection#setReadOnly(boolean)\r
 670          */\r
 671         public void setReadOnly(boolean readOnly) throws SQLException {\r
 672                 clusterCall("setReadOnly", new Object[]{new Boolean(readOnly)},\r
 673                                 new Class<?>[]{Boolean.TYPE});\r
 674                 isReadOnly = readOnly;\r
 675         }\r
 676 \r
 677         /* (非 Javadoc)\r
 678          * @see java.sql.Connection#getCatalog()\r
 679          */\r
 680         public String getCatalog() throws SQLException {\r
 681                 return catalog;\r
 682 //              return (String)clusterCall("getCatalog", null, null);\r
 683 \r
 684         }\r
 685 \r
 686         /* (非 Javadoc)\r
 687          * @see java.sql.Connection#setCatalog(java.lang.String)\r
 688          */\r
 689         public void setCatalog(String setCatalog) throws SQLException {\r
 690                 clusterCall("setCatalog", new Object[]{setCatalog},\r
 691                                 new Class<?>[]{String.class});\r
 692                 this.catalog = setCatalog;\r
 693         }\r
 694 \r
 695         /**\r
 696          * Oracle10gののojdbc14に合わせてsynchronizedにする。\r
 697          * @see java.sql.Connection#getMetaData()\r
 698          */\r
 699         public synchronized DatabaseMetaData getMetaData() throws SQLException {\r
 700                 return (DatabaseMetaData)clusterCall("getMetaData", null, null);\r
 701         }\r
 702 \r
 703         /* (非 Javadoc)\r
 704          * @see java.sql.Connection#getWarnings()\r
 705          */\r
 706         public SQLWarning getWarnings() throws SQLException {\r
 707                 return (SQLWarning)clusterCall("getWarnings", null, null);\r
 708         }\r
 709 \r
 710         /**\r
 711          * 名前無しセーブポイントの作成。\r
 712          * クラスタ接続ではセーブポイントの管理は行わない。\r
 713         /* (非 Javadoc)\r
 714          * @see java.sql.Connection#setSavepoint()\r
 715          */\r
 716         public Savepoint setSavepoint() throws SQLException {\r
 717                 throw new UnsupportedOperationException();\r
 718                 // con.setSavepoint();\r
 719         }\r
 720 \r
 721         /**\r
 722          * セーブポイント破棄。\r
 723          * クラスタ接続ではセーブポイントの管理は行わない。\r
 724          * @see java.sql.Connection#releaseSavepoint(java.sql.Savepoint)\r
 725          */\r
 726         public void releaseSavepoint(Savepoint savepoint) throws SQLException {\r
 727                 throw new UnsupportedOperationException();\r
 728                 //con.releaseSavepoint(savepoint);\r
 729         }\r
 730 \r
 731         /**\r
 732          * 指定のセーブポイントまでのロールバック。\r
 733          * クラスタ接続ではセーブポイントの管理は行わない。\r
 734          * @see java.sql.Connection#rollback(java.sql.Savepoint)\r
 735          */\r
 736         public void rollback(Savepoint savepoint) throws SQLException {\r
 737                 throw new UnsupportedOperationException();\r
 738                 //con.rollback(savepoint);\r
 739         }\r
 740 \r
 741 \r
 742         /* (非 Javadoc)\r
 743          * @see java.sql.Connection#getTypeMap()\r
 744          */\r
 745         public Map<String, Class<?>> getTypeMap() throws SQLException {\r
 746                 return typeMap;\r
 747 //              return (Map)clusterCall("getTypeMap", null, null);\r
 748         }\r
 749 \r
 750         /* (非 Javadoc)\r
 751          * @see java.sql.Connection#setTypeMap(java.util.Map)\r
 752          */\r
 753         public void setTypeMap(Map<String, Class<?>> map) throws SQLException {\r
 754                 clusterCall("setTypeMap", new Object[]{map},\r
 755                                 new Class<?>[]{Map.class});\r
 756                 this.typeMap = map;\r
 757         }\r
 758 \r
 759         /* (非 Javadoc)\r
 760          * @see java.sql.Connection#nativeSQL(java.lang.String)\r
 761          */\r
 762         public String nativeSQL(String sql) throws SQLException {\r
 763                 return (String)clusterCall("nativeSQL", new Object[]{sql},\r
 764                                 new Class<?>[]{String.class});\r
 765         }\r
 766 \r
 767         /**\r
 768          * 名前無しセーブポイントの作成。\r
 769          * クラスタ接続ではセーブポイントの管理は行わない。\r
 770          * @see java.sql.Connection#setSavepoint(java.lang.String)\r
 771          */\r
 772         public Savepoint setSavepoint(String name) throws SQLException {\r
 773                 throw new UnsupportedOperationException();\r
 774                 // return con.setSavepoint(name);\r
 775         }\r
 776 \r
 777         // ---\r
 778         // 以下未実装\r
 779         // ---\r
 780 \r
 781         public Array createArrayOf(String arg0, Object[] arg1) throws SQLException {\r
 782                 // TODO 自動生成されたメソッド・スタブ\r
 783                 return null;\r
 784         }\r
 785 \r
 786         public Blob createBlob() throws SQLException {\r
 787                 // TODO 自動生成されたメソッド・スタブ\r
 788                 return null;\r
 789         }\r
 790 \r
 791         public Clob createClob() throws SQLException {\r
 792                 // TODO 自動生成されたメソッド・スタブ\r
 793                 return null;\r
 794         }\r
 795 \r
 796         public NClob createNClob() throws SQLException {\r
 797                 // TODO 自動生成されたメソッド・スタブ\r
 798                 return null;\r
 799         }\r
 800 \r
 801         public SQLXML createSQLXML() throws SQLException {\r
 802                 // TODO 自動生成されたメソッド・スタブ\r
 803                 return null;\r
 804         }\r
 805 \r
 806         public Struct createStruct(String arg0, Object[] arg1) throws SQLException {\r
 807                 // TODO 自動生成されたメソッド・スタブ\r
 808                 return null;\r
 809         }\r
 810 \r
 811         public Properties getClientInfo() throws SQLException {\r
 812                 // TODO 自動生成されたメソッド・スタブ\r
 813                 return null;\r
 814         }\r
 815 \r
 816         public String getClientInfo(String arg0) throws SQLException {\r
 817                 // TODO 自動生成されたメソッド・スタブ\r
 818                 return null;\r
 819         }\r
 820 \r
 821         public boolean isValid(int arg0) throws SQLException {\r
 822                 // TODO 自動生成されたメソッド・スタブ\r
 823                 return false;\r
 824         }\r
 825 \r
 826         public void setClientInfo(Properties arg0) throws SQLClientInfoException {\r
 827                 // TODO 自動生成されたメソッド・スタブ\r
 828 \r
 829         }\r
 830 \r
 831         public void setClientInfo(String arg0, String arg1)\r
 832                         throws SQLClientInfoException {\r
 833                 // TODO 自動生成されたメソッド・スタブ\r
 834 \r
 835         }\r
 836 \r
 837         public boolean isWrapperFor(Class<?> iface) throws SQLException {\r
 838                 // TODO 自動生成されたメソッド・スタブ\r
 839                 return false;\r
 840         }\r
 841 \r
 842         public <T> T unwrap(Class<T> iface) throws SQLException {\r
 843                 // TODO 自動生成されたメソッド・スタブ\r
 844                 return null;\r
 845         }\r
 846 }\r