KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > derby > impl > jdbc > EmbedCallableStatement40


1 /*
2
3    Derby - Class org.apache.derby.impl.jdbc.EmbedCallableStatement40
4
5    Licensed to the Apache Software Foundation (ASF) under one or more
6    contributor license agreements. See the NOTICE file distributed with
7    this work for additional information regarding copyright ownership.
8    The ASF licenses this file to you under the Apache License, Version 2.0
9    (the "License"); you may not use this file except in compliance with
10    the License. You may obtain a copy of the License at
11
12       http://www.apache.org/licenses/LICENSE-2.0
13
14    Unless required by applicable law or agreed to in writing, software
15    distributed under the License is distributed on an "AS IS" BASIS,
16    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17    See the License for the specific language governing permissions and
18    limitations under the License.
19
20  */
21
22 package org.apache.derby.impl.jdbc;
23
24 import java.io.InputStream JavaDoc;
25 import java.io.Reader JavaDoc;
26 import java.sql.Blob JavaDoc;
27 import java.sql.Clob JavaDoc;
28 import java.sql.NClob JavaDoc;
29 import java.sql.ParameterMetaData JavaDoc;
30 import java.sql.RowId JavaDoc;
31 import java.sql.SQLException JavaDoc;
32 import java.sql.SQLXML JavaDoc;
33
34 import org.apache.derby.iapi.reference.SQLState;
35
36 public class EmbedCallableStatement40 extends EmbedCallableStatement30 {
37     
38         
39     /** Creates a new instance of EmbedCallableStatement40 */
40     public EmbedCallableStatement40(EmbedConnection conn, String JavaDoc sql,
41         int resultSetType,
42         int resultSetConcurrency,
43         int resultSetHoldability) throws SQLException JavaDoc{
44         super(conn, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
45     }
46     
47     public Reader JavaDoc getCharacterStream(String JavaDoc parameterName)
48         throws SQLException JavaDoc {
49         throw Util.notImplemented();
50     }
51
52     public Reader JavaDoc getNCharacterStream(int parameterIndex)
53         throws SQLException JavaDoc {
54         throw Util.notImplemented();
55     }
56     
57     public Reader JavaDoc getNCharacterStream(String JavaDoc parameterName)
58         throws SQLException JavaDoc {
59         throw Util.notImplemented();
60     }
61     
62     public String JavaDoc getNString(int parameterIndex)
63         throws SQLException JavaDoc {
64         throw Util.notImplemented();
65     }
66     
67     public String JavaDoc getNString(String JavaDoc parameterName)
68         throws SQLException JavaDoc {
69         throw Util.notImplemented();
70     }
71
72     public void setBlob(String JavaDoc parameterName, Blob JavaDoc x)
73         throws SQLException JavaDoc {
74         throw Util.notImplemented();
75     }
76     
77     public void setClob(String JavaDoc parameterName, Clob JavaDoc x)
78         throws SQLException JavaDoc {
79         throw Util.notImplemented();
80     }
81
82     public RowId JavaDoc getRowId(int parameterIndex) throws SQLException JavaDoc {
83         throw Util.notImplemented();
84     }
85     
86     public RowId JavaDoc getRowId(String JavaDoc parameterName) throws SQLException JavaDoc {
87         throw Util.notImplemented();
88     }
89     
90     public void setRowId(String JavaDoc parameterName, RowId JavaDoc x) throws SQLException JavaDoc {
91         throw Util.notImplemented();
92     }
93     
94     
95     public void setNString(String JavaDoc parameterName, String JavaDoc value)
96     throws SQLException JavaDoc {
97         throw Util.notImplemented();
98     }
99     
100     public void setNCharacterStream(String JavaDoc parameterName, Reader JavaDoc value, long length)
101     throws SQLException JavaDoc {
102         throw Util.notImplemented();
103     }
104     
105     public void setNClob(String JavaDoc parameterName, NClob JavaDoc value) throws SQLException JavaDoc {
106         throw Util.notImplemented();
107     }
108     
109     public void setClob(String JavaDoc parameterName, Reader JavaDoc reader, long length)
110     throws SQLException JavaDoc{
111         throw Util.notImplemented();
112         
113     }
114     
115     public void setBlob(String JavaDoc parameterName, InputStream JavaDoc inputStream, long length)
116     throws SQLException JavaDoc{
117         throw Util.notImplemented();
118     }
119     
120     public void setNClob(String JavaDoc parameterName, Reader JavaDoc reader, long length)
121     throws SQLException JavaDoc {
122         throw Util.notImplemented();
123     }
124     
125     public NClob JavaDoc getNClob(int i) throws SQLException JavaDoc {
126         throw Util.notImplemented();
127     }
128     
129     
130     public NClob JavaDoc getNClob(String JavaDoc parameterName) throws SQLException JavaDoc {
131         throw Util.notImplemented();
132     }
133     
134     public void setSQLXML(String JavaDoc parameterName, SQLXML JavaDoc xmlObject) throws SQLException JavaDoc {
135         throw Util.notImplemented();
136         
137     }
138     
139     public SQLXML JavaDoc getSQLXML(int parameterIndex) throws SQLException JavaDoc {
140         throw Util.notImplemented();
141     }
142     
143     public SQLXML JavaDoc getSQLXML(String JavaDoc parametername) throws SQLException JavaDoc {
144         throw Util.notImplemented();
145     }
146     
147     
148     
149     
150     
151     /************************************************************************
152      * The prepared statement methods
153      *************************************************************************/
154     
155     
156     public void setRowId(int parameterIndex, RowId JavaDoc x) throws SQLException JavaDoc{
157         throw Util.notImplemented("setRowId(int, RowId)");
158     }
159     
160     public void setNString(int index, String JavaDoc value) throws SQLException JavaDoc{
161         throw Util.notImplemented("setNString (int,value)");
162     }
163     
164     public void setNCharacterStream(int parameterIndex, Reader JavaDoc value)
165             throws SQLException JavaDoc {
166         throw Util.notImplemented();
167     }
168
169     public void setNCharacterStream(int index, Reader JavaDoc value, long length) throws SQLException JavaDoc{
170         throw Util.notImplemented ("setNCharacterStream (int, Reader, long)");
171     }
172     
173     public void setNClob(int index, NClob JavaDoc value) throws SQLException JavaDoc{
174         throw Util.notImplemented ("setNClob (int, NClob)");
175     }
176
177     public void setNClob(int parameterIndex, Reader JavaDoc reader)
178             throws SQLException JavaDoc {
179         throw Util.notImplemented();
180     }
181
182     public void setNClob(int parameterIndex, Reader JavaDoc reader, long length)
183     throws SQLException JavaDoc{
184         throw Util.notImplemented ("setNClob(int,reader,length)");
185     }
186     
187     public void setSQLXML(int parameterIndex, SQLXML JavaDoc xmlObject) throws SQLException JavaDoc{
188         throw Util.notImplemented ("setSQLXML (int, SQLXML)");
189     }
190     
191     /**
192     * JDBC 4.0
193     *
194     * Retrieves the number, types and properties of this CallableStatement
195     * object's parameters.
196     *
197     * @return a ParameterMetaData object that contains information about the
198     * number, types and properties of this CallableStatement object's parameters.
199     * @exception SQLException if a database access error occurs
200     *
201     */
202     public ParameterMetaData JavaDoc getParameterMetaData()
203         throws SQLException JavaDoc
204     {
205       checkStatus();
206       return new EmbedParameterMetaData40(
207                 getParms(), preparedStatement.getParameterTypes());
208     }
209     
210     /**
211      * Returns false unless <code>interfaces</code> is implemented
212      *
213      * @param interfaces a Class defining an interface.
214      * @return true if this implements the interface or
215      * directly or indirectly wraps an object
216      * that does.
217      * @throws java.sql.SQLException if an error occurs while determining
218      * whether this is a wrapper for an object
219      * with the given interface.
220      */
221     public boolean isWrapperFor(Class JavaDoc<?> interfaces) throws SQLException JavaDoc {
222         checkStatus();
223         return interfaces.isInstance(this);
224     }
225
226     public void setAsciiStream(String JavaDoc parameterName, InputStream JavaDoc x)
227             throws SQLException JavaDoc {
228         throw Util.notImplemented("setAsciiStream(String,InputStream)");
229     }
230
231     public void setBinaryStream(String JavaDoc parameterName, InputStream JavaDoc x)
232             throws SQLException JavaDoc {
233         throw Util.notImplemented("setBinaryStream(String,InputStream)");
234     }
235
236     public void setBlob(String JavaDoc parameterName, InputStream JavaDoc inputStream)
237             throws SQLException JavaDoc {
238         throw Util.notImplemented("setBlob(String,InputStream)");
239     }
240
241     public void setCharacterStream(String JavaDoc parameterName, Reader JavaDoc reader)
242             throws SQLException JavaDoc {
243         throw Util.notImplemented("setCharacterStream(String,Reader)");
244     }
245
246     public void setClob(String JavaDoc parameterName, Reader JavaDoc reader)
247             throws SQLException JavaDoc {
248         throw Util.notImplemented("setClob(String,Reader)");
249     }
250
251     public void setNCharacterStream(String JavaDoc parameterName, Reader JavaDoc value)
252             throws SQLException JavaDoc {
253         throw Util.notImplemented("setNCharacterStream(String,Reader)");
254     }
255
256     public void setNClob(String JavaDoc parameterName, Reader JavaDoc reader)
257             throws SQLException JavaDoc {
258         throw Util.notImplemented("setNClob(String,Reader)");
259     }
260
261     /**
262      * Returns <code>this</code> if this class implements the interface
263      *
264      * @param interfaces a Class defining an interface
265      * @return an object that implements the interface
266      * @throws java.sql.SQLException if no object if found that implements the
267      * interface
268      */
269     public <T> T unwrap(java.lang.Class JavaDoc<T> interfaces)
270                             throws SQLException JavaDoc{
271         checkStatus();
272         try {
273             return interfaces.cast(this);
274         } catch (ClassCastException JavaDoc cce) {
275             throw newSQLException(SQLState.UNABLE_TO_UNWRAP,interfaces);
276         }
277     }
278     
279     /**
280      * Sets the designated parameter to the given input stream, which will have
281      * the specified number of bytes.
282      *
283      * @param parameterName the name of the first parameter
284      * @param x the java input stream which contains the ASCII parameter value
285      * @param length the number of bytes in the stream
286      * @exception SQLException thrown on failure.
287      *
288      */
289
290     public final void setAsciiStream(String JavaDoc parameterName, InputStream JavaDoc x, long length)
291     throws SQLException JavaDoc {
292         throw Util.notImplemented();
293     }
294
295     /**
296      * Sets the designated parameter to the given input stream, which will have
297      * the specified number of bytes.
298      *
299      * @param parameterName the name of the first parameter
300      * @param x the java input stream which contains the binary parameter value
301      * @param length the number of bytes in the stream
302      * @exception SQLException thrown on failure.
303      *
304      */
305
306     public final void setBinaryStream(String JavaDoc parameterName, InputStream JavaDoc x, long length)
307     throws SQLException JavaDoc {
308         throw Util.notImplemented();
309     }
310
311     /**
312      * Sets the designated parameter to the given Reader, which will have
313      * the specified number of bytes.
314      *
315      * @param parameterName the name of the first parameter
316      * @param x the java Reader which contains the UNICODE value
317      * @param length the number of bytes in the stream
318      * @exception SQLException thrown on failure.
319      *
320      */
321
322     public final void setCharacterStream(String JavaDoc parameterName, Reader JavaDoc x, long length)
323     throws SQLException JavaDoc {
324         throw Util.notImplemented();
325     }
326 }
327
Popular Tags