001: /*
002:
003: Derby - Class org.apache.derby.client.am.CallableStatement40
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to You under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.client.am;
023:
024: import java.io.InputStream;
025: import java.io.Reader;
026: import java.sql.Blob;
027: import java.sql.Clob;
028: import java.sql.NClob;
029: import java.sql.RowId;
030: import java.sql.SQLException;
031: import java.sql.SQLXML;
032: import org.apache.derby.client.ClientPooledConnection;
033: import org.apache.derby.client.am.SqlException;
034: import org.apache.derby.client.am.ClientMessageId;
035: import org.apache.derby.shared.common.reference.SQLState;
036:
037: public class CallableStatement40 extends
038: org.apache.derby.client.am.CallableStatement {
039:
040: /**
041: * Calls the superclass constructor and passes the parameters
042: *
043: * @param agent The instance of NetAgent associated with this
044: * CallableStatement object.
045: * @param connection The connection object associated with this
046: * PreparedStatement Object.
047: * @param sql A String object that is the SQL statement to be sent
048: * to the database.
049: * @param type One of the ResultSet type constants
050: * @param concurrency One of the ResultSet concurrency constants
051: * @param holdability One of the ResultSet holdability constants
052: * @param cpc The PooledConnection object that will be used to
053: * notify the PooledConnection reference of the Error
054: * Occurred and the Close events.
055: * @throws SqlException
056: */
057: public CallableStatement40(Agent agent, Connection connection,
058: String sql, int type, int concurrency, int holdability,
059: ClientPooledConnection cpc) throws SqlException {
060: super (agent, connection, sql, type, concurrency, holdability,
061: cpc);
062: }
063:
064: public Reader getCharacterStream(String parameterName)
065: throws SQLException {
066: throw SQLExceptionFactory
067: .notImplemented("getCharacterStream(String)");
068: }
069:
070: public Reader getNCharacterStream(int parameterIndex)
071: throws SQLException {
072: throw SQLExceptionFactory
073: .notImplemented("getNCharacterStream(int)");
074: }
075:
076: public Reader getNCharacterStream(String parameterName)
077: throws SQLException {
078: throw SQLExceptionFactory
079: .notImplemented("getNCharacterStream(String)");
080: }
081:
082: public String getNString(int parameterIndex) throws SQLException {
083: throw SQLExceptionFactory.notImplemented("getNString(int)");
084: }
085:
086: public String getNString(String parameterIndex) throws SQLException {
087: throw SQLExceptionFactory.notImplemented("getNString(String)");
088: }
089:
090: public RowId getRowId(int parameterIndex) throws SQLException {
091: throw SQLExceptionFactory.notImplemented("getRowId (int)");
092: }
093:
094: public RowId getRowId(String parameterName) throws SQLException {
095: throw SQLExceptionFactory.notImplemented("getRowId (String)");
096: }
097:
098: public void setRowId(String parameterName, RowId x)
099: throws SQLException {
100: throw SQLExceptionFactory
101: .notImplemented("setRowId (String, RowId)");
102: }
103:
104: public void setBlob(String parameterName, Blob x)
105: throws SQLException {
106: throw SQLExceptionFactory
107: .notImplemented("setBlob(String, Blob)");
108: }
109:
110: public void setClob(String parameterName, Clob x)
111: throws SQLException {
112: throw SQLExceptionFactory
113: .notImplemented("setClob(String, Clob)");
114: }
115:
116: public void setNString(String parameterName, String value)
117: throws SQLException {
118: throw SQLExceptionFactory
119: .notImplemented("setNString (String, String)");
120: }
121:
122: public void setNCharacterStream(String parameterName, Reader value,
123: long length) throws SQLException {
124: throw SQLExceptionFactory
125: .notImplemented("setNString (String, Reader, long)");
126: }
127:
128: public void setNClob(String parameterName, NClob value)
129: throws SQLException {
130: throw SQLExceptionFactory
131: .notImplemented("setNClob (String, NClob)");
132: }
133:
134: public void setClob(String parameterName, Reader reader, long length)
135: throws SQLException {
136: throw SQLExceptionFactory
137: .notImplemented("setClob (String, Reader, long)");
138:
139: }
140:
141: public void setBlob(String parameterName, InputStream inputStream,
142: long length) throws SQLException {
143: throw SQLExceptionFactory
144: .notImplemented("setBlob (String, InputStream, long)");
145: }
146:
147: public void setNClob(String parameterName, Reader reader,
148: long length) throws SQLException {
149: throw SQLExceptionFactory
150: .notImplemented("setNClob (String, Reader, long)");
151: }
152:
153: public NClob getNClob(int i) throws SQLException {
154: throw SQLExceptionFactory.notImplemented("setNClob (int)");
155: }
156:
157: public NClob getNClob(String parameterName) throws SQLException {
158: throw SQLExceptionFactory.notImplemented("setNClob (String)");
159: }
160:
161: public void setSQLXML(String parameterName, SQLXML xmlObject)
162: throws SQLException {
163: throw SQLExceptionFactory
164: .notImplemented("setSQLXML (String, SQLXML)");
165:
166: }
167:
168: public SQLXML getSQLXML(int parameterIndex) throws SQLException {
169: throw SQLExceptionFactory.notImplemented("getSQLXML (int)");
170: }
171:
172: public SQLXML getSQLXML(String parametername) throws SQLException {
173: throw SQLExceptionFactory.notImplemented("getSQLXML (String)");
174: }
175:
176: public void setRowId(int parameterIndex, RowId x)
177: throws SQLException {
178: throw SQLExceptionFactory
179: .notImplemented("setRowId (int, RowId)");
180: }
181:
182: /**************************************************************************
183: * The methods from PreparedStatement for JDBC 4.0. *
184: * These are added here because we can't inherit *
185: * PreparedStatement40.java. Instead of moving the non-implemented *
186: * classes to PreparedStatement.java, we duplicate them here. *
187: **************************************************************************/
188: public void setNString(int index, String value) throws SQLException {
189: throw SQLExceptionFactory
190: .notImplemented("setNString (int, String)");
191: }
192:
193: public void setNCharacterStream(int parameterIndex, Reader value)
194: throws SQLException {
195: throw SQLExceptionFactory.notImplemented("setNCharacterStream"
196: + "(int,Reader)");
197: }
198:
199: public void setNCharacterStream(int index, Reader value, long length)
200: throws SQLException {
201: throw SQLExceptionFactory.notImplemented("setNCharacterStream "
202: + "(int,Reader,long)");
203: }
204:
205: public void setNClob(int index, NClob value) throws SQLException {
206: throw SQLExceptionFactory
207: .notImplemented("setNClob (int, NClob)");
208: }
209:
210: public void setNClob(int parameterIndex, Reader reader)
211: throws SQLException {
212: throw SQLExceptionFactory
213: .notImplemented("setNClob(int,Reader)");
214: }
215:
216: public void setNClob(int parameterIndex, Reader reader, long length)
217: throws SQLException {
218: throw SQLExceptionFactory.notImplemented("setNClob (int, "
219: + "Reader, long)");
220: }
221:
222: public void setSQLXML(int parameterIndex, SQLXML xmlObject)
223: throws SQLException {
224: throw SQLExceptionFactory
225: .notImplemented("setSQLXML (int, SQLXML)");
226: }
227:
228: /**************************************************************************
229: * End of methods from PreparedStatement for JDBC 4.0. *
230: **************************************************************************/
231:
232: public void setAsciiStream(String parameterName, InputStream x)
233: throws SQLException {
234: throw SQLExceptionFactory
235: .notImplemented("setAsciiStream(String,InputStream)");
236: }
237:
238: public void setBinaryStream(String parameterName, InputStream x)
239: throws SQLException {
240: throw SQLExceptionFactory
241: .notImplemented("setBinaryStream(String,InputStream)");
242: }
243:
244: public void setBlob(String parameterName, InputStream inputStream)
245: throws SQLException {
246: throw SQLExceptionFactory
247: .notImplemented("setBlob(String,InputStream)");
248: }
249:
250: public void setCharacterStream(String parameterName, Reader reader)
251: throws SQLException {
252: throw SQLExceptionFactory
253: .notImplemented("setCharacterStream(String,Reader)");
254: }
255:
256: public void setClob(String parameterName, Reader reader)
257: throws SQLException {
258: throw SQLExceptionFactory
259: .notImplemented("setClob(String,Reader)");
260: }
261:
262: public void setNCharacterStream(String parameterName, Reader value)
263: throws SQLException {
264: throw SQLExceptionFactory
265: .notImplemented("setNCharacterStream(String,Reader)");
266: }
267:
268: public void setNClob(String parameterName, Reader reader)
269: throws SQLException {
270: throw SQLExceptionFactory
271: .notImplemented("setNClob(String,Reader)");
272: }
273:
274: /**
275: * Returns <code>this</code> if this class implements the interface
276: *
277: * @param interfaces a Class defining an interface
278: * @return an object that implements the interface
279: * @throws java.sql.SQLExption if no object if found that implements the
280: * interface
281: */
282: public <T> T unwrap(java.lang.Class<T> interfaces)
283: throws SQLException {
284: try {
285: checkForClosedStatement();
286: return interfaces.cast(this );
287: } catch (ClassCastException cce) {
288: throw new SqlException(null, new ClientMessageId(
289: SQLState.UNABLE_TO_UNWRAP), interfaces)
290: .getSQLException();
291: } catch (SqlException se) {
292: throw se.getSQLException();
293: }
294: }
295:
296: /**
297: * Sets the designated parameter to the given input stream, which will have
298: * the specified number of bytes.
299: *
300: * @param parameterName the name of the first parameter
301: * @param x the java input stream which contains the ASCII parameter value
302: * @param length the number of bytes in the stream
303: * @exception SQLException thrown on failure.
304: *
305: */
306:
307: public final void setAsciiStream(String parameterName,
308: InputStream x, long length) throws SQLException {
309: throw SQLExceptionFactory
310: .notImplemented("setAsciiStream(String,InputStream,long)");
311: }
312:
313: /**
314: * Sets the designated parameter to the given input stream, which will have
315: * the specified number of bytes.
316: *
317: * @param parameterName the name of the first parameter
318: * @param x the java input stream which contains the binary parameter value
319: * @param length the number of bytes in the stream
320: * @exception SQLException thrown on failure.
321: *
322: */
323:
324: public final void setBinaryStream(String parameterName,
325: InputStream x, long length) throws SQLException {
326: throw SQLExceptionFactory
327: .notImplemented("setBinaryStream(String,InputStream,long)");
328: }
329:
330: /**
331: * Sets the designated parameter to the given Reader, which will have
332: * the specified number of bytes.
333: *
334: * @param parameterName the name of the first parameter
335: * @param x the java Reader which contains the UNICODE value
336: * @param length the number of bytes in the stream
337: * @exception SQLException thrown on failure.
338: *
339: */
340:
341: public final void setCharacterStream(String parameterName,
342: Reader x, long length) throws SQLException {
343: throw SQLExceptionFactory
344: .notImplemented("setCharacterStream(String,Reader,long)");
345: }
346: }
|