home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &… the Search for Life CD 3 / 0_CD-ROM.iso / install / jre1_3 / lib / rt.jar / sun / jdbc / odbc / JdbcOdbcDatabaseMetaData.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  29.3 KB  |  2,106 lines
  1. package sun.jdbc.odbc;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.DatabaseMetaData;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.SQLWarning;
  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 2;
  145.    }
  146.  
  147.    public int getDriverMinorVersion() {
  148.       return 1;
  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 == 3;
  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 == 3;
  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 / 2);
  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.       boolean var4 = false;
  632.       int var5 = 0;
  633.       switch (var1) {
  634.          case -7:
  635.             var3 = 55;
  636.             break;
  637.          case -6:
  638.             var3 = 68;
  639.             break;
  640.          case -5:
  641.             var3 = 53;
  642.             break;
  643.          case -4:
  644.             var3 = 71;
  645.             break;
  646.          case -3:
  647.             var3 = 69;
  648.             break;
  649.          case -2:
  650.             var3 = 54;
  651.             break;
  652.          case -1:
  653.             var3 = 62;
  654.             break;
  655.          case 1:
  656.             var3 = 56;
  657.             break;
  658.          case 2:
  659.             var3 = 63;
  660.             break;
  661.          case 3:
  662.             var3 = 58;
  663.             break;
  664.          case 4:
  665.             var3 = 61;
  666.             break;
  667.          case 5:
  668.             var3 = 65;
  669.             break;
  670.          case 6:
  671.             var3 = 60;
  672.             break;
  673.          case 7:
  674.             var3 = 64;
  675.             break;
  676.          case 8:
  677.             var3 = 59;
  678.             break;
  679.          case 12:
  680.             var3 = 70;
  681.             break;
  682.          case 91:
  683.             var3 = 57;
  684.             break;
  685.          case 92:
  686.             var3 = 66;
  687.             break;
  688.          case 93:
  689.             var3 = 67;
  690.       }
  691.  
  692.       int var6 = this.getInfo(var3);
  693.       switch (var2) {
  694.          case -7:
  695.             var5 = 4096;
  696.             break;
  697.          case -6:
  698.             var5 = 8192;
  699.             break;
  700.          case -5:
  701.             var5 = 16384;
  702.             break;
  703.          case -4:
  704.             var5 = 262144;
  705.             break;
  706.          case -3:
  707.             var5 = 2048;
  708.             break;
  709.          case -2:
  710.             var5 = 1024;
  711.             break;
  712.          case -1:
  713.             var5 = 512;
  714.             break;
  715.          case 1:
  716.             var5 = 1;
  717.             break;
  718.          case 2:
  719.             var5 = 2;
  720.             break;
  721.          case 3:
  722.             var5 = 4;
  723.             break;
  724.          case 4:
  725.             var5 = 8;
  726.             break;
  727.          case 5:
  728.             var5 = 16;
  729.             break;
  730.          case 6:
  731.             var5 = 32;
  732.             break;
  733.          case 7:
  734.             var5 = 64;
  735.             break;
  736.          case 8:
  737.             var5 = 128;
  738.             break;
  739.          case 12:
  740.             var5 = 256;
  741.             break;
  742.          case 91:
  743.             var5 = 32768;
  744.             break;
  745.          case 92:
  746.             var5 = 65536;
  747.             break;
  748.          case 93:
  749.             var5 = 131072;
  750.       }
  751.  
  752.       return (var6 & var5) > 0;
  753.    }
  754.  
  755.    public boolean supportsTableCorrelationNames() throws SQLException {
  756.       if (JdbcOdbcObject.isTracing()) {
  757.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsTableCorrelationNames");
  758.       }
  759.  
  760.       int var1 = this.getInfoShort((short)74);
  761.       return var1 == 1 || var1 == 2;
  762.    }
  763.  
  764.    public boolean supportsDifferentTableCorrelationNames() throws SQLException {
  765.       if (JdbcOdbcObject.isTracing()) {
  766.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsDifferentTableCorrelationNames");
  767.       }
  768.  
  769.       int var1 = this.getInfoShort((short)74);
  770.       return var1 == 1;
  771.    }
  772.  
  773.    public boolean supportsExpressionsInOrderBy() throws SQLException {
  774.       if (JdbcOdbcObject.isTracing()) {
  775.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsExpressionsInOrderBy");
  776.       }
  777.  
  778.       return this.getInfoBooleanString((short)27);
  779.    }
  780.  
  781.    public boolean supportsOrderByUnrelated() throws SQLException {
  782.       if (JdbcOdbcObject.isTracing()) {
  783.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOrderByUnrelated");
  784.       }
  785.  
  786.       return this.getInfoBooleanString((short)90);
  787.    }
  788.  
  789.    public boolean supportsGroupBy() throws SQLException {
  790.       if (JdbcOdbcObject.isTracing()) {
  791.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsGroupBy");
  792.       }
  793.  
  794.       int var1 = this.getInfoShort((short)88);
  795.       return var1 != 0;
  796.    }
  797.  
  798.    public boolean supportsGroupByUnrelated() throws SQLException {
  799.       if (JdbcOdbcObject.isTracing()) {
  800.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsGroupByUnrelated");
  801.       }
  802.  
  803.       int var1 = this.getInfoShort((short)88);
  804.       return var1 == 3;
  805.    }
  806.  
  807.    public boolean supportsGroupByBeyondSelect() throws SQLException {
  808.       if (JdbcOdbcObject.isTracing()) {
  809.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsGroupByBeyondSelect");
  810.       }
  811.  
  812.       int var1 = this.getInfoShort((short)88);
  813.       return var1 == 2;
  814.    }
  815.  
  816.    public boolean supportsLikeEscapeClause() throws SQLException {
  817.       if (JdbcOdbcObject.isTracing()) {
  818.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsLikeEscapeClause");
  819.       }
  820.  
  821.       return this.getInfoBooleanString((short)113);
  822.    }
  823.  
  824.    public boolean supportsMultipleResultSets() throws SQLException {
  825.       if (JdbcOdbcObject.isTracing()) {
  826.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMultipleResultSets");
  827.       }
  828.  
  829.       return this.getInfoBooleanString((short)36);
  830.    }
  831.  
  832.    public boolean supportsMultipleTransactions() throws SQLException {
  833.       if (JdbcOdbcObject.isTracing()) {
  834.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMultipleTransactions");
  835.       }
  836.  
  837.       return this.getInfoBooleanString((short)37);
  838.    }
  839.  
  840.    public boolean supportsNonNullableColumns() throws SQLException {
  841.       if (JdbcOdbcObject.isTracing()) {
  842.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsNonNullableColumns");
  843.       }
  844.  
  845.       int var1 = this.getInfoShort((short)75);
  846.       return var1 == 1;
  847.    }
  848.  
  849.    public boolean supportsMinimumSQLGrammar() throws SQLException {
  850.       if (JdbcOdbcObject.isTracing()) {
  851.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsMinimumSQLGrammar");
  852.       }
  853.  
  854.       int var1 = this.getInfoShort((short)15);
  855.       return var1 == 0 || var1 == 1 || var1 == 2;
  856.    }
  857.  
  858.    public boolean supportsCoreSQLGrammar() throws SQLException {
  859.       if (JdbcOdbcObject.isTracing()) {
  860.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCoreSQLGrammar");
  861.       }
  862.  
  863.       int var1 = this.getInfoShort((short)15);
  864.       return var1 == 1 || var1 == 2;
  865.    }
  866.  
  867.    public boolean supportsANSI92EntryLevelSQL() throws SQLException {
  868.       return true;
  869.    }
  870.  
  871.    public boolean supportsANSI92IntermediateSQL() throws SQLException {
  872.       return false;
  873.    }
  874.  
  875.    public boolean supportsANSI92FullSQL() throws SQLException {
  876.       return false;
  877.    }
  878.  
  879.    public boolean supportsExtendedSQLGrammar() throws SQLException {
  880.       if (JdbcOdbcObject.isTracing()) {
  881.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsExtendedSQLGrammar");
  882.       }
  883.  
  884.       int var1 = this.getInfoShort((short)15);
  885.       return var1 == 2;
  886.    }
  887.  
  888.    public boolean supportsIntegrityEnhancementFacility() throws SQLException {
  889.       if (JdbcOdbcObject.isTracing()) {
  890.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsIntegrityEnhancementFacility");
  891.       }
  892.  
  893.       return this.getInfoBooleanString((short)73);
  894.    }
  895.  
  896.    public boolean supportsOuterJoins() throws SQLException {
  897.       if (JdbcOdbcObject.isTracing()) {
  898.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOuterJoins");
  899.       }
  900.  
  901.       String var1 = this.getInfoString((short)38);
  902.       return !var1.equalsIgnoreCase("N");
  903.    }
  904.  
  905.    public boolean supportsFullOuterJoins() throws SQLException {
  906.       if (JdbcOdbcObject.isTracing()) {
  907.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsFullOuterJoins");
  908.       }
  909.  
  910.       String var1 = this.getInfoString((short)38);
  911.       return var1.equalsIgnoreCase("F");
  912.    }
  913.  
  914.    public boolean supportsLimitedOuterJoins() throws SQLException {
  915.       if (JdbcOdbcObject.isTracing()) {
  916.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsLimitedOuterJoins");
  917.       }
  918.  
  919.       String var1 = this.getInfoString((short)38);
  920.       return var1.equalsIgnoreCase("P");
  921.    }
  922.  
  923.    public String getSchemaTerm() throws SQLException {
  924.       if (JdbcOdbcObject.isTracing()) {
  925.          JdbcOdbcObject.trace("*DatabaseMetaData.getSchemaTerm");
  926.       }
  927.  
  928.       return this.getInfoString((short)39);
  929.    }
  930.  
  931.    public String getProcedureTerm() throws SQLException {
  932.       if (JdbcOdbcObject.isTracing()) {
  933.          JdbcOdbcObject.trace("*DatabaseMetaData.getProcedureTerm");
  934.       }
  935.  
  936.       return this.getInfoString((short)40);
  937.    }
  938.  
  939.    public String getCatalogTerm() throws SQLException {
  940.       if (JdbcOdbcObject.isTracing()) {
  941.          JdbcOdbcObject.trace("*DatabaseMetaData.getCatalogTerm");
  942.       }
  943.  
  944.       return this.getInfoString((short)42);
  945.    }
  946.  
  947.    public boolean isCatalogAtStart() throws SQLException {
  948.       if (JdbcOdbcObject.isTracing()) {
  949.          JdbcOdbcObject.trace("*DatabaseMetaData.isCatalogAtStart");
  950.       }
  951.  
  952.       int var1 = this.getInfoShort((short)114);
  953.       return var1 == 1;
  954.    }
  955.  
  956.    public String getCatalogSeparator() throws SQLException {
  957.       if (JdbcOdbcObject.isTracing()) {
  958.          JdbcOdbcObject.trace("*DatabaseMetaData.getCatalogSeparator");
  959.       }
  960.  
  961.       return this.getInfoString((short)41);
  962.    }
  963.  
  964.    public boolean supportsSchemasInDataManipulation() throws SQLException {
  965.       if (JdbcOdbcObject.isTracing()) {
  966.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInDataManipulation");
  967.       }
  968.  
  969.       int var1 = this.getInfo((short)91);
  970.       return (var1 & 1) > 0;
  971.    }
  972.  
  973.    public boolean supportsSchemasInProcedureCalls() throws SQLException {
  974.       if (JdbcOdbcObject.isTracing()) {
  975.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInProcedureCalls");
  976.       }
  977.  
  978.       int var1 = this.getInfo((short)91);
  979.       return (var1 & 2) > 0;
  980.    }
  981.  
  982.    public boolean supportsSchemasInTableDefinitions() throws SQLException {
  983.       if (JdbcOdbcObject.isTracing()) {
  984.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInTableDefinitions");
  985.       }
  986.  
  987.       int var1 = this.getInfo((short)91);
  988.       return (var1 & 4) > 0;
  989.    }
  990.  
  991.    public boolean supportsSchemasInIndexDefinitions() throws SQLException {
  992.       if (JdbcOdbcObject.isTracing()) {
  993.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInIndexDefintions");
  994.       }
  995.  
  996.       int var1 = this.getInfo((short)91);
  997.       return (var1 & 8) > 0;
  998.    }
  999.  
  1000.    public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
  1001.       if (JdbcOdbcObject.isTracing()) {
  1002.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSchemasInPrivilegeDefintions");
  1003.       }
  1004.  
  1005.       int var1 = this.getInfo((short)91);
  1006.       return (var1 & 16) > 0;
  1007.    }
  1008.  
  1009.    public boolean supportsCatalogsInDataManipulation() throws SQLException {
  1010.       if (JdbcOdbcObject.isTracing()) {
  1011.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInDataManipulation");
  1012.       }
  1013.  
  1014.       int var1 = this.getInfo((short)92);
  1015.       return (var1 & 1) > 0;
  1016.    }
  1017.  
  1018.    public boolean supportsCatalogsInProcedureCalls() throws SQLException {
  1019.       if (JdbcOdbcObject.isTracing()) {
  1020.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInProcedureCalls");
  1021.       }
  1022.  
  1023.       int var1 = this.getInfo((short)92);
  1024.       return (var1 & 2) > 0;
  1025.    }
  1026.  
  1027.    public boolean supportsCatalogsInTableDefinitions() throws SQLException {
  1028.       if (JdbcOdbcObject.isTracing()) {
  1029.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInTableDefinitions");
  1030.       }
  1031.  
  1032.       int var1 = this.getInfo((short)92);
  1033.       return (var1 & 4) > 0;
  1034.    }
  1035.  
  1036.    public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
  1037.       if (JdbcOdbcObject.isTracing()) {
  1038.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInIndexDefinitions");
  1039.       }
  1040.  
  1041.       int var1 = this.getInfo((short)92);
  1042.       return (var1 & 8) > 0;
  1043.    }
  1044.  
  1045.    public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
  1046.       if (JdbcOdbcObject.isTracing()) {
  1047.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCatalogsInPrivilegeDefintions");
  1048.       }
  1049.  
  1050.       int var1 = this.getInfo((short)92);
  1051.       return (var1 & 16) > 0;
  1052.    }
  1053.  
  1054.    public boolean supportsPositionedDelete() throws SQLException {
  1055.       if (JdbcOdbcObject.isTracing()) {
  1056.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsPositionedDelete");
  1057.       }
  1058.  
  1059.       int var1 = this.getInfo((short)80);
  1060.       return (var1 & 1) > 0;
  1061.    }
  1062.  
  1063.    public boolean supportsPositionedUpdate() throws SQLException {
  1064.       if (JdbcOdbcObject.isTracing()) {
  1065.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsPositionedUpdate");
  1066.       }
  1067.  
  1068.       int var1 = this.getInfo((short)80);
  1069.       return (var1 & 2) > 0;
  1070.    }
  1071.  
  1072.    public boolean supportsSelectForUpdate() throws SQLException {
  1073.       if (JdbcOdbcObject.isTracing()) {
  1074.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSelectForUpdate");
  1075.       }
  1076.  
  1077.       int var1 = this.getInfo((short)80);
  1078.       return (var1 & 4) > 0;
  1079.    }
  1080.  
  1081.    public boolean supportsStoredProcedures() throws SQLException {
  1082.       if (JdbcOdbcObject.isTracing()) {
  1083.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsStoredProcedures");
  1084.       }
  1085.  
  1086.       return this.getInfoBooleanString((short)21);
  1087.    }
  1088.  
  1089.    public boolean supportsSubqueriesInComparisons() throws SQLException {
  1090.       if (JdbcOdbcObject.isTracing()) {
  1091.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInComparisions");
  1092.       }
  1093.  
  1094.       int var1 = this.getInfo((short)95);
  1095.       return (var1 & 1) > 0;
  1096.    }
  1097.  
  1098.    public boolean supportsSubqueriesInExists() throws SQLException {
  1099.       if (JdbcOdbcObject.isTracing()) {
  1100.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInExists");
  1101.       }
  1102.  
  1103.       int var1 = this.getInfo((short)95);
  1104.       return (var1 & 2) > 0;
  1105.    }
  1106.  
  1107.    public boolean supportsSubqueriesInIns() throws SQLException {
  1108.       if (JdbcOdbcObject.isTracing()) {
  1109.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInIns");
  1110.       }
  1111.  
  1112.       int var1 = this.getInfo((short)95);
  1113.       return (var1 & 4) > 0;
  1114.    }
  1115.  
  1116.    public boolean supportsSubqueriesInQuantifieds() throws SQLException {
  1117.       if (JdbcOdbcObject.isTracing()) {
  1118.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsSubqueriesInQuantifieds");
  1119.       }
  1120.  
  1121.       int var1 = this.getInfo((short)95);
  1122.       return (var1 & 8) > 0;
  1123.    }
  1124.  
  1125.    public boolean supportsCorrelatedSubqueries() throws SQLException {
  1126.       if (JdbcOdbcObject.isTracing()) {
  1127.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsCorrelatedSubqueries");
  1128.       }
  1129.  
  1130.       int var1 = this.getInfo((short)95);
  1131.       return (var1 & 16) > 0;
  1132.    }
  1133.  
  1134.    public boolean supportsUnion() throws SQLException {
  1135.       if (JdbcOdbcObject.isTracing()) {
  1136.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsUnion");
  1137.       }
  1138.  
  1139.       int var1 = this.getInfo((short)96);
  1140.       return (var1 & 1) > 0;
  1141.    }
  1142.  
  1143.    public boolean supportsUnionAll() throws SQLException {
  1144.       if (JdbcOdbcObject.isTracing()) {
  1145.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsUnionAll");
  1146.       }
  1147.  
  1148.       int var1 = this.getInfo((short)96);
  1149.       return (var1 & 2) > 0;
  1150.    }
  1151.  
  1152.    public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
  1153.       if (JdbcOdbcObject.isTracing()) {
  1154.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenCursorsAcrossCommit");
  1155.       }
  1156.  
  1157.       int var1 = this.getInfoShort((short)23);
  1158.       return var1 == 2;
  1159.    }
  1160.  
  1161.    public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
  1162.       if (JdbcOdbcObject.isTracing()) {
  1163.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenCursorsAcrossRollback");
  1164.       }
  1165.  
  1166.       int var1 = this.getInfoShort((short)24);
  1167.       return var1 == 2;
  1168.    }
  1169.  
  1170.    public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
  1171.       if (JdbcOdbcObject.isTracing()) {
  1172.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenStatementsAcrossCommit");
  1173.       }
  1174.  
  1175.       int var1 = this.getInfoShort((short)23);
  1176.       return var1 == 2 || var1 == 1;
  1177.    }
  1178.  
  1179.    public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
  1180.       if (JdbcOdbcObject.isTracing()) {
  1181.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsOpenStatementsAcrossRollback");
  1182.       }
  1183.  
  1184.       int var1 = this.getInfoShort((short)24);
  1185.       return var1 == 2 || var1 == 1;
  1186.    }
  1187.  
  1188.    public int getMaxBinaryLiteralLength() throws SQLException {
  1189.       if (JdbcOdbcObject.isTracing()) {
  1190.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxBinaryLiteralLength");
  1191.       }
  1192.  
  1193.       return this.getInfo((short)112);
  1194.    }
  1195.  
  1196.    public int getMaxCharLiteralLength() throws SQLException {
  1197.       if (JdbcOdbcObject.isTracing()) {
  1198.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxCharLiteralLength");
  1199.       }
  1200.  
  1201.       return this.getInfo((short)108);
  1202.    }
  1203.  
  1204.    public int getMaxColumnNameLength() throws SQLException {
  1205.       if (JdbcOdbcObject.isTracing()) {
  1206.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnNameLength");
  1207.       }
  1208.  
  1209.       return this.getInfoShort((short)30);
  1210.    }
  1211.  
  1212.    public int getMaxColumnsInGroupBy() throws SQLException {
  1213.       if (JdbcOdbcObject.isTracing()) {
  1214.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInGroupBy");
  1215.       }
  1216.  
  1217.       return this.getInfoShort((short)97);
  1218.    }
  1219.  
  1220.    public int getMaxColumnsInIndex() throws SQLException {
  1221.       if (JdbcOdbcObject.isTracing()) {
  1222.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInIndex");
  1223.       }
  1224.  
  1225.       return this.getInfoShort((short)98);
  1226.    }
  1227.  
  1228.    public int getMaxColumnsInOrderBy() throws SQLException {
  1229.       if (JdbcOdbcObject.isTracing()) {
  1230.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInOrderBy");
  1231.       }
  1232.  
  1233.       return this.getInfoShort((short)99);
  1234.    }
  1235.  
  1236.    public int getMaxColumnsInSelect() throws SQLException {
  1237.       if (JdbcOdbcObject.isTracing()) {
  1238.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInSeleted");
  1239.       }
  1240.  
  1241.       return this.getInfoShort((short)100);
  1242.    }
  1243.  
  1244.    public int getMaxColumnsInTable() throws SQLException {
  1245.       if (JdbcOdbcObject.isTracing()) {
  1246.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxColumnsInTable");
  1247.       }
  1248.  
  1249.       return this.getInfoShort((short)101);
  1250.    }
  1251.  
  1252.    public int getMaxConnections() throws SQLException {
  1253.       if (JdbcOdbcObject.isTracing()) {
  1254.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxConnections");
  1255.       }
  1256.  
  1257.       return this.getInfoShort((short)0);
  1258.    }
  1259.  
  1260.    public int getMaxCursorNameLength() throws SQLException {
  1261.       if (JdbcOdbcObject.isTracing()) {
  1262.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxCursorNameLength");
  1263.       }
  1264.  
  1265.       return this.getInfo((short)31);
  1266.    }
  1267.  
  1268.    public int getMaxIndexLength() throws SQLException {
  1269.       if (JdbcOdbcObject.isTracing()) {
  1270.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxIndexLength");
  1271.       }
  1272.  
  1273.       return this.getInfo((short)102);
  1274.    }
  1275.  
  1276.    public int getMaxSchemaNameLength() throws SQLException {
  1277.       if (JdbcOdbcObject.isTracing()) {
  1278.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxSchemaNameLength");
  1279.       }
  1280.  
  1281.       return this.getInfoShort((short)32);
  1282.    }
  1283.  
  1284.    public int getMaxProcedureNameLength() throws SQLException {
  1285.       if (JdbcOdbcObject.isTracing()) {
  1286.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxProcedureNameLength");
  1287.       }
  1288.  
  1289.       return this.getInfoShort((short)33);
  1290.    }
  1291.  
  1292.    public int getMaxCatalogNameLength() throws SQLException {
  1293.       if (JdbcOdbcObject.isTracing()) {
  1294.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxCatalogNameLength");
  1295.       }
  1296.  
  1297.       return this.getInfoShort((short)34);
  1298.    }
  1299.  
  1300.    public int getMaxRowSize() throws SQLException {
  1301.       if (JdbcOdbcObject.isTracing()) {
  1302.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxRowSize");
  1303.       }
  1304.  
  1305.       return this.getInfo((short)104);
  1306.    }
  1307.  
  1308.    public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
  1309.       if (JdbcOdbcObject.isTracing()) {
  1310.          JdbcOdbcObject.trace("*DatabaseMetaData.doesMaxRowSizeIncludeBlobs");
  1311.       }
  1312.  
  1313.       return this.getInfoBooleanString((short)103);
  1314.    }
  1315.  
  1316.    public int getMaxStatementLength() throws SQLException {
  1317.       if (JdbcOdbcObject.isTracing()) {
  1318.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxStatementLength");
  1319.       }
  1320.  
  1321.       return this.getInfo((short)105);
  1322.    }
  1323.  
  1324.    public int getMaxStatements() throws SQLException {
  1325.       if (JdbcOdbcObject.isTracing()) {
  1326.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxStatements");
  1327.       }
  1328.  
  1329.       return this.getInfoShort((short)1);
  1330.    }
  1331.  
  1332.    public int getMaxTableNameLength() throws SQLException {
  1333.       if (JdbcOdbcObject.isTracing()) {
  1334.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxTableNameLength");
  1335.       }
  1336.  
  1337.       return this.getInfoShort((short)35);
  1338.    }
  1339.  
  1340.    public int getMaxTablesInSelect() throws SQLException {
  1341.       if (JdbcOdbcObject.isTracing()) {
  1342.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxTablesInSelect");
  1343.       }
  1344.  
  1345.       return this.getInfoShort((short)106);
  1346.    }
  1347.  
  1348.    public int getMaxUserNameLength() throws SQLException {
  1349.       if (JdbcOdbcObject.isTracing()) {
  1350.          JdbcOdbcObject.trace("*DatabaseMetaData.getMaxUserNameLength");
  1351.       }
  1352.  
  1353.       return this.getInfoShort((short)107);
  1354.    }
  1355.  
  1356.    public int getDefaultTransactionIsolation() throws SQLException {
  1357.       if (JdbcOdbcObject.isTracing()) {
  1358.          JdbcOdbcObject.trace("*DatabaseMetaData.getDefaultTransactionIsolation");
  1359.       }
  1360.  
  1361.       int var1 = this.getInfo((short)26);
  1362.       byte var2 = 0;
  1363.       switch (var1) {
  1364.          case 1:
  1365.             var2 = 1;
  1366.             break;
  1367.          case 2:
  1368.             var2 = 2;
  1369.          case 3:
  1370.          case 5:
  1371.          case 6:
  1372.          case 7:
  1373.          default:
  1374.             break;
  1375.          case 4:
  1376.             var2 = 4;
  1377.             break;
  1378.          case 8:
  1379.             var2 = 8;
  1380.       }
  1381.  
  1382.       return var2;
  1383.    }
  1384.  
  1385.    public boolean supportsTransactions() throws SQLException {
  1386.       if (JdbcOdbcObject.isTracing()) {
  1387.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsTransactions");
  1388.       }
  1389.  
  1390.       int var1 = this.getInfoShort((short)46);
  1391.       return var1 != 0;
  1392.    }
  1393.  
  1394.    public boolean supportsTransactionIsolationLevel(int var1) throws SQLException {
  1395.       if (JdbcOdbcObject.isTracing()) {
  1396.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsTransactionIsolationLevel (" + var1 + ")");
  1397.       }
  1398.  
  1399.       if (var1 == 0) {
  1400.          return !this.supportsTransactions();
  1401.       } else {
  1402.          int var2 = this.getInfo((short)72);
  1403.          boolean var3 = false;
  1404.          switch (var1) {
  1405.             case 1:
  1406.                var3 = (var2 & 1) > 0;
  1407.                break;
  1408.             case 2:
  1409.                var3 = (var2 & 2) > 0;
  1410.             case 3:
  1411.             case 5:
  1412.             case 6:
  1413.             case 7:
  1414.             default:
  1415.                break;
  1416.             case 4:
  1417.                var3 = (var2 & 4) > 0;
  1418.                break;
  1419.             case 8:
  1420.                var3 = (var2 & 8) > 0;
  1421.          }
  1422.  
  1423.          return var3;
  1424.       }
  1425.    }
  1426.  
  1427.    public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
  1428.       if (JdbcOdbcObject.isTracing()) {
  1429.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsDataDefinitionAndDataManipulationTransactions");
  1430.       }
  1431.  
  1432.       int var1 = this.getInfoShort((short)46);
  1433.       return (var1 & 2) > 0;
  1434.    }
  1435.  
  1436.    public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
  1437.       if (JdbcOdbcObject.isTracing()) {
  1438.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsDataManipulationTransactionsOnly");
  1439.       }
  1440.  
  1441.       int var1 = this.getInfoShort((short)46);
  1442.       return (var1 & 1) > 0;
  1443.    }
  1444.  
  1445.    public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
  1446.       if (JdbcOdbcObject.isTracing()) {
  1447.          JdbcOdbcObject.trace("*DatabaseMetaData.dataDefintionCausesTransactionCommit");
  1448.       }
  1449.  
  1450.       int var1 = this.getInfoShort((short)46);
  1451.       return (var1 & 3) > 0;
  1452.    }
  1453.  
  1454.    public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
  1455.       if (JdbcOdbcObject.isTracing()) {
  1456.          JdbcOdbcObject.trace("*DatabaseMetaData.dataDefintionIgnoredInTransactions");
  1457.       }
  1458.  
  1459.       int var1 = this.getInfoShort((short)46);
  1460.       return (var1 & 4) > 0;
  1461.    }
  1462.  
  1463.    public ResultSet getProcedures(String var1, String var2, String var3) throws SQLException {
  1464.       if (JdbcOdbcObject.isTracing()) {
  1465.          JdbcOdbcObject.trace("*DatabaseMetaData.getProcedures (" + var1 + "," + var2 + "," + var3 + ")");
  1466.       }
  1467.  
  1468.       Object var5 = null;
  1469.       SQLWarning var6 = null;
  1470.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1471.  
  1472.       try {
  1473.          this.OdbcApi.SQLProcedures(var4, var1, var2, var3);
  1474.       } catch (SQLWarning var9) {
  1475.          var6 = var9;
  1476.       } catch (SQLException var10) {
  1477.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1478.          throw var10;
  1479.       }
  1480.  
  1481.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1482.       var11.initialize(this.OdbcApi, this.hDbc, var4, false, (JdbcOdbcStatement)null);
  1483.       var11.setWarning(var6);
  1484.       return var11;
  1485.    }
  1486.  
  1487.    public ResultSet getProcedureColumns(String var1, String var2, String var3, String var4) throws SQLException {
  1488.       if (JdbcOdbcObject.isTracing()) {
  1489.          JdbcOdbcObject.trace("*DatabaseMetaData.getProcedureColumns (" + var1 + "," + var2 + "," + var3 + "," + var4 + ")");
  1490.       }
  1491.  
  1492.       Object var6 = null;
  1493.       SQLWarning var7 = null;
  1494.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1495.  
  1496.       try {
  1497.          this.OdbcApi.SQLProcedureColumns(var5, var1, var2, var3, var4);
  1498.       } catch (SQLWarning var10) {
  1499.          var7 = var10;
  1500.       } catch (SQLException var11) {
  1501.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1502.          throw var11;
  1503.       }
  1504.  
  1505.       JdbcOdbcResultSet var12 = new JdbcOdbcResultSet();
  1506.       var12.initialize(this.OdbcApi, this.hDbc, var5, false, (JdbcOdbcStatement)null);
  1507.       var12.setWarning(var7);
  1508.       if (this.Con.getODBCVer() >= 2) {
  1509.          var12.setSQLTypeColumn(6);
  1510.          var12.setAliasColumnName("PRECISION", 8);
  1511.          var12.setAliasColumnName("LENGTH", 9);
  1512.          var12.setAliasColumnName("SCALE", 10);
  1513.          var12.setAliasColumnName("RADIX", 11);
  1514.       }
  1515.  
  1516.       return var12;
  1517.    }
  1518.  
  1519.    public ResultSet getTables(String var1, String var2, String var3, String[] var4) throws SQLException {
  1520.       Object var6 = null;
  1521.       String var7 = null;
  1522.       SQLWarning var8 = null;
  1523.       if (var4 != null) {
  1524.          var7 = "";
  1525.          boolean var9 = false;
  1526.  
  1527.          for(short var14 = 0; var14 < var4.length; ++var14) {
  1528.             String var10 = var4[var14];
  1529.             if (var14 > 0) {
  1530.                var7 = var7 + ",";
  1531.             }
  1532.  
  1533.             var7 = var7 + var10;
  1534.          }
  1535.       }
  1536.  
  1537.       if (JdbcOdbcObject.isTracing()) {
  1538.          JdbcOdbcObject.trace("*DatabaseMetaData.getTables (" + var1 + "," + var2 + "," + var3 + "," + var7 + ")");
  1539.       }
  1540.  
  1541.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1542.  
  1543.       try {
  1544.          this.OdbcApi.SQLTables(var5, var1, var2, var3, var7);
  1545.       } catch (SQLWarning var11) {
  1546.          var8 = var11;
  1547.       } catch (SQLException var12) {
  1548.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1549.          throw var12;
  1550.       }
  1551.  
  1552.       JdbcOdbcResultSet var13 = new JdbcOdbcResultSet();
  1553.       var13.initialize(this.OdbcApi, this.hDbc, var5, false, (JdbcOdbcStatement)null);
  1554.       var13.setWarning(var8);
  1555.       return var13;
  1556.    }
  1557.  
  1558.    public ResultSet getSchemas() throws SQLException {
  1559.       if (JdbcOdbcObject.isTracing()) {
  1560.          JdbcOdbcObject.trace("*DatabaseMetaData.getSchemas");
  1561.       }
  1562.  
  1563.       JdbcOdbcResultSet var1 = (JdbcOdbcResultSet)this.getTables("", "%", "", (String[])null);
  1564.       int[] var2 = new int[]{2};
  1565.       var1.setColumnMappings(var2);
  1566.       return var1;
  1567.    }
  1568.  
  1569.    public ResultSet getCatalogs() throws SQLException {
  1570.       if (JdbcOdbcObject.isTracing()) {
  1571.          JdbcOdbcObject.trace("*DatabaseMetaData.getCatalogs");
  1572.       }
  1573.  
  1574.       JdbcOdbcResultSet var1 = (JdbcOdbcResultSet)this.getTables("%", "", "", (String[])null);
  1575.       int[] var2 = new int[]{1};
  1576.       var1.setColumnMappings(var2);
  1577.       return var1;
  1578.    }
  1579.  
  1580.    public ResultSet getTableTypes() throws SQLException {
  1581.       if (JdbcOdbcObject.isTracing()) {
  1582.          JdbcOdbcObject.trace("*DatabaseMetaData.getTableTypes");
  1583.       }
  1584.  
  1585.       String[] var1 = new String[]{"%"};
  1586.       JdbcOdbcResultSet var2 = (JdbcOdbcResultSet)this.getTables("", "", "", var1);
  1587.       int[] var3 = new int[]{4};
  1588.       var2.setColumnMappings(var3);
  1589.       return var2;
  1590.    }
  1591.  
  1592.    public ResultSet getColumns(String var1, String var2, String var3, String var4) throws SQLException {
  1593.       if (JdbcOdbcObject.isTracing()) {
  1594.          JdbcOdbcObject.trace("*DatabaseMetaData.getColumns (" + var1 + "," + var2 + "," + var3 + "," + var4 + ")");
  1595.       }
  1596.  
  1597.       Object var6 = null;
  1598.       SQLWarning var7 = null;
  1599.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1600.  
  1601.       try {
  1602.          this.OdbcApi.SQLColumns(var5, var1, var2, var3, var4);
  1603.       } catch (SQLWarning var10) {
  1604.          var7 = var10;
  1605.       } catch (SQLException var11) {
  1606.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1607.          throw var11;
  1608.       }
  1609.  
  1610.       JdbcOdbcResultSet var12 = new JdbcOdbcResultSet();
  1611.       var12.initialize(this.OdbcApi, this.hDbc, var5, false, (JdbcOdbcStatement)null);
  1612.       var12.setWarning(var7);
  1613.       if (this.Con.getODBCVer() == 2) {
  1614.          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)};
  1615.          var12.setPseudoCols(13, 18, var8);
  1616.          var12.setSQLTypeColumn(5);
  1617.       } else if (this.Con.getODBCVer() >= 3) {
  1618.          var12.setSQLTypeColumn(5);
  1619.          var12.setAliasColumnName("SQL_DATETIME_SUB", 15);
  1620.       }
  1621.  
  1622.       return var12;
  1623.    }
  1624.  
  1625.    public ResultSet getColumnPrivileges(String var1, String var2, String var3, String var4) throws SQLException {
  1626.       if (JdbcOdbcObject.isTracing()) {
  1627.          JdbcOdbcObject.trace("*DatabaseMetaData.getColumnPrivileges (" + var1 + "," + var2 + "," + var3 + "," + var4 + ")");
  1628.       }
  1629.  
  1630.       Object var6 = null;
  1631.       SQLWarning var7 = null;
  1632.       int var5 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1633.  
  1634.       try {
  1635.          this.OdbcApi.SQLColumnPrivileges(var5, var1, var2, var3, var4);
  1636.       } catch (SQLWarning var10) {
  1637.          var7 = var10;
  1638.       } catch (SQLException var11) {
  1639.          this.OdbcApi.SQLFreeStmt(var5, 1);
  1640.          throw var11;
  1641.       }
  1642.  
  1643.       JdbcOdbcResultSet var12 = new JdbcOdbcResultSet();
  1644.       var12.initialize(this.OdbcApi, this.hDbc, var5, false, (JdbcOdbcStatement)null);
  1645.       var12.setWarning(var7);
  1646.       return var12;
  1647.    }
  1648.  
  1649.    public ResultSet getTablePrivileges(String var1, String var2, String var3) throws SQLException {
  1650.       if (JdbcOdbcObject.isTracing()) {
  1651.          JdbcOdbcObject.trace("*DatabaseMetaData.getTablePrivileges (" + var1 + "," + var2 + "," + var3 + ")");
  1652.       }
  1653.  
  1654.       Object var5 = null;
  1655.       SQLWarning var6 = null;
  1656.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1657.  
  1658.       try {
  1659.          this.OdbcApi.SQLTablePrivileges(var4, var1, var2, var3);
  1660.       } catch (SQLWarning var9) {
  1661.          var6 = var9;
  1662.       } catch (SQLException var10) {
  1663.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1664.          throw var10;
  1665.       }
  1666.  
  1667.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1668.       var11.initialize(this.OdbcApi, this.hDbc, var4, false, (JdbcOdbcStatement)null);
  1669.       var11.setWarning(var6);
  1670.       return var11;
  1671.    }
  1672.  
  1673.    public ResultSet getBestRowIdentifier(String var1, String var2, String var3, int var4, boolean var5) throws SQLException {
  1674.       if (JdbcOdbcObject.isTracing()) {
  1675.          JdbcOdbcObject.trace("*DatabaseMetaData.getBestRowIdentifier (" + var1 + "," + var2 + "," + var3 + "," + var4 + "," + var5 + ")");
  1676.       }
  1677.  
  1678.       Object var7 = null;
  1679.       SQLWarning var8 = null;
  1680.       int var6 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1681.  
  1682.       try {
  1683.          this.OdbcApi.SQLSpecialColumns(var6, (short)1, var1, var2, var3, var4, var5);
  1684.       } catch (SQLWarning var11) {
  1685.          var8 = var11;
  1686.       } catch (SQLException var12) {
  1687.          this.OdbcApi.SQLFreeStmt(var6, 1);
  1688.          throw var12;
  1689.       }
  1690.  
  1691.       JdbcOdbcResultSet var13 = new JdbcOdbcResultSet();
  1692.       var13.initialize(this.OdbcApi, this.hDbc, var6, false, (JdbcOdbcStatement)null);
  1693.       var13.setWarning(var8);
  1694.       if (this.Con.getODBCVer() >= 2) {
  1695.          var13.setSQLTypeColumn(3);
  1696.       }
  1697.  
  1698.       return var13;
  1699.    }
  1700.  
  1701.    public ResultSet getVersionColumns(String var1, String var2, String var3) throws SQLException {
  1702.       if (JdbcOdbcObject.isTracing()) {
  1703.          JdbcOdbcObject.trace("*DatabaseMetaData.getVersionColumns (" + var1 + "," + var2 + "," + var3 + ")");
  1704.       }
  1705.  
  1706.       Object var5 = null;
  1707.       SQLWarning var6 = null;
  1708.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1709.  
  1710.       try {
  1711.          this.OdbcApi.SQLSpecialColumns(var4, (short)2, var1, var2, var3, 0, false);
  1712.       } catch (SQLWarning var9) {
  1713.          var6 = var9;
  1714.       } catch (SQLException var10) {
  1715.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1716.          throw var10;
  1717.       }
  1718.  
  1719.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1720.       var11.initialize(this.OdbcApi, this.hDbc, var4, false, (JdbcOdbcStatement)null);
  1721.       var11.setWarning(var6);
  1722.       if (this.Con.getODBCVer() >= 2) {
  1723.          var11.setSQLTypeColumn(3);
  1724.       }
  1725.  
  1726.       return var11;
  1727.    }
  1728.  
  1729.    public ResultSet getPrimaryKeys(String var1, String var2, String var3) throws SQLException {
  1730.       if (JdbcOdbcObject.isTracing()) {
  1731.          JdbcOdbcObject.trace("*DatabaseMetaData.getPrimaryKeys (" + var1 + "," + var2 + "," + var3 + ")");
  1732.       }
  1733.  
  1734.       Object var5 = null;
  1735.       SQLWarning var6 = null;
  1736.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1737.  
  1738.       try {
  1739.          this.OdbcApi.SQLPrimaryKeys(var4, var1, var2, var3);
  1740.       } catch (SQLWarning var9) {
  1741.          var6 = var9;
  1742.       } catch (SQLException var10) {
  1743.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1744.          throw var10;
  1745.       }
  1746.  
  1747.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1748.       var11.initialize(this.OdbcApi, this.hDbc, var4, false, (JdbcOdbcStatement)null);
  1749.       var11.setWarning(var6);
  1750.       return var11;
  1751.    }
  1752.  
  1753.    public ResultSet getImportedKeys(String var1, String var2, String var3) throws SQLException {
  1754.       if (JdbcOdbcObject.isTracing()) {
  1755.          JdbcOdbcObject.trace("*DatabaseMetaData.getImportedKeys (" + var1 + "," + var2 + "," + var3 + ")");
  1756.       }
  1757.  
  1758.       Object var5 = null;
  1759.       SQLWarning var6 = null;
  1760.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1761.  
  1762.       try {
  1763.          this.OdbcApi.SQLForeignKeys(var4, (String)null, (String)null, (String)null, var1, var2, var3);
  1764.       } catch (SQLWarning var9) {
  1765.          var6 = var9;
  1766.       } catch (SQLException var10) {
  1767.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1768.          throw var10;
  1769.       }
  1770.  
  1771.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1772.       var11.initialize(this.OdbcApi, this.hDbc, var4, false, (JdbcOdbcStatement)null);
  1773.       var11.setWarning(var6);
  1774.       if (this.Con.getODBCVer() == 2) {
  1775.          JdbcOdbcPseudoCol[] var7 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("DEFERRABILITY", 5, 0)};
  1776.          var11.setPseudoCols(14, 14, var7);
  1777.       }
  1778.  
  1779.       return var11;
  1780.    }
  1781.  
  1782.    public ResultSet getExportedKeys(String var1, String var2, String var3) throws SQLException {
  1783.       if (JdbcOdbcObject.isTracing()) {
  1784.          JdbcOdbcObject.trace("*DatabaseMetaData.getExportedKeys (" + var1 + "," + var2 + "," + var3 + ")");
  1785.       }
  1786.  
  1787.       Object var5 = null;
  1788.       SQLWarning var6 = null;
  1789.       int var4 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1790.  
  1791.       try {
  1792.          this.OdbcApi.SQLForeignKeys(var4, var1, var2, var3, (String)null, (String)null, (String)null);
  1793.       } catch (SQLWarning var9) {
  1794.          var6 = var9;
  1795.       } catch (SQLException var10) {
  1796.          this.OdbcApi.SQLFreeStmt(var4, 1);
  1797.          throw var10;
  1798.       }
  1799.  
  1800.       JdbcOdbcResultSet var11 = new JdbcOdbcResultSet();
  1801.       var11.initialize(this.OdbcApi, this.hDbc, var4, false, (JdbcOdbcStatement)null);
  1802.       var11.setWarning(var6);
  1803.       if (this.Con.getODBCVer() == 2) {
  1804.          JdbcOdbcPseudoCol[] var7 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("DEFERRABILITY", 5, 0)};
  1805.          var11.setPseudoCols(14, 14, var7);
  1806.       }
  1807.  
  1808.       return var11;
  1809.    }
  1810.  
  1811.    public ResultSet getCrossReference(String var1, String var2, String var3, String var4, String var5, String var6) throws SQLException {
  1812.       if (JdbcOdbcObject.isTracing()) {
  1813.          JdbcOdbcObject.trace("*DatabaseMetaData.getCrossReference (" + var1 + "," + var2 + "," + var3 + "," + var4 + "," + var5 + "," + var6 + ")");
  1814.       }
  1815.  
  1816.       Object var8 = null;
  1817.       SQLWarning var9 = null;
  1818.       int var7 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1819.  
  1820.       try {
  1821.          this.OdbcApi.SQLForeignKeys(var7, var1, var2, var3, var4, var5, var6);
  1822.       } catch (SQLWarning var12) {
  1823.          var9 = var12;
  1824.       } catch (SQLException var13) {
  1825.          this.OdbcApi.SQLFreeStmt(var7, 1);
  1826.          throw var13;
  1827.       }
  1828.  
  1829.       JdbcOdbcResultSet var14 = new JdbcOdbcResultSet();
  1830.       var14.initialize(this.OdbcApi, this.hDbc, var7, false, (JdbcOdbcStatement)null);
  1831.       var14.setWarning(var9);
  1832.       if (this.Con.getODBCVer() == 2) {
  1833.          JdbcOdbcPseudoCol[] var10 = new JdbcOdbcPseudoCol[]{new JdbcOdbcPseudoCol("DEFERRABILITY", 5, 0)};
  1834.          var14.setPseudoCols(14, 14, var10);
  1835.       }
  1836.  
  1837.       return var14;
  1838.    }
  1839.  
  1840.    public boolean supportsResultSetType(int var1) throws SQLException {
  1841.       short var2 = this.getConnectionSupportType(var1);
  1842.       switch (var1) {
  1843.          case 1003:
  1844.             return var2 == 0;
  1845.          case 1004:
  1846.             return var2 == 3 || var2 == 1;
  1847.          case 1005:
  1848.             if (var2 == 1) {
  1849.                int var3 = this.Con.getOdbcCursorAttr2(var2);
  1850.                if ((var3 & 64) != 0) {
  1851.                   return true;
  1852.                }
  1853.  
  1854.                return false;
  1855.             }
  1856.  
  1857.             return var2 == 2;
  1858.          default:
  1859.             return false;
  1860.       }
  1861.    }
  1862.  
  1863.    public boolean supportsResultSetConcurrency(int var1, int var2) throws SQLException {
  1864.       if (this.supportsResultSetType(var1)) {
  1865.          short var3 = this.Con.getOdbcConcurrency(var2);
  1866.          switch (var2) {
  1867.             case 1007:
  1868.                return var3 == 1;
  1869.             case 1008:
  1870.                if (var1 != 1003) {
  1871.                   return var3 == 2;
  1872.                }
  1873.  
  1874.                return false;
  1875.             default:
  1876.                return false;
  1877.          }
  1878.       } else {
  1879.          return false;
  1880.       }
  1881.    }
  1882.  
  1883.    public boolean ownUpdatesAreVisible(int var1) throws SQLException {
  1884.       return var1 != 1003 ? this.updatesAreDetected(var1) : false;
  1885.    }
  1886.  
  1887.    public boolean ownDeletesAreVisible(int var1) throws SQLException {
  1888.       return var1 != 1003 ? this.deletesAreDetected(var1) : false;
  1889.    }
  1890.  
  1891.    public boolean ownInsertsAreVisible(int var1) throws SQLException {
  1892.       return var1 != 1003 ? this.insertsAreDetected(var1) : false;
  1893.    }
  1894.  
  1895.    public boolean othersUpdatesAreVisible(int var1) throws SQLException {
  1896.       return var1 == 1005 ? this.updatesAreDetected(var1) : false;
  1897.    }
  1898.  
  1899.    public boolean othersDeletesAreVisible(int var1) throws SQLException {
  1900.       return var1 == 1005 ? this.deletesAreDetected(var1) : false;
  1901.    }
  1902.  
  1903.    public boolean othersInsertsAreVisible(int var1) throws SQLException {
  1904.       return var1 == 1005 ? this.insertsAreDetected(var1) : false;
  1905.    }
  1906.  
  1907.    public boolean updatesAreDetected(int var1) throws SQLException {
  1908.       short var2 = this.getCursorAttribute(var1);
  1909.       if (var2 > 0) {
  1910.          try {
  1911.             int var3 = this.OdbcApi.SQLGetInfo(this.hDbc, var2);
  1912.             return (var3 & 64) > 0;
  1913.          } catch (SQLException var4) {
  1914.             return false;
  1915.          }
  1916.       } else {
  1917.          return false;
  1918.       }
  1919.    }
  1920.  
  1921.    public boolean deletesAreDetected(int var1) throws SQLException {
  1922.       short var2 = this.getCursorAttribute(var1);
  1923.       if (var2 > 0) {
  1924.          try {
  1925.             int var3 = this.OdbcApi.SQLGetInfo(this.hDbc, var2);
  1926.             return (var3 & 32) > 0;
  1927.          } catch (SQLException var4) {
  1928.             return false;
  1929.          }
  1930.       } else {
  1931.          return false;
  1932.       }
  1933.    }
  1934.  
  1935.    public boolean insertsAreDetected(int var1) throws SQLException {
  1936.       short var2 = this.getCursorAttribute(var1);
  1937.       if (var2 > 0) {
  1938.          try {
  1939.             int var3 = this.OdbcApi.SQLGetInfo(this.hDbc, var2);
  1940.             return (var3 & 16) > 0;
  1941.          } catch (SQLException var4) {
  1942.             return false;
  1943.          }
  1944.       } else {
  1945.          return false;
  1946.       }
  1947.    }
  1948.  
  1949.    public boolean supportsBatchUpdates() throws SQLException {
  1950.       if (JdbcOdbcObject.isTracing()) {
  1951.          JdbcOdbcObject.trace("*DatabaseMetaData.supportsBatchUpdates");
  1952.       }
  1953.  
  1954.       int var1 = 0;
  1955.       boolean var2 = false;
  1956.       boolean var3 = false;
  1957.       boolean var4 = false;
  1958.  
  1959.       try {
  1960.          var1 = this.OdbcApi.SQLGetInfo(this.hDbc, (short)121);
  1961.          if ((var1 & 2) > 0) {
  1962.             var2 = true;
  1963.          }
  1964.  
  1965.          var1 = this.OdbcApi.SQLGetInfo(this.hDbc, (short)153);
  1966.          if ((var1 & 1) > 0) {
  1967.             var4 = true;
  1968.          }
  1969.       } catch (SQLException var6) {
  1970.          var2 = false;
  1971.          var4 = false;
  1972.       }
  1973.  
  1974.       return var2 && var4 ? true : true;
  1975.    }
  1976.  
  1977.    public ResultSet getUDTs(String var1, String var2, String var3, int[] var4) throws SQLException {
  1978.       throw new UnsupportedOperationException();
  1979.    }
  1980.  
  1981.    public Connection getConnection() throws SQLException {
  1982.       return this.Con != null && this.hDbc > 0 ? this.Con : null;
  1983.    }
  1984.  
  1985.    public ResultSet getTypeInfo() throws SQLException {
  1986.       if (JdbcOdbcObject.isTracing()) {
  1987.          JdbcOdbcObject.trace("*DatabaseMetaData.getTypeInfo");
  1988.       }
  1989.  
  1990.       Object var2 = null;
  1991.       SQLWarning var3 = null;
  1992.       int var1 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  1993.  
  1994.       try {
  1995.          this.OdbcApi.SQLGetTypeInfo(var1, (short)0);
  1996.       } catch (SQLWarning var6) {
  1997.          var3 = var6;
  1998.       } catch (SQLException var7) {
  1999.          this.OdbcApi.SQLFreeStmt(var1, 1);
  2000.          throw var7;
  2001.       }
  2002.  
  2003.       JdbcOdbcResultSet var8 = new JdbcOdbcResultSet();
  2004.       var8.initialize(this.OdbcApi, this.hDbc, var1, false, (JdbcOdbcStatement)null);
  2005.       var8.setWarning(var3);
  2006.       if (this.Con.getODBCVer() == 2) {
  2007.          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};
  2008.          var8.setPseudoCols(16, 18, var4);
  2009.          var8.setSQLTypeColumn(2);
  2010.       } else if (this.Con.getODBCVer() >= 3) {
  2011.          var8.setSQLTypeColumn(2);
  2012.       }
  2013.  
  2014.       if (this.Con.getODBCVer() >= 2) {
  2015.          var8.setAliasColumnName("PRECISION", 3);
  2016.          var8.setAliasColumnName("AUTO_INCREMENT", 12);
  2017.       }
  2018.  
  2019.       return var8;
  2020.    }
  2021.  
  2022.    public ResultSet getIndexInfo(String var1, String var2, String var3, boolean var4, boolean var5) throws SQLException {
  2023.       if (JdbcOdbcObject.isTracing()) {
  2024.          JdbcOdbcObject.trace("*DatabaseMetaData.getIndexInfo (" + var1 + "," + var2 + "," + var3 + var4 + "," + var5 + ")");
  2025.       }
  2026.  
  2027.       Object var7 = null;
  2028.       SQLWarning var8 = null;
  2029.       int var6 = this.OdbcApi.SQLAllocStmt(this.hDbc);
  2030.  
  2031.       try {
  2032.          this.OdbcApi.SQLStatistics(var6, var1, var2, var3, var4, var5);
  2033.       } catch (SQLWarning var11) {
  2034.          var8 = var11;
  2035.       } catch (SQLException var12) {
  2036.          this.OdbcApi.SQLFreeStmt(var6, 1);
  2037.          throw var12;
  2038.       }
  2039.  
  2040.       JdbcOdbcResultSet var13 = new JdbcOdbcResultSet();
  2041.       var13.initialize(this.OdbcApi, this.hDbc, var6, false, (JdbcOdbcStatement)null);
  2042.       var13.setWarning(var8);
  2043.       return var13;
  2044.    }
  2045.  
  2046.    protected void validateConnection() throws SQLException {
  2047.       this.Con.validateConnection();
  2048.    }
  2049.  
  2050.    protected int getInfo(short var1) throws SQLException {
  2051.       this.validateConnection();
  2052.       return this.OdbcApi.SQLGetInfo(this.hDbc, var1);
  2053.    }
  2054.  
  2055.    protected int getInfoShort(short var1) throws SQLException {
  2056.       this.validateConnection();
  2057.       return this.OdbcApi.SQLGetInfoShort(this.hDbc, var1);
  2058.    }
  2059.  
  2060.    protected boolean getInfoBooleanString(short var1) throws SQLException {
  2061.       this.validateConnection();
  2062.       String var2 = this.OdbcApi.SQLGetInfoString(this.hDbc, var1);
  2063.       return var2.equalsIgnoreCase("Y");
  2064.    }
  2065.  
  2066.    protected String getInfoString(short var1) throws SQLException {
  2067.       this.validateConnection();
  2068.       return this.OdbcApi.SQLGetInfoString(this.hDbc, var1);
  2069.    }
  2070.  
  2071.    protected String getInfoString(short var1, int var2) throws SQLException {
  2072.       this.validateConnection();
  2073.       return this.OdbcApi.SQLGetInfoString(this.hDbc, var1, var2);
  2074.    }
  2075.  
  2076.    protected short getConnectionSupportType(int var1) throws SQLException {
  2077.       short var2 = this.Con.getOdbcCursorType(var1);
  2078.       if (var2 == -1) {
  2079.          var2 = this.Con.getBestOdbcCursorType();
  2080.       }
  2081.  
  2082.       return var2;
  2083.    }
  2084.  
  2085.    protected short getCursorAttribute(int var1) throws SQLException {
  2086.       short var2 = 0;
  2087.       if (this.supportsResultSetType(var1)) {
  2088.          short var3 = this.getConnectionSupportType(var1);
  2089.          switch (var3) {
  2090.             case 1:
  2091.                var2 = 151;
  2092.                break;
  2093.             case 2:
  2094.                var2 = 145;
  2095.                break;
  2096.             case 3:
  2097.                var2 = 168;
  2098.          }
  2099.  
  2100.          return var2;
  2101.       } else {
  2102.          return var2;
  2103.       }
  2104.    }
  2105. }
  2106.