home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / sun / jdbc / odbc / JdbcOdbcDatabaseMetaData.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  32.6 KB  |  1,906 lines
  1. package sun.jdbc.odbc;
  2.  
  3. import java.sql.DatabaseMetaData;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.SQLWarning;
  7. import java.sql.Statement;
  8.  
  9. public class JdbcOdbcDatabaseMetaData extends JdbcOdbcObject implements DatabaseMetaData {
  10.    protected JdbcOdbc OdbcApi;
  11.    protected JdbcOdbcConnectionInterface Con;
  12.    protected int hDbc;
  13.  
  14.    public JdbcOdbcDatabaseMetaData(JdbcOdbc var1, JdbcOdbcConnectionInterface var2) {
  15.       this.OdbcApi = var1;
  16.       this.Con = var2;
  17.       this.hDbc = this.Con.getHDBC();
  18.    }
  19.  
  20.    public boolean allProceduresAreCallable() throws SQLException {
  21.       if (JdbcOdbcObject.isTracing()) {
  22.          JdbcOdbcObject.trace("*DatabaseMetaData.allProceduresAreCallable");
  23.       }
  24.  
  25.       return this.getInfoBooleanString((short)20);
  26.    }
  27.  
  28.    public boolean allTablesAreSelectable() throws SQLException {
  29.       if (JdbcOdbcObject.isTracing()) {
  30.          JdbcOdbcObject.trace("*DatabaseMetaData.allTablesAreSelectable");
  31.       }
  32.  
  33.       return this.getInfoBooleanString((short)19);
  34.    }
  35.  
  36.    public String getURL() throws SQLException {
  37.       if (JdbcOdbcObject.isTracing()) {
  38.          JdbcOdbcObject.trace("*DatabaseMetaData.getURL");
  39.       }
  40.  
  41.       return this.Con.getURL();
  42.    }
  43.  
  44.    public String getUserName() throws SQLException {
  45.       if (JdbcOdbcObject.isTracing()) {
  46.          JdbcOdbcObject.trace("*DatabaseMetaData.getUserName");
  47.       }
  48.  
  49.       return this.getInfoString((short)47);
  50.    }
  51.  
  52.    public boolean isReadOnly() throws SQLException {
  53.       if (JdbcOdbcObject.isTracing()) {
  54.          JdbcOdbcObject.trace("*DatabaseMetaData.isReadOnly");
  55.       }
  56.  
  57.       return this.getInfoBooleanString((short)25);
  58.    }
  59.  
  60.    public boolean nullsAreSortedHigh() throws SQLException {
  61.       if (JdbcOdbcObject.isTracing()) {
  62.          JdbcOdbcObject.trace("*DatabaseMetaData.nullsAreSortedHigh");
  63.       }
  64.  
  65.       int var1 = this.getInfoShort((short)85);
  66.       return var1 == 0;
  67.    }
  68.  
  69.    public boolean nullsAreSortedLow() throws SQLException {
  70.       if (JdbcOdbcObject.isTracing()) {
  71.          JdbcOdbcObject.trace("*DatabaseMetaData.nullsAreSortedLow");
  72.       }
  73.  
  74.       int var1 = this.getInfo((short)85);
  75.       return var1 == 1;
  76.    }
  77.  
  78.    public boolean nullsAreSortedAtStart() throws SQLException {
  79.       if (JdbcOdbcObject.isTracing()) {
  80.          JdbcOdbcObject.trace("*DatabaseMetaData.nullsAreSortedAtStart");
  81.       }
  82.  
  83.       int var1 = this.getInfo((short)85);
  84.       return var1 == 2;
  85.    }
  86.  
  87.    public boolean nullsAreSortedAtEnd() throws SQLException {
  88.       if (JdbcOdbcObject.isTracing()) {
  89.          JdbcOdbcObject.trace("*DatabaseMetaData.nullsAreSortedAtEnd");
  90.       }
  91.  
  92.       int var1 = this.getInfo((short)85);
  93.       return var1 == 4;
  94.    }
  95.  
  96.    public String getDatabaseProductName() throws SQLException {
  97.       if (JdbcOdbcObject.isTracing()) {
  98.          JdbcOdbcObject.trace("*DatabaseMetaData.getDatabaseProductName");
  99.       }
  100.  
  101.       return this.getInfoString((short)17);
  102.    }
  103.  
  104.    public String getDatabaseProductVersion() throws SQLException {
  105.       if (JdbcOdbcObject.isTracing()) {
  106.          JdbcOdbcObject.trace("*DatabaseMetaData.getDatabaseProductVersion");
  107.       }
  108.  
  109.       return this.getInfoString((short)18);
  110.    }
  111.  
  112.    public String getDriverName() throws SQLException {
  113.       if (JdbcOdbcObject.isTracing()) {
  114.          JdbcOdbcObject.trace("*DatabaseMetaData.getDriverName");
  115.       }
  116.  
  117.       return "JDBC-ODBC Bridge (" + this.getInfoString((short)6) + ")";
  118.    }
  119.  
  120.    public String getDriverVersion() throws SQLException {
  121.       if (JdbcOdbcObject.isTracing()) {
  122.          JdbcOdbcObject.trace("*DatabaseMetaData.getDriverVersion");
  123.       }
  124.  
  125.       int var1 = this.getDriverMinorVersion();
  126.       String var2 = "";
  127.       if (var1 < 1000) {
  128.          var2 = var2 + "0";
  129.       }
  130.  
  131.       if (var1 < 100) {
  132.          var2 = var2 + "0";
  133.       }
  134.  
  135.       if (var1 < 10) {
  136.          var2 = var2 + "0";
  137.       }
  138.  
  139.       var2 = var2 + "" + var1;
  140.       return this.getDriverMajorVersion() + "." + var2 + " (" + this.getInfoString((short)7) + ")";
  141.    }
  142.  
  143.    public int getDriverMajorVersion() {
  144.       return 1;
  145.    }
  146.  
  147.    public int getDriverMinorVersion() {
  148.       return 1001;
  149.    }
  150.  
  151.    public boolean usesLocalFiles() throws SQLException {
  152.       if (JdbcOdbcObject.isTracing()) {
  153.          JdbcOdbcObject.trace("*DatabaseMetaData.usesLocalFiles");
  154.       }
  155.  
  156.       int var1 = this.getInfoShort((short)84);
  157.       return var1 == 2;
  158.    }
  159.  
  160.    public boolean usesLocalFilePerTable() throws SQLException {
  161.       if (JdbcOdbcObject.isTracing()) {
  162.          JdbcOdbcObject.trace("*DatabaseMetaData.usesLocalFilePerTable");
  163.       }
  164.  
  165.       int var1 = this.getInfoShort((short)84);
  166.       return var1 == 1;
  167.    }
  168.  
  169.    public boolean supportsMixedCaseIdentifiers() throws SQLException {
  170.       if (JdbcOdbcObject.isTracing()) {
  171.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMixedCaseIdentifiers");
  172.       }
  173.  
  174.       int var1 = this.getInfoShort((short)28);
  175.       return var1 == 4 || var1 == 1 || var1 == 2;
  176.    }
  177.  
  178.    public boolean storesUpperCaseIdentifiers() throws SQLException {
  179.       if (JdbcOdbcObject.isTracing()) {
  180.          JdbcOdbcObject.trace("*DatabaseMetaData.storesUpperCaseIdentifiers");
  181.       }
  182.  
  183.       int var1 = this.getInfoShort((short)28);
  184.       return var1 == 1;
  185.    }
  186.  
  187.    public boolean storesLowerCaseIdentifiers() throws SQLException {
  188.       if (JdbcOdbcObject.isTracing()) {
  189.          JdbcOdbcObject.trace("*DatabaseMetaData.storesLowerCaseIdentifiers");
  190.       }
  191.  
  192.       int var1 = this.getInfoShort((short)28);
  193.       return var1 == 2;
  194.    }
  195.  
  196.    public boolean storesMixedCaseIdentifiers() throws SQLException {
  197.       if (JdbcOdbcObject.isTracing()) {
  198.          JdbcOdbcObject.trace("*DatabaseMetaData.storesMixedCaseIdentifiers");
  199.       }
  200.  
  201.       int var1 = this.getInfoShort((short)28);
  202.       return var1 == 4;
  203.    }
  204.  
  205.    public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
  206.       if (JdbcOdbcObject.isTracing()) {
  207.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMixedCaseQuotedIdentifiers");
  208.       }
  209.  
  210.       int var1 = this.getInfoShort((short)93);
  211.       return var1 == 4 || var1 == 1 || var1 == 2;
  212.    }
  213.  
  214.    public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
  215.       if (JdbcOdbcObject.isTracing()) {
  216.          JdbcOdbcObject.trace("*DatabaseMetaData.storesUpperCaseQuotedIdentifiers");
  217.       }
  218.  
  219.       int var1 = this.getInfoShort((short)93);
  220.       return var1 == 1;
  221.    }
  222.  
  223.    public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
  224.       if (JdbcOdbcObject.isTracing()) {
  225.          JdbcOdbcObject.trace("*DatabaseMetaData.storesLowerCaseQuotedIdentifiers");
  226.       }
  227.  
  228.       int var1 = this.getInfoShort((short)93);
  229.       return var1 == 2;
  230.    }
  231.  
  232.    public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
  233.       if (JdbcOdbcObject.isTracing()) {
  234.          JdbcOdbcObject.trace("*DatabaseMetaData.storesMixedCaseQuotedIdentifiers");
  235.       }
  236.  
  237.       int var1 = this.getInfoShort((short)93);
  238.       return var1 == 4;
  239.    }
  240.  
  241.    public String getIdentifierQuoteString() throws SQLException {
  242.       if (JdbcOdbcObject.isTracing()) {
  243.          JdbcOdbcObject.trace("*DatabaseMetaData.getIdentifierQuoteString");
  244.       }
  245.  
  246.       return this.getInfoString((short)29);
  247.    }
  248.  
  249.    public String getSQLKeywords() throws SQLException {
  250.       if (JdbcOdbcObject.isTracing()) {
  251.          JdbcOdbcObject.trace("*DatabaseMetaData.getSQLKeywords");
  252.       }
  253.  
  254.       return this.getInfoString((short)89, JdbcOdbcLimits.MAX_GET_DATA_LENGTH);
  255.    }
  256.  
  257.    public String getNumericFunctions() throws SQLException {
  258.       if (JdbcOdbcObject.isTracing()) {
  259.          JdbcOdbcObject.trace("*DatabaseMetaData.getNumericFunctions");
  260.       }
  261.  
  262.       String var2 = "";
  263.       int var1 = this.getInfo((short)49);
  264.       if ((var1 & 1) != 0) {
  265.          var2 = var2 + "ABS,";
  266.       }
  267.  
  268.       if ((var1 & 2) != 0) {
  269.          var2 = var2 + "ACOS,";
  270.       }
  271.  
  272.       if ((var1 & 4) != 0) {
  273.          var2 = var2 + "ASIN,";
  274.       }
  275.  
  276.       if ((var1 & 8) != 0) {
  277.          var2 = var2 + "ATAN,";
  278.       }
  279.  
  280.       if ((var1 & 16) != 0) {
  281.          var2 = var2 + "ATAN2,";
  282.       }
  283.  
  284.       if ((var1 & 32) != 0) {
  285.          var2 = var2 + "CEILING,";
  286.       }
  287.  
  288.       if ((var1 & 64) != 0) {
  289.          var2 = var2 + "COS,";
  290.       }
  291.  
  292.       if ((var1 & 128) != 0) {
  293.          var2 = var2 + "COT,";
  294.       }
  295.  
  296.       if ((var1 & 262144) != 0) {
  297.          var2 = var2 + "DEGREES,";
  298.       }
  299.  
  300.       if ((var1 & 256) != 0) {
  301.          var2 = var2 + "EXP,";
  302.       }
  303.  
  304.       if ((var1 & 512) != 0) {
  305.          var2 = var2 + "FLOOR,";
  306.       }
  307.  
  308.       if ((var1 & 1024) != 0) {
  309.          var2 = var2 + "LOG,";
  310.       }
  311.  
  312.       if ((var1 & 524288) != 0) {
  313.          var2 = var2 + "LOG10,";
  314.       }
  315.  
  316.       if ((var1 & 2048) != 0) {
  317.          var2 = var2 + "MOD,";
  318.       }
  319.  
  320.       if ((var1 & 65536) != 0) {
  321.          var2 = var2 + "PI,";
  322.       }
  323.  
  324.       if ((var1 & 1048576) != 0) {
  325.          var2 = var2 + "POWER,";
  326.       }
  327.  
  328.       if ((var1 & 2097152) != 0) {
  329.          var2 = var2 + "RADIANS,";
  330.       }
  331.  
  332.       if ((var1 & 131072) != 0) {
  333.          var2 = var2 + "RAND,";
  334.       }
  335.  
  336.       if ((var1 & 4194304) != 0) {
  337.          var2 = var2 + "ROUND,";
  338.       }
  339.  
  340.       if ((var1 & 4096) != 0) {
  341.          var2 = var2 + "SIGN,";
  342.       }
  343.  
  344.       if ((var1 & 8192) != 0) {
  345.          var2 = var2 + "SIN,";
  346.       }
  347.  
  348.       if ((var1 & 16384) != 0) {
  349.          var2 = var2 + "SQRT,";
  350.       }
  351.  
  352.       if ((var1 & 'ΦÇÇ') != 0) {
  353.          var2 = var2 + "TAN,";
  354.       }
  355.  
  356.       if ((var1 & 8388608) != 0) {
  357.          var2 = var2 + "TRUNCATE,";
  358.       }
  359.  
  360.       if (var2.length() > 0) {
  361.          var2 = var2.substring(0, var2.length() - 1);
  362.       }
  363.  
  364.       return var2;
  365.    }
  366.  
  367.    public String getStringFunctions() throws SQLException {
  368.       if (JdbcOdbcObject.isTracing()) {
  369.          JdbcOdbcObject.trace("*DatabaseMetaData.getStringFunctions");
  370.       }
  371.  
  372.       String var2 = "";
  373.       int var1 = this.getInfo((short)50);
  374.       if ((var1 & 8192) != 0) {
  375.          var2 = var2 + "ASCII,";
  376.       }
  377.  
  378.       if ((var1 & 16384) != 0) {
  379.          var2 = var2 + "CHAR,";
  380.       }
  381.  
  382.       if ((var1 & 1) != 0) {
  383.          var2 = var2 + "CONCAT,";
  384.       }
  385.  
  386.       if ((var1 & 'ΦÇÇ') != 0) {
  387.          var2 = var2 + "DIFFERENCE,";
  388.       }
  389.  
  390.       if ((var1 & 2) != 0) {
  391.          var2 = var2 + "INSERT,";
  392.       }
  393.  
  394.       if ((var1 & 64) != 0) {
  395.          var2 = var2 + "LCASE,";
  396.       }
  397.  
  398.       if ((var1 & 4) != 0) {
  399.          var2 = var2 + "LEFT,";
  400.       }
  401.  
  402.       if ((var1 & 16) != 0) {
  403.          var2 = var2 + "LENGTH,";
  404.       }
  405.  
  406.       if ((var1 & 32) != 0) {
  407.          var2 = var2 + "LOCATE,";
  408.       }
  409.  
  410.       if ((var1 & 65536) != 0) {
  411.          var2 = var2 + "LOCATE_2,";
  412.       }
  413.  
  414.       if ((var1 & 8) != 0) {
  415.          var2 = var2 + "LTRIM,";
  416.       }
  417.  
  418.       if ((var1 & 128) != 0) {
  419.          var2 = var2 + "REPEAT,";
  420.       }
  421.  
  422.       if ((var1 & 256) != 0) {
  423.          var2 = var2 + "REPLACE,";
  424.       }
  425.  
  426.       if ((var1 & 512) != 0) {
  427.          var2 = var2 + "RIGHT,";
  428.       }
  429.  
  430.       if ((var1 & 1024) != 0) {
  431.          var2 = var2 + "RTRIM,";
  432.       }
  433.  
  434.       if ((var1 & 131072) != 0) {
  435.          var2 = var2 + "SOUNDEX,";
  436.       }
  437.  
  438.       if ((var1 & 262144) != 0) {
  439.          var2 = var2 + "SPACE,";
  440.       }
  441.  
  442.       if ((var1 & 2048) != 0) {
  443.          var2 = var2 + "SUBSTRING,";
  444.       }
  445.  
  446.       if ((var1 & 4096) != 0) {
  447.          var2 = var2 + "UCASE,";
  448.       }
  449.  
  450.       if (var2.length() > 0) {
  451.          var2 = var2.substring(0, var2.length() - 1);
  452.       }
  453.  
  454.       return var2;
  455.    }
  456.  
  457.    public String getSystemFunctions() throws SQLException {
  458.       if (JdbcOdbcObject.isTracing()) {
  459.          JdbcOdbcObject.trace("*DatabaseMetaData.getSystemFunctions");
  460.       }
  461.  
  462.       String var2 = "";
  463.       int var1 = this.getInfo((short)51);
  464.       if ((var1 & 2) != 0) {
  465.          var2 = var2 + "DBNAME,";
  466.       }
  467.  
  468.       if ((var1 & 4) != 0) {
  469.          var2 = var2 + "IFNULL,";
  470.       }
  471.  
  472.       if ((var1 & 1) != 0) {
  473.          var2 = var2 + "USERNAME,";
  474.       }
  475.  
  476.       if (var2.length() > 0) {
  477.          var2 = var2.substring(0, var2.length() - 1);
  478.       }
  479.  
  480.       return var2;
  481.    }
  482.  
  483.    public String getTimeDateFunctions() throws SQLException {
  484.       if (JdbcOdbcObject.isTracing()) {
  485.          JdbcOdbcObject.trace("*DatabaseMetaData.getTimeDateFunctions");
  486.       }
  487.  
  488.       String var2 = "";
  489.       int var1 = this.getInfo((short)52);
  490.       if ((var1 & 2) != 0) {
  491.          var2 = var2 + "CURDATE,";
  492.       }
  493.  
  494.       if ((var1 & 512) != 0) {
  495.          var2 = var2 + "CURTIME,";
  496.       }
  497.  
  498.       if ((var1 & 'ΦÇÇ') != 0) {
  499.          var2 = var2 + "DAYNAME,";
  500.       }
  501.  
  502.       if ((var1 & 4) != 0) {
  503.          var2 = var2 + "DAYOFMONTH,";
  504.       }
  505.  
  506.       if ((var1 & 8) != 0) {
  507.          var2 = var2 + "DAYOFWEEK,";
  508.       }
  509.  
  510.       if ((var1 & 16) != 0) {
  511.          var2 = var2 + "DAYOFYEAR,";
  512.       }
  513.  
  514.       if ((var1 & 1024) != 0) {
  515.          var2 = var2 + "HOUR,";
  516.       }
  517.  
  518.       if ((var1 & 2048) != 0) {
  519.          var2 = var2 + "MINUTE,";
  520.       }
  521.  
  522.       if ((var1 & 32) != 0) {
  523.          var2 = var2 + "MONTH,";
  524.       }
  525.  
  526.       if ((var1 & 65536) != 0) {
  527.          var2 = var2 + "MONTHNAME,";
  528.       }
  529.  
  530.       if ((var1 & 1) != 0) {
  531.          var2 = var2 + "NOW,";
  532.       }
  533.  
  534.       if ((var1 & 64) != 0) {
  535.          var2 = var2 + "QUARTER,";
  536.       }
  537.  
  538.       if ((var1 & 4096) != 0) {
  539.          var2 = var2 + "SECOND,";
  540.       }
  541.  
  542.       if ((var1 & 8192) != 0) {
  543.          var2 = var2 + "TIMESTAMPADD,";
  544.       }
  545.  
  546.       if ((var1 & 16384) != 0) {
  547.          var2 = var2 + "TIMESTAMPDIFF,";
  548.       }
  549.  
  550.       if ((var1 & 128) != 0) {
  551.          var2 = var2 + "WEEK,";
  552.       }
  553.  
  554.       if ((var1 & 256) != 0) {
  555.          var2 = var2 + "YEAR,";
  556.       }
  557.  
  558.       if (var2.length() > 0) {
  559.          var2 = var2.substring(0, var2.length() - 1);
  560.       }
  561.  
  562.       return var2;
  563.    }
  564.  
  565.    public String getSearchStringEscape() throws SQLException {
  566.       if (JdbcOdbcObject.isTracing()) {
  567.          JdbcOdbcObject.trace("*DatabaseMetaData.getSearchStringEscape");
  568.       }
  569.  
  570.       return this.getInfoString((short)14);
  571.    }
  572.  
  573.    public String getExtraNameCharacters() throws SQLException {
  574.       if (JdbcOdbcObject.isTracing()) {
  575.          JdbcOdbcObject.trace("*DatabaseMetaData.getExtraNameCharacters");
  576.       }
  577.  
  578.       return this.getInfoString((short)94);
  579.    }
  580.  
  581.    public boolean supportsAlterTableWithAddColumn() throws SQLException {
  582.       if (JdbcOdbcObject.isTracing()) {
  583.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsAlterTableWithAddColumn");
  584.       }
  585.  
  586.       int var1 = this.getInfo((short)86);
  587.       return (var1 & 1) > 0;
  588.    }
  589.  
  590.    public boolean supportsAlterTableWithDropColumn() throws SQLException {
  591.       if (JdbcOdbcObject.isTracing()) {
  592.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsAlterTableWithDropColumn");
  593.       }
  594.  
  595.       int var1 = this.getInfo((short)86);
  596.       return (var1 & 2) > 0;
  597.    }
  598.  
  599.    public boolean supportsColumnAliasing() throws SQLException {
  600.       if (JdbcOdbcObject.isTracing()) {
  601.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsColumnAliasing");
  602.       }
  603.  
  604.       return this.getInfoBooleanString((short)87);
  605.    }
  606.  
  607.    public boolean nullPlusNonNullIsNull() throws SQLException {
  608.       if (JdbcOdbcObject.isTracing()) {
  609.          JdbcOdbcObject.trace("*DatabaseMetaData.nullPlusNullIsNull");
  610.       }
  611.  
  612.       int var1 = this.getInfoShort((short)22);
  613.       return var1 == 0;
  614.    }
  615.  
  616.    public boolean supportsConvert() throws SQLException {
  617.       if (JdbcOdbcObject.isTracing()) {
  618.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsConvert");
  619.       }
  620.  
  621.       int var1 = this.getInfo((short)48);
  622.       return var1 == 1;
  623.    }
  624.  
  625.    public boolean supportsConvert(int var1, int var2) throws SQLException {
  626.       if (JdbcOdbcObject.isTracing()) {
  627.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsConvert (" + var1 + "," + var2 + ")");
  628.       }
  629.  
  630.       byte var3 = 0;
  631.       int var4 = 0;
  632.       switch (var1) {
  633.          case -7:
  634.             var3 = 55;
  635.             break;
  636.          case -6:
  637.             var3 = 68;
  638.             break;
  639.          case -5:
  640.             var3 = 53;
  641.             break;
  642.          case -4:
  643.             var3 = 71;
  644.             break;
  645.          case -3:
  646.             var3 = 69;
  647.             break;
  648.          case -2:
  649.             var3 = 54;
  650.             break;
  651.          case -1:
  652.             var3 = 62;
  653.             break;
  654.          case 1:
  655.             var3 = 56;
  656.             break;
  657.          case 2:
  658.             var3 = 63;
  659.             break;
  660.          case 3:
  661.             var3 = 58;
  662.             break;
  663.          case 4:
  664.             var3 = 61;
  665.             break;
  666.          case 5:
  667.             var3 = 65;
  668.             break;
  669.          case 6:
  670.             var3 = 60;
  671.             break;
  672.          case 7:
  673.             var3 = 64;
  674.             break;
  675.          case 8:
  676.             var3 = 59;
  677.             break;
  678.          case 12:
  679.             var3 = 70;
  680.             break;
  681.          case 91:
  682.             var3 = 57;
  683.             break;
  684.          case 92:
  685.             var3 = 66;
  686.             break;
  687.          case 93:
  688.             var3 = 67;
  689.       }
  690.  
  691.       int var5 = this.getInfo(var3);
  692.       switch (var2) {
  693.          case -7:
  694.             var4 = 4096;
  695.             break;
  696.          case -6:
  697.             var4 = 8192;
  698.             break;
  699.          case -5:
  700.             var4 = 16384;
  701.             break;
  702.          case -4:
  703.             var4 = 262144;
  704.             break;
  705.          case -3:
  706.             var4 = 2048;
  707.             break;
  708.          case -2:
  709.             var4 = 1024;
  710.             break;
  711.          case -1:
  712.             var4 = 512;
  713.             break;
  714.          case 1:
  715.             var4 = 1;
  716.             break;
  717.          case 2:
  718.             var4 = 2;
  719.             break;
  720.          case 3:
  721.             var4 = 4;
  722.             break;
  723.          case 4:
  724.             var4 = 8;
  725.             break;
  726.          case 5:
  727.             var4 = 16;
  728.             break;
  729.          case 6:
  730.             var4 = 32;
  731.             break;
  732.          case 7:
  733.             var4 = 64;
  734.             break;
  735.          case 8:
  736.             var4 = 128;
  737.             break;
  738.          case 12:
  739.             var4 = 256;
  740.             break;
  741.          case 91:
  742.             var4 = 32768;
  743.             break;
  744.          case 92:
  745.             var4 = 65536;
  746.             break;
  747.          case 93:
  748.             var4 = 131072;
  749.       }
  750.  
  751.       return (var5 & var4) > 0;
  752.    }
  753.  
  754.    public boolean supportsTableCorrelationNames() throws SQLException {
  755.       if (JdbcOdbcObject.isTracing()) {
  756.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsTableCorrelationNames");
  757.       }
  758.  
  759.       int var1 = this.getInfoShort((short)74);
  760.       return var1 == 1 || var1 == 2;
  761.    }
  762.  
  763.    public boolean supportsDifferentTableCorrelationNames() throws SQLException {
  764.       if (JdbcOdbcObject.isTracing()) {
  765.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsDifferentTableCorrelationNames");
  766.       }
  767.  
  768.       int var1 = this.getInfoShort((short)74);
  769.       return var1 == 1;
  770.    }
  771.  
  772.    public boolean supportsExpressionsInOrderBy() throws SQLException {
  773.       if (JdbcOdbcObject.isTracing()) {
  774.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsExpressionsInOrderBy");
  775.       }
  776.  
  777.       return this.getInfoBooleanString((short)27);
  778.    }
  779.  
  780.    public boolean supportsOrderByUnrelated() throws SQLException {
  781.       if (JdbcOdbcObject.isTracing()) {
  782.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOrderByUnrelated");
  783.       }
  784.  
  785.       return this.getInfoBooleanString((short)90);
  786.    }
  787.  
  788.    public boolean supportsGroupBy() throws SQLException {
  789.       if (JdbcOdbcObject.isTracing()) {
  790.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsGroupBy");
  791.       }
  792.  
  793.       int var1 = this.getInfoShort((short)88);
  794.       return var1 != 0;
  795.    }
  796.  
  797.    public boolean supportsGroupByUnrelated() throws SQLException {
  798.       if (JdbcOdbcObject.isTracing()) {
  799.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsGroupByUnrelated");
  800.       }
  801.  
  802.       int var1 = this.getInfoShort((short)88);
  803.       return var1 == 3;
  804.    }
  805.  
  806.    public boolean supportsGroupByBeyondSelect() throws SQLException {
  807.       if (JdbcOdbcObject.isTracing()) {
  808.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsGroupByBeyondSelect");
  809.       }
  810.  
  811.       int var1 = this.getInfoShort((short)88);
  812.       return var1 == 2;
  813.    }
  814.  
  815.    public boolean supportsLikeEscapeClause() throws SQLException {
  816.       if (JdbcOdbcObject.isTracing()) {
  817.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsLikeEscapeClause");
  818.       }
  819.  
  820.       return this.getInfoBooleanString((short)113);
  821.    }
  822.  
  823.    public boolean supportsMultipleResultSets() throws SQLException {
  824.       if (JdbcOdbcObject.isTracing()) {
  825.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMultipleResultSets");
  826.       }
  827.  
  828.       return this.getInfoBooleanString((short)36);
  829.    }
  830.  
  831.    public boolean supportsMultipleTransactions() throws SQLException {
  832.       if (JdbcOdbcObject.isTracing()) {
  833.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMultipleTransactions");
  834.       }
  835.  
  836.       return this.getInfoBooleanString((short)37);
  837.    }
  838.  
  839.    public boolean supportsNonNullableColumns() throws SQLException {
  840.       if (JdbcOdbcObject.isTracing()) {
  841.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsNonNullableColumns");
  842.       }
  843.  
  844.       int var1 = this.getInfoShort((short)75);
  845.       return var1 == 1;
  846.    }
  847.  
  848.    public boolean supportsMinimumSQLGrammar() throws SQLException {
  849.       if (JdbcOdbcObject.isTracing()) {
  850.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMinimumSQLGrammar");
  851.       }
  852.  
  853.       int var1 = this.getInfoShort((short)15);
  854.       return var1 == 0 || var1 == 1 || var1 == 2;
  855.    }
  856.  
  857.    public boolean supportsCoreSQLGrammar() throws SQLException {
  858.       if (JdbcOdbcObject.isTracing()) {
  859.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCoreSQLGrammar");
  860.       }
  861.  
  862.       int var1 = this.getInfoShort((short)15);
  863.       return var1 == 1 || var1 == 2;
  864.    }
  865.  
  866.    public boolean supportsANSI92EntryLevelSQL() throws SQLException {
  867.       return true;
  868.    }
  869.  
  870.    public boolean supportsANSI92IntermediateSQL() throws SQLException {
  871.       return false;
  872.    }
  873.  
  874.    public boolean supportsANSI92FullSQL() throws SQLException {
  875.       return false;
  876.    }
  877.  
  878.    public boolean supportsExtendedSQLGrammar() throws SQLException {
  879.       if (JdbcOdbcObject.isTracing()) {
  880.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsExtendedSQLGrammar");
  881.       }
  882.  
  883.       int var1 = this.getInfoShort((short)15);
  884.       return var1 == 2;
  885.    }
  886.  
  887.    public boolean supportsIntegrityEnhancementFacility() throws SQLException {
  888.       if (JdbcOdbcObject.isTracing()) {
  889.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsIntegrityEnhancementFacility");
  890.       }
  891.  
  892.       return this.getInfoBooleanString((short)73);
  893.    }
  894.  
  895.    public boolean supportsOuterJoins() throws SQLException {
  896.       if (JdbcOdbcObject.isTracing()) {
  897.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOuterJoins");
  898.       }
  899.  
  900.       String var1 = this.getInfoString((short)38);
  901.       return !var1.equalsIgnoreCase("N");
  902.    }
  903.  
  904.    public boolean supportsFullOuterJoins() throws SQLException {
  905.       if (JdbcOdbcObject.isTracing()) {
  906.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsFullOuterJoins");
  907.       }
  908.  
  909.       String var1 = this.getInfoString((short)38);
  910.       return var1.equalsIgnoreCase("F");
  911.    }
  912.  
  913.    public boolean supportsLimitedOuterJoins() throws SQLException {
  914.       if (JdbcOdbcObject.isTracing()) {
  915.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsLimitedOuterJoins");
  916.       }
  917.  
  918.       String var1 = this.getInfoString((short)38);
  919.       return var1.equalsIgnoreCase("P");
  920.    }
  921.  
  922.    public String getSchemaTerm() throws SQLException {
  923.       if (JdbcOdbcObject.isTracing()) {
  924.          JdbcOdbcObject.trace("*DatabaseMetaData.getSchemaTerm");
  925.       }
  926.  
  927.       return this.getInfoString((short)39);
  928.    }
  929.  
  930.    public String getProcedureTerm() throws SQLException {
  931.       if (JdbcOdbcObject.isTracing()) {
  932.          JdbcOdbcObject.trace("*DatabaseMetaData.getProcedureTerm");
  933.       }
  934.  
  935.       return this.getInfoString((short)40);
  936.    }
  937.  
  938.    public String getCatalogTerm() throws SQLException {
  939.       if (JdbcOdbcObject.isTracing()) {
  940.          JdbcOdbcObject.trace("*DatabaseMetaData.getCatalogTerm");
  941.       }
  942.  
  943.       return this.getInfoString((short)42);
  944.    }
  945.  
  946.    public boolean isCatalogAtStart() throws SQLException {
  947.       if (JdbcOdbcObject.isTracing()) {
  948.          JdbcOdbcObject.trace("*DatabaseMetaData.isCatalogAtStart");
  949.       }
  950.  
  951.       int var1 = this.getInfoShort((short)114);
  952.       return var1 == 1;
  953.    }
  954.  
  955.    public String getCatalogSeparator() throws SQLException {
  956.       if (JdbcOdbcObject.isTracing()) {
  957.          JdbcOdbcObject.trace("*DatabaseMetaData.getCatalogSeparator");
  958.       }
  959.  
  960.       return this.getInfoString((short)41);
  961.    }
  962.  
  963.    public boolean supportsSchemasInDataManipulation() throws SQLException {
  964.       if (JdbcOdbcObject.isTracing()) {
  965.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInDataManipulation");
  966.       }
  967.  
  968.       int var1 = this.getInfo((short)91);
  969.       return (var1 & 1) > 0;
  970.    }
  971.  
  972.    public boolean supportsSchemasInProcedureCalls() throws SQLException {
  973.       if (JdbcOdbcObject.isTracing()) {
  974.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInProcedureCalls");
  975.       }
  976.  
  977.       int var1 = this.getInfo((short)91);
  978.       return (var1 & 2) > 0;
  979.    }
  980.  
  981.    public boolean supportsSchemasInTableDefinitions() throws SQLException {
  982.       if (JdbcOdbcObject.isTracing()) {
  983.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInTableDefinitions");
  984.       }
  985.  
  986.       int var1 = this.getInfo((short)91);
  987.       return (var1 & 4) > 0;
  988.    }
  989.  
  990.    public boolean supportsSchemasInIndexDefinitions() throws SQLException {
  991.       if (JdbcOdbcObject.isTracing()) {
  992.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInIndexDefintions");
  993.       }
  994.  
  995.       int var1 = this.getInfo((short)91);
  996.       return (var1 & 8) > 0;
  997.    }
  998.  
  999.    public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
  1000.       if (JdbcOdbcObject.isTracing()) {
  1001.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInPrivilegeDefintions");
  1002.       }
  1003.  
  1004.       int var1 = this.getInfo((short)91);
  1005.       return (var1 & 16) > 0;
  1006.    }
  1007.  
  1008.    public boolean supportsCatalogsInDataManipulation() throws SQLException {
  1009.       if (JdbcOdbcObject.isTracing()) {
  1010.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInDataManipulation");
  1011.       }
  1012.  
  1013.       int var1 = this.getInfo((short)92);
  1014.       return (var1 & 1) > 0;
  1015.    }
  1016.  
  1017.    public boolean supportsCatalogsInProcedureCalls() throws SQLException {
  1018.       if (JdbcOdbcObject.isTracing()) {
  1019.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInProcedureCalls");
  1020.       }
  1021.  
  1022.       int var1 = this.getInfo((short)92);
  1023.       return (var1 & 2) > 0;
  1024.    }
  1025.  
  1026.    public boolean supportsCatalogsInTableDefinitions() throws SQLException {
  1027.       if (JdbcOdbcObject.isTracing()) {
  1028.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInTableDefinitions");
  1029.       }
  1030.  
  1031.       int var1 = this.getInfo((short)92);
  1032.       return (var1 & 4) > 0;
  1033.    }
  1034.  
  1035.    public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
  1036.       if (JdbcOdbcObject.isTracing()) {
  1037.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInIndexDefinitions");
  1038.       }
  1039.  
  1040.       int var1 = this.getInfo((short)92);
  1041.       return (var1 & 8) > 0;
  1042.    }
  1043.  
  1044.    public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
  1045.       if (JdbcOdbcObject.isTracing()) {
  1046.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInPrivilegeDefintions");
  1047.       }
  1048.  
  1049.       int var1 = this.getInfo((short)92);
  1050.       return (var1 & 16) > 0;
  1051.    }
  1052.  
  1053.    public boolean supportsPositionedDelete() throws SQLException {
  1054.       if (JdbcOdbcObject.isTracing()) {
  1055.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsPositionedDelete");
  1056.       }
  1057.  
  1058.       int var1 = this.getInfo((short)80);
  1059.       return (var1 & 1) > 0;
  1060.    }
  1061.  
  1062.    public boolean supportsPositionedUpdate() throws SQLException {
  1063.       if (JdbcOdbcObject.isTracing()) {
  1064.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsPositionedUpdate");
  1065.       }
  1066.  
  1067.       int var1 = this.getInfo((short)80);
  1068.       return (var1 & 2) > 0;
  1069.    }
  1070.  
  1071.    public boolean supportsSelectForUpdate() throws SQLException {
  1072.       if (JdbcOdbcObject.isTracing()) {
  1073.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSelectForUpdate");
  1074.       }
  1075.  
  1076.       int var1 = this.getInfo((short)80);
  1077.       return (var1 & 4) > 0;
  1078.    }
  1079.  
  1080.    public boolean supportsStoredProcedures() throws SQLException {
  1081.       if (JdbcOdbcObject.isTracing()) {
  1082.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsStoredProcedures");
  1083.       }
  1084.  
  1085.       return this.getInfoBooleanString((short)21);
  1086.    }
  1087.  
  1088.    public boolean supportsSubqueriesInComparisons() throws SQLException {
  1089.       if (JdbcOdbcObject.isTracing()) {
  1090.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInComparisions");
  1091.       }
  1092.  
  1093.       int var1 = this.getInfo((short)95);
  1094.       return (var1 & 1) > 0;
  1095.    }
  1096.  
  1097.    public boolean supportsSubqueriesInExists() throws SQLException {
  1098.       if (JdbcOdbcObject.isTracing()) {
  1099.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInExists");
  1100.       }
  1101.  
  1102.       int var1 = this.getInfo((short)95);
  1103.       return (var1 & 2) > 0;
  1104.    }
  1105.  
  1106.    public boolean supportsSubqueriesInIns() throws SQLException {
  1107.       if (JdbcOdbcObject.isTracing()) {
  1108.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInIns");
  1109.       }
  1110.  
  1111.       int var1 = this.getInfo((short)95);
  1112.       return (var1 & 4) > 0;
  1113.    }
  1114.  
  1115.    public boolean supportsSubqueriesInQuantifieds() throws SQLException {
  1116.       if (JdbcOdbcObject.isTracing()) {
  1117.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInQuantifieds");
  1118.       }
  1119.  
  1120.       int var1 = this.getInfo((short)95);
  1121.       return (var1 & 8) > 0;
  1122.    }
  1123.  
  1124.    public boolean supportsCorrelatedSubqueries() throws SQLException {
  1125.       if (JdbcOdbcObject.isTracing()) {
  1126.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCorrelatedSubqueries");
  1127.       }
  1128.  
  1129.       int var1 = this.getInfo((short)95);
  1130.       return (var1 & 16) > 0;
  1131.    }
  1132.  
  1133.    public boolean supportsUnion() throws SQLException {
  1134.       if (JdbcOdbcObject.isTracing()) {
  1135.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsUnion");
  1136.       }
  1137.  
  1138.       int var1 = this.getInfo((short)96);
  1139.       return (var1 & 1) > 0;
  1140.    }
  1141.  
  1142.    public boolean supportsUnionAll() throws SQLException {
  1143.       if (JdbcOdbcObject.isTracing()) {
  1144.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsUnionAll");
  1145.       }
  1146.  
  1147.       int var1 = this.getInfo((short)96);
  1148.       return (var1 & 2) > 0;
  1149.    }
  1150.  
  1151.    public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
  1152.       if (JdbcOdbcObject.isTracing()) {
  1153.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenCursorsAcrossCommit");
  1154.       }
  1155.  
  1156.       int var1 = this.getInfoShort((short)23);
  1157.       return var1 == 2;
  1158.    }
  1159.  
  1160.    public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
  1161.       if (JdbcOdbcObject.isTracing()) {
  1162.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenCursorsAcrossRollback");
  1163.       }
  1164.  
  1165.       int var1 = this.getInfoShort((short)24);
  1166.       return var1 == 2;
  1167.    }
  1168.  
  1169.    public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
  1170.       if (JdbcOdbcObject.isTracing()) {
  1171.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenStatementsAcrossCommit");
  1172.       }
  1173.  
  1174.       int var1 = this.getInfoShort((short)23);
  1175.       return var1 == 2 || var1 == 1;
  1176.    }
  1177.  
  1178.    public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
  1179.       if (JdbcOdbcObject.isTracing()) {
  1180.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenStatementsAcrossRollback");
  1181.       }
  1182.  
  1183.       int var1 = this.getInfoShort((short)24);
  1184.       return var1 == 2 || var1 == 1;
  1185.    }
  1186.  
  1187.    public int getMaxBinaryLiteralLength() throws SQLException {
  1188.       if (JdbcOdbcObject.isTracing()) {
  1189.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxBinaryLiteralLength");
  1190.       }
  1191.  
  1192.       return this.getInfo((short)112);
  1193.    }
  1194.  
  1195.    public int getMaxCharLiteralLength() throws SQLException {
  1196.       if (JdbcOdbcObject.isTracing()) {
  1197.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxCharLiteralLength");
  1198.       }
  1199.  
  1200.       return this.getInfo((short)108);
  1201.    }
  1202.  
  1203.    public int getMaxColumnNameLength() throws SQLException {
  1204.       if (JdbcOdbcObject.isTracing()) {
  1205.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnNameLength");
  1206.       }
  1207.  
  1208.       return this.getInfoShort((short)30);
  1209.    }
  1210.  
  1211.    public int getMaxColumnsInGroupBy() throws SQLException {
  1212.       if (JdbcOdbcObject.isTracing()) {
  1213.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInGroupBy");
  1214.       }
  1215.  
  1216.       return this.getInfoShort((short)97);
  1217.    }
  1218.  
  1219.    public int getMaxColumnsInIndex() throws SQLException {
  1220.       if (JdbcOdbcObject.isTracing()) {
  1221.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInIndex");
  1222.       }
  1223.  
  1224.       return this.getInfoShort((short)98);
  1225.    }
  1226.  
  1227.    public int getMaxColumnsInOrderBy() throws SQLException {
  1228.       if (JdbcOdbcObject.isTracing()) {
  1229.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInOrderBy");
  1230.       }
  1231.  
  1232.       return this.getInfoShort((short)99);
  1233.    }
  1234.  
  1235.    public int getMaxColumnsInSelect() throws SQLException {
  1236.       if (JdbcOdbcObject.isTracing()) {
  1237.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInSeleted");
  1238.       }
  1239.  
  1240.       return this.getInfoShort((short)100);
  1241.    }
  1242.  
  1243.    public int getMaxColumnsInTable() throws SQLException {
  1244.       if (JdbcOdbcObject.isTracing()) {
  1245.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInTable");
  1246.       }
  1247.  
  1248.       return this.getInfoShort((short)101);
  1249.    }
  1250.  
  1251.    public int getMaxConnections() throws SQLException {
  1252.       if (JdbcOdbcObject.isTracing()) {
  1253.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxConnections");
  1254.       }
  1255.  
  1256.       return this.getInfoShort((short)0);
  1257.    }
  1258.  
  1259.    public int getMaxCursorNameLength() throws SQLException {
  1260.       if (JdbcOdbcObject.isTracing()) {
  1261.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxCursorNameLength");
  1262.       }
  1263.  
  1264.       return this.getInfo((short)31);
  1265.    }
  1266.  
  1267.    public int getMaxIndexLength() throws SQLException {
  1268.       if (JdbcOdbcObject.isTracing()) {
  1269.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxIndexLength");
  1270.       }
  1271.  
  1272.       return this.getInfo((short)102);
  1273.    }
  1274.  
  1275.    public int getMaxSchemaNameLength() throws SQLException {
  1276.       if (JdbcOdbcObject.isTracing()) {
  1277.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxSchemaNameLength");
  1278.       }
  1279.  
  1280.       return this.getInfoShort((short)32);
  1281.    }
  1282.  
  1283.    public int getMaxProcedureNameLength() throws SQLException {
  1284.       if (JdbcOdbcObject.isTracing()) {
  1285.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxProcedureNameLength");
  1286.       }
  1287.  
  1288.       return this.getInfoShort((short)33);
  1289.    }
  1290.  
  1291.    public int getMaxCatalogNameLength() throws SQLException {
  1292.       if (JdbcOdbcObject.isTracing()) {
  1293.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxCatalogNameLength");
  1294.       }
  1295.  
  1296.       return this.getInfoShort((short)34);
  1297.    }
  1298.  
  1299.    public int getMaxRowSize() throws SQLException {
  1300.       if (JdbcOdbcObject.isTracing()) {
  1301.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxRowSize");
  1302.       }
  1303.  
  1304.       return this.getInfo((short)104);
  1305.    }
  1306.  
  1307.    public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
  1308.       if (JdbcOdbcObject.isTracing()) {
  1309.          JdbcOdbcObject.trace("*DatabaseMetaData.doesMaxRowSizeIncludeBlobs");
  1310.       }
  1311.  
  1312.       return this.getInfoBooleanString((short)103);
  1313.    }
  1314.  
  1315.    public int getMaxStatementLength() throws SQLException {
  1316.       if (JdbcOdbcObject.isTracing()) {
  1317.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxStatementLength");
  1318.       }
  1319.  
  1320.       return this.getInfo((short)105);
  1321.    }
  1322.  
  1323.    public int getMaxStatements() throws SQLException {
  1324.       if (JdbcOdbcObject.isTracing()) {
  1325.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxStatements");
  1326.       }
  1327.  
  1328.       return this.getInfoShort((short)1);
  1329.    }
  1330.  
  1331.    public int getMaxTableNameLength() throws SQLException {
  1332.       if (JdbcOdbcObject.isTracing()) {
  1333.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxTableNameLength");
  1334.       }
  1335.  
  1336.       return this.getInfoShort((short)35);
  1337.    }
  1338.  
  1339.    public int getMaxTablesInSelect() throws SQLException {
  1340.       if (JdbcOdbcObject.isTracing()) {
  1341.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxTablesInSelect");
  1342.       }
  1343.  
  1344.       return this.getInfoShort((short)106);
  1345.    }
  1346.  
  1347.    public int getMaxUserNameLength() throws SQLException {
  1348.       if (JdbcOdbcObject.isTracing()) {
  1349.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxUserNameLength");
  1350.       }
  1351.  
  1352.       return this.getInfoShort((short)107);
  1353.    }
  1354.  
  1355.    public int getDefaultTransactionIsolation() throws SQLException {
  1356.       if (JdbcOdbcObject.isTracing()) {
  1357.          JdbcOdbcObject.trace("*DatabaseMetaData.getDefaultTransactionIsolation");
  1358.       }
  1359.  
  1360.       int var1 = this.getInfo((short)26);
  1361.       byte var2 = 0;
  1362.       switch (var1) {
  1363.          case 1:
  1364.             var2 = 1;
  1365.             break;
  1366.          case 2:
  1367.             var2 = 2;
  1368.             break;
  1369.          case 4:
  1370.             var2 = 4;
  1371.             break;
  1372.          case 8:
  1373.             var2 = 8;
  1374.       }
  1375.  
  1376.       return var2;
  1377.    }
  1378.  
  1379.    public boolean supportsTransactions() throws SQLException {
  1380.       if (JdbcOdbcObject.isTracing()) {
  1381.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsTransactions");
  1382.       }
  1383.  
  1384.       int var1 = this.getInfoShort((short)46);
  1385.       return var1 != 0;
  1386.    }
  1387.  
  1388.    public boolean supportsTransactionIsolationLevel(int var1) throws SQLException {
  1389.       if (JdbcOdbcObject.isTracing()) {
  1390.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsTransactionIsolationLevel (" + var1 + ")");
  1391.       }
  1392.  
  1393.       if (var1 == 0) {
  1394.          return !this.supportsTransactions();
  1395.       } else {
  1396.          int var2 = this.getInfo((short)72);
  1397.          boolean var3 = false;
  1398.          switch (var1) {
  1399.             case 1:
  1400.                var3 = (var2 & 1) > 0;
  1401.                break;
  1402.             case 2:
  1403.                var3 = (var2 & 2) > 0;
  1404.                break;
  1405.             case 4:
  1406.                var3 = (var2 & 4) > 0;
  1407.                break;
  1408.             case 8:
  1409.                var3 = (var2 & 8) > 0;
  1410.          }
  1411.  
  1412.          return var3;
  1413.       }
  1414.    }
  1415.  
  1416.    public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
  1417.       if (JdbcOdbcObject.isTracing()) {
  1418.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsDataDefinitionAndDataManipulationTransactions");
  1419.       }
  1420.  
  1421.       int var1 = this.getInfoShort((short)46);
  1422.       return (var1 & 2) > 0;
  1423.    }
  1424.  
  1425.    public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
  1426.       if (JdbcOdbcObject.isTracing()) {
  1427.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsDataManipulationTransactionsOnly");
  1428.       }
  1429.  
  1430.       int var1 = this.getInfoShort((short)46);
  1431.       return (var1 & 1) > 0;
  1432.    }
  1433.  
  1434.    public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
  1435.       if (JdbcOdbcObject.isTracing()) {
  1436.          JdbcOdbcObject.trace("*DatabaseMetaData.dataDefintionCausesTransactionCommit");
  1437.       }
  1438.  
  1439.       int var1 = this.getInfoShort((short)46);
  1440.       return (var1 & 3) > 0;
  1441.    }
  1442.  
  1443.    public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
  1444.       if (JdbcOdbcObject.isTracing()) {
  1445.          JdbcOdbcObject.trace("*DatabaseMetaData.dataDefintionIgnoredInTransactions");
  1446.       }
  1447.  
  1448.       int var1 = this.getInfoShort((short)46);
  1449.       return (var1 & 4) > 0;
  1450.    }
  1451.  
  1452.    public ResultSet getProcedures(String var1, String var2, String var3) throws SQLException {
  1453.       if (JdbcOdbcObject.isTracing()) {
  1454.          JdbcOdbcObject.trace("*DatabaseMetaData.getProcedures (" + var1 + "," + var2 + "," + var3 + ")");
  1455.       }
  1456.  
  1457.       Object var5 = null;
  1458.       SQLWarning var6 = null;
  1459.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1460.  
  1461.       try {
  1462.          this.OdbcApi.SQLProcedures(var4, var1, var2, var3);
  1463.       } catch (SQLWarning var8) {
  1464.          var6 = var8;
  1465.       } catch (SQLException var9) {
  1466.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1467.          throw var9;
  1468.       }
  1469.  
  1470.       JdbcOdbcResultSet var10 = new JdbcOdbcResultSet();
  1471.       var10.initialize(this.OdbcApi, this.hDbc, var4, false, (Statement)null);
  1472.       var10.setWarning(var6);
  1473.       return var10;
  1474.    }
  1475.  
  1476.    public ResultSet getProcedureColumns(String var1, String var2, String var3, String var4) throws SQLException {
  1477.       if (JdbcOdbcObject.isTracing()) {
  1478.          JdbcOdbcObject.trace("*DatabaseMetaData.getProcedureColumns (" + var1 + "," + var2 + "," + var3 + "," + var4 + ")");
  1479.       }
  1480.  
  1481.       Object var6 = null;
  1482.       SQLWarning var7 = null;
  1483.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1484.  
  1485.       try {
  1486.          this.OdbcApi.SQLProcedureColumns(var5, var1, var2, var3, var4);
  1487.       } catch (SQLWarning var9) {
  1488.          var7 = var9;
  1489.       } catch (SQLException var10) {
  1490.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1491.          throw var10;
  1492.       }
  1493.  
  1494.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1495.       var11.initialize(this.OdbcApi, this.hDbc, var5, false, (Statement)null);
  1496.       var11.setWarning(var7);
  1497.       if (this.Con.getODBCVer() == 2) {
  1498.          var11.setSQLTypeColumn(6);
  1499.       }
  1500.  
  1501.       return var11;
  1502.    }
  1503.  
  1504.    public ResultSet getTables(String var1, String var2, String var3, String[] var4) throws SQLException {
  1505.       Object var6 = null;
  1506.       String var7 = null;
  1507.       SQLWarning var8 = null;
  1508.       if (var4 != null) {
  1509.          var7 = "";
  1510.          boolean var9 = false;
  1511.  
  1512.          for(short var14 = 0; var14 < var4.length; ++var14) {
  1513.             String var10 = var4[var14];
  1514.             if (var14 > 0) {
  1515.                var7 = var7 + ",";
  1516.             }
  1517.  
  1518.             var7 = var7 + var10;
  1519.          }
  1520.       }
  1521.  
  1522.       if (JdbcOdbcObject.isTracing()) {
  1523.          JdbcOdbcObject.trace("*DatabaseMetaData.getTables (" + var1 + "," + var2 + "," + var3 + "," + var7 + ")");
  1524.       }
  1525.  
  1526.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1527.  
  1528.       try {
  1529.          this.OdbcApi.SQLTables(var5, var1, var2, var3, var7);
  1530.       } catch (SQLWarning var11) {
  1531.          var8 = var11;
  1532.       } catch (SQLException var12) {
  1533.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1534.          throw var12;
  1535.       }
  1536.  
  1537.       JdbcOdbcResultSet var13 = new JdbcOdbcResultSet();
  1538.       var13.initialize(this.OdbcApi, this.hDbc, var5, false, (Statement)null);
  1539.       var13.setWarning(var8);
  1540.       return var13;
  1541.    }
  1542.  
  1543.    public ResultSet getSchemas() throws SQLException {
  1544.       if (JdbcOdbcObject.isTracing()) {
  1545.          JdbcOdbcObject.trace("*DatabaseMetaData.getSchemas");
  1546.       }
  1547.  
  1548.       JdbcOdbcResultSet var1 = (JdbcOdbcResultSet)this.getTables("", "%", "", (String[])null);
  1549.       int[] var2 = new int[]{2};
  1550.       var1.setColumnMappings(var2);
  1551.       return var1;
  1552.    }
  1553.  
  1554.    public ResultSet getCatalogs() throws SQLException {
  1555.       if (JdbcOdbcObject.isTracing()) {
  1556.          JdbcOdbcObject.trace("*DatabaseMetaData.getCatalogs");
  1557.       }
  1558.  
  1559.       JdbcOdbcResultSet var1 = (JdbcOdbcResultSet)this.getTables("%", "", "", (String[])null);
  1560.       int[] var2 = new int[]{1};
  1561.       var1.setColumnMappings(var2);
  1562.       return var1;
  1563.    }
  1564.  
  1565.    public ResultSet getTableTypes() throws SQLException {
  1566.       if (JdbcOdbcObject.isTracing()) {
  1567.          JdbcOdbcObject.trace("*DatabaseMetaData.getTableTypes");
  1568.       }
  1569.  
  1570.       String[] var1 = new String[]{"%"};
  1571.       JdbcOdbcResultSet var2 = (JdbcOdbcResultSet)this.getTables("", "", "", var1);
  1572.       int[] var3 = new int[]{4};
  1573.       var2.setColumnMappings(var3);
  1574.       return var2;
  1575.    }
  1576.  
  1577.    public ResultSet getColumns(String var1, String var2, String var3, String var4) throws SQLException {
  1578.       if (JdbcOdbcObject.isTracing()) {
  1579.          JdbcOdbcObject.trace("*DatabaseMetaData.getColumns (" + var1 + "," + var2 + "," + var3 + "," + var4 + ")");
  1580.       }
  1581.  
  1582.       Object var6 = null;
  1583.       SQLWarning var7 = null;
  1584.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1585.  
  1586.       try {
  1587.          this.OdbcApi.SQLColumns(var5, var1, var2, var3, var4);
  1588.       } catch (SQLWarning var9) {
  1589.          var7 = var9;
  1590.       } catch (SQLException var10) {
  1591.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1592.          throw var10;
  1593.       }
  1594.  
  1595.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1596.       var11.initialize(this.OdbcApi, this.hDbc, var5, false, (Statement)null);
  1597.       var11.setWarning(var7);
  1598.       if (this.Con.getODBCVer() == 2) {
  1599.          JdbcOdbcPseudoCol[] var8 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("COLUMN_DEF", 12, 254), new JdbcOdbcPseudoCol("SQL_DATA_TYPE", 5, 0), new JdbcOdbcPseudoCol("SQL_DATETIME_SUB", 5, 0), new JdbcOdbcPseudoCol("CHAR_OCTET_LENGTH", 4, 0), new JdbcOdbcPseudoCol("ORDINAL_POSITION", 4, 0), new JdbcOdbcPseudoCol("IS_NULLABLE", 12, 254)};
  1600.          var11.setPseudoCols(13, 18, var8);
  1601.          var11.setSQLTypeColumn(5);
  1602.       }
  1603.  
  1604.       return var11;
  1605.    }
  1606.  
  1607.    public ResultSet getColumnPrivileges(String var1, String var2, String var3, String var4) throws SQLException {
  1608.       if (JdbcOdbcObject.isTracing()) {
  1609.          JdbcOdbcObject.trace("*DatabaseMetaData.getColumnPrivileges (" + var1 + "," + var2 + "," + var3 + "," + var4 + ")");
  1610.       }
  1611.  
  1612.       Object var6 = null;
  1613.       SQLWarning var7 = null;
  1614.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1615.  
  1616.       try {
  1617.          this.OdbcApi.SQLColumnPrivileges(var5, var1, var2, var3, var4);
  1618.       } catch (SQLWarning var9) {
  1619.          var7 = var9;
  1620.       } catch (SQLException var10) {
  1621.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1622.          throw var10;
  1623.       }
  1624.  
  1625.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1626.       var11.initialize(this.OdbcApi, this.hDbc, var5, false, (Statement)null);
  1627.       var11.setWarning(var7);
  1628.       return var11;
  1629.    }
  1630.  
  1631.    public ResultSet getTablePrivileges(String var1, String var2, String var3) throws SQLException {
  1632.       if (JdbcOdbcObject.isTracing()) {
  1633.          JdbcOdbcObject.trace("*DatabaseMetaData.getTablePrivileges (" + var1 + "," + var2 + "," + var3 + ")");
  1634.       }
  1635.  
  1636.       Object var5 = null;
  1637.       SQLWarning var6 = null;
  1638.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1639.  
  1640.       try {
  1641.          this.OdbcApi.SQLTablePrivileges(var4, var1, var2, var3);
  1642.       } catch (SQLWarning var8) {
  1643.          var6 = var8;
  1644.       } catch (SQLException var9) {
  1645.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1646.          throw var9;
  1647.       }
  1648.  
  1649.       JdbcOdbcResultSet var10 = new JdbcOdbcResultSet();
  1650.       var10.initialize(this.OdbcApi, this.hDbc, var4, false, (Statement)null);
  1651.       var10.setWarning(var6);
  1652.       return var10;
  1653.    }
  1654.  
  1655.    public ResultSet getBestRowIdentifier(String var1, String var2, String var3, int var4, boolean var5) throws SQLException {
  1656.       if (JdbcOdbcObject.isTracing()) {
  1657.          JdbcOdbcObject.trace("*DatabaseMetaData.getBestRowIdentifier (" + var1 + "," + var2 + "," + var3 + "," + var4 + "," + var5 + ")");
  1658.       }
  1659.  
  1660.       Object var7 = null;
  1661.       SQLWarning var8 = null;
  1662.       int var6 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1663.  
  1664.       try {
  1665.          this.OdbcApi.SQLSpecialColumns(var6, (short)1, var1, var2, var3, var4, var5);
  1666.       } catch (SQLWarning var10) {
  1667.          var8 = var10;
  1668.       } catch (SQLException var11) {
  1669.          this.OdbcApi.SQLFreeStmt(var6, 1);
  1670.          throw var11;
  1671.       }
  1672.  
  1673.       JdbcOdbcResultSet var12 = new JdbcOdbcResultSet();
  1674.       var12.initialize(this.OdbcApi, this.hDbc, var6, false, (Statement)null);
  1675.       var12.setWarning(var8);
  1676.       if (this.Con.getODBCVer() == 2) {
  1677.          var12.setSQLTypeColumn(3);
  1678.       }
  1679.  
  1680.       return var12;
  1681.    }
  1682.  
  1683.    public ResultSet getVersionColumns(String var1, String var2, String var3) throws SQLException {
  1684.       if (JdbcOdbcObject.isTracing()) {
  1685.          JdbcOdbcObject.trace("*DatabaseMetaData.getVersionColumns (" + var1 + "," + var2 + "," + var3 + ")");
  1686.       }
  1687.  
  1688.       Object var5 = null;
  1689.       SQLWarning var6 = null;
  1690.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1691.  
  1692.       try {
  1693.          this.OdbcApi.SQLSpecialColumns(var4, (short)2, var1, var2, var3, 0, false);
  1694.       } catch (SQLWarning var8) {
  1695.          var6 = var8;
  1696.       } catch (SQLException var9) {
  1697.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1698.          throw var9;
  1699.       }
  1700.  
  1701.       JdbcOdbcResultSet var10 = new JdbcOdbcResultSet();
  1702.       var10.initialize(this.OdbcApi, this.hDbc, var4, false, (Statement)null);
  1703.       var10.setWarning(var6);
  1704.       if (this.Con.getODBCVer() == 2) {
  1705.          var10.setSQLTypeColumn(3);
  1706.       }
  1707.  
  1708.       return var10;
  1709.    }
  1710.  
  1711.    public ResultSet getPrimaryKeys(String var1, String var2, String var3) throws SQLException {
  1712.       if (JdbcOdbcObject.isTracing()) {
  1713.          JdbcOdbcObject.trace("*DatabaseMetaData.getPrimaryKeys (" + var1 + "," + var2 + "," + var3 + ")");
  1714.       }
  1715.  
  1716.       Object var5 = null;
  1717.       SQLWarning var6 = null;
  1718.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1719.  
  1720.       try {
  1721.          this.OdbcApi.SQLPrimaryKeys(var4, var1, var2, var3);
  1722.       } catch (SQLWarning var8) {
  1723.          var6 = var8;
  1724.       } catch (SQLException var9) {
  1725.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1726.          throw var9;
  1727.       }
  1728.  
  1729.       JdbcOdbcResultSet var10 = new JdbcOdbcResultSet();
  1730.       var10.initialize(this.OdbcApi, this.hDbc, var4, false, (Statement)null);
  1731.       var10.setWarning(var6);
  1732.       return var10;
  1733.    }
  1734.  
  1735.    public ResultSet getImportedKeys(String var1, String var2, String var3) throws SQLException {
  1736.       if (JdbcOdbcObject.isTracing()) {
  1737.          JdbcOdbcObject.trace("*DatabaseMetaData.getImportedKeys (" + var1 + "," + var2 + "," + var3 + ")");
  1738.       }
  1739.  
  1740.       Object var5 = null;
  1741.       SQLWarning var6 = null;
  1742.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1743.  
  1744.       try {
  1745.          this.OdbcApi.SQLForeignKeys(var4, (String)null, (String)null, (String)null, var1, var2, var3);
  1746.       } catch (SQLWarning var8) {
  1747.          var6 = var8;
  1748.       } catch (SQLException var9) {
  1749.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1750.          throw var9;
  1751.       }
  1752.  
  1753.       JdbcOdbcResultSet var10 = new JdbcOdbcResultSet();
  1754.       var10.initialize(this.OdbcApi, this.hDbc, var4, false, (Statement)null);
  1755.       var10.setWarning(var6);
  1756.       if (this.Con.getODBCVer() == 2) {
  1757.          JdbcOdbcPseudoCol[] var7 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("DEFERRABILITY", 5, 0)};
  1758.          var10.setPseudoCols(14, 14, var7);
  1759.       }
  1760.  
  1761.       return var10;
  1762.    }
  1763.  
  1764.    public ResultSet getExportedKeys(String var1, String var2, String var3) throws SQLException {
  1765.       if (JdbcOdbcObject.isTracing()) {
  1766.          JdbcOdbcObject.trace("*DatabaseMetaData.getExportedKeys (" + var1 + "," + var2 + "," + var3 + ")");
  1767.       }
  1768.  
  1769.       Object var5 = null;
  1770.       SQLWarning var6 = null;
  1771.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1772.  
  1773.       try {
  1774.          this.OdbcApi.SQLForeignKeys(var4, var1, var2, var3, (String)null, (String)null, (String)null);
  1775.       } catch (SQLWarning var8) {
  1776.          var6 = var8;
  1777.       } catch (SQLException var9) {
  1778.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1779.          throw var9;
  1780.       }
  1781.  
  1782.       JdbcOdbcResultSet var10 = new JdbcOdbcResultSet();
  1783.       var10.initialize(this.OdbcApi, this.hDbc, var4, false, (Statement)null);
  1784.       var10.setWarning(var6);
  1785.       if (this.Con.getODBCVer() == 2) {
  1786.          JdbcOdbcPseudoCol[] var7 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("DEFERRABILITY", 5, 0)};
  1787.          var10.setPseudoCols(14, 14, var7);
  1788.       }
  1789.  
  1790.       return var10;
  1791.    }
  1792.  
  1793.    public ResultSet getCrossReference(String var1, String var2, String var3, String var4, String var5, String var6) throws SQLException {
  1794.       if (JdbcOdbcObject.isTracing()) {
  1795.          JdbcOdbcObject.trace("*DatabaseMetaData.getCrossReference (" + var1 + "," + var2 + "," + var3 + "," + var4 + "," + var5 + "," + var6 + ")");
  1796.       }
  1797.  
  1798.       Object var8 = null;
  1799.       SQLWarning var9 = null;
  1800.       int var7 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1801.  
  1802.       try {
  1803.          this.OdbcApi.SQLForeignKeys(var7, var1, var2, var3, var4, var5, var6);
  1804.       } catch (SQLWarning var11) {
  1805.          var9 = var11;
  1806.       } catch (SQLException var12) {
  1807.          this.OdbcApi.SQLFreeStmt(var7, 1);
  1808.          throw var12;
  1809.       }
  1810.  
  1811.       JdbcOdbcResultSet var13 = new JdbcOdbcResultSet();
  1812.       var13.initialize(this.OdbcApi, this.hDbc, var7, false, (Statement)null);
  1813.       var13.setWarning(var9);
  1814.       if (this.Con.getODBCVer() == 2) {
  1815.          JdbcOdbcPseudoCol[] var10 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("DEFERRABILITY", 5, 0)};
  1816.          var13.setPseudoCols(14, 14, var10);
  1817.       }
  1818.  
  1819.       return var13;
  1820.    }
  1821.  
  1822.    public ResultSet getTypeInfo() throws SQLException {
  1823.       if (JdbcOdbcObject.isTracing()) {
  1824.          JdbcOdbcObject.trace("*DatabaseMetaData.getTypeInfo");
  1825.       }
  1826.  
  1827.       Object var2 = null;
  1828.       SQLWarning var3 = null;
  1829.       int var1 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1830.  
  1831.       try {
  1832.          this.OdbcApi.SQLGetTypeInfo(var1, (short)0);
  1833.       } catch (SQLWarning var5) {
  1834.          var3 = var5;
  1835.       } catch (SQLException var6) {
  1836.          this.OdbcApi.SQLFreeStmt(var1, 1);
  1837.          throw var6;
  1838.       }
  1839.  
  1840.       JdbcOdbcResultSet var7 = new JdbcOdbcResultSet();
  1841.       var7.initialize(this.OdbcApi, this.hDbc, var1, false, (Statement)null);
  1842.       var7.setWarning(var3);
  1843.       if (this.Con.getODBCVer() == 2) {
  1844.          JdbcOdbcPseudoCol[] var4 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("SQL_DATA_TYPE", 5, 0), new JdbcOdbcPseudoCol("SQL_DATETIME_SUB", 5, 0), new JdbcOdbcPseudoCol("NUM_PREC_RADIX", 5, 0), null, null};
  1845.          var7.setPseudoCols(16, 18, var4);
  1846.          var7.setSQLTypeColumn(2);
  1847.       }
  1848.  
  1849.       return var7;
  1850.    }
  1851.  
  1852.    public ResultSet getIndexInfo(String var1, String var2, String var3, boolean var4, boolean var5) throws SQLException {
  1853.       if (JdbcOdbcObject.isTracing()) {
  1854.          JdbcOdbcObject.trace("*DatabaseMetaData.getIndexInfo (" + var1 + "," + var2 + "," + var3 + var4 + "," + var5 + ")");
  1855.       }
  1856.  
  1857.       Object var7 = null;
  1858.       SQLWarning var8 = null;
  1859.       int var6 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1860.  
  1861.       try {
  1862.          this.OdbcApi.SQLStatistics(var6, var1, var2, var3, var4, var5);
  1863.       } catch (SQLWarning var10) {
  1864.          var8 = var10;
  1865.       } catch (SQLException var11) {
  1866.          this.OdbcApi.SQLFreeStmt(var6, 1);
  1867.          throw var11;
  1868.       }
  1869.  
  1870.       JdbcOdbcResultSet var12 = new JdbcOdbcResultSet();
  1871.       var12.initialize(this.OdbcApi, this.hDbc, var6, false, (Statement)null);
  1872.       var12.setWarning(var8);
  1873.       return var12;
  1874.    }
  1875.  
  1876.    protected void validateConnection() throws SQLException {
  1877.       this.Con.validateConnection();
  1878.    }
  1879.  
  1880.    protected int getInfo(short var1) throws SQLException {
  1881.       this.validateConnection();
  1882.       return this.OdbcApi.SQLGetInfo(this.hDbc, var1);
  1883.    }
  1884.  
  1885.    protected int getInfoShort(short var1) throws SQLException {
  1886.       this.validateConnection();
  1887.       return this.OdbcApi.SQLGetInfoShort(this.hDbc, var1);
  1888.    }
  1889.  
  1890.    protected boolean getInfoBooleanString(short var1) throws SQLException {
  1891.       this.validateConnection();
  1892.       String var2 = this.OdbcApi.SQLGetInfoString(this.hDbc, var1);
  1893.       return var2.equalsIgnoreCase("Y");
  1894.    }
  1895.  
  1896.    protected String getInfoString(short var1) throws SQLException {
  1897.       this.validateConnection();
  1898.       return this.OdbcApi.SQLGetInfoString(this.hDbc, var1);
  1899.    }
  1900.  
  1901.    protected String getInfoString(short var1, int var2) throws SQLException {
  1902.       this.validateConnection();
  1903.       return this.OdbcApi.SQLGetInfoString(this.hDbc, var1, var2);
  1904.    }
  1905. }
  1906.