OSDN -- Develop and Download Open Source Software
  • R/O
  • SSH
  • HTTPS

jdbcdebugger: Commit


Commit MetaInfo

Revision34 (tree)
Time2011-02-04 17:45:40
Authoramsoft

Log Message

add ijyou

Change Summary

Incremental Difference

--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/Connection.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/Connection.java (revision 34)
@@ -1,13 +1,21 @@
11 package jp.co.powerbeans.jdbcdebug.sql;
22
3+import java.sql.Array;
4+import java.sql.Blob;
35 import java.sql.CallableStatement;
6+import java.sql.Clob;
47 import java.sql.DatabaseMetaData;
8+import java.sql.NClob;
59 import java.sql.PreparedStatement;
10+import java.sql.SQLClientInfoException;
611 import java.sql.SQLException;
712 import java.sql.SQLWarning;
13+import java.sql.SQLXML;
814 import java.sql.Savepoint;
915 import java.sql.Statement;
16+import java.sql.Struct;
1017 import java.util.Map;
18+import java.util.Properties;
1119
1220 import jp.co.powerbeans.jdbcdebug.notify.NotifyUtil;
1321 import jp.co.powerbeans.jdbcdebug.util.ConCheckMgr;
@@ -401,4 +409,135 @@
401409 sql);
402410 }
403411
412+ /**
413+ * @param typeName
414+ * @param elements
415+ * @return
416+ * @throws SQLException
417+ * @see java.sql.Connection#createArrayOf(java.lang.String, java.lang.Object[])
418+ */
419+ public Array createArrayOf(String typeName, Object[] elements)
420+ throws SQLException {
421+ return rcon.createArrayOf(typeName, elements);
422+ }
423+
424+ /**
425+ * @return
426+ * @throws SQLException
427+ * @see java.sql.Connection#createBlob()
428+ */
429+ public Blob createBlob() throws SQLException {
430+ return rcon.createBlob();
431+ }
432+
433+ /**
434+ * @return
435+ * @throws SQLException
436+ * @see java.sql.Connection#createClob()
437+ */
438+ public Clob createClob() throws SQLException {
439+ return rcon.createClob();
440+ }
441+
442+ /**
443+ * @return
444+ * @throws SQLException
445+ * @see java.sql.Connection#createNClob()
446+ */
447+ public NClob createNClob() throws SQLException {
448+ return rcon.createNClob();
449+ }
450+
451+ /**
452+ * @return
453+ * @throws SQLException
454+ * @see java.sql.Connection#createSQLXML()
455+ */
456+ public SQLXML createSQLXML() throws SQLException {
457+ return rcon.createSQLXML();
458+ }
459+
460+ /**
461+ * @param typeName
462+ * @param attributes
463+ * @return
464+ * @throws SQLException
465+ * @see java.sql.Connection#createStruct(java.lang.String, java.lang.Object[])
466+ */
467+ public Struct createStruct(String typeName, Object[] attributes)
468+ throws SQLException {
469+ return rcon.createStruct(typeName, attributes);
470+ }
471+
472+ /**
473+ * @return
474+ * @throws SQLException
475+ * @see java.sql.Connection#getClientInfo()
476+ */
477+ public Properties getClientInfo() throws SQLException {
478+ return rcon.getClientInfo();
479+ }
480+
481+ /**
482+ * @param name
483+ * @return
484+ * @throws SQLException
485+ * @see java.sql.Connection#getClientInfo(java.lang.String)
486+ */
487+ public String getClientInfo(String name) throws SQLException {
488+ return rcon.getClientInfo(name);
489+ }
490+
491+ /**
492+ * @param timeout
493+ * @return
494+ * @throws SQLException
495+ * @see java.sql.Connection#isValid(int)
496+ */
497+ public boolean isValid(int timeout) throws SQLException {
498+ return rcon.isValid(timeout);
499+ }
500+
501+ /**
502+ * @param iface
503+ * @return
504+ * @throws SQLException
505+ * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
506+ */
507+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
508+ return rcon.isWrapperFor(iface);
509+ }
510+
511+ /**
512+ * @param properties
513+ * @throws SQLClientInfoException
514+ * @see java.sql.Connection#setClientInfo(java.util.Properties)
515+ */
516+ public void setClientInfo(Properties properties)
517+ throws SQLClientInfoException {
518+ rcon.setClientInfo(properties);
519+ }
520+
521+ /**
522+ * @param name
523+ * @param value
524+ * @throws SQLClientInfoException
525+ * @see java.sql.Connection#setClientInfo(java.lang.String, java.lang.String)
526+ */
527+ public void setClientInfo(String name, String value)
528+ throws SQLClientInfoException {
529+ rcon.setClientInfo(name, value);
530+ }
531+
532+ /**
533+ * @param <T>
534+ * @param iface
535+ * @return
536+ * @throws SQLException
537+ * @see java.sql.Wrapper#unwrap(java.lang.Class)
538+ */
539+ public <T> T unwrap(Class<T> iface) throws SQLException {
540+ return rcon.unwrap(iface);
541+ }
542+
404543 }
--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/CallableStatement.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/CallableStatement.java (revision 34)
@@ -9,12 +9,15 @@
99 import java.sql.Clob;
1010 import java.sql.Connection;
1111 import java.sql.Date;
12+import java.sql.NClob;
1213 import java.sql.ParameterMetaData;
1314 import java.sql.Ref;
1415 import java.sql.ResultSet;
1516 import java.sql.ResultSetMetaData;
17+import java.sql.RowId;
1618 import java.sql.SQLException;
1719 import java.sql.SQLWarning;
20+import java.sql.SQLXML;
1821 import java.sql.Time;
1922 import java.sql.Timestamp;
2023 import java.util.Calendar;
@@ -1456,4 +1459,596 @@
14561459 return st.getResultSetHoldability();
14571460 }
14581461
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+
14592054 }
--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/Statement.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/Statement.java (revision 34)
@@ -406,4 +406,52 @@
406406 st.setQueryTimeout(seconds);
407407 }
408408
409+ /**
410+ * @return
411+ * @throws SQLException
412+ * @see java.sql.Statement#isClosed()
413+ */
414+ public boolean isClosed() throws SQLException {
415+ return st.isClosed();
416+ }
417+
418+ /**
419+ * @return
420+ * @throws SQLException
421+ * @see java.sql.Statement#isPoolable()
422+ */
423+ public boolean isPoolable() throws SQLException {
424+ return st.isPoolable();
425+ }
426+
427+ /**
428+ * @param iface
429+ * @return
430+ * @throws SQLException
431+ * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
432+ */
433+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
434+ return st.isWrapperFor(iface);
435+ }
436+
437+ /**
438+ * @param poolable
439+ * @throws SQLException
440+ * @see java.sql.Statement#setPoolable(boolean)
441+ */
442+ public void setPoolable(boolean poolable) throws SQLException {
443+ st.setPoolable(poolable);
444+ }
445+
446+ /**
447+ * @param <T>
448+ * @param iface
449+ * @return
450+ * @throws SQLException
451+ * @see java.sql.Wrapper#unwrap(java.lang.Class)
452+ */
453+ public <T> T unwrap(Class<T> iface) throws SQLException {
454+ return st.unwrap(iface);
455+ }
456+
409457 }
--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/DatabaseMetaData.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/DatabaseMetaData.java (revision 34)
@@ -2,6 +2,7 @@
22
33 import java.sql.Connection;
44 import java.sql.ResultSet;
5+import java.sql.RowIdLifetime;
56 import java.sql.SQLException;
67
78 /**
@@ -1187,4 +1188,102 @@
11871188 return this.dm.usesLocalFiles();
11881189 }
11891190
1191+ /**
1192+ * @return
1193+ * @throws SQLException
1194+ * @see java.sql.DatabaseMetaData#autoCommitFailureClosesAllResultSets()
1195+ */
1196+ public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
1197+ return dm.autoCommitFailureClosesAllResultSets();
1198+ }
1199+
1200+ /**
1201+ * @return
1202+ * @throws SQLException
1203+ * @see java.sql.DatabaseMetaData#getClientInfoProperties()
1204+ */
1205+ public ResultSet getClientInfoProperties() throws SQLException {
1206+ return dm.getClientInfoProperties();
1207+ }
1208+
1209+ /**
1210+ * @param catalog
1211+ * @param schemaPattern
1212+ * @param functionNamePattern
1213+ * @param columnNamePattern
1214+ * @return
1215+ * @throws SQLException
1216+ * @see java.sql.DatabaseMetaData#getFunctionColumns(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
1217+ */
1218+ public ResultSet getFunctionColumns(String catalog, String schemaPattern,
1219+ String functionNamePattern, String columnNamePattern)
1220+ throws SQLException {
1221+ return dm.getFunctionColumns(catalog, schemaPattern,
1222+ functionNamePattern, columnNamePattern);
1223+ }
1224+
1225+ /**
1226+ * @param catalog
1227+ * @param schemaPattern
1228+ * @param functionNamePattern
1229+ * @return
1230+ * @throws SQLException
1231+ * @see java.sql.DatabaseMetaData#getFunctions(java.lang.String, java.lang.String, java.lang.String)
1232+ */
1233+ public ResultSet getFunctions(String catalog, String schemaPattern,
1234+ String functionNamePattern) throws SQLException {
1235+ return dm.getFunctions(catalog, schemaPattern, functionNamePattern);
1236+ }
1237+
1238+ /**
1239+ * @return
1240+ * @throws SQLException
1241+ * @see java.sql.DatabaseMetaData#getRowIdLifetime()
1242+ */
1243+ public RowIdLifetime getRowIdLifetime() throws SQLException {
1244+ return dm.getRowIdLifetime();
1245+ }
1246+
1247+ /**
1248+ * @param catalog
1249+ * @param schemaPattern
1250+ * @return
1251+ * @throws SQLException
1252+ * @see java.sql.DatabaseMetaData#getSchemas(java.lang.String, java.lang.String)
1253+ */
1254+ public ResultSet getSchemas(String catalog, String schemaPattern)
1255+ throws SQLException {
1256+ return dm.getSchemas(catalog, schemaPattern);
1257+ }
1258+
1259+ /**
1260+ * @param iface
1261+ * @return
1262+ * @throws SQLException
1263+ * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
1264+ */
1265+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
1266+ return dm.isWrapperFor(iface);
1267+ }
1268+
1269+ /**
1270+ * @return
1271+ * @throws SQLException
1272+ * @see java.sql.DatabaseMetaData#supportsStoredFunctionsUsingCallSyntax()
1273+ */
1274+ public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
1275+ return dm.supportsStoredFunctionsUsingCallSyntax();
1276+ }
1277+
1278+ /**
1279+ * @param <T>
1280+ * @param iface
1281+ * @return
1282+ * @throws SQLException
1283+ * @see java.sql.Wrapper#unwrap(java.lang.Class)
1284+ */
1285+ public <T> T unwrap(Class<T> iface) throws SQLException {
1286+ return dm.unwrap(iface);
1287+ }
1288+
11901289 }
--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/PreparedStatement.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/PreparedStatement.java (revision 34)
@@ -9,12 +9,15 @@
99 import java.sql.Clob;
1010 import java.sql.Connection;
1111 import java.sql.Date;
12+import java.sql.NClob;
1213 import java.sql.ParameterMetaData;
1314 import java.sql.Ref;
1415 import java.sql.ResultSet;
1516 import java.sql.ResultSetMetaData;
17+import java.sql.RowId;
1618 import java.sql.SQLException;
1719 import java.sql.SQLWarning;
20+import java.sql.SQLXML;
1821 import java.sql.Time;
1922 import java.sql.Timestamp;
2023 import java.util.ArrayList;
@@ -42,7 +45,7 @@
4245 private String sql;
4346
4447 /** バッチSQL */
45- private ArrayList batchSqlList = new ArrayList();
48+ private ArrayList<String> batchSqlList = new ArrayList<String>();
4649
4750 /** パラメータマップ 　key:parameterIndex(1.2..), value:object of value */
4851 private HashMap paramMap = new HashMap();
@@ -828,4 +831,251 @@
828831
829832 }
830833
834+/**
835+ * @return
836+ * @throws SQLException
837+ * @see java.sql.Statement#isClosed()
838+ */
839+public boolean isClosed() throws SQLException {
840+ return st.isClosed();
831841 }
842+
843+/**
844+ * @return
845+ * @throws SQLException
846+ * @see java.sql.Statement#isPoolable()
847+ */
848+public boolean isPoolable() throws SQLException {
849+ return st.isPoolable();
850+}
851+
852+/**
853+ * @param iface
854+ * @return
855+ * @throws SQLException
856+ * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
857+ */
858+public boolean isWrapperFor(Class<?> iface) throws SQLException {
859+ return st.isWrapperFor(iface);
860+}
861+
862+/**
863+ * @param parameterIndex
864+ * @param x
865+ * @param length
866+ * @throws SQLException
867+ * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream, long)
868+ */
869+public void setAsciiStream(int parameterIndex, InputStream x, long length)
870+ throws SQLException {
871+ st.setAsciiStream(parameterIndex, x, length);
872+}
873+
874+/**
875+ * @param parameterIndex
876+ * @param x
877+ * @throws SQLException
878+ * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream)
879+ */
880+public void setAsciiStream(int parameterIndex, InputStream x)
881+ throws SQLException {
882+ st.setAsciiStream(parameterIndex, x);
883+}
884+
885+/**
886+ * @param parameterIndex
887+ * @param x
888+ * @param length
889+ * @throws SQLException
890+ * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, long)
891+ */
892+public void setBinaryStream(int parameterIndex, InputStream x, long length)
893+ throws SQLException {
894+ st.setBinaryStream(parameterIndex, x, length);
895+}
896+
897+/**
898+ * @param parameterIndex
899+ * @param x
900+ * @throws SQLException
901+ * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream)
902+ */
903+public void setBinaryStream(int parameterIndex, InputStream x)
904+ throws SQLException {
905+ st.setBinaryStream(parameterIndex, x);
906+}
907+
908+/**
909+ * @param parameterIndex
910+ * @param inputStream
911+ * @param length
912+ * @throws SQLException
913+ * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream, long)
914+ */
915+public void setBlob(int parameterIndex, InputStream inputStream, long length)
916+ throws SQLException {
917+ st.setBlob(parameterIndex, inputStream, length);
918+}
919+
920+/**
921+ * @param parameterIndex
922+ * @param inputStream
923+ * @throws SQLException
924+ * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream)
925+ */
926+public void setBlob(int parameterIndex, InputStream inputStream)
927+ throws SQLException {
928+ st.setBlob(parameterIndex, inputStream);
929+}
930+
931+/**
932+ * @param parameterIndex
933+ * @param reader
934+ * @param length
935+ * @throws SQLException
936+ * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, long)
937+ */
938+public void setCharacterStream(int parameterIndex, Reader reader, long length)
939+ throws SQLException {
940+ st.setCharacterStream(parameterIndex, reader, length);
941+}
942+
943+/**
944+ * @param parameterIndex
945+ * @param reader
946+ * @throws SQLException
947+ * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader)
948+ */
949+public void setCharacterStream(int parameterIndex, Reader reader)
950+ throws SQLException {
951+ st.setCharacterStream(parameterIndex, reader);
952+}
953+
954+/**
955+ * @param parameterIndex
956+ * @param reader
957+ * @param length
958+ * @throws SQLException
959+ * @see java.sql.PreparedStatement#setClob(int, java.io.Reader, long)
960+ */
961+public void setClob(int parameterIndex, Reader reader, long length)
962+ throws SQLException {
963+ st.setClob(parameterIndex, reader, length);
964+}
965+
966+/**
967+ * @param parameterIndex
968+ * @param reader
969+ * @throws SQLException
970+ * @see java.sql.PreparedStatement#setClob(int, java.io.Reader)
971+ */
972+public void setClob(int parameterIndex, Reader reader) throws SQLException {
973+ st.setClob(parameterIndex, reader);
974+}
975+
976+/**
977+ * @param parameterIndex
978+ * @param value
979+ * @param length
980+ * @throws SQLException
981+ * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader, long)
982+ */
983+public void setNCharacterStream(int parameterIndex, Reader value, long length)
984+ throws SQLException {
985+ st.setNCharacterStream(parameterIndex, value, length);
986+}
987+
988+/**
989+ * @param parameterIndex
990+ * @param value
991+ * @throws SQLException
992+ * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader)
993+ */
994+public void setNCharacterStream(int parameterIndex, Reader value)
995+ throws SQLException {
996+ st.setNCharacterStream(parameterIndex, value);
997+}
998+
999+/**
1000+ * @param parameterIndex
1001+ * @param value
1002+ * @throws SQLException
1003+ * @see java.sql.PreparedStatement#setNClob(int, java.sql.NClob)
1004+ */
1005+public void setNClob(int parameterIndex, NClob value) throws SQLException {
1006+ st.setNClob(parameterIndex, value);
1007+}
1008+
1009+/**
1010+ * @param parameterIndex
1011+ * @param reader
1012+ * @param length
1013+ * @throws SQLException
1014+ * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader, long)
1015+ */
1016+public void setNClob(int parameterIndex, Reader reader, long length)
1017+ throws SQLException {
1018+ st.setNClob(parameterIndex, reader, length);
1019+}
1020+
1021+/**
1022+ * @param parameterIndex
1023+ * @param reader
1024+ * @throws SQLException
1025+ * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader)
1026+ */
1027+public void setNClob(int parameterIndex, Reader reader) throws SQLException {
1028+ st.setNClob(parameterIndex, reader);
1029+}
1030+
1031+/**
1032+ * @param parameterIndex
1033+ * @param value
1034+ * @throws SQLException
1035+ * @see java.sql.PreparedStatement#setNString(int, java.lang.String)
1036+ */
1037+public void setNString(int parameterIndex, String value) throws SQLException {
1038+ st.setNString(parameterIndex, value);
1039+}
1040+
1041+/**
1042+ * @param poolable
1043+ * @throws SQLException
1044+ * @see java.sql.Statement#setPoolable(boolean)
1045+ */
1046+public void setPoolable(boolean poolable) throws SQLException {
1047+ st.setPoolable(poolable);
1048+}
1049+
1050+/**
1051+ * @param parameterIndex
1052+ * @param x
1053+ * @throws SQLException
1054+ * @see java.sql.PreparedStatement#setRowId(int, java.sql.RowId)
1055+ */
1056+public void setRowId(int parameterIndex, RowId x) throws SQLException {
1057+ st.setRowId(parameterIndex, x);
1058+}
1059+
1060+/**
1061+ * @param parameterIndex
1062+ * @param xmlObject
1063+ * @throws SQLException
1064+ * @see java.sql.PreparedStatement#setSQLXML(int, java.sql.SQLXML)
1065+ */
1066+public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
1067+ st.setSQLXML(parameterIndex, xmlObject);
1068+}
1069+
1070+/**
1071+ * @param <T>
1072+ * @param iface
1073+ * @return
1074+ * @throws SQLException
1075+ * @see java.sql.Wrapper#unwrap(java.lang.Class)
1076+ */
1077+public <T> T unwrap(Class<T> iface) throws SQLException {
1078+ return st.unwrap(iface);
1079+}
1080+
1081+}
--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/ResultSet.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/sql/ResultSet.java (revision 34)
@@ -8,10 +8,13 @@
88 import java.sql.Blob;
99 import java.sql.Clob;
1010 import java.sql.Date;
11+import java.sql.NClob;
1112 import java.sql.Ref;
1213 import java.sql.ResultSetMetaData;
14+import java.sql.RowId;
1315 import java.sql.SQLException;
1416 import java.sql.SQLWarning;
17+import java.sql.SQLXML;
1518 import java.sql.Statement;
1619 import java.sql.Time;
1720 import java.sql.Timestamp;
@@ -1049,4 +1052,547 @@
10491052 return rs.wasNull();
10501053 }
10511054
1055+ /**
1056+ * @return
1057+ * @throws SQLException
1058+ * @see java.sql.ResultSet#getHoldability()
1059+ */
1060+ public int getHoldability() throws SQLException {
1061+ return rs.getHoldability();
1062+ }
1063+
1064+ /**
1065+ * @param columnIndex
1066+ * @return
1067+ * @throws SQLException
1068+ * @see java.sql.ResultSet#getNCharacterStream(int)
1069+ */
1070+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
1071+ return rs.getNCharacterStream(columnIndex);
1072+ }
1073+
1074+ /**
1075+ * @param columnLabel
1076+ * @return
1077+ * @throws SQLException
1078+ * @see java.sql.ResultSet#getNCharacterStream(java.lang.String)
1079+ */
1080+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
1081+ return rs.getNCharacterStream(columnLabel);
1082+ }
1083+
1084+ /**
1085+ * @param columnIndex
1086+ * @return
1087+ * @throws SQLException
1088+ * @see java.sql.ResultSet#getNClob(int)
1089+ */
1090+ public NClob getNClob(int columnIndex) throws SQLException {
1091+ return rs.getNClob(columnIndex);
1092+ }
1093+
1094+ /**
1095+ * @param columnLabel
1096+ * @return
1097+ * @throws SQLException
1098+ * @see java.sql.ResultSet#getNClob(java.lang.String)
1099+ */
1100+ public NClob getNClob(String columnLabel) throws SQLException {
1101+ return rs.getNClob(columnLabel);
1102+ }
1103+
1104+ /**
1105+ * @param columnIndex
1106+ * @return
1107+ * @throws SQLException
1108+ * @see java.sql.ResultSet#getNString(int)
1109+ */
1110+ public String getNString(int columnIndex) throws SQLException {
1111+ return rs.getNString(columnIndex);
1112+ }
1113+
1114+ /**
1115+ * @param columnLabel
1116+ * @return
1117+ * @throws SQLException
1118+ * @see java.sql.ResultSet#getNString(java.lang.String)
1119+ */
1120+ public String getNString(String columnLabel) throws SQLException {
1121+ return rs.getNString(columnLabel);
1122+ }
1123+
1124+ /**
1125+ * @param columnIndex
1126+ * @return
1127+ * @throws SQLException
1128+ * @see java.sql.ResultSet#getRowId(int)
1129+ */
1130+ public RowId getRowId(int columnIndex) throws SQLException {
1131+ return rs.getRowId(columnIndex);
1132+ }
1133+
1134+ /**
1135+ * @param columnLabel
1136+ * @return
1137+ * @throws SQLException
1138+ * @see java.sql.ResultSet#getRowId(java.lang.String)
1139+ */
1140+ public RowId getRowId(String columnLabel) throws SQLException {
1141+ return rs.getRowId(columnLabel);
1142+ }
1143+
1144+ /**
1145+ * @param columnIndex
1146+ * @return
1147+ * @throws SQLException
1148+ * @see java.sql.ResultSet#getSQLXML(int)
1149+ */
1150+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
1151+ return rs.getSQLXML(columnIndex);
1152+ }
1153+
1154+ /**
1155+ * @param columnLabel
1156+ * @return
1157+ * @throws SQLException
1158+ * @see java.sql.ResultSet#getSQLXML(java.lang.String)
1159+ */
1160+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
1161+ return rs.getSQLXML(columnLabel);
1162+ }
1163+
1164+ /**
1165+ * @return
1166+ * @throws SQLException
1167+ * @see java.sql.ResultSet#isClosed()
1168+ */
1169+ public boolean isClosed() throws SQLException {
1170+ return rs.isClosed();
1171+ }
1172+
1173+ /**
1174+ * @param iface
1175+ * @return
1176+ * @throws SQLException
1177+ * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
1178+ */
1179+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
1180+ return rs.isWrapperFor(iface);
1181+ }
1182+
1183+ /**
1184+ * @param <T>
1185+ * @param iface
1186+ * @return
1187+ * @throws SQLException
1188+ * @see java.sql.Wrapper#unwrap(java.lang.Class)
1189+ */
1190+ public <T> T unwrap(Class<T> iface) throws SQLException {
1191+ return rs.unwrap(iface);
1192+ }
1193+
1194+ /**
1195+ * @param columnIndex
1196+ * @param x
1197+ * @param length
1198+ * @throws SQLException
1199+ * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, long)
1200+ */
1201+ public void updateAsciiStream(int columnIndex, InputStream x, long length)
1202+ throws SQLException {
1203+ rs.updateAsciiStream(columnIndex, x, length);
1204+ }
1205+
1206+ /**
1207+ * @param columnIndex
1208+ * @param x
1209+ * @throws SQLException
1210+ * @see java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream)
1211+ */
1212+ public void updateAsciiStream(int columnIndex, InputStream x)
1213+ throws SQLException {
1214+ rs.updateAsciiStream(columnIndex, x);
1215+ }
1216+
1217+ /**
1218+ * @param columnLabel
1219+ * @param x
1220+ * @param length
1221+ * @throws SQLException
1222+ * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, long)
1223+ */
1224+ public void updateAsciiStream(String columnLabel, InputStream x, long length)
1225+ throws SQLException {
1226+ rs.updateAsciiStream(columnLabel, x, length);
1227+ }
1228+
1229+ /**
1230+ * @param columnLabel
1231+ * @param x
1232+ * @throws SQLException
1233+ * @see java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream)
1234+ */
1235+ public void updateAsciiStream(String columnLabel, InputStream x)
1236+ throws SQLException {
1237+ rs.updateAsciiStream(columnLabel, x);
1238+ }
1239+
1240+ /**
1241+ * @param columnIndex
1242+ * @param x
1243+ * @param length
1244+ * @throws SQLException
1245+ * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, long)
1246+ */
1247+ public void updateBinaryStream(int columnIndex, InputStream x, long length)
1248+ throws SQLException {
1249+ rs.updateBinaryStream(columnIndex, x, length);
1250+ }
1251+
1252+ /**
1253+ * @param columnIndex
1254+ * @param x
1255+ * @throws SQLException
1256+ * @see java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream)
1257+ */
1258+ public void updateBinaryStream(int columnIndex, InputStream x)
1259+ throws SQLException {
1260+ rs.updateBinaryStream(columnIndex, x);
1261+ }
1262+
1263+ /**
1264+ * @param columnLabel
1265+ * @param x
1266+ * @param length
1267+ * @throws SQLException
1268+ * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, long)
1269+ */
1270+ public void updateBinaryStream(String columnLabel, InputStream x,
1271+ long length) throws SQLException {
1272+ rs.updateBinaryStream(columnLabel, x, length);
1273+ }
1274+
1275+ /**
1276+ * @param columnLabel
1277+ * @param x
1278+ * @throws SQLException
1279+ * @see java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream)
1280+ */
1281+ public void updateBinaryStream(String columnLabel, InputStream x)
1282+ throws SQLException {
1283+ rs.updateBinaryStream(columnLabel, x);
1284+ }
1285+
1286+ /**
1287+ * @param columnIndex
1288+ * @param inputStream
1289+ * @param length
1290+ * @throws SQLException
1291+ * @see java.sql.ResultSet#updateBlob(int, java.io.InputStream, long)
1292+ */
1293+ public void updateBlob(int columnIndex, InputStream inputStream, long length)
1294+ throws SQLException {
1295+ rs.updateBlob(columnIndex, inputStream, length);
1296+ }
1297+
1298+ /**
1299+ * @param columnIndex
1300+ * @param inputStream
1301+ * @throws SQLException
1302+ * @see java.sql.ResultSet#updateBlob(int, java.io.InputStream)
1303+ */
1304+ public void updateBlob(int columnIndex, InputStream inputStream)
1305+ throws SQLException {
1306+ rs.updateBlob(columnIndex, inputStream);
1307+ }
1308+
1309+ /**
1310+ * @param columnLabel
1311+ * @param inputStream
1312+ * @param length
1313+ * @throws SQLException
1314+ * @see java.sql.ResultSet#updateBlob(java.lang.String, java.io.InputStream, long)
1315+ */
1316+ public void updateBlob(String columnLabel, InputStream inputStream,
1317+ long length) throws SQLException {
1318+ rs.updateBlob(columnLabel, inputStream, length);
1319+ }
1320+
1321+ /**
1322+ * @param columnLabel
1323+ * @param inputStream
1324+ * @throws SQLException
1325+ * @see java.sql.ResultSet#updateBlob(java.lang.String, java.io.InputStream)
1326+ */
1327+ public void updateBlob(String columnLabel, InputStream inputStream)
1328+ throws SQLException {
1329+ rs.updateBlob(columnLabel, inputStream);
1330+ }
1331+
1332+ /**
1333+ * @param columnIndex
1334+ * @param x
1335+ * @param length
1336+ * @throws SQLException
1337+ * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, long)
1338+ */
1339+ public void updateCharacterStream(int columnIndex, Reader x, long length)
1340+ throws SQLException {
1341+ rs.updateCharacterStream(columnIndex, x, length);
1342+ }
1343+
1344+ /**
1345+ * @param columnIndex
1346+ * @param x
1347+ * @throws SQLException
1348+ * @see java.sql.ResultSet#updateCharacterStream(int, java.io.Reader)
1349+ */
1350+ public void updateCharacterStream(int columnIndex, Reader x)
1351+ throws SQLException {
1352+ rs.updateCharacterStream(columnIndex, x);
1353+ }
1354+
1355+ /**
1356+ * @param columnLabel
1357+ * @param reader
1358+ * @param length
1359+ * @throws SQLException
1360+ * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, long)
1361+ */
1362+ public void updateCharacterStream(String columnLabel, Reader reader,
1363+ long length) throws SQLException {
1364+ rs.updateCharacterStream(columnLabel, reader, length);
1365+ }
1366+
1367+ /**
1368+ * @param columnLabel
1369+ * @param reader
1370+ * @throws SQLException
1371+ * @see java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader)
1372+ */
1373+ public void updateCharacterStream(String columnLabel, Reader reader)
1374+ throws SQLException {
1375+ rs.updateCharacterStream(columnLabel, reader);
1376+ }
1377+
1378+ /**
1379+ * @param columnIndex
1380+ * @param reader
1381+ * @param length
1382+ * @throws SQLException
1383+ * @see java.sql.ResultSet#updateClob(int, java.io.Reader, long)
1384+ */
1385+ public void updateClob(int columnIndex, Reader reader, long length)
1386+ throws SQLException {
1387+ rs.updateClob(columnIndex, reader, length);
1388+ }
1389+
1390+ /**
1391+ * @param columnIndex
1392+ * @param reader
1393+ * @throws SQLException
1394+ * @see java.sql.ResultSet#updateClob(int, java.io.Reader)
1395+ */
1396+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
1397+ rs.updateClob(columnIndex, reader);
1398+ }
1399+
1400+ /**
1401+ * @param columnLabel
1402+ * @param reader
1403+ * @param length
1404+ * @throws SQLException
1405+ * @see java.sql.ResultSet#updateClob(java.lang.String, java.io.Reader, long)
1406+ */
1407+ public void updateClob(String columnLabel, Reader reader, long length)
1408+ throws SQLException {
1409+ rs.updateClob(columnLabel, reader, length);
1410+ }
1411+
1412+ /**
1413+ * @param columnLabel
1414+ * @param reader
1415+ * @throws SQLException
1416+ * @see java.sql.ResultSet#updateClob(java.lang.String, java.io.Reader)
1417+ */
1418+ public void updateClob(String columnLabel, Reader reader)
1419+ throws SQLException {
1420+ rs.updateClob(columnLabel, reader);
1421+ }
1422+
1423+ /**
1424+ * @param columnIndex
1425+ * @param x
1426+ * @param length
1427+ * @throws SQLException
1428+ * @see java.sql.ResultSet#updateNCharacterStream(int, java.io.Reader, long)
1429+ */
1430+ public void updateNCharacterStream(int columnIndex, Reader x, long length)
1431+ throws SQLException {
1432+ rs.updateNCharacterStream(columnIndex, x, length);
1433+ }
1434+
1435+ /**
1436+ * @param columnIndex
1437+ * @param x
1438+ * @throws SQLException
1439+ * @see java.sql.ResultSet#updateNCharacterStream(int, java.io.Reader)
1440+ */
1441+ public void updateNCharacterStream(int columnIndex, Reader x)
1442+ throws SQLException {
1443+ rs.updateNCharacterStream(columnIndex, x);
1444+ }
1445+
1446+ /**
1447+ * @param columnLabel
1448+ * @param reader
1449+ * @param length
1450+ * @throws SQLException
1451+ * @see java.sql.ResultSet#updateNCharacterStream(java.lang.String, java.io.Reader, long)
1452+ */
1453+ public void updateNCharacterStream(String columnLabel, Reader reader,
1454+ long length) throws SQLException {
1455+ rs.updateNCharacterStream(columnLabel, reader, length);
1456+ }
1457+
1458+ /**
1459+ * @param columnLabel
1460+ * @param reader
1461+ * @throws SQLException
1462+ * @see java.sql.ResultSet#updateNCharacterStream(java.lang.String, java.io.Reader)
1463+ */
1464+ public void updateNCharacterStream(String columnLabel, Reader reader)
1465+ throws SQLException {
1466+ rs.updateNCharacterStream(columnLabel, reader);
1467+ }
1468+
1469+ /**
1470+ * @param columnIndex
1471+ * @param clob
1472+ * @throws SQLException
1473+ * @see java.sql.ResultSet#updateNClob(int, java.sql.NClob)
1474+ */
1475+ public void updateNClob(int columnIndex, NClob clob) throws SQLException {
1476+ rs.updateNClob(columnIndex, clob);
1477+ }
1478+
1479+ /**
1480+ * @param columnIndex
1481+ * @param reader
1482+ * @param length
1483+ * @throws SQLException
1484+ * @see java.sql.ResultSet#updateNClob(int, java.io.Reader, long)
1485+ */
1486+ public void updateNClob(int columnIndex, Reader reader, long length)
1487+ throws SQLException {
1488+ rs.updateNClob(columnIndex, reader, length);
1489+ }
1490+
1491+ /**
1492+ * @param columnIndex
1493+ * @param reader
1494+ * @throws SQLException
1495+ * @see java.sql.ResultSet#updateNClob(int, java.io.Reader)
1496+ */
1497+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
1498+ rs.updateNClob(columnIndex, reader);
1499+ }
1500+
1501+ /**
1502+ * @param columnLabel
1503+ * @param clob
1504+ * @throws SQLException
1505+ * @see java.sql.ResultSet#updateNClob(java.lang.String, java.sql.NClob)
1506+ */
1507+ public void updateNClob(String columnLabel, NClob clob) throws SQLException {
1508+ rs.updateNClob(columnLabel, clob);
1509+ }
1510+
1511+ /**
1512+ * @param columnLabel
1513+ * @param reader
1514+ * @param length
1515+ * @throws SQLException
1516+ * @see java.sql.ResultSet#updateNClob(java.lang.String, java.io.Reader, long)
1517+ */
1518+ public void updateNClob(String columnLabel, Reader reader, long length)
1519+ throws SQLException {
1520+ rs.updateNClob(columnLabel, reader, length);
1521+ }
1522+
1523+ /**
1524+ * @param columnLabel
1525+ * @param reader
1526+ * @throws SQLException
1527+ * @see java.sql.ResultSet#updateNClob(java.lang.String, java.io.Reader)
1528+ */
1529+ public void updateNClob(String columnLabel, Reader reader)
1530+ throws SQLException {
1531+ rs.updateNClob(columnLabel, reader);
1532+ }
1533+
1534+ /**
1535+ * @param columnIndex
1536+ * @param string
1537+ * @throws SQLException
1538+ * @see java.sql.ResultSet#updateNString(int, java.lang.String)
1539+ */
1540+ public void updateNString(int columnIndex, String string)
1541+ throws SQLException {
1542+ rs.updateNString(columnIndex, string);
1543+ }
1544+
1545+ /**
1546+ * @param columnLabel
1547+ * @param string
1548+ * @throws SQLException
1549+ * @see java.sql.ResultSet#updateNString(java.lang.String, java.lang.String)
1550+ */
1551+ public void updateNString(String columnLabel, String string)
1552+ throws SQLException {
1553+ rs.updateNString(columnLabel, string);
1554+ }
1555+
1556+ /**
1557+ * @param columnIndex
1558+ * @param x
1559+ * @throws SQLException
1560+ * @see java.sql.ResultSet#updateRowId(int, java.sql.RowId)
1561+ */
1562+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
1563+ rs.updateRowId(columnIndex, x);
1564+ }
1565+
1566+ /**
1567+ * @param columnLabel
1568+ * @param x
1569+ * @throws SQLException
1570+ * @see java.sql.ResultSet#updateRowId(java.lang.String, java.sql.RowId)
1571+ */
1572+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
1573+ rs.updateRowId(columnLabel, x);
1574+ }
1575+
1576+ /**
1577+ * @param columnIndex
1578+ * @param xmlObject
1579+ * @throws SQLException
1580+ * @see java.sql.ResultSet#updateSQLXML(int, java.sql.SQLXML)
1581+ */
1582+ public void updateSQLXML(int columnIndex, SQLXML xmlObject)
1583+ throws SQLException {
1584+ rs.updateSQLXML(columnIndex, xmlObject);
1585+ }
1586+
1587+ /**
1588+ * @param columnLabel
1589+ * @param xmlObject
1590+ * @throws SQLException
1591+ * @see java.sql.ResultSet#updateSQLXML(java.lang.String, java.sql.SQLXML)
1592+ */
1593+ public void updateSQLXML(String columnLabel, SQLXML xmlObject)
1594+ throws SQLException {
1595+ rs.updateSQLXML(columnLabel, xmlObject);
1596+ }
1597+
10521598 }
--- jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/notify/FileOutputNotify.java (revision 33)
+++ jdbcdebugger/trunk/src/jp/co/powerbeans/jdbcdebug/notify/FileOutputNotify.java (revision 34)
@@ -21,9 +21,9 @@
2121
2222 public class FileOutputNotify extends JDBCEventNotifyBase {
2323
24- /** ファイル名日付フォーマット */
25- private static SimpleDateFormat df_file =
26- new SimpleDateFormat("yyyyMMdd_HHmmss");
24+// /** ファイル名日付フォーマット */
25+// private static SimpleDateFormat df_file =
26+// new SimpleDateFormat("yyyyMMdd_HHmmss");
2727
2828 /** 出力先 */
2929 // private static final String path;
Show on old repository browser