    001/*
    002 * Copyright (c) 2009 The openGion Project.
    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,
    013 * either express or implied. See the License for the specific language
    014 * governing permissions and limitations under the License.
    015 */
    016package org.opengion.hayabusa.taglib;
    017
    018import org.opengion.fukurou.db.ConnectionFactory;
    019import org.opengion.hayabusa.common.HybsSystem;
    020import org.opengion.hayabusa.common.HybsSystemException;
    021import static org.opengion.fukurou.util.StringUtil.nval ;
    022
    023import java.util.ArrayList;
    024import java.util.Locale ;
    025
    026import java.sql.ResultSetMetaData ;
    027import java.sql.DatabaseMetaData ;
    028import java.sql.Connection;
    029import java.sql.ResultSet;
    030import java.sql.SQLException;
    031import java.sql.Types;
    032
    033/**
    034 * DatabaseMetaData の情報を検索するタグです。
    035 *
    036 * データベースに関する包括的な情報を提供する、DatabaseMetaData の内容を
    037 * 表示する、タグです。テスト的に使用します。
    038 *
    039 * @og.formSample
    040 * ●形式：
    041 *  &lt;og:databaseMetaData
    042 *      dbid            = &quot;{&#064;DBID}&quot;
    043 *      catalog         = &quot;{&#064;catalog}&quot;
    044 *      schema          = &quot;{&#064;schema}&quot;
    045 *      tableName       = &quot;{&#064;tableName}&quot;
    046 *      columnName      = &quot;{&#064;columnName}&quot;
    047 *      typeName        = &quot;{&#064;typeName}&quot;
    048 *      attributeName   = &quot;{&#064;attriName}&quot;
    049 *      procedureName   = &quot;{&#064;procName}&quot;
    050 *      maxRowCount     = &quot;{&#064;maxRowCount}&quot;
    051 *      likeKey         = &quot;{&#064;likeKey}&quot;
    052 *  /&gt;
    053 *
    054 * ●body：なし
    055 *
    056 * ●Tag定義：
    057 *   &lt;og:databaseMetaData
    058 *       dbid               【TAG】(通常は使いません)Queryオブジェクトを作成する時のDB接続IDを指定します
    059 *       catalog            【TAG】(通常は使いません)Queryオブジェクトを作成する時のカタログを指定します
    060 *       schema             【TAG】(通常は使いません)Queryオブジェクトを作成する時のスキーマを指定します
    061 *       attributeName      【TAG】(通常は使いません)Queryオブジェクトを作成する時の属性名を指定します
    062 *       columnName         【TAG】(通常は使いません)Queryオブジェクトを作成する時のカラム名を指定します
    063 *       procedureName      【TAG】(通常は使いません)Queryオブジェクトを作成する時のプロダクト名を指定します
    064 *       tableName          【TAG】(通常は使いません)Queryオブジェクトを作成する時のテーブル名を指定します
    065 *       typeName           【TAG】(通常は使いません)Queryオブジェクトを作成する時のタイプ名を指定します
    066 *       maxRowCount        【TAG】maxRowCount ResultSetで検索するパラメータの最大検索件数を指定します(初期値:20)
    067 *       likeKey            【TAG】実行するメソッドを選別するための部分一致するキーを指定します
    068 *       debug              【TAG】デバッグ情報を出力するかどうか[true/false]を指定します(初期値:false)
    069 *   /&gt;
    070 *
    071 * ●使用例
    072 *       &lt;og:databaseMetaData /&gt;
    073 *
    074 * @og.group ＤＢ検索
    075 *
    076 * @version  0.9.0      2000/10/17
    077 * @author       Kazuhiko Hasegawa
    078 * @since    JDK5.0,
    079 */
    080public class DatabaseMetaDataTag extends CommonTagSupport {
    081        //* このプログラムのVERSION文字列を設定します。   {@value} */
    082        private static final String VERSION = "5.5.8.5 (2012/11/27)" ;
    083
    084        private static final long serialVersionUID = 558520121127L ;
    085
    086        // 4.0.0.0 (2007/10/10) dbid の初期値を、"DEFAULT" から null に変更
    087//      private String  dbid                    = "DEFAULT";
    088        private String  dbid                    = null ;
    089        private String  catalog                 = null ;
    090        private String  schema                  = null ;
    091        private String  tableName               = null ;
    092        private String  columnName              = null ;
    093        private String  typeName                = null ;
    094        private String  attributeName   = null ;
    095        private String  procedureName   = null ;
    096        private int             rowNo                   = 0;
    097        private int             maxRowCount             = 20;           // 5.5.3.2 (2012/06/08) 最大検索件数を、指定できるようにする。
    098        private String  likeKey                 = null ;        // 5.5.3.2 (2012/06/08) 特定の処理だけを実行できるように、あいまい検索
    099
    100        /**
    101         * Taglibの終了タグが見つかったときに処理する doEndTag() を オーバーライドします。
    102         *
    103         * @og.rev 3.8.7.0 (2006/12/15) アクセスログ取得の為,ApplicationInfoオブジェクトを設定
    104         * @og.rev 4.0.0.1 (2007/12/03) try 〜 catch 〜 finally をきちんと行う。
    105         *
    106         * @return      後続処理の指示(EVAL_PAGE)
    107         */
    108        @Override
    109        public int doEndTag() {
    110                debugPrint();           // 4.0.0 (2005/02/28)
    111                Connection conn = null;
    112                boolean errFlag = true;
    113                try {
    114                        conn = ConnectionFactory.connection( dbid,getApplicationInfo() );       // 3.8.7.0 (2006/12/15)
    115                        DatabaseMetaData metaData = conn.getMetaData() ;
    116
    117                        callPrintMessage( metaData );
    118                        errFlag = false;                // エラーではない
    119                }
    120                catch (Throwable ex) {
    121                        String errMsg = "データベース処理を実行できませんでした。"
    122                                                + ex.getMessage()  + HybsSystem.CR ;
    123//                      errMsg = errMsg + HybsSystem.CR ;
    124//                      errMsg = errMsg + ex.getMessage() ;
    125
    126//                      ConnectionFactory.remove( conn,dbid );
    127//                      conn = null;
    128                        throw new HybsSystemException( errMsg,ex );             // 3.5.5.4 (2004/04/15) 引数の並び順変更
    129                }
    130                finally {
    131                        // 以下のコーディングの見直しを考える必要有り。
    132                        // Connection はプールしている為、close() しても再利用されるだけ。
    133//                      ConnectionFactory.close( conn,dbid );
    134                        if( errFlag ) { ConnectionFactory.remove( conn,dbid ); }        // 削除
    135                        else {                  ConnectionFactory.close( conn,dbid );  }        // 返却
    136//                      conn = null;
    137                }
    138
    139                jspPrint( "処理が完了しました。" + HybsSystem.CR );               // 5.5.3.2 (2012/06/08) 終了メッセージ追加
    140                return(EVAL_PAGE);
    141        }
    142
    143        /**
    144         * タグリブオブジェクトをリリースします。
    145         * キャッシュされて再利用されるので、フィールドの初期設定を行います。
    146         *
    147         * @og.rev 4.0.0.0 (2007/10/10) dbid の初期値を、"DEFAULT" から null に変更
    148         * @og.rev 5.5.3.2 (2012/06/08) maxRowCount 最大検索件数を、指定できるようにする。
    149         * @og.rev 5.5.3.2 (2012/06/08) likeKey 特定の処理だけを実行できるように、あいまい検索
    150         */
    151        @Override
    152        protected void release2() {
    153                super.release2();
    154//              dbid                    = "DEFAULT";
    155                dbid                    = null ;
    156                catalog                 = null ;
    157                schema                  = null ;
    158                tableName               = null ;
    159                columnName              = null ;
    160                typeName                = null ;
    161                procedureName   = null ;
    162                attributeName   = null ;
    163                rowNo                   = 0;
    164                maxRowCount             = 20;           // 5.5.3.2 (2012/06/08) 最大検索件数を、指定できるようにする。
    165                likeKey                 = null;         // 5.5.3.2 (2012/06/08) 特定の処理だけを実行できるように、あいまい検索
    166        }
    167
    168        /**
    169         * 画面にテーブルタグの(TR)として、情報を出力します。
    170         *
    171         * 第一引数が、boolean の場合のオーバーロードメソッドです。
    172         *
    173         * @param       in      第一引数(boolean)
    174         * @param       lbl     ラベル
    175         * @param       msg     メッセージ
    176         */
    177        private void printMessage( final boolean in, final String lbl, final String msg ) {
    178                String str = "<tr class=\"row_" + (rowNo++ % 2) + "\"><td>"
    179                                 + rowNo + "</td><td>"                      // 5.5.3.2 (2012/06/08) 行番号を表示
    180                                 + lbl + "</td><td>" + in + "</td><td>" + msg + "</td></tr>" + HybsSystem.CR ;
    181                jspPrint( str );
    182        }
    183
    184        /**
    185         * 画面にテーブルタグの(TR)として、情報を出力します。
    186         *
    187         * 第一引数が、int の場合のオーバーロードメソッドです。
    188         *
    189         * @param       in      第一引数(int)
    190         * @param       lbl     ラベル
    191         * @param       msg     メッセージ
    192         */
    193        private void printMessage( final int in, final String lbl, final String msg ) {
    194                String str = "<tr class=\"row_" + (rowNo++ % 2) + "\"><td>"
    195                                 + rowNo + "</td><td>"                      // 5.5.3.2 (2012/06/08) 行番号を表示
    196                                 + lbl + "</td><td>" + in + "</td><td>" + msg + "</td></tr>" + HybsSystem.CR ;
    197                jspPrint( str );
    198        }
    199
    200        /**
    201         * 画面にテーブルタグの(TR)として、情報を出力します。
    202         *
    203         * 第一引数が、String の場合のオーバーロードメソッドです。
    204         *
    205         * @param       in      第一引数(String)
    206         * @param       lbl     ラベル
    207         * @param       msg     メッセージ
    208         */
    209        private void printMessage( final String in, final String lbl, final String msg ) {
    210                String str = "<tr class=\"row_" + (rowNo++ % 2) + "\"><td>"
    211                                 + rowNo + "</td><td>"                      // 5.5.3.2 (2012/06/08) 行番号を表示
    212                                 + lbl + "</td><td>" + in + "</td><td>" + msg + "</td></tr>" + HybsSystem.CR ;
    213                jspPrint( str );
    214        }
    215
    216        /**
    217         * 画面にテーブルとして、情報を出力します。
    218         *
    219         * 第一引数が、ResultSet の場合のオーバーロードメソッドです。
    220         *
    221         * @param       resultSet       ResultSetオブジェクト
    222         * @param       msg                     メッセージ
    223         */
    224        private void printMessage( final ResultSet resultSet, final String msg ) {
    225//              jspPrint( msg + HybsSystem.BR );
    226                jspPrint( makeTableTag( resultToString( resultSet ) ) );
    227        }
    228
    229        /**
    230         * 画面にテーブルとして、情報を出力します。
    231         *
    232         * 第一引数が、存在しない場合のオーバーロードメソッドです。
    233         *
    234         * @param       lbl     ラベル
    235         * @param       msg     メッセージ
    236         */
    237        private void printMessage( final String lbl, final String msg ) {
    238//              jspPrint( msg + HybsSystem.BR );
    239                String str = "<table><tr><td>" + lbl + "</td></tr></table>" + HybsSystem.CR ;
    240                jspPrint( str );
    241        }
    242
    243        /**
    244         * 指定の文字列配列をテーブル上に表示する為の、テーブルを作成します。
    245         *
    246         * @og.rev 5.5.3.2 (2012/06/08) 行番号を表示するように修正
    247         *
    248         * @param       data    文字列配列
    249         *
    250         * @return      文字列配列を表示する為のHTMLテーブル書式
    251         */
    252        private String makeTableTag( final String[][] data ) {
    253                if( data == null || data.length == 0 ) { return "" ; }
    254
    255                StringBuilder buf = new StringBuilder( HybsSystem.BUFFER_LARGE );
    256                buf.append( "<table>" ).append( HybsSystem.CR );
    257
    258                int maxRow = data.length ;
    259                int maxClm = data[0].length ;
    260
    261                buf.append( "<tr class=\"row_h\">" );
    262                buf.append( "<th>No</th>" );                                        // 5.5.3.2 (2012/06/08) 行番号を表示
    263                for( int clm=0; clm<maxClm; clm++ ) {
    264                        buf.append( "<th>" ).append( data[0][clm] ).append( "</th>" );
    265                }
    266                buf.append( "</tr>" ).append( HybsSystem.CR );
    267                for( int row=1; row<maxRow; row++ ) {
    268                        buf.append( "<tr class=\"row_" ).append( (row-1) % 2 ).append( "\">" );
    269                        buf.append( "<td>" ).append( row ).append( "</td>" );                       // 5.5.3.2 (2012/06/08) 行番号を表示
    270                        for( int clm=0; clm<maxClm; clm++ ) {
    271                                buf.append( "<td>" ).append( data[row][clm] ).append( "</td>" );
    272                        }
    273                        buf.append( "</tr>" ).append( HybsSystem.CR );
    274                }
    275                buf.append( "</table>" ).append( HybsSystem.CR );
    276
    277                return buf.toString();
    278        }
    279
    280        /**
    281         * ステートメントと引数により、Queryを実行します。
    282         * これは、Prepared クエリーの検索のみ実行します。
    283         * 結果は,すべて文字列に変換されて格納されます。
    284         *
    285         * @og.rev 5.5.3.2 (2012/06/08) 最大検索件数を、指定できるようにする。
    286         *
    287         * @param   resultSet ResultSetオブジェクト
    288         *
    289         * @return  ResultSetの検索結果配列
    290         */
    291        private String[][] resultToString( final ResultSet resultSet ) {
    292                ArrayList<String[]> data = new ArrayList<String[]>();
    293                try {
    294                        ResultSetMetaData metaData  = resultSet.getMetaData();
    295                        int numberOfColumns =  metaData.getColumnCount();
    296
    297                        String[] columnNames = new String[numberOfColumns];
    298                        for(int column = 0; column < numberOfColumns; column++) {
    299                                columnNames[column]      = (metaData.getColumnLabel(column+1)).toUpperCase(Locale.JAPAN) ;
    300                        }
    301                        data.add( columnNames );
    302
    303                        // とりあえず MAX １０件とする。
    304                        int maxcnt = 0 ;
    305                        // 5.5.3.2 (2012/06/08) 最大検索件数を、指定できるようにする。
    306                        while( resultSet.next() && ( maxcnt++ < maxRowCount ) ) {
    307                                String[] columnValues = new String[numberOfColumns];
    308                                for(int i = 1; i <= numberOfColumns; i++) {
    309                                        Object obj = resultSet.getObject(i);
    310                                        if( obj == null ) {
    311                                                columnValues[i-1] = "";
    312                                        }
    313                                        else {
    314                                                columnValues[i-1] = String.valueOf( obj );
    315                                        }
    316                                }
    317                                data.add( columnValues );
    318                        }
    319                }
    320                catch (SQLException ex) {
    321                        String errMsg = "処理結果を実行できませんでした。"
    322                                                + ex.getMessage();              // 5.1.8.0 (2010/07/01) errMsg 修正
    323                        throw new HybsSystemException( errMsg,ex );             // 3.5.5.4 (2004/04/15) 引数の並び順変更
    324                }
    325
    326                int size = data.size();
    327                String[][] rtn = new String[size][];
    328                for( int i=0; i<size; i++ ) {
    329                        rtn[i] = data.get(i);
    330                }
    331
    332                return rtn;
    333        }
    334
    335        /**
    336         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のDB接続IDを指定します。
    337         *
    338         * @og.tag Queryオブジェクトを作成する時のDB接続IDを指定します。
    339         *
    340         * @param       id データベース接続ID
    341         */
    342        public void setDbid( final String id ) {
    343                dbid = nval( getRequestParameter( id ),dbid );
    344        }
    345
    346        /**
    347         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のカタログを指定します。
    348         *
    349         * @og.tag Queryオブジェクトを作成する時のカタログを指定します。
    350         *
    351         * @param       val     カタログ情報
    352         */
    353        public void setCatalog( final String val ) {
    354                catalog = nval( getRequestParameter( val ),catalog );
    355        }
    356
    357        /**
    358         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のスキーマを指定します。
    359         *
    360         * @og.tag Queryオブジェクトを作成する時のスキーマを指定します。
    361         *
    362         * @param       val     スキーマ情報
    363         */
    364        public void setSchema( final String val ) {
    365                schema = nval( getRequestParameter( val ),schema );
    366        }
    367
    368        /**
    369         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のテーブル名を指定します。
    370         *
    371         * @og.tag Queryオブジェクトを作成する時のテーブル名を指定します。
    372         *
    373         * @param       val     テーブル名情報
    374         */
    375        public void setTableName( final String val ) {
    376                tableName = nval( getRequestParameter( val ),tableName );
    377        }
    378
    379        /**
    380         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のカラム名を指定します。
    381         *
    382         * @og.tag Queryオブジェクトを作成する時のカラム名を指定します。
    383         *
    384         * @param       val     カラム名情報
    385         */
    386        public void setColumnName( final String val ) {
    387                columnName = nval( getRequestParameter( val ),columnName );
    388        }
    389
    390        /**
    391         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のタイプ名を指定します。
    392         *
    393         * @og.tag Queryオブジェクトを作成する時のタイプ名を指定します。
    394         *
    395         * @param       val     タイプ名情報
    396         */
    397        public void setTypeName( final String val ) {
    398                typeName = nval( getRequestParameter( val ),typeName );
    399        }
    400
    401        /**
    402         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時のプロダクト名を指定します。
    403         *
    404         * @og.tag Queryオブジェクトを作成する時のプロダクト名を指定します。
    405         *
    406         * @param       val     プロダクト名情報
    407         */
    408        public void setProcedureName( final String val ) {
    409                procedureName = nval( getRequestParameter( val ),procedureName );
    410        }
    411
    412        /**
    413         * 【TAG】(通常は使いません)Queryオブジェクトを作成する時の属性名を指定します。
    414         *
    415         * @og.tag Queryオブジェクトを作成する時の属性名を指定します。
    416         *
    417         * @param       val     属性名情報
    418         */
    419        public void setAttributeName( final String val ) {
    420                attributeName = nval( getRequestParameter( val ),attributeName );
    421        }
    422
    423        /**
    424         * 【TAG】maxRowCount ResultSetで検索するパラメータの最大検索件数を指定します(初期値:20)。
    425         *
    426         * @og.tag
    427         * 大量に検索されて、処理速度が低下するのを避けるため、最大件数を指定します。
    428         * 他のタグの maxRowCount の初期値設定(初期値:DB_MAX_ROW_COUNT)は利用せず、独自に設定値を持っています。
    429         * 0は、無制限とします。
    430         *
    431         * @og.rev 5.5.3.2 (2012/06/08) likeKey 特定の処理だけを実行できるように、あいまい検索
    432         * @og.rev 5.5.8.5 (2012/11/27) 0を無制限として処理します。
    433         *
    434         * @param       maxSize ResultSetで検索する最大検索件数
    435         */
    436        public void setMaxRowCount( final String maxSize ) {
    437                maxRowCount = nval( getRequestParameter( maxSize ),maxRowCount );
    438                if( maxRowCount == 0 ) { maxRowCount = Integer.MAX_VALUE ; }                    // 5.5.8.5 (2012/11/27)
    439        }
    440
    441        /**
    442         * 【TAG】実行するメソッドを選別するための部分一致するキーを指定します。
    443         *
    444         * @og.tag
    445         * DatabaseMetaData で取得できる各種情報をアクセスするにあたり、指定のキーで部分一致する
    446         * メソッドだけ処理するように指定します。
    447         * メソッドの部分一致で判断します。
    448         * 処理は、大文字、小文字を認識したうえで、部分一致で判定します。
    449         *
    450         * @og.rev 5.5.3.2 (2012/06/08) likeKey 特定の処理だけを実行できるように、あいまい検索
    451         *
    452         * @param       key     実行するメソッドを選別するためのキー
    453         */
    454        public void setLikeKey( final String key ) {
    455                likeKey = nval( getRequestParameter( key ),likeKey );
    456        }
    457
    458        /**
    459         * DatabaseMetaData のフィールドで定義されている値に対応する メッセージを返します。
    460         *
    461         * @param       code short のコード番号
    462         */
    463//      private String dbMessage( final short code ) {
    464//              String msg = null ;
    465//              switch( code ) {
    466//                      case DatabaseMetaData.attributeNoNulls :
    467//                                      msg = "NULL 値が許可されない可能性があります。" ;
    468//                                      break ;
    469//                      case DatabaseMetaData.attributeNullable :
    470//                                      msg = "NULL 値が必ず許可されます。" ;
    471//                                      break ;
    472//                      case DatabaseMetaData.attributeNullableUnknown :
    473//                                      msg = "NULL 値が許可されるかどうかが不明です。" ;
    474//                                      break ;
    475//                      case DatabaseMetaData.tableIndexClustered :
    476//                                      msg = "このテーブルインデックスがクラスタ化されたインデックスです。" ;
    477//                                      break ;
    478//                      case DatabaseMetaData.tableIndexHashed :
    479//                                      msg = "このテーブルインデックスがハッシュ化されたインデックスです。" ;
    480//                                      break ;
    481//                      case DatabaseMetaData.tableIndexOther :
    482//                                      msg = "このテーブルインデックスがクラスタ化されたインデックスでも、ハッシュ化されたインデックスでも、テーブルの統計情報でもありません。" ;
    483//                                      break ;
    484//                      case DatabaseMetaData.tableIndexStatistic :
    485//                                      msg = "この列がテーブルのインデックスの記述と連動して返されるテーブルの統計情報を格納します。" ;
    486//                                      break ;
    487//                      default :
    488//                                      msg = "対象のメッセージがありません。" ;
    489//                                      break ;
    490//              }
    491//
    492//              return msg ;
    493//      }
    494
    495        /**
    496         * DatabaseMetaData のフィールドで定義されている値に対応する メッセージを返します。
    497         *
    498         * @param       code short のコード番号
    499         */
    500//      private String dbMessage( final int code ) {
    501//              String msg = null ;
    502//              switch( code ) {
    503//                      case DatabaseMetaData.bestRowNotPseudo :
    504//                                      msg = "最適な行識別子が擬似列ではありません。" ;
    505//                                      break ;
    506//                      case DatabaseMetaData.bestRowPseudo :
    507//                                      msg = "最適な行識別子が擬似列です。" ;
    508//                                      break ;
    509//                      case DatabaseMetaData.bestRowSession :
    510//                                      msg = "最適な行識別子のスコープが現在のセッションの残りの部分です。" ;
    511//                                      break ;
    512//                      case DatabaseMetaData.bestRowTemporary :
    513//                                      msg = "最適な行識別子のスコープが一時的 (行が使用されている間だけ) です。" ;
    514//                                      break ;
    515//                      case DatabaseMetaData.bestRowTransaction :
    516//                                      msg = "最適な行識別子のスコープが現在のトランザクションの残りの部分です。" ;
    517//                                      break ;
    518//                      case DatabaseMetaData.bestRowUnknown :
    519//                                      msg = "最適な行識別子が擬似列である場合とそうでない場合があります。" ;
    520//                                      break ;
    521//                      case DatabaseMetaData.columnNoNulls :
    522//                                      msg = "列が NULL 値を許可しない場合があります。" ;
    523//                                      break ;
    524//                      case DatabaseMetaData.columnNullable :
    525//                                      msg = "列が必ず NULL 値を許可されます。" ;
    526//                                      break ;
    527//                      case DatabaseMetaData.columnNullableUnknown :
    528//                                      msg = "列が NULL 値を許可するかどうか不明です。" ;
    529//                                      break ;
    530//                      case DatabaseMetaData.importedKeyCascade :
    531//                                      msg = "列 UPDATE_RULE の場合は、主キーが更新されるときに、外部キー (インポートされたキー) がそれに合致するように変更されます。" ;
    532//                                      break ;
    533//                      case DatabaseMetaData.importedKeyInitiallyDeferred :
    534//                                      msg = "遅延可能性を示します。" ;
    535//                                      break ;
    536//                      case DatabaseMetaData.importedKeyInitiallyImmediate :
    537//                                      msg = "遅延可能性を示します。" ;
    538//                                      break ;
    539//                      case DatabaseMetaData.importedKeyNoAction :
    540//                                      msg = "列 UPDATE_RULE および DELETE_RULE の場合は、主キーがインポートされている場合、それが更新および削除ができません。" ;
    541//                                      break ;
    542//                      case DatabaseMetaData.importedKeyNotDeferrable :
    543//                                      msg = "遅延可能性を示します。" ;
    544//                                      break ;
    545//                      case DatabaseMetaData.importedKeyRestrict :
    546//                                      msg = "列 UPDATE_RULE の場合は、別のテーブルによって外部キーとしてインポートされている場合に、主キーは更新できません。" ;
    547//                                      break ;
    548//                      case DatabaseMetaData.importedKeySetDefault :
    549//                                      msg = "列 UPDATE_RULE および DELETE_RULE の場合は、主キーが更新または削除された場合に、外部キー (インポートされたキー) がデフォルト値に変更されます。" ;
    550//                                      break ;
    551//                      case DatabaseMetaData.importedKeySetNull :
    552//                                      msg = "列 UPDATE_RULE および DELETE_RULE の場合、主キーが更新または削除されたときに、外部キー (インポートされたキー) が NULL に変更されます。" ;
    553//                                      break ;
    554//                      case DatabaseMetaData.procedureColumnIn :
    555//                                      msg = "列が IN パラメータを格納されます。" ;
    556//                                      break ;
    557//                      case DatabaseMetaData.procedureColumnInOut :
    558//                                      msg = "列が INOUT パラメータを格納されます。" ;
    559//                                      break ;
    560//                      case DatabaseMetaData.procedureColumnOut :
    561//                                      msg = "列が OUT パラメータを格納されます。" ;
    562//                                      break ;
    563//                      case DatabaseMetaData.procedureColumnResult :
    564//                                      msg = "列が結果を格納されます。" ;
    565//                                      break ;
    566//                      case DatabaseMetaData.procedureColumnReturn :
    567//                                      msg = "列が戻り値を格納されます。" ;
    568//                                      break ;
    569//                      case DatabaseMetaData.procedureColumnUnknown :
    570//                                      msg = "列の型が不明です。" ;
    571//                                      break ;
    572//                      case DatabaseMetaData.procedureNoNulls :
    573//                                      msg = "NULL 値が許可されません。" ;
    574//                                      break ;
    575//                      case DatabaseMetaData.procedureNoResult :
    576//                                      msg = "プロシージャが結果を返しません。" ;
    577//                                      break ;
    578//                      case DatabaseMetaData.procedureNullable :
    579//                                      msg = "NULL 値が許可されます。" ;
    580//                                      break ;
    581//                      case DatabaseMetaData.procedureNullableUnknown :
    582//                                      msg = "NULL 値が許可されるかどうかが不明です。" ;
    583//                                      break ;
    584//                      case DatabaseMetaData.procedureResultUnknown :
    585//                                      msg = "プロシージャが結果を返すかどうかが不明です。" ;
    586//                                      break ;
    587//                      case DatabaseMetaData.procedureReturnsResult :
    588//                                      msg = "プロシージャが結果を返すことを示します。" ;
    589//                                      break ;
    590//                      case DatabaseMetaData.sqlStateSQL99 :
    591//                                      msg = "値が SQL99 SQLSTATE 値です。" ;
    592//                                      break ;
    593//                      case DatabaseMetaData.sqlStateXOpen :
    594//                                      msg = "値が X/Open (現在は Open Group) の SQL CLI SQLSTATE 値です。" ;
    595//                                      break ;
    596//                      case DatabaseMetaData.typeNoNulls :
    597//                                      msg = "このデータの型で NULL 値が許可されません。" ;
    598//                                      break ;
    599//                      case DatabaseMetaData.typeNullable :
    600//                                      msg = "このデータの型で NULL 値が許可されます。" ;
    601//                                      break ;
    602//                      case DatabaseMetaData.typeNullableUnknown :
    603//                                      msg = "このデータの型で NULL 値が許可されるかどうかが不明です。" ;
    604//                                      break ;
    605//                      case DatabaseMetaData.typePredBasic :
    606//                                      msg = "WHERE . . .LIKE を除くすべての WHERE 検索の節がこのデータの型に基づくことができます。" ;
    607//                                      break ;
    608//                      case DatabaseMetaData.typePredChar :
    609//                                      msg = "この型に基づくことができる唯一の WHERE 検索の節が WHERE . . .LIKE です。" ;
    610//                                      break ;
    611//                      case DatabaseMetaData.typePredNone :
    612//                                      msg = "この型で WHERE 検索の節がサポートされていません。" ;
    613//                                      break ;
    614//                      case DatabaseMetaData.typeSearchable :
    615//                                      msg = "すべての WHERE 検索の節がこの型に基づくことができます。" ;
    616//                                      break ;
    617//                      case DatabaseMetaData.versionColumnNotPseudo :
    618//                                      msg = "このバージョンの列が擬似列でありません。" ;
    619//                                      break ;
    620//                      case DatabaseMetaData.versionColumnPseudo :
    621//                                      msg = "このバージョンの列が擬似列です。" ;
    622//                                      break ;
    623//                      case DatabaseMetaData.versionColumnUnknown :
    624//                                      msg = "このバージョンの列が擬似列である場合とそうでない場合があります。" ;
    625//                                      break ;
    626//                      default :
    627//                                      msg = "対象のメッセージがありません。" ;
    628//                                      break ;
    629//              }
    630//
    631//              return msg ;
    632//      }
    633
    634        /**
    635         * 各メソッド情報を画面に出力していきます。
    636         *
    637         * @og.rev 5.5.3.2 (2012/06/08) JDk1.6 用のメソッドを追加します。
    638         *
    639         * @param metaData DatabaseMetaDataオブジェクト
    640         * @throws Throwable 何らかのエラーが発生した場合。
    641         */
    642        private void callPrintMessage( final DatabaseMetaData metaData ) throws Throwable {
    643                // 単体のリターン値を持つ メタデータ
    644
    645//              int type = ResultSet.TYPE_FORWARD_ONLY ;
    646//              int concurrency = ResultSet.CONCUR_READ_ONLY;
    647//              int holdability = ResultSet.CLOSE_CURSORS_AT_COMMIT;
    648
    649                Integer type = ResultSet.TYPE_FORWARD_ONLY ;
    650                Integer concurrency = ResultSet.CONCUR_READ_ONLY;
    651                Integer holdability = ResultSet.CLOSE_CURSORS_AT_COMMIT;
    652
    653                jspPrint( "<table>" );
    654                jspPrint( "<tr class=\"row_h\"><th>No</th><th>キー</th><th>値</th><th>説明</th></tr>" );
    655
    656                // 5.5.3.2 (2012/06/08) 個別に呼び出す箇所を、リフレクションに変更。
    657                for( int i=0; i<METHOD_LIST.length; i++ ) {
    658                        MetaDataInvoke inv = METHOD_LIST[i];
    659                        if( inv.isUseMethod( likeKey ) && inv.getType() < 10 ) {
    660                                Object obj = null;
    661                                switch( inv.getType() ) {
    662                                        case 0: obj = inv.invokeA( metaData ); break;
    663                                        case 1: obj = inv.invokeA( metaData,type ); break;
    664                                        case 2: obj = inv.invokeA( metaData,type,concurrency ); break;
    665                                        case 3: obj = inv.invokeA( metaData,holdability ); break;
    666                                        case 4: obj = inv.invokeA( metaData ); break;
    667                                        default : jspPrint( "*** タイプ不明 ***" + HybsSystem.BR ); continue;
    668                                }
    669                                String msg = (obj == null) ? inv.getErrMsg() : String.valueOf( obj );
    670
    671                                String str = "<tr class=\"row_" + (rowNo++ % 2) + "\"><td>"
    672                                                + rowNo + "</td><td>"                       // 5.5.3.2 (2012/06/08) 行番号を表示
    673                                                + inv.getMethod() + "</td><td>" + msg + "</td><td>" + inv.getComment() + "</td></tr>" + HybsSystem.CR ;
    674                                jspPrint( str );
    675                        }
    676                }
    677
    678                // 5.5.3.2 (2012/06/08) 個別に呼び出す箇所を、リフレクションに変更。
    679//              for( int i=0; i<METHOD_LIST.length; i++ ) {
    680//                      String methodKey = METHOD_LIST[i][0];
    681//                      int    flag  = Integer.parseInt( METHOD_LIST[i][2] );                   // 0:通常 1:type 2:type, concurrency 3:holdability 4:ResultSet.TYPE_FORWARD_ONLY 5:Connection.TRANSACTION_READ_COMMITTED
    682//                      if( likeKey == null || methodKey.indexOf( likeKey ) >= 0 ) {
    683//                              try {
    684//                                      Object obj= null;
    685//                                      if( flag == 0 ) {
    686//                                              obj= metaData.getClass().getMethod( methodKey ).invoke(metaData);
    687//                                      }
    688//                                      else if( flag == 1 ) {
    689//                                              obj= metaData.getClass().getMethod( methodKey,int.class ).invoke(metaData,type);
    690//                                      }
    691//                                      else if( flag == 2 ) {
    692//                                              obj= metaData.getClass().getMethod( methodKey,int.class,int.class ).invoke(metaData,type,concurrency);
    693//                                      }
    694//                                      else if( flag == 3 ) {
    695//                                              obj= metaData.getClass().getMethod( methodKey,int.class ).invoke(metaData,holdability);
    696//                                      }
    697//                                      else if( flag == 4 ) {
    698//                                              obj= metaData.getClass().getMethod( methodKey,int.class ).invoke(metaData,Integer.valueOf(ResultSet.TYPE_FORWARD_ONLY));
    699//                                              // TYPE_SCROLL_INSENSITIVE , TYPE_SCROLL_SENSITIVE
    700//                                      }
    701//                                      else if( flag == 5 ) {
    702//                                              obj= metaData.getClass().getMethod( methodKey,int.class ).invoke(metaData,Integer.valueOf(Connection.TRANSACTION_READ_COMMITTED));
    703//                                              // TRANSACTION_READ_UNCOMMITTED , TRANSACTION_REPEATABLE_READ , TRANSACTION_SERIALIZABLE
    704//                                      }
    705//
    706//                                      String str = "<tr class=\"row_" + (rowNo++ % 2) + "\"><td>"
    707//                                                      + rowNo + "</td><td>"                       // 5.5.3.2 (2012/06/08) 行番号を表示
    708//                                                      + methodKey + "</td><td>" + obj + "</td><td>" + METHOD_LIST[i][1] + "</td></tr>" + HybsSystem.CR ;
    709//                                      jspPrint( str );
    710//                              }
    711//                              catch( Throwable ex ) {
    712//                                      String str = "<tr class=\"row_" + (rowNo++ % 2) + "\"><td>"
    713//                                                      + rowNo + "</td><td>"                       // 5.5.3.2 (2012/06/08) 行番号を表示
    714//                                                      + methodKey + "</td><td>" + "*** 実行時エラー ***" + "</td><td>" + METHOD_LIST[i][1] + "</td></tr>" + HybsSystem.CR ;
    715//                                      jspPrint( str );
    716//                              }
    717//                      }
    718//              }
    719
    720//              try { printMessage( metaData.getCatalogSeparator() ,"getCatalogSeparator",getCatalogSeparator); }
    721//                      catch( Throwable e ) { printMessage( e.getMessage(),"getCatalogSeparator",getCatalogSeparator); }
    722//              try { printMessage( metaData.getCatalogTerm() ,"getCatalogTerm",getCatalogTerm); }
    723//                      catch( Throwable e ) { printMessage( e.getMessage(),"getCatalogTerm",getCatalogTerm); }
    724//              try { printMessage( metaData.getDatabaseProductName() ,"getDatabaseProductName",getDatabaseProductName); }
    725//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDatabaseProductName",getDatabaseProductName); }
    726//              try { printMessage( metaData.getDatabaseProductVersion() ,"getDatabaseProductVersion",getDatabaseProductVersion); }
    727//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDatabaseProductVersion",getDatabaseProductVersion); }
    728//              try { printMessage( metaData.getDriverMajorVersion() ,"getDriverMajorVersion",getDriverMajorVersion); }
    729//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDriverMajorVersion",getDriverMajorVersion); }
    730//              try { printMessage( metaData.getDriverMinorVersion() ,"getDriverMinorVersion",getDriverMinorVersion); }
    731//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDriverMinorVersion",getDriverMinorVersion); }
    732//              try { printMessage( metaData.getDriverName() ,"getDriverName",getDriverName); }
    733//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDriverName",getDriverName); }
    734//              try { printMessage( metaData.getDriverVersion() ,"getDriverVersion",getDriverVersion); }
    735//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDriverVersion",getDriverVersion); }
    736//              try { printMessage( metaData.getExtraNameCharacters() ,"getExtraNameCharacters",getExtraNameCharacters); }
    737//                      catch( Throwable e ) { printMessage( e.getMessage(),"getExtraNameCharacters",getExtraNameCharacters); }
    738//              try { printMessage( metaData.getIdentifierQuoteString() ,"getIdentifierQuoteString",getIdentifierQuoteString); }
    739//                      catch( Throwable e ) { printMessage( e.getMessage(),"getIdentifierQuoteString",getIdentifierQuoteString); }
    740//              try { printMessage( metaData.getNumericFunctions() ,"getNumericFunctions",getNumericFunctions); }
    741//                      catch( Throwable e ) { printMessage( e.getMessage(),"getNumericFunctions",getNumericFunctions); }
    742//              try { printMessage( metaData.getProcedureTerm() ,"getProcedureTerm",getProcedureTerm); }
    743//                      catch( Throwable e ) { printMessage( e.getMessage(),"getProcedureTerm",getProcedureTerm); }
    744//              try { printMessage( metaData.getSchemaTerm() ,"getSchemaTerm",getSchemaTerm); }
    745//                      catch( Throwable e ) { printMessage( e.getMessage(),"getSchemaTerm",getSchemaTerm); }
    746//              try { printMessage( metaData.getSearchStringEscape() ,"getSearchStringEscape",getSearchStringEscape); }
    747//                      catch( Throwable e ) { printMessage( e.getMessage(),"getSearchStringEscape",getSearchStringEscape); }
    748//              try { printMessage( metaData.getSQLKeywords() ,"getSQLKeywords",getSQLKeywords); }
    749//                      catch( Throwable e ) { printMessage( e.getMessage(),"getSQLKeywords",getSQLKeywords); }
    750//              try { printMessage( metaData.getStringFunctions() ,"getStringFunctions",getStringFunctions); }
    751//                      catch( Throwable e ) { printMessage( e.getMessage(),"getStringFunctions",getStringFunctions); }
    752//              try { printMessage( metaData.getSystemFunctions() ,"getSystemFunctions",getSystemFunctions); }
    753//                      catch( Throwable e ) { printMessage( e.getMessage(),"getSystemFunctions",getSystemFunctions); }
    754                try { printMessage( metaData.getTimeDateFunctions() ,"getTimeDateFunctions",getTimeDateFunctions); }
    755                        catch( Throwable e ) { printMessage( e.getMessage(),"getTimeDateFunctions",getTimeDateFunctions); }
    756//              try { printMessage( metaData.getURL() ,"getURL",getURL); }
    757//                      catch( Throwable e ) { printMessage( e.getMessage(),"getURL",getURL); }
    758//              try { printMessage( metaData.getUserName() ,"getUserName",getUserName); }
    759//                      catch( Throwable e ) { printMessage( e.getMessage(),"getUserName",getUserName); }
    760//              try { printMessage( metaData.getDefaultTransactionIsolation() ,"getDefaultTransactionIsolation",getDefaultTransactionIsolation); }
    761//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDefaultTransactionIsolation",getDefaultTransactionIsolation); }
    762//              try { printMessage( metaData.getSQLStateType() ,"getSQLStateType",getSQLStateType); }
    763//                      catch( Throwable e ) { printMessage( e.getMessage(),"getSQLStateType",getSQLStateType); }
    764//              try { printMessage( metaData.getResultSetHoldability() ,"getResultSetHoldability",getResultSetHoldability); }
    765//                      catch( Throwable e ) { printMessage( e.getMessage(),"getResultSetHoldability",getResultSetHoldability); }
    766//              try { printMessage( metaData.allProceduresAreCallable() ,"allProceduresAreCallable",allProceduresAreCallable); }
    767//                      catch( Throwable e ) { printMessage( e.getMessage(),"allProceduresAreCallable",allProceduresAreCallable); }
    768//              try { printMessage( metaData.allTablesAreSelectable() ,"allTablesAreSelectable",allTablesAreSelectable); }
    769//                      catch( Throwable e ) { printMessage( e.getMessage(),"allTablesAreSelectable",allTablesAreSelectable); }
    770//              try { printMessage( metaData.dataDefinitionCausesTransactionCommit() ,"dataDefinitionCausesTransactionCommit",dataDefinitionCausesTransactionCommit); }
    771//                      catch( Throwable e ) { printMessage( e.getMessage(),"dataDefinitionCausesTransactionCommit",dataDefinitionCausesTransactionCommit); }
    772//              try { printMessage( metaData.dataDefinitionIgnoredInTransactions() ,"dataDefinitionIgnoredInTransactions",dataDefinitionIgnoredInTransactions); }
    773//                      catch( Throwable e ) { printMessage( e.getMessage(),"dataDefinitionIgnoredInTransactions",dataDefinitionIgnoredInTransactions); }
    774//              try { printMessage( metaData.deletesAreDetected(type) ,"deletesAreDetected",deletesAreDetected); }
    775//                      catch( Throwable e ) { printMessage( e.getMessage(),"deletesAreDetected",deletesAreDetected); }
    776//              try { printMessage( metaData.doesMaxRowSizeIncludeBlobs() ,"doesMaxRowSizeIncludeBlobs",doesMaxRowSizeIncludeBlobs); }
    777//                      catch( Throwable e ) { printMessage( e.getMessage(),"doesMaxRowSizeIncludeBlobs",doesMaxRowSizeIncludeBlobs); }
    778//              try { printMessage( metaData.insertsAreDetected(type) ,"insertsAreDetected",insertsAreDetected); }
    779//                      catch( Throwable e ) { printMessage( e.getMessage(),"insertsAreDetected",insertsAreDetected); }
    780//              try { printMessage( metaData.isCatalogAtStart() ,"isCatalogAtStart",isCatalogAtStart); }
    781//                      catch( Throwable e ) { printMessage( e.getMessage(),"isCatalogAtStart",isCatalogAtStart); }
    782//              try { printMessage( metaData.isReadOnly() ,"isReadOnly",isReadOnly); }
    783//                      catch( Throwable e ) { printMessage( e.getMessage(),"isReadOnly",isReadOnly); }
    784//              try { printMessage( metaData.locatorsUpdateCopy() ,"locatorsUpdateCopy",locatorsUpdateCopy); }
    785//                      catch( Throwable e ) { printMessage( e.getMessage(),"locatorsUpdateCopy",locatorsUpdateCopy); }
    786//              try { printMessage( metaData.nullPlusNonNullIsNull() ,"nullPlusNonNullIsNull",nullPlusNonNullIsNull); }
    787//                      catch( Throwable e ) { printMessage( e.getMessage(),"nullPlusNonNullIsNull",nullPlusNonNullIsNull); }
    788//              try { printMessage( metaData.nullsAreSortedAtEnd() ,"nullsAreSortedAtEnd",nullsAreSortedAtEnd); }
    789//                      catch( Throwable e ) { printMessage( e.getMessage(),"nullsAreSortedAtEnd",nullsAreSortedAtEnd); }
    790//              try { printMessage( metaData.nullsAreSortedAtStart() ,"nullsAreSortedAtStart",nullsAreSortedAtStart); }
    791//                      catch( Throwable e ) { printMessage( e.getMessage(),"nullsAreSortedAtStart",nullsAreSortedAtStart); }
    792//              try { printMessage( metaData.nullsAreSortedHigh() ,"nullsAreSortedHigh",nullsAreSortedHigh); }
    793//                      catch( Throwable e ) { printMessage( e.getMessage(),"nullsAreSortedHigh",nullsAreSortedHigh); }
    794//              try { printMessage( metaData.nullsAreSortedLow() ,"nullsAreSortedLow",nullsAreSortedLow); }
    795//                      catch( Throwable e ) { printMessage( e.getMessage(),"nullsAreSortedLow",nullsAreSortedLow); }
    796//              try { printMessage( metaData.othersDeletesAreVisible(type) ,"othersDeletesAreVisible",othersDeletesAreVisible); }
    797//                      catch( Throwable e ) { printMessage( e.getMessage(),"othersDeletesAreVisible",othersDeletesAreVisible); }
    798//              try { printMessage( metaData.othersInsertsAreVisible(type) ,"othersInsertsAreVisible",othersInsertsAreVisible); }
    799//                      catch( Throwable e ) { printMessage( e.getMessage(),"othersInsertsAreVisible",othersInsertsAreVisible); }
    800//              try { printMessage( metaData.othersUpdatesAreVisible(type) ,"othersUpdatesAreVisible",othersUpdatesAreVisible); }
    801//                      catch( Throwable e ) { printMessage( e.getMessage(),"othersUpdatesAreVisible",othersUpdatesAreVisible); }
    802//              try { printMessage( metaData.ownDeletesAreVisible(type) ,"ownDeletesAreVisible",ownDeletesAreVisible); }
    803//                      catch( Throwable e ) { printMessage( e.getMessage(),"ownDeletesAreVisible",ownDeletesAreVisible); }
    804//              try { printMessage( metaData.ownInsertsAreVisible(type) ,"ownInsertsAreVisible",ownInsertsAreVisible); }
    805//                      catch( Throwable e ) { printMessage( e.getMessage(),"ownInsertsAreVisible",ownInsertsAreVisible); }
    806//              try { printMessage( metaData.ownUpdatesAreVisible(type) ,"ownUpdatesAreVisible",ownUpdatesAreVisible); }
    807//                      catch( Throwable e ) { printMessage( e.getMessage(),"ownUpdatesAreVisible",ownUpdatesAreVisible); }
    808//              try { printMessage( metaData.storesLowerCaseIdentifiers() ,"storesLowerCaseIdentifiers",storesLowerCaseIdentifiers); }
    809//                      catch( Throwable e ) { printMessage( e.getMessage(),"storesLowerCaseIdentifiers",storesLowerCaseIdentifiers); }
    810//              try { printMessage( metaData.storesLowerCaseQuotedIdentifiers() ,"storesLowerCaseQuotedIdentifiers",storesLowerCaseQuotedIdentifiers); }
    811//                      catch( Throwable e ) { printMessage( e.getMessage(),"storesLowerCaseQuotedIdentifiers",storesLowerCaseQuotedIdentifiers); }
    812//              try { printMessage( metaData.storesMixedCaseIdentifiers() ,"storesMixedCaseIdentifiers",storesMixedCaseIdentifiers); }
    813//                      catch( Throwable e ) { printMessage( e.getMessage(),"storesMixedCaseIdentifiers",storesMixedCaseIdentifiers); }
    814//              try { printMessage( metaData.storesMixedCaseQuotedIdentifiers() ,"storesMixedCaseQuotedIdentifiers",storesMixedCaseQuotedIdentifiers); }
    815//                      catch( Throwable e ) { printMessage( e.getMessage(),"storesMixedCaseQuotedIdentifiers",storesMixedCaseQuotedIdentifiers); }
    816//              try { printMessage( metaData.storesUpperCaseIdentifiers() ,"storesUpperCaseIdentifiers",storesUpperCaseIdentifiers); }
    817//                      catch( Throwable e ) { printMessage( e.getMessage(),"storesUpperCaseIdentifiers",storesUpperCaseIdentifiers); }
    818//              try { printMessage( metaData.storesUpperCaseQuotedIdentifiers() ,"storesUpperCaseQuotedIdentifiers",storesUpperCaseQuotedIdentifiers); }
    819//                      catch( Throwable e ) { printMessage( e.getMessage(),"storesUpperCaseQuotedIdentifiers",storesUpperCaseQuotedIdentifiers); }
    820//              try { printMessage( metaData.supportsAlterTableWithAddColumn() ,"supportsAlterTableWithAddColumn",supportsAlterTableWithAddColumn); }
    821//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsAlterTableWithAddColumn",supportsAlterTableWithAddColumn); }
    822//              try { printMessage( metaData.supportsAlterTableWithDropColumn() ,"supportsAlterTableWithDropColumn",supportsAlterTableWithDropColumn); }
    823//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsAlterTableWithDropColumn",supportsAlterTableWithDropColumn); }
    824//              try { printMessage( metaData.supportsANSI92EntryLevelSQL() ,"supportsANSI92EntryLevelSQL",supportsANSI92EntryLevelSQL); }
    825//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsANSI92EntryLevelSQL",supportsANSI92EntryLevelSQL); }
    826//              try { printMessage( metaData.supportsANSI92FullSQL() ,"supportsANSI92FullSQL",supportsANSI92FullSQL); }
    827//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsANSI92FullSQL",supportsANSI92FullSQL); }
    828//              try { printMessage( metaData.supportsANSI92IntermediateSQL() ,"supportsANSI92IntermediateSQL",supportsANSI92IntermediateSQL); }
    829//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsANSI92IntermediateSQL",supportsANSI92IntermediateSQL); }
    830//              try { printMessage( metaData.supportsBatchUpdates() ,"supportsBatchUpdates",supportsBatchUpdates); }
    831//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsBatchUpdates",supportsBatchUpdates); }
    832//              try { printMessage( metaData.supportsCatalogsInDataManipulation() ,"supportsCatalogsInDataManipulation",supportsCatalogsInDataManipulation); }
    833//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCatalogsInDataManipulation",supportsCatalogsInDataManipulation); }
    834//              try { printMessage( metaData.supportsCatalogsInIndexDefinitions() ,"supportsCatalogsInIndexDefinitions",supportsCatalogsInIndexDefinitions); }
    835//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCatalogsInIndexDefinitions",supportsCatalogsInIndexDefinitions); }
    836//              try { printMessage( metaData.supportsCatalogsInPrivilegeDefinitions() ,"supportsCatalogsInPrivilegeDefinitions",supportsCatalogsInPrivilegeDefinitions); }
    837//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCatalogsInPrivilegeDefinitions",supportsCatalogsInPrivilegeDefinitions); }
    838//              try { printMessage( metaData.supportsCatalogsInProcedureCalls() ,"supportsCatalogsInProcedureCalls",supportsCatalogsInProcedureCalls); }
    839//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCatalogsInProcedureCalls",supportsCatalogsInProcedureCalls); }
    840//              try { printMessage( metaData.supportsCatalogsInTableDefinitions() ,"supportsCatalogsInTableDefinitions",supportsCatalogsInTableDefinitions); }
    841//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCatalogsInTableDefinitions",supportsCatalogsInTableDefinitions); }
    842//              try { printMessage( metaData.supportsColumnAliasing() ,"supportsColumnAliasing",supportsColumnAliasing); }
    843//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsColumnAliasing",supportsColumnAliasing); }
    844//              try { printMessage( metaData.supportsConvert() ,"supportsConvert",supportsConvertFunc); }
    845//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsConvert",supportsConvertFunc); }
    846//              try { printMessage( metaData.supportsCoreSQLGrammar() ,"supportsCoreSQLGrammar",supportsCoreSQLGrammar); }
    847//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCoreSQLGrammar",supportsCoreSQLGrammar); }
    848//              try { printMessage( metaData.supportsCorrelatedSubqueries() ,"supportsCorrelatedSubqueries",supportsCorrelatedSubqueries); }
    849//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsCorrelatedSubqueries",supportsCorrelatedSubqueries); }
    850//              try { printMessage( metaData.supportsDataDefinitionAndDataManipulationTransactions() ,"supportsDataDefinitionAndDataManipulationTransactions",supportsDataDefinitionAndDataManipulationTransactions); }
    851//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsDataDefinitionAndDataManipulationTransactions",supportsDataDefinitionAndDataManipulationTransactions); }
    852//              try { printMessage( metaData.supportsDataManipulationTransactionsOnly() ,"supportsDataManipulationTransactionsOnly",supportsDataManipulationTransactionsOnly); }
    853//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsDataManipulationTransactionsOnly",supportsDataManipulationTransactionsOnly); }
    854//              try { printMessage( metaData.supportsDifferentTableCorrelationNames() ,"supportsDifferentTableCorrelationNames",supportsDifferentTableCorrelationNames); }
    855//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsDifferentTableCorrelationNames",supportsDifferentTableCorrelationNames); }
    856//              try { printMessage( metaData.supportsExpressionsInOrderBy() ,"supportsExpressionsInOrderBy",supportsExpressionsInOrderBy); }
    857//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsExpressionsInOrderBy",supportsExpressionsInOrderBy); }
    858//              try { printMessage( metaData.supportsExtendedSQLGrammar() ,"supportsExtendedSQLGrammar",supportsExtendedSQLGrammar); }
    859//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsExtendedSQLGrammar",supportsExtendedSQLGrammar); }
    860//              try { printMessage( metaData.supportsFullOuterJoins() ,"supportsFullOuterJoins",supportsFullOuterJoins); }
    861//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsFullOuterJoins",supportsFullOuterJoins); }
    862//              try { printMessage( metaData.supportsGetGeneratedKeys() ,"supportsGetGeneratedKeys",supportsGetGeneratedKeys); }
    863//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsGetGeneratedKeys",supportsGetGeneratedKeys); }
    864//              try { printMessage( metaData.supportsGroupBy() ,"supportsGroupBy",supportsGroupBy); }
    865//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsGroupBy",supportsGroupBy); }
    866//              try { printMessage( metaData.supportsGroupByBeyondSelect() ,"supportsGroupByBeyondSelect",supportsGroupByBeyondSelect); }
    867//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsGroupByBeyondSelect",supportsGroupByBeyondSelect); }
    868//              try { printMessage( metaData.supportsGroupByUnrelated() ,"supportsGroupByUnrelated",supportsGroupByUnrelated); }
    869//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsGroupByUnrelated",supportsGroupByUnrelated); }
    870//              try { printMessage( metaData.supportsIntegrityEnhancementFacility() ,"supportsIntegrityEnhancementFacility",supportsIntegrityEnhancementFacility); }
    871//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsIntegrityEnhancementFacility",supportsIntegrityEnhancementFacility); }
    872//              try { printMessage( metaData.supportsLikeEscapeClause() ,"supportsLikeEscapeClause",supportsLikeEscapeClause); }
    873//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsLikeEscapeClause",supportsLikeEscapeClause); }
    874//              try { printMessage( metaData.supportsLimitedOuterJoins() ,"supportsLimitedOuterJoins",supportsLimitedOuterJoins); }
    875//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsLimitedOuterJoins",supportsLimitedOuterJoins); }
    876//              try { printMessage( metaData.supportsMinimumSQLGrammar() ,"supportsMinimumSQLGrammar",supportsMinimumSQLGrammar); }
    877//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsMinimumSQLGrammar",supportsMinimumSQLGrammar); }
    878//              try { printMessage( metaData.supportsMixedCaseIdentifiers() ,"supportsMixedCaseIdentifiers",supportsMixedCaseIdentifiers); }
    879//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsMixedCaseIdentifiers",supportsMixedCaseIdentifiers); }
    880//              try { printMessage( metaData.supportsMixedCaseQuotedIdentifiers() ,"supportsMixedCaseQuotedIdentifiers",supportsMixedCaseQuotedIdentifiers); }
    881//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsMixedCaseQuotedIdentifiers",supportsMixedCaseQuotedIdentifiers); }
    882//              try { printMessage( metaData.supportsMultipleOpenResults() ,"supportsMultipleOpenResults",supportsMultipleOpenResults); }
    883//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsMultipleOpenResults",supportsMultipleOpenResults); }
    884//              try { printMessage( metaData.supportsMultipleResultSets() ,"supportsMultipleResultSets",supportsMultipleResultSets); }
    885//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsMultipleResultSets",supportsMultipleResultSets); }
    886//              try { printMessage( metaData.supportsMultipleTransactions() ,"supportsMultipleTransactions",supportsMultipleTransactions); }
    887//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsMultipleTransactions",supportsMultipleTransactions); }
    888//              try { printMessage( metaData.supportsNamedParameters() ,"supportsNamedParameters",supportsNamedParameters); }
    889//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsNamedParameters",supportsNamedParameters); }
    890//              try { printMessage( metaData.supportsNonNullableColumns() ,"supportsNonNullableColumns",supportsNonNullableColumns); }
    891//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsNonNullableColumns",supportsNonNullableColumns); }
    892//              try { printMessage( metaData.supportsOpenCursorsAcrossCommit() ,"supportsOpenCursorsAcrossCommit",supportsOpenCursorsAcrossCommit); }
    893//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsOpenCursorsAcrossCommit",supportsOpenCursorsAcrossCommit); }
    894//              try { printMessage( metaData.supportsOpenCursorsAcrossRollback() ,"supportsOpenCursorsAcrossRollback",supportsOpenCursorsAcrossRollback); }
    895//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsOpenCursorsAcrossRollback",supportsOpenCursorsAcrossRollback); }
    896//              try { printMessage( metaData.supportsOpenStatementsAcrossCommit() ,"supportsOpenStatementsAcrossCommit",supportsOpenStatementsAcrossCommit); }
    897//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsOpenStatementsAcrossCommit",supportsOpenStatementsAcrossCommit); }
    898//              try { printMessage( metaData.supportsOpenStatementsAcrossRollback() ,"supportsOpenStatementsAcrossRollback",supportsOpenStatementsAcrossRollback); }
    899//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsOpenStatementsAcrossRollback",supportsOpenStatementsAcrossRollback); }
    900//              try { printMessage( metaData.supportsOrderByUnrelated() ,"supportsOrderByUnrelated",supportsOrderByUnrelated); }
    901//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsOrderByUnrelated",supportsOrderByUnrelated); }
    902//              try { printMessage( metaData.supportsOuterJoins() ,"supportsOuterJoins",supportsOuterJoins); }
    903//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsOuterJoins",supportsOuterJoins); }
    904//              try { printMessage( metaData.supportsPositionedDelete() ,"supportsPositionedDelete",supportsPositionedDelete); }
    905//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsPositionedDelete",supportsPositionedDelete); }
    906//              try { printMessage( metaData.supportsPositionedUpdate() ,"supportsPositionedUpdate",supportsPositionedUpdate); }
    907//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsPositionedUpdate",supportsPositionedUpdate); }
    908//              try { printMessage( metaData.supportsResultSetConcurrency(type, concurrency) ,"supportsResultSetConcurrency",supportsResultSetConcurrency); }
    909//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsResultSetConcurrency",supportsResultSetConcurrency); }
    910//              try { printMessage( metaData.supportsResultSetHoldability(holdability) ,"supportsResultSetHoldability",supportsResultSetHoldability); }
    911//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsResultSetHoldability",supportsResultSetHoldability); }
    912//              try { printMessage( metaData.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY) ,"supportsResultSetType[TYPE_FORWARD_ONLY]",supportsResultSetType); }
    913//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsResultSetType",supportsResultSetType); }
    914//              try { printMessage( metaData.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE) ,"supportsResultSetType[TYPE_SCROLL_INSENSITIVE]", supportsResultSetType); }
    915//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsResultSetType",supportsResultSetType); }
    916//              try { printMessage( metaData.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE) ,"supportsResultSetType[TYPE_SCROLL_SENSITIVE]", supportsResultSetType); }
    917//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsResultSetType",supportsResultSetType); }
    918//              try { printMessage( metaData.supportsSavepoints() ,"supportsSavepoints",supportsSavepoints); }
    919//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSavepoints",supportsSavepoints); }
    920//              try { printMessage( metaData.supportsSchemasInDataManipulation() ,"supportsSchemasInDataManipulation",supportsSchemasInDataManipulation); }
    921//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSchemasInDataManipulation",supportsSchemasInDataManipulation); }
    922//              try { printMessage( metaData.supportsSchemasInIndexDefinitions() ,"supportsSchemasInIndexDefinitions",supportsSchemasInIndexDefinitions); }
    923//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSchemasInIndexDefinitions",supportsSchemasInIndexDefinitions); }
    924//              try { printMessage( metaData.supportsSchemasInPrivilegeDefinitions() ,"supportsSchemasInPrivilegeDefinitions",supportsSchemasInPrivilegeDefinitions); }
    925//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSchemasInPrivilegeDefinitions",supportsSchemasInPrivilegeDefinitions); }
    926//              try { printMessage( metaData.supportsSchemasInProcedureCalls() ,"supportsSchemasInProcedureCalls",supportsSchemasInProcedureCalls); }
    927//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSchemasInProcedureCalls",supportsSchemasInProcedureCalls); }
    928//              try { printMessage( metaData.supportsSchemasInTableDefinitions() ,"supportsSchemasInTableDefinitions",supportsSchemasInTableDefinitions); }
    929//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSchemasInTableDefinitions",supportsSchemasInTableDefinitions); }
    930//              try { printMessage( metaData.supportsSelectForUpdate() ,"supportsSelectForUpdate",supportsSelectForUpdate); }
    931//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSelectForUpdate",supportsSelectForUpdate); }
    932//              try { printMessage( metaData.supportsStatementPooling() ,"supportsStatementPooling",supportsStatementPooling); }
    933//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsStatementPooling",supportsStatementPooling); }
    934//              try { printMessage( metaData.supportsStoredProcedures() ,"supportsStoredProcedures",supportsStoredProcedures); }
    935//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsStoredProcedures",supportsStoredProcedures); }
    936//              try { printMessage( metaData.supportsSubqueriesInComparisons() ,"supportsSubqueriesInComparisons",supportsSubqueriesInComparisons); }
    937//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSubqueriesInComparisons",supportsSubqueriesInComparisons); }
    938//              try { printMessage( metaData.supportsSubqueriesInExists() ,"supportsSubqueriesInExists",supportsSubqueriesInExists); }
    939//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSubqueriesInExists",supportsSubqueriesInExists); }
    940//              try { printMessage( metaData.supportsSubqueriesInIns() ,"supportsSubqueriesInIns",supportsSubqueriesInIns); }
    941//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSubqueriesInIns",supportsSubqueriesInIns); }
    942//              try { printMessage( metaData.supportsSubqueriesInQuantifieds() ,"supportsSubqueriesInQuantifieds",supportsSubqueriesInQuantifieds); }
    943//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsSubqueriesInQuantifieds",supportsSubqueriesInQuantifieds); }
    944//              try { printMessage( metaData.supportsTableCorrelationNames() ,"supportsTableCorrelationNames",supportsTableCorrelationNames); }
    945//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsTableCorrelationNames",supportsTableCorrelationNames); }
    946//              try { printMessage( metaData.supportsTransactions() ,"supportsTransactions",supportsTransactions); }
    947//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsTransactions",supportsTransactions); }
    948//              try { printMessage( metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED) ,"supportsTransactionIsolationLevel[TRANSACTION_READ_COMMITTED]",supportsTransactionIsolationLevel); }
    949//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsTransactionIsolationLevel",supportsTransactionIsolationLevel); }
    950//              try { printMessage( metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED) ,"supportsTransactionIsolationLevel[TRANSACTION_READ_UNCOMMITTED]",supportsTransactionIsolationLevel); }
    951//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsTransactionIsolationLevel",supportsTransactionIsolationLevel); }
    952//              try { printMessage( metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ) ,"supportsTransactionIsolationLevel[TRANSACTION_REPEATABLE_READ]",supportsTransactionIsolationLevel); }
    953//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsTransactionIsolationLevel",supportsTransactionIsolationLevel); }
    954//              try { printMessage( metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE) ,"supportsTransactionIsolationLevel[TRANSACTION_SERIALIZABLE]",supportsTransactionIsolationLevel); }
    955//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsTransactionIsolationLevel",supportsTransactionIsolationLevel); }
    956//              try { printMessage( metaData.supportsUnion() ,"supportsUnion",supportsUnion); }
    957//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsUnion",supportsUnion); }
    958//              try { printMessage( metaData.supportsUnionAll() ,"supportsUnionAll",supportsUnionAll); }
    959//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsUnionAll",supportsUnionAll); }
    960//              try { printMessage( metaData.updatesAreDetected(type) ,"updatesAreDetected",updatesAreDetected); }
    961//                      catch( Throwable e ) { printMessage( e.getMessage(),"updatesAreDetected",updatesAreDetected); }
    962//              try { printMessage( metaData.usesLocalFilePerTable() ,"usesLocalFilePerTable",usesLocalFilePerTable); }
    963//                      catch( Throwable e ) { printMessage( e.getMessage(),"usesLocalFilePerTable",usesLocalFilePerTable); }
    964//              try { printMessage( metaData.usesLocalFiles() ,"usesLocalFiles",usesLocalFiles); }
    965//                      catch( Throwable e ) { printMessage( e.getMessage(),"usesLocalFiles",usesLocalFiles); }
    966//
    967//              // 5.5.3.2 (2012/06/08) JDk1.6 用のメソッドを追加します。
    968//              try { printMessage( metaData.autoCommitFailureClosesAllResultSets() ,"autoCommitFailureClosesAllResultSets",autoCommitFailureClosesAllResultSets); }
    969//                      catch( Throwable e ) { printMessage( e.getMessage(),"autoCommitFailureClosesAllResultSets",autoCommitFailureClosesAllResultSets); }
    970//              try { printMessage( metaData.getDatabaseMajorVersion() ,"getDatabaseMajorVersion",getDatabaseMajorVersion); }
    971//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDatabaseMajorVersion",getDatabaseMajorVersion); }
    972//              try { printMessage( metaData.getDatabaseMinorVersion() ,"getDatabaseMinorVersion",getDatabaseMinorVersion); }
    973//                      catch( Throwable e ) { printMessage( e.getMessage(),"getDatabaseMinorVersion",getDatabaseMinorVersion); }
    974//              try { printMessage( metaData.getJDBCMajorVersion() ,"getJDBCMajorVersion",getJDBCMajorVersion); }
    975//                      catch( Throwable e ) { printMessage( e.getMessage(),"getJDBCMajorVersion",getJDBCMajorVersion); }
    976//              try { printMessage( metaData.getJDBCMinorVersion() ,"getJDBCMinorVersion",getJDBCMinorVersion); }
    977//                      catch( Throwable e ) { printMessage( e.getMessage(),"getJDBCMinorVersion",getJDBCMinorVersion); }
    978//              try { printMessage( metaData.getMaxBinaryLiteralLength() ,"getMaxBinaryLiteralLength",getMaxBinaryLiteralLength); }
    979//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxBinaryLiteralLength",getMaxBinaryLiteralLength); }
    980//              try { printMessage( metaData.getMaxCatalogNameLength() ,"getMaxCatalogNameLength",getMaxCatalogNameLength); }
    981//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxCatalogNameLength",getMaxCatalogNameLength); }
    982//              try { printMessage( metaData.getMaxCharLiteralLength() ,"getMaxCharLiteralLength",getMaxCharLiteralLength); }
    983//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxCharLiteralLength",getMaxCharLiteralLength); }
    984//              try { printMessage( metaData.getMaxColumnNameLength() ,"getMaxColumnNameLength",getMaxColumnNameLength); }
    985//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxColumnNameLength",getMaxColumnNameLength); }
    986//              try { printMessage( metaData.getMaxColumnsInGroupBy() ,"getMaxColumnsInGroupBy",getMaxColumnsInGroupBy); }
    987//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxColumnsInGroupBy",getMaxColumnsInGroupBy); }
    988//              try { printMessage( metaData.getMaxColumnsInIndex() ,"getMaxColumnsInIndex",getMaxColumnsInIndex); }
    989//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxColumnsInIndex",getMaxColumnsInIndex); }
    990//              try { printMessage( metaData.getMaxColumnsInOrderBy() ,"getMaxColumnsInOrderBy",getMaxColumnsInOrderBy); }
    991//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxColumnsInOrderBy",getMaxColumnsInOrderBy); }
    992//              try { printMessage( metaData.getMaxColumnsInSelect() ,"getMaxColumnsInSelect",getMaxColumnsInSelect); }
    993//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxColumnsInSelect",getMaxColumnsInSelect); }
    994//              try { printMessage( metaData.getMaxColumnsInTable() ,"getMaxColumnsInTable",getMaxColumnsInTable); }
    995//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxColumnsInTable",getMaxColumnsInTable); }
    996//              try { printMessage( metaData.getMaxConnections() ,"getMaxConnections",getMaxConnections); }
    997//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxConnections",getMaxConnections); }
    998//              try { printMessage( metaData.getMaxCursorNameLength() ,"getMaxCursorNameLength",getMaxCursorNameLength); }
    999//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxCursorNameLength",getMaxCursorNameLength); }
    1000//              try { printMessage( metaData.getMaxIndexLength() ,"getMaxIndexLength",getMaxIndexLength); }
    1001//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxIndexLength",getMaxIndexLength); }
    1002//              try { printMessage( metaData.getMaxProcedureNameLength() ,"getMaxProcedureNameLength",getMaxProcedureNameLength); }
    1003//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxProcedureNameLength",getMaxProcedureNameLength); }
    1004//              try { printMessage( metaData.getMaxRowSize() ,"getMaxRowSize",getMaxRowSize); }
    1005//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxRowSize",getMaxRowSize); }
    1006//              try { printMessage( metaData.getMaxSchemaNameLength() ,"getMaxSchemaNameLength",getMaxSchemaNameLength); }
    1007//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxSchemaNameLength",getMaxSchemaNameLength); }
    1008//              try { printMessage( metaData.getMaxStatementLength() ,"getMaxStatementLength",getMaxStatementLength); }
    1009//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxStatementLength",getMaxStatementLength); }
    1010//              try { printMessage( metaData.getMaxStatements() ,"getMaxStatements",getMaxStatements); }
    1011//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxStatements",getMaxStatements); }
    1012//              try { printMessage( metaData.getMaxTableNameLength() ,"getMaxTableNameLength",getMaxTableNameLength); }
    1013//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxTableNameLength",getMaxTableNameLength); }
    1014//              try { printMessage( metaData.getMaxTablesInSelect() ,"getMaxTablesInSelect",getMaxTablesInSelect); }
    1015//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxTablesInSelect",getMaxTablesInSelect); }
    1016//              try { printMessage( metaData.getMaxUserNameLength() ,"getMaxUserNameLength",getMaxUserNameLength); }
    1017//                      catch( Throwable e ) { printMessage( e.getMessage(),"getMaxUserNameLength",getMaxUserNameLength); }
    1018//              try { printMessage( metaData.supportsConvert() ,"supportsConvert",supportsConvert); }
    1019//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsConvert",supportsConvert); }
    1020//              try { printMessage( metaData.supportsStoredFunctionsUsingCallSyntax() ,"supportsStoredFunctionsUsingCallSyntax",supportsStoredFunctionsUsingCallSyntax); }
    1021//                      catch( Throwable e ) { printMessage( e.getMessage(),"supportsStoredFunctionsUsingCallSyntax",supportsStoredFunctionsUsingCallSyntax); }
    1022
    1023                jspPrint( "</table>" );
    1024
    1025                if( metaData.supportsConvert() ) {
    1026                        supportsConvert( metaData );
    1027                }
    1028
    1029                // ResultSet のリターン値を持つ メタデータ
    1030                boolean nullable = true;
    1031                int scope = 0;
    1032
    1033                // 5.5.3.2 (2012/06/08) 個別に呼び出す箇所を、リフレクションに変更。
    1034                for( int i=0; i<METHOD_LIST.length; i++ ) {
    1035                        MetaDataInvoke inv = METHOD_LIST[i];
    1036                        if( inv.isUseMethod( likeKey ) && inv.getType() >= 10 ) {
    1037                                ResultSet obj = null;
    1038                                switch( inv.getType() ) {
    1039                                        case 50: obj = inv.invokeB( metaData ); break;
    1040                                        case 60:
    1041                                        case 62:
    1042                                        case 63:
    1043                                        case 64:
    1044                                        case 65: obj = inv.invokeB( metaData, catalog, schema, tableName ); break;
    1045                                        case 70:
    1046                                        case 71: obj = inv.invokeB( metaData, catalog, schema, typeName ); break;
    1047                                        case 61: obj = inv.invokeB( metaData, catalog, schema, tableName, columnName ); break;
    1048                                        case 72: obj = inv.invokeB( metaData, catalog, schema, typeName, attributeName ); break;
    1049                                        case 81: obj = inv.invokeB( metaData, catalog, schema, procedureName, columnName ); break;
    1050                                        case 80: obj = inv.invokeB( metaData, catalog, schema, procedureName ); break;
    1051                                        default : jspPrint( "*** タイプ不明 ***" + HybsSystem.BR ); continue;
    1052                                }
    1053
    1054                                jspPrint( inv.getMethod() + ":" + inv.getComment() + HybsSystem.BR );
    1055                                if( obj != null ) {
    1056                                        jspPrint( makeTableTag( resultToString( obj ) ) );
    1057                                }
    1058                                else {
    1059                                        jspPrint( inv.getErrMsg() + HybsSystem.BR );
    1060                                }
    1061                        }
    1062                }
    1063
    1064                // 以下、リフレクションが、エラーなどで結果を返さないメソッド。
    1065                jspPrint( "****************************************************************************************************" + HybsSystem.BR );
    1066
    1067                if( likeKey == null || "getAttributes".indexOf( likeKey ) >= 0 ) {
    1068                        jspPrint( "getAttributes:" + getAttributes + HybsSystem.BR );
    1069                        try { printMessage( metaData.getAttributes(catalog, schema, typeName, attributeName) ,getAttributes); }
    1070                                catch( Throwable e ) { printMessage( e.getMessage() ,getAttributes); }
    1071                }
    1072//              if( likeKey == null || "getBestRowIdentifier".indexOf( likeKey ) >= 0 ) {
    1073//                      jspPrint( "getBestRowIdentifier:B:" + getBestRowIdentifier + HybsSystem.BR );
    1074//                      try { printMessage( metaData.getBestRowIdentifier(catalog, schema, tableName, scope, nullable) ,getBestRowIdentifier); }
    1075//                              catch( Throwable e ) { printMessage( e.getMessage() ,getBestRowIdentifier); }
    1076//              }
    1077//              if( likeKey == null || "getCatalogs".indexOf( likeKey ) >= 0 ) {
    1078//                      jspPrint( "getCatalogs:" + getCatalogs + HybsSystem.BR );
    1079//                      try { printMessage( metaData.getCatalogs() ,getCatalogs); }
    1080//                              catch( Throwable e ) { printMessage( e.getMessage() ,getCatalogs); }
    1081//              }
    1082//              if( likeKey == null || "getColumnPrivileges".indexOf( likeKey ) >= 0 ) {
    1083//                      jspPrint( "getColumnPrivileges:" + getColumnPrivileges + HybsSystem.BR );
    1084//                      try { printMessage( metaData.getColumnPrivileges(catalog, schema, tableName, columnName) ,getColumnPrivileges); }
    1085//                              catch( Throwable e ) { printMessage( e.getMessage() ,getColumnPrivileges); }
    1086//              }
    1087                if( likeKey == null || "getColumns".indexOf( likeKey ) >= 0 ) {
    1088                        jspPrint( "getColumns:" + getColumns + HybsSystem.BR );
    1089                        try { printMessage( metaData.getColumns(catalog, schema, tableName, columnName) ,getColumns); }
    1090                                catch( Throwable e ) { printMessage( e.getMessage() ,getColumns); }
    1091                }
    1092//              if( likeKey == null || "getCrossReference".indexOf( likeKey ) >= 0 ) {
    1093//                      jspPrint( "getCrossReference:" + getCrossReference + HybsSystem.BR );
    1094////                    try { printMessage( metaData.getCrossReference(catalog, schema, tableName, catalog, schema, tableName) ,getCrossReference); }
    1095//                      try { printMessage( metaData.getCrossReference(catalog, schema, tableName, null, null, null) ,getCrossReference); }
    1096//                              catch( Throwable e ) { printMessage( e.getMessage() ,getCrossReference); }
    1097//              }
    1098//              if( likeKey == null || "getExportedKeys".indexOf( likeKey ) >= 0 ) {
    1099//                      jspPrint( "getExportedKeys:" + getExportedKeys + HybsSystem.BR );
    1100//                      try { printMessage( metaData.getExportedKeys(catalog, schema, tableName) ,getExportedKeys); }
    1101//                              catch( Throwable e ) { printMessage( e.getMessage() ,getExportedKeys); }
    1102//              }
    1103//              if( likeKey == null || "getImportedKeys".indexOf( likeKey ) >= 0 ) {
    1104//                      jspPrint( "getImportedKeys:" + getImportedKeys + HybsSystem.BR );
    1105//                      try { printMessage( metaData.getImportedKeys(catalog, schema, tableName) ,getImportedKeys); }
    1106//                              catch( Throwable e ) { printMessage( e.getMessage() ,getImportedKeys); }
    1107//              }
    1108                if( likeKey == null || "getIndexInfo".indexOf( likeKey ) >= 0 ) {
    1109                        jspPrint( "getIndexInfo:" + getIndexInfo + HybsSystem.BR );
    1110                        try { printMessage( metaData.getIndexInfo(catalog, schema, tableName, false, false) ,getIndexInfo); }
    1111                                catch( Throwable e ) { printMessage( e.getMessage() ,getIndexInfo); }
    1112                }
    1113//              if( likeKey == null || "getPrimaryKeys".indexOf( likeKey ) >= 0 ) {
    1114//                      jspPrint( "getPrimaryKeys:" + getPrimaryKeys + HybsSystem.BR );
    1115//                      try { printMessage( metaData.getPrimaryKeys(catalog, schema, tableName) ,getPrimaryKeys); }
    1116//                              catch( Throwable e ) { printMessage( e.getMessage() ,getPrimaryKeys); }
    1117//              }
    1118//              if( likeKey == null || "getProcedureColumns".indexOf( likeKey ) >= 0 ) {
    1119//                      jspPrint( "getProcedureColumns:" + getProcedureColumns + HybsSystem.BR );
    1120//                      try { printMessage( metaData.getProcedureColumns(catalog, schema, procedureName, columnName) ,getProcedureColumns); }
    1121//                              catch( Throwable e ) { printMessage( e.getMessage() ,getProcedureColumns); }
    1122//              }
    1123//              if( likeKey == null || "getProcedures".indexOf( likeKey ) >= 0 ) {
    1124//                      jspPrint( "getProcedures:" + getProcedures + HybsSystem.BR );
    1125//                      try { printMessage( metaData.getProcedures(catalog, schema, procedureName) ,getProcedures); }
    1126//                              catch( Throwable e ) { printMessage( e.getMessage() ,getProcedures); }
    1127//              }
    1128//              if( likeKey == null || "getSchemas".indexOf( likeKey ) >= 0 ) {
    1129//                      jspPrint( "getSchemas:" + getSchemas + HybsSystem.BR );
    1130//                      try { printMessage( metaData.getSchemas() ,getSchemas); }
    1131//                              catch( Throwable e ) { printMessage( e.getMessage() ,getSchemas); }
    1132//              }
    1133                if( likeKey == null || "getSuperTables".indexOf( likeKey ) >= 0 ) {
    1134                        jspPrint( "getSuperTables:" + getSuperTables + HybsSystem.BR );
    1135                        try { printMessage( metaData.getSuperTables(catalog, schema, tableName) ,getSuperTables); }
    1136                                catch( Throwable e ) { printMessage( e.getMessage() ,getSuperTables); }
    1137                }
    1138                if( likeKey == null || "getSuperTypes".indexOf( likeKey ) >= 0 ) {
    1139                        jspPrint( "getSuperTypes:" + getSuperTypes + HybsSystem.BR );
    1140                        try { printMessage( metaData.getSuperTypes(catalog, schema, typeName) ,getSuperTypes); }
    1141                                catch( Throwable e ) { printMessage( e.getMessage() ,getSuperTypes); }
    1142                }
    1143//              if( likeKey == null || "getTablePrivileges".indexOf( likeKey ) >= 0 ) {
    1144//                      jspPrint( "getTablePrivileges:" + getTablePrivileges + HybsSystem.BR );
    1145//                      try { printMessage( metaData.getTablePrivileges(catalog, schema, tableName) ,getTablePrivileges); }
    1146//                              catch( Throwable e ) { printMessage( e.getMessage() ,getTablePrivileges); }
    1147//              }
    1148//              if( likeKey == null || "getTables".indexOf( likeKey ) >= 0 ) {
    1149//                      jspPrint( "getTables:" + getTables + HybsSystem.BR );
    1150//                      try { printMessage( metaData.getTables(catalog, schema, tableName, null) ,getTables); }
    1151//                              catch( Throwable e ) { printMessage( e.getMessage() ,getTables); }
    1152//              }
    1153//              if( likeKey == null || "getTableTypes".indexOf( likeKey ) >= 0 ) {
    1154//                      jspPrint( "getTableTypes:" + getTableTypes + HybsSystem.BR );
    1155//                      try { printMessage( metaData.getTableTypes() ,getTableTypes); }
    1156//                              catch( Throwable e ) { printMessage( e.getMessage() ,getTableTypes); }
    1157//              }
    1158                if( likeKey == null || "getTypeInfo".indexOf( likeKey ) >= 0 ) {
    1159                        jspPrint( "getTypeInfo:" + getTypeInfo + HybsSystem.BR );
    1160                        try { printMessage( metaData.getTypeInfo() ,getTypeInfo); }
    1161                                catch( Throwable e ) { printMessage( e.getMessage() ,getTypeInfo); }
    1162                }
    1163//              if( likeKey == null || "getUDTs".indexOf( likeKey ) >= 0 ) {
    1164//                      jspPrint( "getUDTs:" + getUDTs + HybsSystem.BR );
    1165//                      try { printMessage( metaData.getUDTs(catalog, schema, typeName, null) ,getUDTs); }
    1166//                              catch( Throwable e ) { printMessage( e.getMessage() ,getUDTs); }
    1167//              }
    1168//              if( likeKey == null || "getVersionColumns".indexOf( likeKey ) >= 0 ) {
    1169//                      jspPrint( "getVersionColumns:" + getVersionColumns + HybsSystem.BR );
    1170//                      try { printMessage( metaData.getVersionColumns(catalog, schema, tableName) ,getVersionColumns); }
    1171//                              catch( Throwable e ) { printMessage( e.getMessage() ,getVersionColumns); }
    1172//              }
    1173//
    1174//              // 5.5.3.2 (2012/06/08) JDk1.6 用のメソッドを追加します。
    1175//              if( likeKey == null || "getClientInfoProperties".indexOf( likeKey ) >= 0 ) {
    1176//                      jspPrint( "getClientInfoProperties:" + getClientInfoProperties + HybsSystem.BR );
    1177//                      try { printMessage( metaData.getClientInfoProperties() ,getClientInfoProperties); }
    1178//                              catch( Throwable e ) { printMessage( e.getMessage() ,getClientInfoProperties); }
    1179//              }
    1180//              if( likeKey == null || "getFunctionColumns".indexOf( likeKey ) >= 0 ) {
    1181//                      jspPrint( "getFunctionColumns:" + getFunctionColumns + HybsSystem.BR );
    1182//                      try { printMessage( metaData.getFunctionColumns(catalog, schema, procedureName ,columnName),getFunctionColumns); }
    1183//                              catch( Throwable e ) { printMessage( e.getMessage() ,getFunctionColumns); }
    1184//              }
    1185//              if( likeKey == null || "getFunctions".indexOf( likeKey ) >= 0 ) {
    1186//                      jspPrint( "getFunctions:" + getFunctions + HybsSystem.BR );
    1187//                      try { printMessage( metaData.getFunctions(catalog, schema, procedureName) ,getFunctions); }
    1188//                              catch( Throwable e ) { printMessage( e.getMessage() ,getFunctions); }
    1189//              }
    1190        }
    1191
    1192        /**
    1193         * データベースの Types 定数を文字列に変換したテーブルを画面に出力します。
    1194         *
    1195         * @param metaData DatabaseMetaDataオブジェクト
    1196         * @throws Throwable 何らかのエラーが発生した場合。
    1197         * @see java.sql.Types
    1198         */
    1199        private void supportsConvert( final DatabaseMetaData metaData ) throws Throwable {
    1200
    1201                int cnt = 36;
    1202                int[]    key = new int[cnt] ;
    1203                String[] msg = new String[cnt] ;
    1204
    1205                int i = 0;
    1206                key[i] = Types.ARRAY ;                  msg[i++] = "ARRAY" ;                    // 0
    1207                key[i] = Types.BIGINT ;                 msg[i++] = "BIGINT" ;                   // 1
    1208                key[i] = Types.BINARY ;                 msg[i++] = "BINARY" ;                   // 2
    1209                key[i] = Types.BIT ;                    msg[i++] = "BIT" ;                              // 3
    1210                key[i] = Types.BLOB ;                   msg[i++] = "BLOB" ;                             // 4
    1211                key[i] = Types.BOOLEAN ;                msg[i++] = "BOOLEAN" ;                  // 5
    1212                key[i] = Types.CHAR ;                   msg[i++] = "CHAR" ;                             // 6
    1213                key[i] = Types.CLOB ;                   msg[i++] = "CLOB" ;                             // 7
    1214                key[i] = Types.DATALINK ;               msg[i++] = "DATALINK" ;                 // 8
    1215                key[i] = Types.DATE ;                   msg[i++] = "DATE" ;                             // 9
    1216                key[i] = Types.DECIMAL ;                msg[i++] = "DECIMAL" ;                  // 10
    1217                key[i] = Types.DISTINCT ;               msg[i++] = "DISTINCT" ;                 // 11
    1218                key[i] = Types.DOUBLE ;                 msg[i++] = "DOUBLE" ;                   // 12
    1219                key[i] = Types.FLOAT ;                  msg[i++] = "FLOAT" ;                    // 13
    1220                key[i] = Types.INTEGER ;                msg[i++] = "INTEGER" ;                  // 14
    1221                key[i] = Types.JAVA_OBJECT ;    msg[i++] = "JAVA_OBJECT" ;              // 15
    1222                key[i] = Types.LONGNVARCHAR ;   msg[i++] = "LONGNVARCHAR" ;             // 16   5.5.3.2 (2012/06/08)
    1223                key[i] = Types.LONGVARBINARY ;  msg[i++] = "LONGVARBINARY" ;    // 17
    1224                key[i] = Types.LONGVARCHAR ;    msg[i++] = "LONGVARCHAR" ;              // 18
    1225                key[i] = Types.NCHAR ;                  msg[i++] = "NCHAR" ;                    // 19   5.5.3.2 (2012/06/08)
    1226                key[i] = Types.NCLOB ;                  msg[i++] = "NCLOB" ;                    // 20   5.5.3.2 (2012/06/08)
    1227                key[i] = Types.NULL ;                   msg[i++] = "NULL" ;                             // 21
    1228                key[i] = Types.NUMERIC ;                msg[i++] = "NUMERIC" ;                  // 22
    1229                key[i] = Types.NVARCHAR ;               msg[i++] = "NVARCHAR" ;                 // 23   5.5.3.2 (2012/06/08)
    1230                key[i] = Types.OTHER ;                  msg[i++] = "OTHER" ;                    // 24
    1231                key[i] = Types.REAL ;                   msg[i++] = "REAL" ;                             // 25
    1232                key[i] = Types.REF ;                    msg[i++] = "REF" ;                              // 26
    1233                key[i] = Types.ROWID ;                  msg[i++] = "ROWID" ;                    // 27   5.5.3.2 (2012/06/08)
    1234                key[i] = Types.SMALLINT ;               msg[i++] = "SMALLINT" ;                 // 28   5.5.3.2 (2012/06/08)
    1235                key[i] = Types.SQLXML ;                 msg[i++] = "SQLXML" ;                   // 29
    1236                key[i] = Types.STRUCT ;                 msg[i++] = "STRUCT" ;                   // 30
    1237                key[i] = Types.TIME ;                   msg[i++] = "TIME" ;                             // 31
    1238                key[i] = Types.TIMESTAMP ;              msg[i++] = "TIMESTAMP" ;                // 32
    1239                key[i] = Types.TINYINT ;                msg[i++] = "TINYINT" ;                  // 33
    1240                key[i] = Types.VARBINARY ;              msg[i++] = "VARBINARY" ;                // 34
    1241                key[i] = Types.VARCHAR ;                msg[i  ] = "VARCHAR" ;                  // 35
    1242
    1243                // それぞれ、Types 名称用のフィールドを追加
    1244                String[][] table = new String[cnt+1][cnt+1];            // ヘッダー行を追加
    1245                for( int hd=0; hd<cnt; hd++ ) {
    1246                        table[0][hd+1] = msg[hd];               // 行のヘッダー
    1247                        table[hd+1][0] = msg[hd];               // 列のヘッダー
    1248                }
    1249
    1250                for( int row=0; row<cnt; row++ ) {
    1251                        for( int clm=0; clm<cnt; clm++ ) {
    1252                                if( metaData.supportsConvert( key[row], key[clm]) ) {
    1253                                        table[row+1][clm+1] = "○" ;
    1254                                }
    1255                                else {
    1256                                        table[row+1][clm+1] = "×" ;
    1257                                }
    1258                        }
    1259                }
    1260
    1261                jspPrint( supportsConvertFunc + HybsSystem.BR );
    1262                jspPrint( makeTableTag( table ) );
    1263        }
    1264
    1265        // 5.5.3.2 (2012/06/08) メソッドのMapです。順序を登録順に保つため、LinkedHashMap を使います。
    1266
    1267//      private static final String[][] METHOD_LIST = new String[][] {
    1268//                { "getCatalogSeparator" , "このデータベースがカタログ名とテーブル名のセパレータとして使用する String"  , "0" }
    1269//              , { "getCatalogTerm" , "「catalog」に対するデータベースベンダーの推奨用語を取得します。 "  , "0" }
    1270//              , { "getDatabaseProductName" , "このデータベース製品の名前を取得します。 "  , "0" }
    1271//              , { "getDatabaseProductVersion" , "このデータベース製品のバージョンを取得します。 "  , "0" }
    1272//              , { "getDriverMajorVersion" , "この JDBC ドライバのメジャーバージョンを取得します。 "  , "0" }
    1273//              , { "getDriverMinorVersion" , "この JDBC ドライバのマイナーバージョンを取得します。 "  , "0" }
    1274//              , { "getDriverName" , "この JDBC ドライバの名前を取得します。 "  , "0" }
    1275//              , { "getDriverVersion" , "この JDBC ドライバのバージョンを String"  , "0" }
    1276//              , { "getExtraNameCharacters" , "引用符で囲まれていない識別名に使用できるすべての「特殊」文字 (a-z、A-Z、0-9、および _ 以外) を取得します。 "  , "0" }
    1277//              , { "getIdentifierQuoteString" , "SQL 識別子を引用するのに使用する文字列を取得します。 "  , "0" }
    1278//              , { "getNumericFunctions" , "このデータベースで使用可能なコンマで区切った数学関数のリストを取得します。 "  , "0" }
    1279//              , { "getProcedureTerm" , "「procedure」に対するデータベースベンダーの推奨用語を取得します。 "  , "0" }
    1280//              , { "getSchemaTerm" , "「schema」に対するデータベースベンダーの推奨用語を取得します。 "  , "0" }
    1281//              , { "getSearchStringEscape" , "ワイルドカード文字をエスケープするのに使用できる文字列を取得します。 "  , "0" }
    1282//              , { "getSQLKeywords" , "このデータベースの SQL キーワードであって、SQL92 のキーワードではない、すべてのキーワードをコンマで区切ったリストを取得します。 "  , "0" }
    1283//              , { "getStringFunctions" , "このデータベースで使用可能なコンマで区切った文字列関数のリストを取得します。 "  , "0" }
    1284//              , { "getSystemFunctions" , "このデータベースで使用可能なコンマで区切ったシステム関数のリストを取得します。 "  , "0" }
    1285//              , { "getTimeDateFunctions" , "このデータベースで使用可能な時間関数と日付関数をコンマで区切ったリストを取得します。 "  , "0" }
    1286//              , { "getURL" , "この DBMS の URL を取得します。 "  , "0" }
    1287//              , { "getUserName" , "このデータベースに記録されているユーザ名を取得します。 "  , "0" }
    1288//
    1289//              , { "getDefaultTransactionIsolation" , "このデータベースのデフォルトのトランザクション遮断レベルを取得します。 "  , "0" }
    1290//              , { "getSQLStateType" , "Throwable.getSQLState によって返される SQLSTATE が X/Open (現在は Open Group) の SQL CLI であるか SQL99 であるかを示します。 "  , "0" }
    1291//              , { "getResultSetHoldability" , "この ResultSet オブジェクトのデフォルトの保持機能を取得します。 "  , "0" }
    1292//
    1293//              , { "allProceduresAreCallable" , "getProcedures メソッドによって返されるすべてのプロシージャが、現在のユーザから呼び出せるかどうかを取得します。 "  , "0" }
    1294//              , { "allTablesAreSelectable" , "getTables メソッドによって返されるすべてのテーブルが、現在のユーザによって使用できるかどうかを取得します。 "  , "0" }
    1295//              , { "dataDefinitionCausesTransactionCommit" , "トランザクションのデータ定義文が、トランザクションを強制的にコミットさせるかどうかを取得します。 "  , "0" }
    1296//              , { "dataDefinitionIgnoredInTransactions" , "このデータベースによって、トランザクションでデータ定義文が無視されるかどうかを取得します。 "  , "0" }
    1297//              , { "deletesAreDetected" , "ResultSet.rowDeleted メソッドを呼び出すことによって可視の行が削除されたことを検出できるかどうかを取得します。 "  , "1" }
    1298//              , { "doesMaxRowSizeIncludeBlobs" , "getMaxRowSize メソッドの戻り値が SQL データの型の LONGVARCHAR および LONGVARBINARY を含むかどうかを取得します。 "  , "0" }
    1299//              , { "insertsAreDetected" , "ResultSet.rowInserted メソッドを呼び出すことによって可視の行が挿入されたことを検出できるかどうかを取得します。 "  , "1" }
    1300//              , { "isCatalogAtStart" , "完全修飾されたテーブル名の開始部分 (または終了部分) にカタログが現れるかどうかを取得します。 "  , "0" }
    1301//              , { "isReadOnly" , "このデータベースが読み込み専用モードかどうかを取得します。 "  , "0" }
    1302//              , { "locatorsUpdateCopy" , "LOB への変更が、コピーに対して行われたのか、LOB に直接行われたのかを示します。 "  , "0" }
    1303//              , { "nullPlusNonNullIsNull" , "このデータベースが、NULL 値と非 NULL 値の連結を NULL とするかどうかを取得します。 "  , "0" }
    1304//              , { "nullsAreSortedAtEnd" , "NULL 値が、終了時にソート順にかかわらずソートされるかどうかを取得します。 "  , "0" }
    1305//              , { "nullsAreSortedAtStart" , "NULL 値が、開始時にソート順にかかわらずソートされるかどうかを取得します。 "  , "0" }
    1306//              , { "nullsAreSortedHigh" , "NULL 値が高位にソートされるかどうかを取得します。 "  , "0" }
    1307//              , { "nullsAreSortedLow" , "NULL 値が下位にソートされるかどうかを取得します。 "  , "0" }
    1308//              , { "othersDeletesAreVisible" , "他で行われた削除が可視かどうかを取得します。 "  , "1" }
    1309//              , { "othersInsertsAreVisible" , "他で行われた挿入が可視かどうかを取得します。 "  , "1" }
    1310//              , { "othersUpdatesAreVisible" , "他で行われた更新が可視かどうかを取得します。 "  , "1" }
    1311//              , { "ownDeletesAreVisible" , "結果セット自身の削除が可視かどうかを取得します。 "  , "1" }
    1312//              , { "ownInsertsAreVisible" , "結果セット自身の挿入が可視かどうかを取得します。 "  , "1" }
    1313//              , { "ownUpdatesAreVisible" , "指定された ResultSet オブジェクトについて、結果セット自身の更新が可視かどうかを取得します。 "  , "1" }
    1314//              , { "storesLowerCaseIdentifiers" , "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、小文字で格納するかどうかを取得します。 "  , "0" }
    1315//              , { "storesLowerCaseQuotedIdentifiers" , "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、小文字で格納するかどうかを取得します。 "  , "0" }
    1316//              , { "storesMixedCaseIdentifiers" , "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、大文字小文字混在で格納するかどうかを取得します。 "  , "0" }
    1317//              , { "storesMixedCaseQuotedIdentifiers" , "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、大文字小文字混在で格納するかどうかを取得します。 "  , "0" }
    1318//              , { "storesUpperCaseIdentifiers" , "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、大文字で格納するかどうかを取得します。 "  , "0" }
    1319//              , { "storesUpperCaseQuotedIdentifiers" , "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、大文字で格納するかどうかを取得します。 "  , "0" }
    1320//              , { "supportsAlterTableWithAddColumn" , "このデータベースによって、追加列のある ALTER TABLE がサポートされるかどうかを取得します。 "  , "0" }
    1321//              , { "supportsAlterTableWithDropColumn" , "このデータベースによって、ドロップ列のある ALTER TABLE がサポートされるかどうかを取得します。 "  , "0" }
    1322//              , { "supportsANSI92EntryLevelSQL" , "このデータベースによって、ANSI92 エントリレベルの SQL 文法がサポートされるかどうかを取得します。 "  , "0" }
    1323//              , { "supportsANSI92FullSQL" , "このデータベースによって、ANSI92 完全レベルの SQL 文法がサポートされるかどうかを取得します。 "  , "0" }
    1324//              , { "supportsANSI92IntermediateSQL" , "このデータベースによって、ANSI92 中間レベルの SQL 文法がサポートされるかどうかを取得します。 "  , "0" }
    1325//              , { "supportsBatchUpdates" , "このデータベースによってバッチ更新がサポートされるかどうかを取得します。 "  , "0" }
    1326//              , { "supportsCatalogsInDataManipulation" , "データ操作文でカタログ名を使用できるかどうかを取得します。 "  , "0" }
    1327//              , { "supportsCatalogsInIndexDefinitions" , "インデックス定義文でカタログ名を使用できるかどうかを取得します。 "  , "0" }
    1328//              , { "supportsCatalogsInPrivilegeDefinitions" , "特権定義文でカタログ名を使用できるかどうかを取得します。 "  , "0" }
    1329//              , { "supportsCatalogsInProcedureCalls" , "プロシージャ呼び出し文でカタログ名を使用できるかどうかを取得します。 "  , "0" }
    1330//              , { "supportsCatalogsInTableDefinitions" , "テーブル定義文でカタログ名を使用できるかどうかを取得します。 "  , "0" }
    1331//              , { "supportsColumnAliasing" , "このデータベースによって列の別名がサポートされるかどうかを取得します。  "  , "0" }
    1332//      //      , { "supportsConvertFunc" , "このデータベースによって、SQL の型間の CONVERT 関数がサポートされるかどうかを取得します。 "  , "0" }
    1333//              , { "supportsCoreSQLGrammar" , "このデータベースによって、ODBC Core SQL 文法がサポートされるかどうかを取得します。 "  , "0" }
    1334//              , { "supportsCorrelatedSubqueries" , "このデータベースによって照合関係サブクエリーがサポートされるかどうかを取得します。 "  , "0" }
    1335//              , { "supportsDataDefinitionAndDataManipulationTransactions" , "このデータベースによって、トランザクションで、データ定義文とデータ操作文の両方がサポートされるかどうかを取得します。 "  , "0" }
    1336//              , { "supportsDataManipulationTransactionsOnly" , "このデータベースによって、トランザクションでデータ操作文だけがサポートされるかどうかを取得します。 "  , "0" }
    1337//              , { "supportsDifferentTableCorrelationNames" , "テーブル相互関係名がサポートされる場合、テーブルの名前と異なる名前であるという制限を付けるかどうかを取得します。 "  , "0" }
    1338//              , { "supportsExpressionsInOrderBy" , "このデータベースによって、ORDER BY リスト中で式がサポートされるかどうかを取得します。 "  , "0" }
    1339//              , { "supportsExtendedSQLGrammar" , "このデータベースによって、ODBC Extended SQL 文法がサポートされるかどうかを取得します。 "  , "0" }
    1340//              , { "supportsFullOuterJoins" , "このデータベースによって、完全入れ子の外部結合がサポートされるかどうかを取得します。 "  , "0" }
    1341//              , { "supportsGetGeneratedKeys" , "文が実行されたあとに自動生成キーを取得できるかどうかを取得します。 "  , "0" }
    1342//              , { "supportsGroupBy" , "このデータベースによって、GROUP BY 節のフォームがサポートされるかどうかを取得します。 "  , "0" }
    1343//              , { "supportsGroupByBeyondSelect" , "SELECT 文中のすべての列が GROUP BY 節に含まれるという条件で、このデータベースによって、GROUP BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 "  , "0" }
    1344//              , { "supportsGroupByUnrelated" , "このデータベースによって、GROUP BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 "  , "0" }
    1345//              , { "supportsIntegrityEnhancementFacility" , "このデータベースによって、SQL Integrity Enhancement Facility がサポートされるかどうかを取得します。 "  , "0" }
    1346//              , { "supportsLikeEscapeClause" , "このデータベースによって、LIKE エスケープ節の指定がサポートされるかどうかを取得します。 "  , "0" }
    1347//              , { "supportsLimitedOuterJoins" , "このデータベースによって、外部結合に関し、制限されたサポートが提供されるかどうかを取得します (supportsFullOuterJoins メソッドが true を返す場合は true)。 "  , "0" }
    1348//              , { "supportsMinimumSQLGrammar" , "このデータベースによって、ODBC Minimum SQL 文法がサポートされるかどうかを取得します。 "  , "0" }
    1349//              , { "supportsMixedCaseIdentifiers" , "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別して処理し、大文字小文字混在で格納するかどうかを取得します。 "  , "0" }
    1350//              , { "supportsMixedCaseQuotedIdentifiers" , "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別して処理し、結果として大文字小文字混在で格納するかどうかを取得します。 "  , "0" }
    1351//              , { "supportsMultipleOpenResults" , "CallableStatement オブジェクトから同時に返された複数の ResultSet オブジェクトを持つことが可能かどうかを取得します。 "  , "0" }
    1352//              , { "supportsMultipleResultSets" , "このデータベースによって、execute メソッドの単一の呼び出しからの複数の ResultSet オブジェクトの取得がサポートされるかどうかを取得します。 "  , "0" }
    1353//              , { "supportsMultipleTransactions" , "このデータベースが一度に複数のトランザクションを (異なった接続で) オープンできるかどうかを取得します。 "  , "0" }
    1354//              , { "supportsNamedParameters" , "このデータベースによって、callable 文への名前付きパラメータがサポートされるかどうかを取得します。 "  , "0" }
    1355//              , { "supportsNonNullableColumns" , "このデータベースの列を非 null として定義できるかどうかを取得します。 "  , "0" }
    1356//              , { "supportsOpenCursorsAcrossCommit" , "このデータベースによって、コミット間でカーソルがオープンされたままの状態がサポートされるかどうかを取得します。 "  , "0" }
    1357//              , { "supportsOpenCursorsAcrossRollback" , "このデータベースによって、ロールバック間でカーソルがオープンされたままの状態がサポートされるかどうかを取得します。 "  , "0" }
    1358//              , { "supportsOpenStatementsAcrossCommit" , "このデータベースによって、コミット間で文がオープンされたままの状態がサポートされるかどうかを取得します。 "  , "0" }
    1359//              , { "supportsOpenStatementsAcrossRollback" , "このデータベースによって、ロールバック間で文がオープンされたままの状態がサポートされるかどうかを取得します。 "  , "0" }
    1360//              , { "supportsOrderByUnrelated" , "このデータベースによって、ORDER BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 "  , "0" }
    1361//              , { "supportsOuterJoins" , "このデータベースによって、外部結合のなんらかの形式がサポートされるかどうかを取得します。 "  , "0" }
    1362//              , { "supportsPositionedDelete" , "このデータベースによって、位置指定された DELETE 文がサポートされるかどうかを取得します。 "  , "0" }
    1363//              , { "supportsPositionedUpdate" , "このデータベースによって、位置指定された UPDATE 文がサポートされるかどうかを取得します。 "  , "0" }
    1364//              , { "supportsResultSetConcurrency" , "このデータベースが、指定された結果セットの型と与えられた並行処理の種類の組み合わせをサポートするかどうかを取得します。 "  , "2" }
    1365//              , { "supportsResultSetHoldability" , "このデータベースが、指定された結果セットの保持機能をサポートするかどうかを取得します。 "  , "3" }
    1366//              , { "supportsResultSetType" , "このデータベースが、[TYPE_FORWARD_ONLY]指定された結果セットの型をサポートするかどうかを取得します。 "  , "41" }
    1367//              , { "supportsResultSetType" , "このデータベースが、[TYPE_SCROLL_INSENSITIVE]指定された結果セットの型をサポートするかどうかを取得します。 "  , "42" }
    1368//              , { "supportsResultSetType" , "このデータベースが、[TYPE_SCROLL_SENSITIVE]指定された結果セットの型をサポートするかどうかを取得します。 "  , "43" }
    1369//              , { "supportsSavepoints" , "このデータベースによってセーブポイントがサポートされるかどうかを取得します。 "  , "0" }
    1370//              , { "supportsSchemasInDataManipulation" , "データ操作文でスキーマ名を使用できるかどうかを取得します。 "  , "0" }
    1371//              , { "supportsSchemasInIndexDefinitions" , "インデックス定義文でスキーマ名を使用できるかどうかを取得します。 "  , "0" }
    1372//              , { "supportsSchemasInPrivilegeDefinitions" , "特権定義文でスキーマ名を使用できるかどうかを取得します。 "  , "0" }
    1373//              , { "supportsSchemasInProcedureCalls" , "プロシージャ呼び出し文でスキーマ名を使用できるかどうかを取得します。 "  , "0" }
    1374//              , { "supportsSchemasInTableDefinitions" , "テーブル定義文でスキーマ名を使用できるかどうかを取得します。 "  , "0" }
    1375//              , { "supportsSelectForUpdate" , "このデータベースによって SELECT FOR UPDATE 文がサポートされるかどうかを取得します。 "  , "0" }
    1376//              , { "supportsStatementPooling" , "このデータベースによって文のプールがサポートされるかどうかを取得します。 "  , "0" }
    1377//              , { "supportsStoredProcedures" , "このデータベースによって、ストアドプロシージャエスケープ構文を使用するストアドプロシージャコールがサポートされるかどうかを判定します。 "  , "0" }
    1378//              , { "supportsSubqueriesInComparisons" , "このデータベースによって、比較式中でサブクエリーがサポートされるかどうかを取得します。 "  , "0" }
    1379//              , { "supportsSubqueriesInExists" , "このデータベースによって、EXISTS 式中でサブクエリーがサポートされるかどうかを取得します。 "  , "0" }
    1380//              , { "supportsSubqueriesInIns" , "このデータベースによって、IN 文中でサブクエリーがサポートされるかどうかを取得します。 "  , "0" }
    1381//              , { "supportsSubqueriesInQuantifieds" , "このデータベースによって、定量化された式中でサブクエリーがサポートされるかどうかを取得します。 "  , "0" }
    1382//              , { "supportsTableCorrelationNames" , "このデータベースによってテーブル相互関係名がサポートされるかどうかを取得します。 "  , "0" }
    1383//              , { "supportsTransactionIsolationLevel" , "このデータベースが、指定されたトランザクション遮断レベルをサポートするかどうかを取得します。 "  , "5" }
    1384//              , { "supportsTransactions" , "このデータベースによってトランザクションがサポートされるかどうかを取得します。 "  , "0" }
    1385//              , { "supportsUnion" , "このデータベースによって SQL UNION がサポートされるかどうかを取得します。 "  , "0" }
    1386//              , { "supportsUnionAll" , "このデータベースによって SQL UNION ALL がサポートされるかどうかを取得します。 "  , "0" }
    1387//              , { "updatesAreDetected" , "ResultSet.rowUpdated メソッドを呼び出すことによって可視の行が更新されたことを検出できるかどうかを取得します。 "  , "1" }
    1388//              , { "usesLocalFilePerTable" , "このデータベースが、各テーブルにファイルを使用するかどうかを取得します。 "  , "0" }
    1389//              , { "usesLocalFiles" , "このデータベースが、ローカルファイルにテーブルを格納するかどうかを取得します。 "  , "0" }
    1390//
    1391//      // これらは、引数が必要なので、リフレクション処理は、とりあえず保留
    1392//      //      , { "getAttributes" , "指定されたスキーマおよびカタログで使用可能なユーザ定義の型 (UDT) のための指定された型の指定された属性に関する記述を取得します。  "  , "0" }
    1393//      //      , { "getBestRowIdentifier" , "行を一意に識別するテーブルの最適な列セットに関する記述を取得します。 "  , "0" }
    1394//      //      , { "getCatalogs" , "このデータベースで使用可能なカタログ名を取得します。 "  , "0" }
    1395//      //      , { "getColumnPrivileges" , "テーブルの列へのアクセス権に関する記述を取得します。  "  , "0" }
    1396//      //      , { "getColumns" , "指定されたカタログで使用可能なテーブル列の記述を取得します。  "  , "0" }
    1397//      //      , { "getCrossReference" , "指定された主キーテーブルの主キー列を参照する指定された外部のキーテーブル中の、外部のキー列に関する記述 (テーブルが別のキーをインポートする方法を記述) を取得します。 "  , "0" }
    1398//      //      , { "getExportedKeys" , "指定されたテーブルの主キー列 (テーブルによってエクスポートされた外部キー) を参照する外部キー列に関する記述を取得します。 "  , "0" }
    1399//      //      , { "getImportedKeys" , "テーブルの外部キー列 (テーブルによってインポートされる主キー) を参照する主キー列に関する記述を取得します。 "  , "0" }
    1400//      //      , { "getIndexInfo" , "指定されたテーブルのインデックスと統計情報に関する記述を取得します。 "  , "0" }
    1401//      //      , { "getPrimaryKeys" , "指定されたテーブルの主キー列の記述を取得します。 "  , "0" }
    1402//      //      , { "getProcedureColumns" , "指定されたカタログのストアドプロシージャパラメータと結果列に関する記述を取得します。  "  , "0" }
    1403//      //      , { "getProcedures" , "指定されたカタログで使用可能なストアドプロシージャに関する記述を取得します。  "  , "0" }
    1404//      //      , { "getSchemas" , "このデータベースで使用可能なスキーマ名を取得します。 "  , "0" }
    1405//      //      , { "getSuperTables" , "このデータベースの特定のスキーマで定義されているテーブル階層の説明を取得します。  "  , "0" }
    1406//      //      , { "getSuperTypes" , "このデータベースの特定のスキーマで定義されているユーザ定義型 (UDT) 階層の説明を取得します。 "  , "0" }
    1407//      //      , { "getTablePrivileges" , "カタログで使用可能な各テーブルに対するアクセス権に関する記述を取得します。 "  , "0" }
    1408//      //      , { "getTables" , "指定されたカタログで使用可能なテーブルに関する記述を取得します。 "  , "0" }
    1409//      //      , { "getTableTypes" , "このデータベースで使用可能なテーブルの型を取得します。 "  , "0" }
    1410//      //      , { "getTypeInfo" , "このデータベースでサポートされているすべての標準 SQL の型に関する記述を取得します。 "  , "0" }
    1411//      //      , { "getUDTs" , "特定のスキーマで定義されているユーザ定義型 (UDT) の説明を取得します。 "  , "0" }
    1412//      //      , { "getVersionColumns" , "行の任意の値が変更された場合に、自動的に更新されるテーブルの列に関する記述を取得します。 "  , "0" }
    1413//
    1414//      // 5.5.3.2 (2012/06/08) JDk1.6 用のメソッドを追加します。
    1415//              , { "autoCommitFailureClosesAllResultSets" , "autoCommit が true の場合に、ResultSet が保持可能であっても、すべてのオープンされた ResultSet がクローズされたことを SQLException が示すかどうかを取得します。"  , "0" }
    1416//              , { "supportsConvert" , "このデータベースによって、JDBC 型 fromType と toType の間の変換に使用される JDBC スカラー関数 CONVERT がサポートされるかどうかを取得します。"  , "0" }
    1417//              , { "supportsStoredFunctionsUsingCallSyntax" , "このデータベースが、ストアドプロシージャーエスケープ構文を使用した、ユーザー定義関数またはベンダー関数の呼び出しをサポートするかどうかを取得します。"  , "0" }
    1418//              , { "getDatabaseMajorVersion" , "基本となるデータベースのメジャーバージョン番号を取得します。"  , "0" }
    1419//              , { "getDatabaseMinorVersion" , "基本となるデータベースのマイナーバージョン番号を取得します。"  , "0" }
    1420//              , { "getJDBCMajorVersion" , "このドライバの JDBC メジャーバージョン番号を取得します。"  , "0" }
    1421//              , { "getJDBCMinorVersion" , "このドライバの JDBC マイナーバージョン番号を取得します。"  , "0" }
    1422//              , { "getMaxBinaryLiteralLength" , "このデータベースで、インラインバイナリリテラル中に入れられる 16 進数の最大文字数を取得します。"  , "0" }
    1423//              , { "getMaxCatalogNameLength" , "このデータベースでの、カタログ名の最大文字数を取得します。"  , "0" }
    1424//              , { "getMaxCharLiteralLength" , "このデータベースでの、キャラクタリテラルの最大文字数を取得します。"  , "0" }
    1425//              , { "getMaxColumnNameLength" , "このデータベースでの、列名の最大文字数を取得します。"  , "0" }
    1426//              , { "getMaxColumnsInGroupBy" , "このデータベースでの、GROUP BY 節中の列数の最大値を取得します。"  , "0" }
    1427//              , { "getMaxColumnsInIndex" , "このデータベースでの、インデックス中の列数の最大値を取得します。"  , "0" }
    1428//              , { "getMaxColumnsInOrderBy" , "このデータベースでの、ORDER BY 節中の列数の最大値を取得します。"  , "0" }
    1429//              , { "getMaxColumnsInSelect" , "このデータベースでの、SELECT リスト中の列数の最大値を取得します。"  , "0" }
    1430//              , { "getMaxColumnsInTable" , "このデータベースでの、テーブル中の列数の最大値を取得します。"  , "0" }
    1431//              , { "getMaxConnections" , "このデータベースに対して可能な並行接続の最大数を取得します。"  , "0" }
    1432//              , { "getMaxCursorNameLength" , "このデータベースでの、カーソル名の最大文字数を取得します。"  , "0" }
    1433//              , { "getMaxIndexLength" , "このデータベースでの、インデックスの全部分を含む、インデックスの最大バイト数を取得します。"  , "0" }
    1434//              , { "getMaxProcedureNameLength" , "このデータベースでの、プロシージャー名の最大文字数を取得します。"  , "0" }
    1435//              , { "getMaxRowSize" , "このデータベースでの、1 行の最大バイト数を取得します。"  , "0" }
    1436//              , { "getMaxSchemaNameLength" , "このデータベースでの、スキーマ名の最大文字数を取得します。"  , "0" }
    1437//              , { "getMaxStatementLength" , "このデータベースでの、SQL 文の最大文字数を取得します。"  , "0" }
    1438//              , { "getMaxStatements" , "このデータベースの同時にオープンできるアクティブな文の最大数を取得します。"  , "0" }
    1439//              , { "getMaxTableNameLength" , "このデータベースでの、テーブル名の最大文字数を取得します。"  , "0" }
    1440//              , { "getMaxTablesInSelect" , "このデータベースでの、SELECT 文の最大テーブル数を取得します。"  , "0" }
    1441//              , { "getMaxUserNameLength" , "このデータベースでの、ユーザー名の最大文字数を取得します。"  , "0" }
    1442//
    1443//      // これらは、引数が必要なので、リフレクション処理は、とりあえず保留
    1444//      //      , { "getClientInfoProperties" , "ドライバがサポートするクライアント情報プロパティーのリストを取得します。"  , "0" }
    1445//      //      , { "getFunctionColumns" , "指定されたカタログのシステム関数またはユーザー関数のパラメータと返される型に関する記述を取得します。"  , "0" }
    1446//      //      , { "getFunctions" , "指定されたカタログで使用可能なシステム関数およびユーザー関数に関する記述を取得します。"  , "0" }
    1447//      };
    1448
    1449        private static final MetaDataInvoke[] METHOD_LIST = new MetaDataInvoke[] {
    1450                  new MetaDataInvoke( "getCatalogSeparator"     ,       0       ,       -1      ,        "このデータベースがカタログ名とテーブル名のセパレータとして使用する String"     )
    1451                , new MetaDataInvoke( "getCatalogTerm"  ,       0       ,       -1      ,        "「catalog」に対するデータベースベンダーの推奨用語を取得します。 "         )
    1452                , new MetaDataInvoke( "getDatabaseProductName"  ,       0       ,       -1      ,        "このデータベース製品の名前を取得します。 "        )
    1453                , new MetaDataInvoke( "getDatabaseProductVersion"       ,       0       ,       -1      ,        "このデータベース製品のバージョンを取得します。 "     )
    1454                , new MetaDataInvoke( "getDriverMajorVersion"   ,       0       ,       -1      ,        "この JDBC ドライバのメジャーバージョンを取得します。 "       )
    1455                , new MetaDataInvoke( "getDriverMinorVersion"   ,       0       ,       -1      ,        "この JDBC ドライバのマイナーバージョンを取得します。 "       )
    1456                , new MetaDataInvoke( "getDriverName"   ,       0       ,       -1      ,        "この JDBC ドライバの名前を取得します。 "      )
    1457                , new MetaDataInvoke( "getDriverVersion"        ,       0       ,       -1      ,        "この JDBC ドライバのバージョンを String"   )
    1458                , new MetaDataInvoke( "getExtraNameCharacters"  ,       0       ,       -1      ,        "引用符で囲まれていない識別名に使用できるすべての「特殊」文字 (a-z、A-Z、0-9、および _ 以外) を取得します。 "       )
    1459                , new MetaDataInvoke( "getIdentifierQuoteString"        ,       0       ,       -1      ,        "SQL 識別子を引用するのに使用する文字列を取得します。 "        )
    1460                , new MetaDataInvoke( "getNumericFunctions"     ,       0       ,       -1      ,        "このデータベースで使用可能なコンマで区切った数学関数のリストを取得します。 "       )
    1461                , new MetaDataInvoke( "getProcedureTerm"        ,       0       ,       -1      ,        "「procedure」に対するデータベースベンダーの推奨用語を取得します。 "       )
    1462                , new MetaDataInvoke( "getSchemaTerm"   ,       0       ,       -1      ,        "「schema」に対するデータベースベンダーの推奨用語を取得します。 "  )
    1463                , new MetaDataInvoke( "getSearchStringEscape"   ,       0       ,       -1      ,        "ワイルドカード文字をエスケープするのに使用できる文字列を取得します。 "  )
    1464                , new MetaDataInvoke( "getSQLKeywords"  ,       0       ,       -1      ,        "このデータベースの SQL キーワードであって、SQL92 のキーワードではない、すべてのキーワードをコンマで区切ったリストを取得します。 "       )
    1465                , new MetaDataInvoke( "getStringFunctions"      ,       0       ,       -1      ,        "このデータベースで使用可能なコンマで区切った文字列関数のリストを取得します。 "      )
    1466                , new MetaDataInvoke( "getSystemFunctions"      ,       0       ,       -1      ,        "このデータベースで使用可能なコンマで区切ったシステム関数のリストを取得します。 "     )
    1467                , new MetaDataInvoke( "getTimeDateFunctions"    ,       0       ,       -1      ,        "このデータベースで使用可能な時間関数と日付関数をコンマで区切ったリストを取得します。 "  )
    1468                , new MetaDataInvoke( "getURL"  ,       0       ,       -1      ,        "この DBMS の URL を取得します。 "       )
    1469                , new MetaDataInvoke( "getUserName"     ,       0       ,       -1      ,        "このデータベースに記録されているユーザ名を取得します。 "         )
    1470
    1471                , new MetaDataInvoke( "getDefaultTransactionIsolation"  ,       0       ,       -1      ,        "このデータベースのデフォルトのトランザクション遮断レベルを取得します。 "         )
    1472                , new MetaDataInvoke( "getSQLStateType"         ,       0       ,       -1      ,        "Throwable.getSQLState によって返される SQLSTATE が X/Open (現在は Open Group) の SQL CLI であるか SQL99 であるかを示します。 "   )
    1473                , new MetaDataInvoke( "getResultSetHoldability"         ,       0       ,       -1      ,        "この ResultSet オブジェクトのデフォルトの保持機能を取得します。 "       )
    1474
    1475                , new MetaDataInvoke( "allProceduresAreCallable"        ,       0       ,       -1      ,        "getProcedures メソッドによって返されるすべてのプロシージャが、現在のユーザから呼び出せるかどうかを取得します。 "      )
    1476                , new MetaDataInvoke( "allTablesAreSelectable"  ,       0       ,       -1      ,        "getTables メソッドによって返されるすべてのテーブルが、現在のユーザによって使用できるかどうかを取得します。 "  )
    1477                , new MetaDataInvoke( "dataDefinitionCausesTransactionCommit"   ,       0       ,       -1      ,        "トランザクションのデータ定義文が、トランザクションを強制的にコミットさせるかどうかを取得します。 "    )
    1478                , new MetaDataInvoke( "dataDefinitionIgnoredInTransactions"     ,       0       ,       -1      ,        "このデータベースによって、トランザクションでデータ定義文が無視されるかどうかを取得します。 "       )
    1479                , new MetaDataInvoke( "deletesAreDetected"      ,       1       ,       -1      ,        "ResultSet.rowDeleted メソッドを呼び出すことによって可視の行が削除されたことを検出できるかどうかを取得します。 "   )
    1480                , new MetaDataInvoke( "doesMaxRowSizeIncludeBlobs"      ,       0       ,       -1      ,        "getMaxRowSize メソッドの戻り値が SQL データの型の LONGVARCHAR および LONGVARBINARY を含むかどうかを取得します。 "     )
    1481                , new MetaDataInvoke( "insertsAreDetected"      ,       1       ,       -1      ,        "ResultSet.rowInserted メソッドを呼び出すことによって可視の行が挿入されたことを検出できるかどうかを取得します。 "  )
    1482                , new MetaDataInvoke( "isCatalogAtStart"        ,       0       ,       -1      ,        "完全修飾されたテーブル名の開始部分 (または終了部分) にカタログが現れるかどうかを取得します。 "    )
    1483                , new MetaDataInvoke( "isReadOnly"      ,       0       ,       -1      ,        "このデータベースが読み込み専用モードかどうかを取得します。 "       )
    1484                , new MetaDataInvoke( "locatorsUpdateCopy"      ,       0       ,       -1      ,        "LOB への変更が、コピーに対して行われたのか、LOB に直接行われたのかを示します。 "         )
    1485                , new MetaDataInvoke( "nullPlusNonNullIsNull"   ,       0       ,       -1      ,        "このデータベースが、NULL 値と非 NULL 値の連結を NULL とするかどうかを取得します。 "   )
    1486                , new MetaDataInvoke( "nullsAreSortedAtEnd"     ,       0       ,       -1      ,        "NULL 値が、終了時にソート順にかかわらずソートされるかどうかを取得します。 "     )
    1487                , new MetaDataInvoke( "nullsAreSortedAtStart"   ,       0       ,       -1      ,        "NULL 値が、開始時にソート順にかかわらずソートされるかどうかを取得します。 "     )
    1488                , new MetaDataInvoke( "nullsAreSortedHigh"      ,       0       ,       -1      ,        "NULL 値が高位にソートされるかどうかを取得します。 "         )
    1489                , new MetaDataInvoke( "nullsAreSortedLow"       ,       0       ,       -1      ,        "NULL 値が下位にソートされるかどうかを取得します。 "         )
    1490                , new MetaDataInvoke( "othersDeletesAreVisible"         ,       1       ,       -1      ,        "他で行われた削除が可視かどうかを取得します。 "      )
    1491                , new MetaDataInvoke( "othersInsertsAreVisible"         ,       1       ,       -1      ,        "他で行われた挿入が可視かどうかを取得します。 "      )
    1492                , new MetaDataInvoke( "othersUpdatesAreVisible"         ,       1       ,       -1      ,        "他で行われた更新が可視かどうかを取得します。 "      )
    1493                , new MetaDataInvoke( "ownDeletesAreVisible"    ,       1       ,       -1      ,        "結果セット自身の削除が可視かどうかを取得します。 "    )
    1494                , new MetaDataInvoke( "ownInsertsAreVisible"    ,       1       ,       -1      ,        "結果セット自身の挿入が可視かどうかを取得します。 "    )
    1495                , new MetaDataInvoke( "ownUpdatesAreVisible"    ,       1       ,       -1      ,        "指定された ResultSet オブジェクトについて、結果セット自身の更新が可視かどうかを取得します。 "         )
    1496                , new MetaDataInvoke( "storesLowerCaseIdentifiers"      ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、小文字で格納するかどうかを取得します。 "   )
    1497                , new MetaDataInvoke( "storesLowerCaseQuotedIdentifiers"        ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、小文字で格納するかどうかを取得します。 "   )
    1498                , new MetaDataInvoke( "storesMixedCaseIdentifiers"      ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、大文字小文字混在で格納するかどうかを取得します。 "      )
    1499                , new MetaDataInvoke( "storesMixedCaseQuotedIdentifiers"        ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、大文字小文字混在で格納するかどうかを取得します。 "      )
    1500                , new MetaDataInvoke( "storesUpperCaseIdentifiers"      ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、大文字で格納するかどうかを取得します。 "   )
    1501                , new MetaDataInvoke( "storesUpperCaseQuotedIdentifiers"        ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、大文字で格納するかどうかを取得します。 "   )
    1502                , new MetaDataInvoke( "supportsAlterTableWithAddColumn"         ,       0       ,       -1      ,        "このデータベースによって、追加列のある ALTER TABLE がサポートされるかどうかを取得します。 "         )
    1503                , new MetaDataInvoke( "supportsAlterTableWithDropColumn"        ,       0       ,       -1      ,        "このデータベースによって、ドロップ列のある ALTER TABLE がサポートされるかどうかを取得します。 "       )
    1504                , new MetaDataInvoke( "supportsANSI92EntryLevelSQL"     ,       0       ,       -1      ,        "このデータベースによって、ANSI92 エントリレベルの SQL 文法がサポートされるかどうかを取得します。 "      )
    1505                , new MetaDataInvoke( "supportsANSI92FullSQL"   ,       0       ,       -1      ,        "このデータベースによって、ANSI92 完全レベルの SQL 文法がサポートされるかどうかを取得します。 "        )
    1506                , new MetaDataInvoke( "supportsANSI92IntermediateSQL"   ,       0       ,       -1      ,        "このデータベースによって、ANSI92 中間レベルの SQL 文法がサポートされるかどうかを取得します。 "        )
    1507                , new MetaDataInvoke( "supportsBatchUpdates"    ,       0       ,       -1      ,        "このデータベースによってバッチ更新がサポートされるかどうかを取得します。 "        )
    1508                , new MetaDataInvoke( "supportsCatalogsInDataManipulation"      ,       0       ,       -1      ,        "データ操作文でカタログ名を使用できるかどうかを取得します。 "       )
    1509                , new MetaDataInvoke( "supportsCatalogsInIndexDefinitions"      ,       0       ,       -1      ,        "インデックス定義文でカタログ名を使用できるかどうかを取得します。 "    )
    1510                , new MetaDataInvoke( "supportsCatalogsInPrivilegeDefinitions"  ,       0       ,       -1      ,        "特権定義文でカタログ名を使用できるかどうかを取得します。 "        )
    1511                , new MetaDataInvoke( "supportsCatalogsInProcedureCalls"        ,       0       ,       -1      ,        "プロシージャ呼び出し文でカタログ名を使用できるかどうかを取得します。 "  )
    1512                , new MetaDataInvoke( "supportsCatalogsInTableDefinitions"      ,       0       ,       -1      ,        "テーブル定義文でカタログ名を使用できるかどうかを取得します。 "      )
    1513                , new MetaDataInvoke( "supportsColumnAliasing"  ,       0       ,       -1      ,        "このデータベースによって列の別名がサポートされるかどうかを取得します。  "        )
    1514        //      , new MetaDataInvoke( "supportsConvertFunc"     ,       0       ,       -1      ,        "このデータベースによって、SQL の型間の CONVERT 関数がサポートされるかどうかを取得します。 "         )
    1515                , new MetaDataInvoke( "supportsCoreSQLGrammar"  ,       0       ,       -1      ,        "このデータベースによって、ODBC Core SQL 文法がサポートされるかどうかを取得します。 "    )
    1516                , new MetaDataInvoke( "supportsCorrelatedSubqueries"    ,       0       ,       -1      ,        "このデータベースによって照合関係サブクエリーがサポートされるかどうかを取得します。 "   )
    1517                , new MetaDataInvoke( "supportsDataDefinitionAndDataManipulationTransactions"   ,       0       ,       -1      ,        "このデータベースによって、トランザクションで、データ定義文とデータ操作文の両方がサポートされるかどうかを取得します。 "  )
    1518                , new MetaDataInvoke( "supportsDataManipulationTransactionsOnly"        ,       0       ,       -1      ,        "このデータベースによって、トランザクションでデータ操作文だけがサポートされるかどうかを取得します。 "   )
    1519                , new MetaDataInvoke( "supportsDifferentTableCorrelationNames"  ,       0       ,       -1      ,        "テーブル相互関係名がサポートされる場合、テーブルの名前と異なる名前であるという制限を付けるかどうかを取得します。 "    )
    1520                , new MetaDataInvoke( "supportsExpressionsInOrderBy"    ,       0       ,       -1      ,        "このデータベースによって、ORDER BY リスト中で式がサポートされるかどうかを取得します。 "     )
    1521                , new MetaDataInvoke( "supportsExtendedSQLGrammar"      ,       0       ,       -1      ,        "このデータベースによって、ODBC Extended SQL 文法がサポートされるかどうかを取得します。 "        )
    1522                , new MetaDataInvoke( "supportsFullOuterJoins"  ,       0       ,       -1      ,        "このデータベースによって、完全入れ子の外部結合がサポートされるかどうかを取得します。 "  )
    1523                , new MetaDataInvoke( "supportsGetGeneratedKeys"        ,       0       ,       -1      ,        "文が実行されたあとに自動生成キーを取得できるかどうかを取得します。 "   )
    1524                , new MetaDataInvoke( "supportsGroupBy"         ,       0       ,       -1      ,        "このデータベースによって、GROUP BY 節のフォームがサポートされるかどうかを取得します。 "     )
    1525                , new MetaDataInvoke( "supportsGroupByBeyondSelect"     ,       0       ,       -1      ,        "SELECT 文中のすべての列が GROUP BY 節に含まれるという条件で、このデータベースによって、GROUP BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 "         )
    1526                , new MetaDataInvoke( "supportsGroupByUnrelated"        ,       0       ,       -1      ,        "このデータベースによって、GROUP BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 "        )
    1527                , new MetaDataInvoke( "supportsIntegrityEnhancementFacility"    ,       0       ,       -1      ,        "このデータベースによって、SQL Integrity Enhancement Facility がサポートされるかどうかを取得します。 "         )
    1528                , new MetaDataInvoke( "supportsLikeEscapeClause"        ,       0       ,       -1      ,        "このデータベースによって、LIKE エスケープ節の指定がサポートされるかどうかを取得します。 "      )
    1529                , new MetaDataInvoke( "supportsLimitedOuterJoins"       ,       0       ,       -1      ,        "このデータベースによって、外部結合に関し、制限されたサポートが提供されるかどうかを取得します (supportsFullOuterJoins メソッドが true を返す場合は true)。 "     )
    1530                , new MetaDataInvoke( "supportsMinimumSQLGrammar"       ,       0       ,       -1      ,        "このデータベースによって、ODBC Minimum SQL 文法がサポートされるかどうかを取得します。 "         )
    1531                , new MetaDataInvoke( "supportsMixedCaseIdentifiers"    ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別して処理し、大文字小文字混在で格納するかどうかを取得します。 "        )
    1532                , new MetaDataInvoke( "supportsMixedCaseQuotedIdentifiers"      ,       0       ,       -1      ,        "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別して処理し、結果として大文字小文字混在で格納するかどうかを取得します。 "   )
    1533                , new MetaDataInvoke( "supportsMultipleOpenResults"     ,       0       ,       -1      ,        "CallableStatement オブジェクトから同時に返された複数の ResultSet オブジェクトを持つことが可能かどうかを取得します。 "    )
    1534                , new MetaDataInvoke( "supportsMultipleResultSets"      ,       0       ,       -1      ,        "このデータベースによって、execute メソッドの単一の呼び出しからの複数の ResultSet オブジェクトの取得がサポートされるかどうかを取得します。 "      )
    1535                , new MetaDataInvoke( "supportsMultipleTransactions"    ,       0       ,       -1      ,        "このデータベースが一度に複数のトランザクションを (異なった接続で) オープンできるかどうかを取得します。 "       )
    1536                , new MetaDataInvoke( "supportsNamedParameters"         ,       0       ,       -1      ,        "このデータベースによって、callable 文への名前付きパラメータがサポートされるかどうかを取得します。 "       )
    1537                , new MetaDataInvoke( "supportsNonNullableColumns"      ,       0       ,       -1      ,        "このデータベースの列を非 null として定義できるかどうかを取得します。 "       )
    1538                , new MetaDataInvoke( "supportsOpenCursorsAcrossCommit"         ,       0       ,       -1      ,        "このデータベースによって、コミット間でカーソルがオープンされたままの状態がサポートされるかどうかを取得します。 "     )
    1539                , new MetaDataInvoke( "supportsOpenCursorsAcrossRollback"       ,       0       ,       -1      ,        "このデータベースによって、ロールバック間でカーソルがオープンされたままの状態がサポートされるかどうかを取得します。 "   )
    1540                , new MetaDataInvoke( "supportsOpenStatementsAcrossCommit"      ,       0       ,       -1      ,        "このデータベースによって、コミット間で文がオープンされたままの状態がサポートされるかどうかを取得します。 "        )
    1541                , new MetaDataInvoke( "supportsOpenStatementsAcrossRollback"    ,       0       ,       -1      ,        "このデータベースによって、ロールバック間で文がオープンされたままの状態がサポートされるかどうかを取得します。 "      )
    1542                , new MetaDataInvoke( "supportsOrderByUnrelated"        ,       0       ,       -1      ,        "このデータベースによって、ORDER BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 "        )
    1543                , new MetaDataInvoke( "supportsOuterJoins"      ,       0       ,       -1      ,        "このデータベースによって、外部結合のなんらかの形式がサポートされるかどうかを取得します。 "        )
    1544                , new MetaDataInvoke( "supportsPositionedDelete"        ,       0       ,       -1      ,        "このデータベースによって、位置指定された DELETE 文がサポートされるかどうかを取得します。 "    )
    1545                , new MetaDataInvoke( "supportsPositionedUpdate"        ,       0       ,       -1      ,        "このデータベースによって、位置指定された UPDATE 文がサポートされるかどうかを取得します。 "    )
    1546                , new MetaDataInvoke( "supportsResultSetConcurrency"    ,       2       ,       -1      ,        "このデータベースが、指定された結果セットの型と与えられた並行処理の種類の組み合わせをサポートするかどうかを取得します。 "         )
    1547                , new MetaDataInvoke( "supportsResultSetHoldability"    ,       3       ,       -1      ,        "このデータベースが、指定された結果セットの保持機能をサポートするかどうかを取得します。 "         )
    1548                , new MetaDataInvoke( "supportsResultSetType"   ,       4       ,       ResultSet.TYPE_FORWARD_ONLY     ,        "このデータベースが、[TYPE_FORWARD_ONLY]指定された結果セットの型をサポートするかどうかを取得します。 "         )
    1549                , new MetaDataInvoke( "supportsResultSetType"   ,       4       ,       ResultSet.TYPE_SCROLL_INSENSITIVE       ,        "このデータベースが、[TYPE_SCROLL_INSENSITIVE]指定された結果セットの型をサポートするかどうかを取得します。 "   )
    1550                , new MetaDataInvoke( "supportsResultSetType"   ,       4       ,       ResultSet.TYPE_SCROLL_SENSITIVE ,        "このデータベースが、[TYPE_SCROLL_SENSITIVE]指定された結果セットの型をサポートするかどうかを取得します。 "     )
    1551                , new MetaDataInvoke( "supportsSavepoints"      ,       0       ,       -1      ,        "このデータベースによってセーブポイントがサポートされるかどうかを取得します。 "      )
    1552                , new MetaDataInvoke( "supportsSchemasInDataManipulation"       ,       0       ,       -1      ,        "データ操作文でスキーマ名を使用できるかどうかを取得します。 "       )
    1553                , new MetaDataInvoke( "supportsSchemasInIndexDefinitions"       ,       0       ,       -1      ,        "インデックス定義文でスキーマ名を使用できるかどうかを取得します。 "    )
    1554                , new MetaDataInvoke( "supportsSchemasInPrivilegeDefinitions"   ,       0       ,       -1      ,        "特権定義文でスキーマ名を使用できるかどうかを取得します。 "        )
    1555                , new MetaDataInvoke( "supportsSchemasInProcedureCalls"         ,       0       ,       -1      ,        "プロシージャ呼び出し文でスキーマ名を使用できるかどうかを取得します。 "  )
    1556                , new MetaDataInvoke( "supportsSchemasInTableDefinitions"       ,       0       ,       -1      ,        "テーブル定義文でスキーマ名を使用できるかどうかを取得します。 "      )
    1557                , new MetaDataInvoke( "supportsSelectForUpdate"         ,       0       ,       -1      ,        "このデータベースによって SELECT FOR UPDATE 文がサポートされるかどうかを取得します。 "         )
    1558                , new MetaDataInvoke( "supportsStatementPooling"        ,       0       ,       -1      ,        "このデータベースによって文のプールがサポートされるかどうかを取得します。 "        )
    1559                , new MetaDataInvoke( "supportsStoredProcedures"        ,       0       ,       -1      ,        "このデータベースによって、ストアドプロシージャエスケープ構文を使用するストアドプロシージャコールがサポートされるかどうかを判定します。 "         )
    1560                , new MetaDataInvoke( "supportsSubqueriesInComparisons"         ,       0       ,       -1      ,        "このデータベースによって、比較式中でサブクエリーがサポートされるかどうかを取得します。 "         )
    1561                , new MetaDataInvoke( "supportsSubqueriesInExists"      ,       0       ,       -1      ,        "このデータベースによって、EXISTS 式中でサブクエリーがサポートされるかどうかを取得します。 "    )
    1562                , new MetaDataInvoke( "supportsSubqueriesInIns"         ,       0       ,       -1      ,        "このデータベースによって、IN 文中でサブクエリーがサポートされるかどうかを取得します。 "        )
    1563                , new MetaDataInvoke( "supportsSubqueriesInQuantifieds"         ,       0       ,       -1      ,        "このデータベースによって、定量化された式中でサブクエリーがサポートされるかどうかを取得します。 "     )
    1564                , new MetaDataInvoke( "supportsTableCorrelationNames"   ,       0       ,       -1      ,        "このデータベースによってテーブル相互関係名がサポートされるかどうかを取得します。 "    )
    1565                , new MetaDataInvoke( "supportsTransactionIsolationLevel"       ,       4       ,       Connection.TRANSACTION_READ_COMMITTED   ,        "このデータベースが、指定されたトランザクション遮断レベルをサポートするかどうかを取得します。 "      )
    1566                , new MetaDataInvoke( "supportsTransactionIsolationLevel"       ,       4       ,       Connection.TRANSACTION_READ_UNCOMMITTED ,        "このデータベースが、指定されたトランザクション遮断レベルをサポートするかどうかを取得します。 "      )
    1567                , new MetaDataInvoke( "supportsTransactionIsolationLevel"       ,       4       ,       Connection.TRANSACTION_REPEATABLE_READ  ,        "このデータベースが、指定されたトランザクション遮断レベルをサポートするかどうかを取得します。 "      )
    1568                , new MetaDataInvoke( "supportsTransactionIsolationLevel"       ,       4       ,       Connection.TRANSACTION_SERIALIZABLE     ,        "このデータベースが、指定されたトランザクション遮断レベルをサポートするかどうかを取得します。 "      )
    1569                , new MetaDataInvoke( "supportsTransactions"    ,       0       ,       -1      ,        "このデータベースによってトランザクションがサポートされるかどうかを取得します。 "     )
    1570                , new MetaDataInvoke( "supportsUnion"   ,       0       ,       -1      ,        "このデータベースによって SQL UNION がサポートされるかどうかを取得します。 "  )
    1571                , new MetaDataInvoke( "supportsUnionAll"        ,       0       ,       -1      ,        "このデータベースによって SQL UNION ALL がサポートされるかどうかを取得します。 "      )
    1572                , new MetaDataInvoke( "updatesAreDetected"      ,       1       ,       -1      ,        "ResultSet.rowUpdated メソッドを呼び出すことによって可視の行が更新されたことを検出できるかどうかを取得します。 "   )
    1573                , new MetaDataInvoke( "usesLocalFilePerTable"   ,       0       ,       -1      ,        "このデータベースが、各テーブルにファイルを使用するかどうかを取得します。 "        )
    1574                , new MetaDataInvoke( "usesLocalFiles"  ,       0       ,       -1      ,        "このデータベースが、ローカルファイルにテーブルを格納するかどうかを取得します。 "     )
    1575
    1576                , new MetaDataInvoke( "getAttributes"   ,       72      ,       -1      ,        "指定されたスキーマおよびカタログで使用可能なユーザ定義の型 (UDT) のための指定された型の指定された属性に関する記述を取得します。  "        )
    1577                , new MetaDataInvoke( "getBestRowIdentifier"    ,       64      ,       -1      ,        "行を一意に識別するテーブルの最適な列セットに関する記述を取得します。 "  )
    1578                , new MetaDataInvoke( "getCatalogs"     ,       50      ,       -1      ,        "このデータベースで使用可能なカタログ名を取得します。 "  )
    1579                , new MetaDataInvoke( "getColumnPrivileges"     ,       61      ,       -1      ,        "テーブルの列へのアクセス権に関する記述を取得します。  "         )
    1580                , new MetaDataInvoke( "getColumns"      ,       61      ,       -1      ,        "指定されたカタログで使用可能なテーブル列の記述を取得します。  "     )
    1581                , new MetaDataInvoke( "getCrossReference"       ,       65      ,       -1      ,        "指定された主キーテーブルの主キー列を参照する指定された外部のキーテーブル中の、外部のキー列に関する記述 (テーブルが別のキーをインポートする方法を記述) を取得します。 "        )
    1582                , new MetaDataInvoke( "getExportedKeys"         ,       60      ,       -1      ,        "指定されたテーブルの主キー列 (テーブルによってエクスポートされた外部キー) を参照する外部キー列に関する記述を取得します。 "      )
    1583                , new MetaDataInvoke( "getImportedKeys"         ,       60      ,       -1      ,        "テーブルの外部キー列 (テーブルによってインポートされる主キー) を参照する主キー列に関する記述を取得します。 "     )
    1584                , new MetaDataInvoke( "getIndexInfo"    ,       63      ,       -1      ,        "指定されたテーブルのインデックスと統計情報に関する記述を取得します。 "  )
    1585                , new MetaDataInvoke( "getPrimaryKeys"  ,       60      ,       -1      ,        "指定されたテーブルの主キー列の記述を取得します。 "    )
    1586                , new MetaDataInvoke( "getProcedureColumns"     ,       81      ,       -1      ,        "指定されたカタログのストアドプロシージャパラメータと結果列に関する記述を取得します。  "         )
    1587                , new MetaDataInvoke( "getProcedures"   ,       80      ,       -1      ,        "指定されたカタログで使用可能なストアドプロシージャに関する記述を取得します。  "     )
    1588                , new MetaDataInvoke( "getSchemas"      ,       50      ,       -1      ,        "このデータベースで使用可能なスキーマ名を取得します。 "  )
    1589                , new MetaDataInvoke( "getSuperTables"  ,       60      ,       -1      ,        "このデータベースの特定のスキーマで定義されているテーブル階層の説明を取得します。  "   )
    1590                , new MetaDataInvoke( "getSuperTypes"   ,       70      ,       -1      ,        "このデータベースの特定のスキーマで定義されているユーザ定義型 (UDT) 階層の説明を取得します。 "   )
    1591                , new MetaDataInvoke( "getTablePrivileges"      ,       60      ,       -1      ,        "カタログで使用可能な各テーブルに対するアクセス権に関する記述を取得します。 "       )
    1592                , new MetaDataInvoke( "getTables"       ,       62      ,       -1      ,        "指定されたカタログで使用可能なテーブルに関する記述を取得します。 "    )
    1593                , new MetaDataInvoke( "getTableTypes"   ,       50      ,       -1      ,        "このデータベースで使用可能なテーブルの型を取得します。 "         )
    1594                , new MetaDataInvoke( "getTypeInfo"     ,       50      ,       -1      ,        "このデータベースでサポートされているすべての標準 SQL の型に関する記述を取得します。 "        )
    1595                , new MetaDataInvoke( "getUDTs"         ,       71      ,       -1      ,        "特定のスキーマで定義されているユーザ定義型 (UDT) の説明を取得します。 "      )
    1596                , new MetaDataInvoke( "getVersionColumns"       ,       60      ,       -1      ,        "行の任意の値が変更された場合に、自動的に更新されるテーブルの列に関する記述を取得します。 "        )
    1597
    1598        // 5.5.3.2 (2012/06/08) JDk1.6 用のメソッドを追加します。
    1599                , new MetaDataInvoke( "autoCommitFailureClosesAllResultSets"    ,       0       ,       -1      ,        "autoCommit が true の場合に、ResultSet が保持可能であっても、すべてのオープンされた ResultSet がクローズされたことを SQLException が示すかどうかを取得します。"    )
    1600                , new MetaDataInvoke( "supportsConvert"         ,       0       ,       -1      ,        "このデータベースによって、JDBC 型 fromType と toType の間の変換に使用される JDBC スカラー関数 CONVERT がサポートされるかどうかを取得します。"    )
    1601                , new MetaDataInvoke( "supportsStoredFunctionsUsingCallSyntax"  ,       0       ,       -1      ,        "このデータベースが、ストアドプロシージャーエスケープ構文を使用した、ユーザー定義関数またはベンダー関数の呼び出しをサポートするかどうかを取得します。"   )
    1602                , new MetaDataInvoke( "getDatabaseMajorVersion"         ,       0       ,       -1      ,        "基本となるデータベースのメジャーバージョン番号を取得します。"       )
    1603                , new MetaDataInvoke( "getDatabaseMinorVersion"         ,       0       ,       -1      ,        "基本となるデータベースのマイナーバージョン番号を取得します。"       )
    1604                , new MetaDataInvoke( "getJDBCMajorVersion"     ,       0       ,       -1      ,        "このドライバの JDBC メジャーバージョン番号を取得します。"      )
    1605                , new MetaDataInvoke( "getJDBCMinorVersion"     ,       0       ,       -1      ,        "このドライバの JDBC マイナーバージョン番号を取得します。"      )
    1606                , new MetaDataInvoke( "getMaxBinaryLiteralLength"       ,       0       ,       -1      ,        "このデータベースで、インラインバイナリリテラル中に入れられる 16 進数の最大文字数を取得します。"    )
    1607                , new MetaDataInvoke( "getMaxCatalogNameLength"         ,       0       ,       -1      ,        "このデータベースでの、カタログ名の最大文字数を取得します。"        )
    1608                , new MetaDataInvoke( "getMaxCharLiteralLength"         ,       0       ,       -1      ,        "このデータベースでの、キャラクタリテラルの最大文字数を取得します。"    )
    1609                , new MetaDataInvoke( "getMaxColumnNameLength"  ,       0       ,       -1      ,        "このデータベースでの、列名の最大文字数を取得します。"   )
    1610                , new MetaDataInvoke( "getMaxColumnsInGroupBy"  ,       0       ,       -1      ,        "このデータベースでの、GROUP BY 節中の列数の最大値を取得します。"         )
    1611                , new MetaDataInvoke( "getMaxColumnsInIndex"    ,       0       ,       -1      ,        "このデータベースでの、インデックス中の列数の最大値を取得します。"     )
    1612                , new MetaDataInvoke( "getMaxColumnsInOrderBy"  ,       0       ,       -1      ,        "このデータベースでの、ORDER BY 節中の列数の最大値を取得します。"         )
    1613                , new MetaDataInvoke( "getMaxColumnsInSelect"   ,       0       ,       -1      ,        "このデータベースでの、SELECT リスト中の列数の最大値を取得します。"         )
    1614                , new MetaDataInvoke( "getMaxColumnsInTable"    ,       0       ,       -1      ,        "このデータベースでの、テーブル中の列数の最大値を取得します。"       )
    1615                , new MetaDataInvoke( "getMaxConnections"       ,       0       ,       -1      ,        "このデータベースに対して可能な並行接続の最大数を取得します。"       )
    1616                , new MetaDataInvoke( "getMaxCursorNameLength"  ,       0       ,       -1      ,        "このデータベースでの、カーソル名の最大文字数を取得します。"        )
    1617                , new MetaDataInvoke( "getMaxIndexLength"       ,       0       ,       -1      ,        "このデータベースでの、インデックスの全部分を含む、インデックスの最大バイト数を取得します。"        )
    1618                , new MetaDataInvoke( "getMaxProcedureNameLength"       ,       0       ,       -1      ,        "このデータベースでの、プロシージャー名の最大文字数を取得します。"     )
    1619                , new MetaDataInvoke( "getMaxRowSize"   ,       0       ,       -1      ,        "このデータベースでの、1 行の最大バイト数を取得します。"         )
    1620                , new MetaDataInvoke( "getMaxSchemaNameLength"  ,       0       ,       -1      ,        "このデータベースでの、スキーマ名の最大文字数を取得します。"        )
    1621                , new MetaDataInvoke( "getMaxStatementLength"   ,       0       ,       -1      ,        "このデータベースでの、SQL 文の最大文字数を取得します。"        )
    1622                , new MetaDataInvoke( "getMaxStatements"        ,       0       ,       -1      ,        "このデータベースの同時にオープンできるアクティブな文の最大数を取得します。"        )
    1623                , new MetaDataInvoke( "getMaxTableNameLength"   ,       0       ,       -1      ,        "このデータベースでの、テーブル名の最大文字数を取得します。"        )
    1624                , new MetaDataInvoke( "getMaxTablesInSelect"    ,       0       ,       -1      ,        "このデータベースでの、SELECT 文の最大テーブル数を取得します。"   )
    1625                , new MetaDataInvoke( "getMaxUserNameLength"    ,       0       ,       -1      ,        "このデータベースでの、ユーザー名の最大文字数を取得します。"        )
    1626
    1627                , new MetaDataInvoke( "getClientInfoProperties" ,       50      ,       -1      ,       "ドライバがサポートするクライアント情報プロパティーのリストを取得します。"  )
    1628                , new MetaDataInvoke( "getFunctionColumns"      ,       81      ,       -1      ,       "指定されたカタログのシステム関数またはユーザー関数のパラメータと返される型に関する記述を取得します。"    )
    1629                , new MetaDataInvoke( "getFunctions"    ,       80      ,       -1      ,       "指定されたカタログで使用可能なシステム関数およびユーザー関数に関する記述を取得します。"   )
    1630        } ;
    1631
    1632        private static final class MetaDataInvoke {
    1633                private final String  method  ;
    1634                private final int     type    ;                 // 0:引数なし 1: 2: 3: 4:内部value
    1635                private final Integer value   ;
    1636                private final String  comment ;
    1637
    1638                public MetaDataInvoke( String method,int type,int value,String comment ) {
    1639                        this.method  = method  ;
    1640                        this.type        = type    ;
    1641                        this.value   = Integer.valueOf(value) ;
    1642                        this.comment = comment ;
    1643                }
    1644
    1645                public String getMethod() { return method; }
    1646
    1647                public boolean isUseMethod( final String likeKey ) {
    1648                        return ( likeKey == null || method.indexOf( likeKey ) >= 0 );
    1649                }
    1650
    1651                public int getType() { return type; }
    1652
    1653                public String getComment() { return comment; }
    1654
    1655                public String getErrMsg() { return errMsg; }
    1656
    1657                public Object invokeA( final DatabaseMetaData metaData , final Integer... vals  ) {
    1658                        Object obj = null ;
    1659synchronized( metaData ) {
    1660                                try {
    1661                                        if( type == 0 ) {
    1662                                                obj = metaData.getClass().getMethod( method ).invoke(metaData);
    1663                                        } else if( type == 1 || type == 3 ) {
    1664                                                obj = metaData.getClass().getMethod( method,int.class ).invoke(metaData,vals[0]);
    1665                                        } else if( type == 2 ) {
    1666                                                obj = metaData.getClass().getMethod( method,int.class,int.class ).invoke(metaData,vals[0],vals[1]);
    1667                                        } else if( type == 4 ) {
    1668                                                obj = metaData.getClass().getMethod( method,int.class ).invoke(metaData,value);
    1669                                        } else {
    1670                                                errMsg = "*** リフレクションタイプなしエラー ***";
    1671                                        }
    1672                                }
    1673                                catch( Throwable ex ) {
    1674                                        errMsg = "*** 実行時エラー ***" + ex.getMessage();
    1675                                        obj = null;                             // "*** 実行時エラー ***"
    1676                                }
    1677}
    1678                                if( obj == null && errMsg == null ) { errMsg = "サポートされない機能です。"; }
    1679                        return obj ;
    1680                }
    1681
    1682                // 50   引数なし
    1683                // 60   (catalog, schema, tableName)
    1684                // 70   (catalog, schema, typeName)
    1685                // 80   (catalog, schema, procedureName)
    1686                // 62   (catalog, schema, tableName, (String[])null)    // String[]
    1687                // 71   (catalog, schema, typeName, (int[])null)                // int[]
    1688                // 63   (catalog, schema, tableName, false, false)
    1689                // 61   (catalog, schema, tableName, columnName)
    1690                // 72   (catalog, schema, typeName, attributeName)
    1691                // 81   (catalog, schema, procedureName, columnName)
    1692                // 64   (catalog, schema, tableName, (int)scope, (boolean)nullable)
    1693                // 65   (catalog, schema, tableName, (String)null, (String)null, (String)null)
    1694
    1695                private static final int     scope    = 0;
    1696                private static final boolean nullable = true;
    1697
    1698                private String errMsg = null;
    1699
    1700                public ResultSet invokeB( final DatabaseMetaData metaData , final String... vals  ) {
    1701                        ResultSet obj = null ;
    1702synchronized( metaData ) {
    1703                        try {
    1704                                if( type == 50 ) {      // 引数なし
    1705                                        obj = (ResultSet)metaData.getClass().getMethod( method ).invoke(metaData);
    1706                                } else if( type == 60 || type == 70 || type == 80 ) {
    1707                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class ).invoke(metaData,vals[0],vals[1],vals[2]);
    1708                                } else if( type == 62 ) {
    1709                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class,String[].class ).invoke(metaData,vals[0],vals[1],vals[2],null);
    1710                                } else if( type == 71 ) {
    1711                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class,int[].class ).invoke(metaData,vals[0],vals[1],vals[2],null);
    1712                                } else if( type == 63 ) {
    1713                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class,boolean.class,boolean.class ).invoke(metaData,vals[0],vals[1],vals[2],false,false);
    1714                                } else if( type == 61 || type == 72 || type == 81 ) {
    1715                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class,String.class ).invoke(metaData,vals[0],vals[1],vals[2],vals[3]);
    1716                                } else if( type == 64 ) {
    1717                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class,int.class,boolean.class ).invoke(metaData,vals[0],vals[1],vals[2],scope,nullable);
    1718                                } else if( type == 65 ) {
    1719                                        obj = (ResultSet)metaData.getClass().getMethod( method,String.class,String.class,String.class,String.class,String.class,String.class ).invoke(metaData,vals[0],vals[1],vals[2],null,null,null);
    1720                                } else {
    1721                                        errMsg = "*** リフレクションタイプなしエラー ***";
    1722                                }
    1723                        }
    1724                        catch( Throwable ex ) {
    1725                                errMsg = "*** 実行時エラー ***" + ex.getMessage();
    1726                                obj = null;                             // "*** 実行時エラー ***"
    1727                        }
    1728}
    1729                        if( obj == null && errMsg == null ) { errMsg = "サポートされない機能です。"; }
    1730                        return obj ;
    1731                }
    1732        }
    1733
    1734//      private static final String getCatalogSeparator = "このデータベースがカタログ名とテーブル名のセパレータとして使用する String" ;
    1735//      private static final String getCatalogTerm = "「catalog」に対するデータベースベンダーの推奨用語を取得します。 " ;
    1736//      private static final String getDatabaseProductName = "このデータベース製品の名前を取得します。 " ;
    1737//      private static final String getDatabaseProductVersion = "このデータベース製品のバージョンを取得します。 " ;
    1738//      private static final String getDriverMajorVersion = "この JDBC ドライバのメジャーバージョンを取得します。 " ;
    1739//      private static final String getDriverMinorVersion = "この JDBC ドライバのマイナーバージョンを取得します。 " ;
    1740//      private static final String getDriverName = "この JDBC ドライバの名前を取得します。 " ;
    1741//      private static final String getDriverVersion = "この JDBC ドライバのバージョンを String" ;
    1742//      private static final String getExtraNameCharacters = "引用符で囲まれていない識別名に使用できるすべての「特殊」文字 (a-z、A-Z、0-9、および _ 以外) を取得します。 " ;
    1743//      private static final String getIdentifierQuoteString = "SQL 識別子を引用するのに使用する文字列を取得します。 " ;
    1744//      private static final String getNumericFunctions = "このデータベースで使用可能なコンマで区切った数学関数のリストを取得します。 " ;
    1745//      private static final String getProcedureTerm = "「procedure」に対するデータベースベンダーの推奨用語を取得します。 " ;
    1746//      private static final String getSchemaTerm = "「schema」に対するデータベースベンダーの推奨用語を取得します。 " ;
    1747//      private static final String getSearchStringEscape = "ワイルドカード文字をエスケープするのに使用できる文字列を取得します。 " ;
    1748//      private static final String getSQLKeywords = "このデータベースの SQL キーワードであって、SQL92 のキーワードではない、すべてのキーワードをコンマで区切ったリストを取得します。 " ;
    1749//      private static final String getStringFunctions = "このデータベースで使用可能なコンマで区切った文字列関数のリストを取得します。 " ;
    1750//      private static final String getSystemFunctions = "このデータベースで使用可能なコンマで区切ったシステム関数のリストを取得します。 " ;
    1751        private static final String getTimeDateFunctions = "このデータベースで使用可能な時間関数と日付関数をコンマで区切ったリストを取得します。 " ;
    1752//      private static final String getURL = "この DBMS の URL を取得します。 " ;
    1753//      private static final String getUserName = "このデータベースに記録されているユーザ名を取得します。 " ;
    1754//
    1755//      private static final String getDefaultTransactionIsolation = "このデータベースのデフォルトのトランザクション遮断レベルを取得します。 " ;
    1756//      private static final String getSQLStateType = "Throwable.getSQLState によって返される SQLSTATE が X/Open (現在は Open Group) の SQL CLI であるか SQL99 であるかを示します。 " ;
    1757//      private static final String getResultSetHoldability = "この ResultSet オブジェクトのデフォルトの保持機能を取得します。 " ;
    1758//
    1759//      private static final String allProceduresAreCallable = "getProcedures メソッドによって返されるすべてのプロシージャが、現在のユーザから呼び出せるかどうかを取得します。 " ;
    1760//      private static final String allTablesAreSelectable = "getTables メソッドによって返されるすべてのテーブルが、現在のユーザによって使用できるかどうかを取得します。 " ;
    1761//      private static final String dataDefinitionCausesTransactionCommit = "トランザクションのデータ定義文が、トランザクションを強制的にコミットさせるかどうかを取得します。 " ;
    1762//      private static final String dataDefinitionIgnoredInTransactions = "このデータベースによって、トランザクションでデータ定義文が無視されるかどうかを取得します。 " ;
    1763//      private static final String deletesAreDetected = "ResultSet.rowDeleted メソッドを呼び出すことによって可視の行が削除されたことを検出できるかどうかを取得します。 " ;
    1764//      private static final String doesMaxRowSizeIncludeBlobs = "getMaxRowSize メソッドの戻り値が SQL データの型の LONGVARCHAR および LONGVARBINARY を含むかどうかを取得します。 " ;
    1765//      private static final String insertsAreDetected = "ResultSet.rowInserted メソッドを呼び出すことによって可視の行が挿入されたことを検出できるかどうかを取得します。 " ;
    1766//      private static final String isCatalogAtStart = "完全修飾されたテーブル名の開始部分 (または終了部分) にカタログが現れるかどうかを取得します。 " ;
    1767//      private static final String isReadOnly = "このデータベースが読み込み専用モードかどうかを取得します。 " ;
    1768//      private static final String locatorsUpdateCopy = "LOB への変更が、コピーに対して行われたのか、LOB に直接行われたのかを示します。 " ;
    1769//      private static final String nullPlusNonNullIsNull = "このデータベースが、NULL 値と非 NULL 値の連結を NULL とするかどうかを取得します。 " ;
    1770//      private static final String nullsAreSortedAtEnd = "NULL 値が、終了時にソート順にかかわらずソートされるかどうかを取得します。 " ;
    1771//      private static final String nullsAreSortedAtStart = "NULL 値が、開始時にソート順にかかわらずソートされるかどうかを取得します。 " ;
    1772//      private static final String nullsAreSortedHigh = "NULL 値が高位にソートされるかどうかを取得します。 " ;
    1773//      private static final String nullsAreSortedLow = "NULL 値が下位にソートされるかどうかを取得します。 " ;
    1774//      private static final String othersDeletesAreVisible = "他で行われた削除が可視かどうかを取得します。 " ;
    1775//      private static final String othersInsertsAreVisible = "他で行われた挿入が可視かどうかを取得します。 " ;
    1776//      private static final String othersUpdatesAreVisible = "他で行われた更新が可視かどうかを取得します。 " ;
    1777//      private static final String ownDeletesAreVisible = "結果セット自身の削除が可視かどうかを取得します。 " ;
    1778//      private static final String ownInsertsAreVisible = "結果セット自身の挿入が可視かどうかを取得します。 " ;
    1779//      private static final String ownUpdatesAreVisible = "指定された ResultSet オブジェクトについて、結果セット自身の更新が可視かどうかを取得します。 " ;
    1780//      private static final String storesLowerCaseIdentifiers = "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、小文字で格納するかどうかを取得します。 " ;
    1781//      private static final String storesLowerCaseQuotedIdentifiers = "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、小文字で格納するかどうかを取得します。 " ;
    1782//      private static final String storesMixedCaseIdentifiers = "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、大文字小文字混在で格納するかどうかを取得します。 " ;
    1783//      private static final String storesMixedCaseQuotedIdentifiers = "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、大文字小文字混在で格納するかどうかを取得します。 " ;
    1784//      private static final String storesUpperCaseIdentifiers = "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別しないで処理し、大文字で格納するかどうかを取得します。 " ;
    1785//      private static final String storesUpperCaseQuotedIdentifiers = "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別しないで処理し、大文字で格納するかどうかを取得します。 " ;
    1786//      private static final String supportsAlterTableWithAddColumn = "このデータベースによって、追加列のある ALTER TABLE がサポートされるかどうかを取得します。 " ;
    1787//      private static final String supportsAlterTableWithDropColumn = "このデータベースによって、ドロップ列のある ALTER TABLE がサポートされるかどうかを取得します。 " ;
    1788//      private static final String supportsANSI92EntryLevelSQL = "このデータベースによって、ANSI92 エントリレベルの SQL 文法がサポートされるかどうかを取得します。 " ;
    1789//      private static final String supportsANSI92FullSQL = "このデータベースによって、ANSI92 完全レベルの SQL 文法がサポートされるかどうかを取得します。 " ;
    1790//      private static final String supportsANSI92IntermediateSQL = "このデータベースによって、ANSI92 中間レベルの SQL 文法がサポートされるかどうかを取得します。 " ;
    1791//      private static final String supportsBatchUpdates = "このデータベースによってバッチ更新がサポートされるかどうかを取得します。 " ;
    1792//      private static final String supportsCatalogsInDataManipulation = "データ操作文でカタログ名を使用できるかどうかを取得します。 " ;
    1793//      private static final String supportsCatalogsInIndexDefinitions = "インデックス定義文でカタログ名を使用できるかどうかを取得します。 " ;
    1794//      private static final String supportsCatalogsInPrivilegeDefinitions = "特権定義文でカタログ名を使用できるかどうかを取得します。 " ;
    1795//      private static final String supportsCatalogsInProcedureCalls = "プロシージャ呼び出し文でカタログ名を使用できるかどうかを取得します。 " ;
    1796//      private static final String supportsCatalogsInTableDefinitions = "テーブル定義文でカタログ名を使用できるかどうかを取得します。 " ;
    1797//      private static final String supportsColumnAliasing = "このデータベースによって列の別名がサポートされるかどうかを取得します。  " ;
    1798        private static final String supportsConvertFunc = "このデータベースによって、SQL の型間の CONVERT 関数がサポートされるかどうかを取得します。 " ;
    1799//      private static final String supportsCoreSQLGrammar = "このデータベースによって、ODBC Core SQL 文法がサポートされるかどうかを取得します。 " ;
    1800//      private static final String supportsCorrelatedSubqueries = "このデータベースによって照合関係サブクエリーがサポートされるかどうかを取得します。 " ;
    1801//      private static final String supportsDataDefinitionAndDataManipulationTransactions = "このデータベースによって、トランザクションで、データ定義文とデータ操作文の両方がサポートされるかどうかを取得します。 " ;
    1802//      private static final String supportsDataManipulationTransactionsOnly = "このデータベースによって、トランザクションでデータ操作文だけがサポートされるかどうかを取得します。 " ;
    1803//      private static final String supportsDifferentTableCorrelationNames = "テーブル相互関係名がサポートされる場合、テーブルの名前と異なる名前であるという制限を付けるかどうかを取得します。 " ;
    1804//      private static final String supportsExpressionsInOrderBy = "このデータベースによって、ORDER BY リスト中で式がサポートされるかどうかを取得します。 " ;
    1805//      private static final String supportsExtendedSQLGrammar = "このデータベースによって、ODBC Extended SQL 文法がサポートされるかどうかを取得します。 " ;
    1806//      private static final String supportsFullOuterJoins = "このデータベースによって、完全入れ子の外部結合がサポートされるかどうかを取得します。 " ;
    1807//      private static final String supportsGetGeneratedKeys = "文が実行されたあとに自動生成キーを取得できるかどうかを取得します。 " ;
    1808//      private static final String supportsGroupBy = "このデータベースによって、GROUP BY 節のフォームがサポートされるかどうかを取得します。 " ;
    1809//      private static final String supportsGroupByBeyondSelect = "SELECT 文中のすべての列が GROUP BY 節に含まれるという条件で、このデータベースによって、GROUP BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 " ;
    1810//      private static final String supportsGroupByUnrelated = "このデータベースによって、GROUP BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 " ;
    1811//      private static final String supportsIntegrityEnhancementFacility = "このデータベースによって、SQL Integrity Enhancement Facility がサポートされるかどうかを取得します。 " ;
    1812//      private static final String supportsLikeEscapeClause = "このデータベースによって、LIKE エスケープ節の指定がサポートされるかどうかを取得します。 " ;
    1813//      private static final String supportsLimitedOuterJoins = "このデータベースによって、外部結合に関し、制限されたサポートが提供されるかどうかを取得します (supportsFullOuterJoins メソッドが true を返す場合は true)。 " ;
    1814//      private static final String supportsMinimumSQLGrammar = "このデータベースによって、ODBC Minimum SQL 文法がサポートされるかどうかを取得します。 " ;
    1815//      private static final String supportsMixedCaseIdentifiers = "このデータベースが、大文字小文字が混在する引用符なしの SQL 識別子を、大文字小文字を区別して処理し、大文字小文字混在で格納するかどうかを取得します。 " ;
    1816//      private static final String supportsMixedCaseQuotedIdentifiers = "このデータベースが、大文字小文字が混在する引用符付きの SQL 識別子を、大文字小文字を区別して処理し、結果として大文字小文字混在で格納するかどうかを取得します。 " ;
    1817//      private static final String supportsMultipleOpenResults = "CallableStatement オブジェクトから同時に返された複数の ResultSet オブジェクトを持つことが可能かどうかを取得します。 " ;
    1818//      private static final String supportsMultipleResultSets = "このデータベースによって、execute メソッドの単一の呼び出しからの複数の ResultSet オブジェクトの取得がサポートされるかどうかを取得します。 " ;
    1819//      private static final String supportsMultipleTransactions = "このデータベースが一度に複数のトランザクションを (異なった接続で) オープンできるかどうかを取得します。 " ;
    1820//      private static final String supportsNamedParameters = "このデータベースによって、callable 文への名前付きパラメータがサポートされるかどうかを取得します。 " ;
    1821//      private static final String supportsNonNullableColumns = "このデータベースの列を非 null として定義できるかどうかを取得します。 " ;
    1822//      private static final String supportsOpenCursorsAcrossCommit = "このデータベースによって、コミット間でカーソルがオープンされたままの状態がサポートされるかどうかを取得します。 " ;
    1823//      private static final String supportsOpenCursorsAcrossRollback = "このデータベースによって、ロールバック間でカーソルがオープンされたままの状態がサポートされるかどうかを取得します。 " ;
    1824//      private static final String supportsOpenStatementsAcrossCommit = "このデータベースによって、コミット間で文がオープンされたままの状態がサポートされるかどうかを取得します。 " ;
    1825//      private static final String supportsOpenStatementsAcrossRollback = "このデータベースによって、ロールバック間で文がオープンされたままの状態がサポートされるかどうかを取得します。 " ;
    1826//      private static final String supportsOrderByUnrelated = "このデータベースによって、ORDER BY 節で SELECT 文中にない列の使用がサポートされるかどうかを取得します。 " ;
    1827//      private static final String supportsOuterJoins = "このデータベースによって、外部結合のなんらかの形式がサポートされるかどうかを取得します。 " ;
    1828//      private static final String supportsPositionedDelete = "このデータベースによって、位置指定された DELETE 文がサポートされるかどうかを取得します。 " ;
    1829//      private static final String supportsPositionedUpdate = "このデータベースによって、位置指定された UPDATE 文がサポートされるかどうかを取得します。 " ;
    1830//      private static final String supportsResultSetConcurrency = "このデータベースが、指定された結果セットの型と与えられた並行処理の種類の組み合わせをサポートするかどうかを取得します。 " ;
    1831//      private static final String supportsResultSetHoldability = "このデータベースが、指定された結果セットの保持機能をサポートするかどうかを取得します。 " ;
    1832//      private static final String supportsResultSetType = "このデータベースが、指定された結果セットの型をサポートするかどうかを取得します。 " ;
    1833//      private static final String supportsSavepoints = "このデータベースによってセーブポイントがサポートされるかどうかを取得します。 " ;
    1834//      private static final String supportsSchemasInDataManipulation = "データ操作文でスキーマ名を使用できるかどうかを取得します。 " ;
    1835//      private static final String supportsSchemasInIndexDefinitions = "インデックス定義文でスキーマ名を使用できるかどうかを取得します。 " ;
    1836//      private static final String supportsSchemasInPrivilegeDefinitions = "特権定義文でスキーマ名を使用できるかどうかを取得します。 " ;
    1837//      private static final String supportsSchemasInProcedureCalls = "プロシージャ呼び出し文でスキーマ名を使用できるかどうかを取得します。 " ;
    1838//      private static final String supportsSchemasInTableDefinitions = "テーブル定義文でスキーマ名を使用できるかどうかを取得します。 " ;
    1839//      private static final String supportsSelectForUpdate = "このデータベースによって SELECT FOR UPDATE 文がサポートされるかどうかを取得します。 " ;
    1840//      private static final String supportsStatementPooling = "このデータベースによって文のプールがサポートされるかどうかを取得します。 " ;
    1841//      private static final String supportsStoredProcedures = "このデータベースによって、ストアドプロシージャエスケープ構文を使用するストアドプロシージャコールがサポートされるかどうかを判定します。 " ;
    1842//      private static final String supportsSubqueriesInComparisons = "このデータベースによって、比較式中でサブクエリーがサポートされるかどうかを取得します。 " ;
    1843//      private static final String supportsSubqueriesInExists = "このデータベースによって、EXISTS 式中でサブクエリーがサポートされるかどうかを取得します。 " ;
    1844//      private static final String supportsSubqueriesInIns = "このデータベースによって、IN 文中でサブクエリーがサポートされるかどうかを取得します。 " ;
    1845//      private static final String supportsSubqueriesInQuantifieds = "このデータベースによって、定量化された式中でサブクエリーがサポートされるかどうかを取得します。 " ;
    1846//      private static final String supportsTableCorrelationNames = "このデータベースによってテーブル相互関係名がサポートされるかどうかを取得します。 " ;
    1847//      private static final String supportsTransactionIsolationLevel = "このデータベースが、指定されたトランザクション遮断レベルをサポートするかどうかを取得します。 " ;
    1848//      private static final String supportsTransactions = "このデータベースによってトランザクションがサポートされるかどうかを取得します。 " ;
    1849//      private static final String supportsUnion = "このデータベースによって SQL UNION がサポートされるかどうかを取得します。 " ;
    1850//      private static final String supportsUnionAll = "このデータベースによって SQL UNION ALL がサポートされるかどうかを取得します。 " ;
    1851//      private static final String updatesAreDetected = "ResultSet.rowUpdated メソッドを呼び出すことによって可視の行が更新されたことを検出できるかどうかを取得します。 " ;
    1852//      private static final String usesLocalFilePerTable = "このデータベースが、各テーブルにファイルを使用するかどうかを取得します。 " ;
    1853//      private static final String usesLocalFiles = "このデータベースが、ローカルファイルにテーブルを格納するかどうかを取得します。 " ;
    1854
    1855        private static final String getAttributes = "指定されたスキーマおよびカタログで使用可能なユーザ定義の型 (UDT) のための指定された型の指定された属性に関する記述を取得します。  " ;
    1856//      private static final String getBestRowIdentifier = "行を一意に識別するテーブルの最適な列セットに関する記述を取得します。 " ;
    1857//      private static final String getCatalogs = "このデータベースで使用可能なカタログ名を取得します。 " ;
    1858//      private static final String getColumnPrivileges = "テーブルの列へのアクセス権に関する記述を取得します。  " ;
    1859        private static final String getColumns = "指定されたカタログで使用可能なテーブル列の記述を取得します。  " ;
    1860//      private static final String getCrossReference = "指定された主キーテーブルの主キー列を参照する指定された外部のキーテーブル中の、外部のキー列に関する記述 (テーブルが別のキーをインポートする方法を記述) を取得します。 " ;
    1861//      private static final String getExportedKeys = "指定されたテーブルの主キー列 (テーブルによってエクスポートされた外部キー) を参照する外部キー列に関する記述を取得します。 " ;
    1862//      private static final String getImportedKeys = "テーブルの外部キー列 (テーブルによってインポートされる主キー) を参照する主キー列に関する記述を取得します。 " ;
    1863        private static final String getIndexInfo = "指定されたテーブルのインデックスと統計情報に関する記述を取得します。 " ;
    1864//      private static final String getPrimaryKeys = "指定されたテーブルの主キー列の記述を取得します。 " ;
    1865//      private static final String getProcedureColumns = "指定されたカタログのストアドプロシージャパラメータと結果列に関する記述を取得します。  " ;
    1866//      private static final String getProcedures = "指定されたカタログで使用可能なストアドプロシージャに関する記述を取得します。  " ;
    1867//      private static final String getSchemas = "このデータベースで使用可能なスキーマ名を取得します。 " ;
    1868        private static final String getSuperTables = "このデータベースの特定のスキーマで定義されているテーブル階層の説明を取得します。  " ;
    1869        private static final String getSuperTypes = "このデータベースの特定のスキーマで定義されているユーザ定義型 (UDT) 階層の説明を取得します。 " ;
    1870//      private static final String getTablePrivileges = "カタログで使用可能な各テーブルに対するアクセス権に関する記述を取得します。 " ;
    1871//      private static final String getTables = "指定されたカタログで使用可能なテーブルに関する記述を取得します。 " ;
    1872//      private static final String getTableTypes = "このデータベースで使用可能なテーブルの型を取得します。 " ;
    1873        private static final String getTypeInfo = "このデータベースでサポートされているすべての標準 SQL の型に関する記述を取得します。 " ;
    1874//      private static final String getUDTs = "特定のスキーマで定義されているユーザ定義型 (UDT) の説明を取得します。 " ;
    1875//      private static final String getVersionColumns = "行の任意の値が変更された場合に、自動的に更新されるテーブルの列に関する記述を取得します。 " ;
    1876
    1877        // 5.5.3.2 (2012/06/08) JDk1.6 用のメソッドを追加します。
    1878//      private static final String autoCommitFailureClosesAllResultSets = "autoCommit が true の場合に、ResultSet が保持可能であっても、すべてのオープンされた ResultSet がクローズされたことを SQLException が示すかどうかを取得します。" ;
    1879//      private static final String supportsConvert = "このデータベースによって、JDBC 型 fromType と toType の間の変換に使用される JDBC スカラー関数 CONVERT がサポートされるかどうかを取得します。" ;
    1880//      private static final String supportsStoredFunctionsUsingCallSyntax = "このデータベースが、ストアドプロシージャーエスケープ構文を使用した、ユーザー定義関数またはベンダー関数の呼び出しをサポートするかどうかを取得します。" ;
    1881//      private static final String getDatabaseMajorVersion = "基本となるデータベースのメジャーバージョン番号を取得します。" ;
    1882//      private static final String getDatabaseMinorVersion = "基本となるデータベースのマイナーバージョン番号を取得します。" ;
    1883//      private static final String getJDBCMajorVersion = "このドライバの JDBC メジャーバージョン番号を取得します。" ;
    1884//      private static final String getJDBCMinorVersion = "このドライバの JDBC マイナーバージョン番号を取得します。" ;
    1885//      private static final String getMaxBinaryLiteralLength = "このデータベースで、インラインバイナリリテラル中に入れられる 16 進数の最大文字数を取得します。" ;
    1886//      private static final String getMaxCatalogNameLength = "このデータベースでの、カタログ名の最大文字数を取得します。" ;
    1887//      private static final String getMaxCharLiteralLength = "このデータベースでの、キャラクタリテラルの最大文字数を取得します。" ;
    1888//      private static final String getMaxColumnNameLength = "このデータベースでの、列名の最大文字数を取得します。" ;
    1889//      private static final String getMaxColumnsInGroupBy = "このデータベースでの、GROUP BY 節中の列数の最大値を取得します。" ;
    1890//      private static final String getMaxColumnsInIndex = "このデータベースでの、インデックス中の列数の最大値を取得します。" ;
    1891//      private static final String getMaxColumnsInOrderBy = "このデータベースでの、ORDER BY 節中の列数の最大値を取得します。" ;
    1892//      private static final String getMaxColumnsInSelect = "このデータベースでの、SELECT リスト中の列数の最大値を取得します。" ;
    1893//      private static final String getMaxColumnsInTable = "このデータベースでの、テーブル中の列数の最大値を取得します。" ;
    1894//      private static final String getMaxConnections = "このデータベースに対して可能な並行接続の最大数を取得します。" ;
    1895//      private static final String getMaxCursorNameLength = "このデータベースでの、カーソル名の最大文字数を取得します。" ;
    1896//      private static final String getMaxIndexLength = "このデータベースでの、インデックスの全部分を含む、インデックスの最大バイト数を取得します。" ;
    1897//      private static final String getMaxProcedureNameLength = "このデータベースでの、プロシージャー名の最大文字数を取得します。" ;
    1898//      private static final String getMaxRowSize = "このデータベースでの、1 行の最大バイト数を取得します。" ;
    1899//      private static final String getMaxSchemaNameLength = "このデータベースでの、スキーマ名の最大文字数を取得します。" ;
    1900//      private static final String getMaxStatementLength = "このデータベースでの、SQL 文の最大文字数を取得します。" ;
    1901//      private static final String getMaxStatements = "このデータベースの同時にオープンできるアクティブな文の最大数を取得します。" ;
    1902//      private static final String getMaxTableNameLength = "このデータベースでの、テーブル名の最大文字数を取得します。" ;
    1903//      private static final String getMaxTablesInSelect = "このデータベースでの、SELECT 文の最大テーブル数を取得します。" ;
    1904//      private static final String getMaxUserNameLength = "このデータベースでの、ユーザー名の最大文字数を取得します。" ;
    1905
    1906//      private static final String getClientInfoProperties = "ドライバがサポートするクライアント情報プロパティーのリストを取得します。" ;
    1907//      private static final String getFunctionColumns = "指定されたカタログのシステム関数またはユーザー関数のパラメータと返される型に関する記述を取得します。" ;
    1908//      private static final String getFunctions = "指定されたカタログで使用可能なシステム関数およびユーザー関数に関する記述を取得します。" ;
    1909
    1910        /**
    1911         * このオブジェクトの文字列表現を返します。
    1912         * 基本的にデバッグ目的に使用します。
    1913         *
    1914         * @return このクラスの文字列表現
    1915         */
    1916        @Override
    1917        public String toString() {
    1918                return org.opengion.fukurou.util.ToString.title( this.getClass().getName() )
    1919                                .println( "VERSION"                     ,VERSION                )
    1920                                .println( "dbid"                        ,dbid                   )
    1921                                .println( "catalog"                     ,catalog                )
    1922                                .println( "schema"                      ,schema                 )
    1923                                .println( "tableName"           ,tableName              )
    1924                                .println( "columnName"          ,columnName             )
    1925                                .println( "typeName"            ,typeName               )
    1926                                .println( "procedureName"       ,procedureName  )
    1927                                .println( "attributeName"       ,attributeName  )
    1928                                .println( "rowNo"                       ,rowNo                  )
    1929                                .println( "Other..."            ,getAttributes().getAttribute() )
    1930                                .fixForm().toString() ;
    1931        }
    1932}