Develop and Download Open Source Software

JDBC Debugger

Browse Subversion Repository

/[jdbcdebugger]/jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/CallableStatement.java

Diff of /jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/CallableStatement.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 33 by amsoft, Wed Aug 24 13:46:54 2005 UTC revision 34 by amsoft, Fri Feb 4 08:45:40 2011 UTC
# Line 9  import java.sql.Blob; Line 9  import java.sql.Blob;
9  import java.sql.Clob;  import java.sql.Clob;
10  import java.sql.Connection;  import java.sql.Connection;
11  import java.sql.Date;  import java.sql.Date;
12    import java.sql.NClob;
13  import java.sql.ParameterMetaData;  import java.sql.ParameterMetaData;
14  import java.sql.Ref;  import java.sql.Ref;
15  import java.sql.ResultSet;  import java.sql.ResultSet;
16  import java.sql.ResultSetMetaData;  import java.sql.ResultSetMetaData;
17    import java.sql.RowId;
18  import java.sql.SQLException;  import java.sql.SQLException;
19  import java.sql.SQLWarning;  import java.sql.SQLWarning;
20    import java.sql.SQLXML;
21  import java.sql.Time;  import java.sql.Time;
22  import java.sql.Timestamp;  import java.sql.Timestamp;
23  import java.util.Calendar;  import java.util.Calendar;
# Line 1456  public class CallableStatement implement Line 1459  public class CallableStatement implement
1459                  return st.getResultSetHoldability();                  return st.getResultSetHoldability();
1460          }          }
1461    
1462            /**
1463             * @param parameterIndex
1464             * @return
1465             * @throws SQLException
1466             * @see java.sql.CallableStatement#getCharacterStream(int)
1467             */
1468            public Reader getCharacterStream(int parameterIndex) throws SQLException {
1469                    return st.getCharacterStream(parameterIndex);
1470            }
1471    
1472            /**
1473             * @param parameterName
1474             * @return
1475             * @throws SQLException
1476             * @see java.sql.CallableStatement#getCharacterStream(java.lang.String)
1477             */
1478            public Reader getCharacterStream(String parameterName) throws SQLException {
1479                    return st.getCharacterStream(parameterName);
1480            }
1481    
1482            /**
1483             * @param parameterIndex
1484             * @return
1485             * @throws SQLException
1486             * @see java.sql.CallableStatement#getNCharacterStream(int)
1487             */
1488            public Reader getNCharacterStream(int parameterIndex) throws SQLException {
1489                    return st.getNCharacterStream(parameterIndex);
1490            }
1491    
1492            /**
1493             * @param parameterName
1494             * @return
1495             * @throws SQLException
1496             * @see java.sql.CallableStatement#getNCharacterStream(java.lang.String)
1497             */
1498            public Reader getNCharacterStream(String parameterName) throws SQLException {
1499                    return st.getNCharacterStream(parameterName);
1500            }
1501    
1502            /**
1503             * @param parameterIndex
1504             * @return
1505             * @throws SQLException
1506             * @see java.sql.CallableStatement#getNClob(int)
1507             */
1508            public NClob getNClob(int parameterIndex) throws SQLException {
1509                    return st.getNClob(parameterIndex);
1510            }
1511    
1512            /**
1513             * @param parameterName
1514             * @return
1515             * @throws SQLException
1516             * @see java.sql.CallableStatement#getNClob(java.lang.String)
1517             */
1518            public NClob getNClob(String parameterName) throws SQLException {
1519                    return st.getNClob(parameterName);
1520            }
1521    
1522            /**
1523             * @param parameterIndex
1524             * @return
1525             * @throws SQLException
1526             * @see java.sql.CallableStatement#getNString(int)
1527             */
1528            public String getNString(int parameterIndex) throws SQLException {
1529                    return st.getNString(parameterIndex);
1530            }
1531    
1532            /**
1533             * @param parameterName
1534             * @return
1535             * @throws SQLException
1536             * @see java.sql.CallableStatement#getNString(java.lang.String)
1537             */
1538            public String getNString(String parameterName) throws SQLException {
1539                    return st.getNString(parameterName);
1540            }
1541    
1542            /**
1543             * @param parameterIndex
1544             * @return
1545             * @throws SQLException
1546             * @see java.sql.CallableStatement#getRowId(int)
1547             */
1548            public RowId getRowId(int parameterIndex) throws SQLException {
1549                    return st.getRowId(parameterIndex);
1550            }
1551    
1552            /**
1553             * @param parameterName
1554             * @return
1555             * @throws SQLException
1556             * @see java.sql.CallableStatement#getRowId(java.lang.String)
1557             */
1558            public RowId getRowId(String parameterName) throws SQLException {
1559                    return st.getRowId(parameterName);
1560            }
1561    
1562            /**
1563             * @param parameterIndex
1564             * @return
1565             * @throws SQLException
1566             * @see java.sql.CallableStatement#getSQLXML(int)
1567             */
1568            public SQLXML getSQLXML(int parameterIndex) throws SQLException {
1569                    return st.getSQLXML(parameterIndex);
1570            }
1571    
1572            /**
1573             * @param parameterName
1574             * @return
1575             * @throws SQLException
1576             * @see java.sql.CallableStatement#getSQLXML(java.lang.String)
1577             */
1578            public SQLXML getSQLXML(String parameterName) throws SQLException {
1579                    return st.getSQLXML(parameterName);
1580            }
1581    
1582            /**
1583             * @return
1584             * @throws SQLException
1585             * @see java.sql.Statement#isClosed()
1586             */
1587            public boolean isClosed() throws SQLException {
1588                    return st.isClosed();
1589            }
1590    
1591            /**
1592             * @return
1593             * @throws SQLException
1594             * @see java.sql.Statement#isPoolable()
1595             */
1596            public boolean isPoolable() throws SQLException {
1597                    return st.isPoolable();
1598            }
1599    
1600            /**
1601             * @param iface
1602             * @return
1603             * @throws SQLException
1604             * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
1605             */
1606            public boolean isWrapperFor(Class<?> iface) throws SQLException {
1607                    return st.isWrapperFor(iface);
1608            }
1609    
1610            /**
1611             * @param parameterIndex
1612             * @param x
1613             * @param length
1614             * @throws SQLException
1615             * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream, long)
1616             */
1617            public void setAsciiStream(int parameterIndex, InputStream x, long length)
1618                            throws SQLException {
1619                    st.setAsciiStream(parameterIndex, x, length);
1620            }
1621    
1622            /**
1623             * @param parameterIndex
1624             * @param x
1625             * @throws SQLException
1626             * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream)
1627             */
1628            public void setAsciiStream(int parameterIndex, InputStream x)
1629                            throws SQLException {
1630                    st.setAsciiStream(parameterIndex, x);
1631            }
1632    
1633            /**
1634             * @param parameterName
1635             * @param x
1636             * @param length
1637             * @throws SQLException
1638             * @see java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream, long)
1639             */
1640            public void setAsciiStream(String parameterName, InputStream x, long length)
1641                            throws SQLException {
1642                    st.setAsciiStream(parameterName, x, length);
1643            }
1644    
1645            /**
1646             * @param parameterName
1647             * @param x
1648             * @throws SQLException
1649             * @see java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream)
1650             */
1651            public void setAsciiStream(String parameterName, InputStream x)
1652                            throws SQLException {
1653                    st.setAsciiStream(parameterName, x);
1654            }
1655    
1656            /**
1657             * @param parameterIndex
1658             * @param x
1659             * @param length
1660             * @throws SQLException
1661             * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, long)
1662             */
1663            public void setBinaryStream(int parameterIndex, InputStream x, long length)
1664                            throws SQLException {
1665                    st.setBinaryStream(parameterIndex, x, length);
1666            }
1667    
1668            /**
1669             * @param parameterIndex
1670             * @param x
1671             * @throws SQLException
1672             * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream)
1673             */
1674            public void setBinaryStream(int parameterIndex, InputStream x)
1675                            throws SQLException {
1676                    st.setBinaryStream(parameterIndex, x);
1677            }
1678    
1679            /**
1680             * @param parameterName
1681             * @param x
1682             * @param length
1683             * @throws SQLException
1684             * @see java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream, long)
1685             */
1686            public void setBinaryStream(String parameterName, InputStream x, long length)
1687                            throws SQLException {
1688                    st.setBinaryStream(parameterName, x, length);
1689            }
1690    
1691            /**
1692             * @param parameterName
1693             * @param x
1694             * @throws SQLException
1695             * @see java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream)
1696             */
1697            public void setBinaryStream(String parameterName, InputStream x)
1698                            throws SQLException {
1699                    st.setBinaryStream(parameterName, x);
1700            }
1701    
1702            /**
1703             * @param parameterIndex
1704             * @param inputStream
1705             * @param length
1706             * @throws SQLException
1707             * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream, long)
1708             */
1709            public void setBlob(int parameterIndex, InputStream inputStream, long length)
1710                            throws SQLException {
1711                    st.setBlob(parameterIndex, inputStream, length);
1712            }
1713    
1714            /**
1715             * @param parameterIndex
1716             * @param inputStream
1717             * @throws SQLException
1718             * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream)
1719             */
1720            public void setBlob(int parameterIndex, InputStream inputStream)
1721                            throws SQLException {
1722                    st.setBlob(parameterIndex, inputStream);
1723            }
1724    
1725            /**
1726             * @param parameterName
1727             * @param x
1728             * @throws SQLException
1729             * @see java.sql.CallableStatement#setBlob(java.lang.String, java.sql.Blob)
1730             */
1731            public void setBlob(String parameterName, Blob x) throws SQLException {
1732                    st.setBlob(parameterName, x);
1733            }
1734    
1735            /**
1736             * @param parameterName
1737             * @param inputStream
1738             * @param length
1739             * @throws SQLException
1740             * @see java.sql.CallableStatement#setBlob(java.lang.String, java.io.InputStream, long)
1741             */
1742            public void setBlob(String parameterName, InputStream inputStream,
1743                            long length) throws SQLException {
1744                    st.setBlob(parameterName, inputStream, length);
1745            }
1746    
1747            /**
1748             * @param parameterName
1749             * @param inputStream
1750             * @throws SQLException
1751             * @see java.sql.CallableStatement#setBlob(java.lang.String, java.io.InputStream)
1752             */
1753            public void setBlob(String parameterName, InputStream inputStream)
1754                            throws SQLException {
1755                    st.setBlob(parameterName, inputStream);
1756            }
1757    
1758            /**
1759             * @param parameterIndex
1760             * @param reader
1761             * @param length
1762             * @throws SQLException
1763             * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, long)
1764             */
1765            public void setCharacterStream(int parameterIndex, Reader reader,
1766                            long length) throws SQLException {
1767                    st.setCharacterStream(parameterIndex, reader, length);
1768            }
1769    
1770            /**
1771             * @param parameterIndex
1772             * @param reader
1773             * @throws SQLException
1774             * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader)
1775             */
1776            public void setCharacterStream(int parameterIndex, Reader reader)
1777                            throws SQLException {
1778                    st.setCharacterStream(parameterIndex, reader);
1779            }
1780    
1781            /**
1782             * @param parameterName
1783             * @param reader
1784             * @param length
1785             * @throws SQLException
1786             * @see java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader, long)
1787             */
1788            public void setCharacterStream(String parameterName, Reader reader,
1789                            long length) throws SQLException {
1790                    st.setCharacterStream(parameterName, reader, length);
1791            }
1792    
1793            /**
1794             * @param parameterName
1795             * @param reader
1796             * @throws SQLException
1797             * @see java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader)
1798             */
1799            public void setCharacterStream(String parameterName, Reader reader)
1800                            throws SQLException {
1801                    st.setCharacterStream(parameterName, reader);
1802            }
1803    
1804            /**
1805             * @param parameterIndex
1806             * @param reader
1807             * @param length
1808             * @throws SQLException
1809             * @see java.sql.PreparedStatement#setClob(int, java.io.Reader, long)
1810             */
1811            public void setClob(int parameterIndex, Reader reader, long length)
1812                            throws SQLException {
1813                    st.setClob(parameterIndex, reader, length);
1814            }
1815    
1816            /**
1817             * @param parameterIndex
1818             * @param reader
1819             * @throws SQLException
1820             * @see java.sql.PreparedStatement#setClob(int, java.io.Reader)
1821             */
1822            public void setClob(int parameterIndex, Reader reader) throws SQLException {
1823                    st.setClob(parameterIndex, reader);
1824            }
1825    
1826            /**
1827             * @param parameterName
1828             * @param x
1829             * @throws SQLException
1830             * @see java.sql.CallableStatement#setClob(java.lang.String, java.sql.Clob)
1831             */
1832            public void setClob(String parameterName, Clob x) throws SQLException {
1833                    st.setClob(parameterName, x);
1834            }
1835    
1836            /**
1837             * @param parameterName
1838             * @param reader
1839             * @param length
1840             * @throws SQLException
1841             * @see java.sql.CallableStatement#setClob(java.lang.String, java.io.Reader, long)
1842             */
1843            public void setClob(String parameterName, Reader reader, long length)
1844                            throws SQLException {
1845                    st.setClob(parameterName, reader, length);
1846            }
1847    
1848            /**
1849             * @param parameterName
1850             * @param reader
1851             * @throws SQLException
1852             * @see java.sql.CallableStatement#setClob(java.lang.String, java.io.Reader)
1853             */
1854            public void setClob(String parameterName, Reader reader)
1855                            throws SQLException {
1856                    st.setClob(parameterName, reader);
1857            }
1858    
1859            /**
1860             * @param parameterIndex
1861             * @param value
1862             * @param length
1863             * @throws SQLException
1864             * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader, long)
1865             */
1866            public void setNCharacterStream(int parameterIndex, Reader value,
1867                            long length) throws SQLException {
1868                    st.setNCharacterStream(parameterIndex, value, length);
1869            }
1870    
1871            /**
1872             * @param parameterIndex
1873             * @param value
1874             * @throws SQLException
1875             * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader)
1876             */
1877            public void setNCharacterStream(int parameterIndex, Reader value)
1878                            throws SQLException {
1879                    st.setNCharacterStream(parameterIndex, value);
1880            }
1881    
1882            /**
1883             * @param parameterName
1884             * @param value
1885             * @param length
1886             * @throws SQLException
1887             * @see java.sql.CallableStatement#setNCharacterStream(java.lang.String, java.io.Reader, long)
1888             */
1889            public void setNCharacterStream(String parameterName, Reader value,
1890                            long length) throws SQLException {
1891                    st.setNCharacterStream(parameterName, value, length);
1892            }
1893    
1894            /**
1895             * @param parameterName
1896             * @param value
1897             * @throws SQLException
1898             * @see java.sql.CallableStatement#setNCharacterStream(java.lang.String, java.io.Reader)
1899             */
1900            public void setNCharacterStream(String parameterName, Reader value)
1901                            throws SQLException {
1902                    st.setNCharacterStream(parameterName, value);
1903            }
1904    
1905            /**
1906             * @param parameterIndex
1907             * @param value
1908             * @throws SQLException
1909             * @see java.sql.PreparedStatement#setNClob(int, java.sql.NClob)
1910             */
1911            public void setNClob(int parameterIndex, NClob value) throws SQLException {
1912                    st.setNClob(parameterIndex, value);
1913            }
1914    
1915            /**
1916             * @param parameterIndex
1917             * @param reader
1918             * @param length
1919             * @throws SQLException
1920             * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader, long)
1921             */
1922            public void setNClob(int parameterIndex, Reader reader, long length)
1923                            throws SQLException {
1924                    st.setNClob(parameterIndex, reader, length);
1925            }
1926    
1927            /**
1928             * @param parameterIndex
1929             * @param reader
1930             * @throws SQLException
1931             * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader)
1932             */
1933            public void setNClob(int parameterIndex, Reader reader) throws SQLException {
1934                    st.setNClob(parameterIndex, reader);
1935            }
1936    
1937            /**
1938             * @param parameterName
1939             * @param value
1940             * @throws SQLException
1941             * @see java.sql.CallableStatement#setNClob(java.lang.String, java.sql.NClob)
1942             */
1943            public void setNClob(String parameterName, NClob value) throws SQLException {
1944                    st.setNClob(parameterName, value);
1945            }
1946    
1947            /**
1948             * @param parameterName
1949             * @param reader
1950             * @param length
1951             * @throws SQLException
1952             * @see java.sql.CallableStatement#setNClob(java.lang.String, java.io.Reader, long)
1953             */
1954            public void setNClob(String parameterName, Reader reader, long length)
1955                            throws SQLException {
1956                    st.setNClob(parameterName, reader, length);
1957            }
1958    
1959            /**
1960             * @param parameterName
1961             * @param reader
1962             * @throws SQLException
1963             * @see java.sql.CallableStatement#setNClob(java.lang.String, java.io.Reader)
1964             */
1965            public void setNClob(String parameterName, Reader reader)
1966                            throws SQLException {
1967                    st.setNClob(parameterName, reader);
1968            }
1969    
1970            /**
1971             * @param parameterIndex
1972             * @param value
1973             * @throws SQLException
1974             * @see java.sql.PreparedStatement#setNString(int, java.lang.String)
1975             */
1976            public void setNString(int parameterIndex, String value)
1977                            throws SQLException {
1978                    st.setNString(parameterIndex, value);
1979            }
1980    
1981            /**
1982             * @param parameterName
1983             * @param value
1984             * @throws SQLException
1985             * @see java.sql.CallableStatement#setNString(java.lang.String, java.lang.String)
1986             */
1987            public void setNString(String parameterName, String value)
1988                            throws SQLException {
1989                    st.setNString(parameterName, value);
1990            }
1991    
1992            /**
1993             * @param poolable
1994             * @throws SQLException
1995             * @see java.sql.Statement#setPoolable(boolean)
1996             */
1997            public void setPoolable(boolean poolable) throws SQLException {
1998                    st.setPoolable(poolable);
1999            }
2000    
2001            /**
2002             * @param parameterIndex
2003             * @param x
2004             * @throws SQLException
2005             * @see java.sql.PreparedStatement#setRowId(int, java.sql.RowId)
2006             */
2007            public void setRowId(int parameterIndex, RowId x) throws SQLException {
2008                    st.setRowId(parameterIndex, x);
2009            }
2010    
2011            /**
2012             * @param parameterName
2013             * @param x
2014             * @throws SQLException
2015             * @see java.sql.CallableStatement#setRowId(java.lang.String, java.sql.RowId)
2016             */
2017            public void setRowId(String parameterName, RowId x) throws SQLException {
2018                    st.setRowId(parameterName, x);
2019            }
2020    
2021            /**
2022             * @param parameterIndex
2023             * @param xmlObject
2024             * @throws SQLException
2025             * @see java.sql.PreparedStatement#setSQLXML(int, java.sql.SQLXML)
2026             */
2027            public void setSQLXML(int parameterIndex, SQLXML xmlObject)
2028                            throws SQLException {
2029                    st.setSQLXML(parameterIndex, xmlObject);
2030            }
2031    
2032            /**
2033             * @param parameterName
2034             * @param xmlObject
2035             * @throws SQLException
2036             * @see java.sql.CallableStatement#setSQLXML(java.lang.String, java.sql.SQLXML)
2037             */
2038            public void setSQLXML(String parameterName, SQLXML xmlObject)
2039                            throws SQLException {
2040                    st.setSQLXML(parameterName, xmlObject);
2041            }
2042    
2043            /**
2044             * @param <T>
2045             * @param iface
2046             * @return
2047             * @throws SQLException
2048             * @see java.sql.Wrapper#unwrap(java.lang.Class)
2049             */
2050            public <T> T unwrap(Class<T> iface) throws SQLException {
2051                    return st.unwrap(iface);
2052            }
2053    
2054  }  }
Legend:
Removed from v.33  
changed lines
  Added in v.34
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help