001    package com.mockrunner.mock.jdbc;
002    
003    import java.io.ByteArrayInputStream;
004    import java.io.InputStream;
005    import java.io.Reader;
006    import java.io.StringReader;
007    import java.math.BigDecimal;
008    import java.net.MalformedURLException;
009    import java.net.URL;
010    import java.sql.Array;
011    import java.sql.BatchUpdateException;
012    import java.sql.Blob;
013    import java.sql.CallableStatement;
014    import java.sql.Clob;
015    import java.sql.Connection;
016    import java.sql.Date;
017    import java.sql.Ref;
018    import java.sql.ResultSet;
019    import java.sql.SQLException;
020    import java.sql.Time;
021    import java.sql.Timestamp;
022    import java.util.ArrayList;
023    import java.util.Calendar;
024    import java.util.Collections;
025    import java.util.HashMap;
026    import java.util.HashSet;
027    import java.util.List;
028    import java.util.Map;
029    import java.util.Set;
030    
031    import com.mockrunner.jdbc.AbstractOutParameterResultSetHandler;
032    import com.mockrunner.util.common.StreamUtil;
033    
034    /**
035     * Mock implementation of <code>CallableStatement</code>.
036     */
037    public class MockCallableStatement extends MockPreparedStatement implements CallableStatement
038    {
039        private AbstractOutParameterResultSetHandler resultSetHandler;
040        private Map paramObjects = new HashMap();
041        private Set outParameterSetIndexed = new HashSet();
042        private Set outParameterSetNamed = new HashSet();
043        private List batchParameters = new ArrayList();
044        private boolean wasNull = false;
045        
046        public MockCallableStatement(Connection connection, String sql)
047        {
048            super(connection, sql);
049        }
050    
051        public MockCallableStatement(Connection connection, String sql, int resultSetType, int resultSetConcurrency)
052        {
053            super(connection, sql, resultSetType, resultSetConcurrency);
054        }
055    
056        public MockCallableStatement(Connection connection, String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
057        {
058            super(connection, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
059        }
060        
061        public void setCallableStatementResultSetHandler(AbstractOutParameterResultSetHandler resultSetHandler)
062        {
063            super.setPreparedStatementResultSetHandler(resultSetHandler);
064            this.resultSetHandler = resultSetHandler;
065        }
066        
067        public Map getNamedParameterMap()
068        {
069            return Collections.unmodifiableMap(paramObjects);
070        }
071        
072        public Map getParameterMap()
073        {
074            Map parameterMap = new HashMap(getIndexedParameterMap());
075            parameterMap.putAll(getNamedParameterMap());
076            return Collections.unmodifiableMap(parameterMap);
077        }
078        
079        public Object getParameter(String name)
080        {
081            return paramObjects.get(name);
082        }
083        
084        public Set getNamedRegisteredOutParameterSet()
085        {
086            return Collections.unmodifiableSet(outParameterSetNamed);
087        }
088        
089        public boolean isOutParameterRegistered(int index)
090        {
091            return outParameterSetIndexed.contains(new Integer(index));
092        }
093        
094        public Set getIndexedRegisteredOutParameterSet()
095        {
096            return Collections.unmodifiableSet(outParameterSetIndexed);
097        }
098        
099        public boolean isOutParameterRegistered(String parameterName)
100        {
101            return outParameterSetNamed.contains(parameterName);
102        }
103        
104        public ResultSet executeQuery() throws SQLException
105        {
106            return executeQuery(getParameterMap());
107        }
108        
109        public int executeUpdate() throws SQLException
110        {
111            return executeUpdate(getParameterMap());
112        }
113        
114        public void addBatch() throws SQLException
115        {
116            batchParameters.add(new HashMap(getParameterMap()));
117        }
118    
119        public int[] executeBatch() throws SQLException
120        {
121            int[] results = new int[batchParameters.size()];
122            if(isQuery(getSQL()))
123            {
124                throw new BatchUpdateException("SQL " + getSQL() + " returned a ResultSet.", null);
125            }
126            for(int ii = 0; ii < results.length; ii++)
127            {
128                Map currentParameters = (Map)batchParameters.get(ii);
129                results[ii] = executeUpdate(currentParameters);
130            }
131            return results;
132        }
133        
134        public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException
135        {
136            outParameterSetIndexed.add(new Integer(parameterIndex));
137        }
138    
139        public void registerOutParameter(int parameterIndex, int sqlType, int scale) throws SQLException
140        {
141            registerOutParameter(parameterIndex, sqlType);
142        }
143    
144        public void registerOutParameter(int parameterIndex, int sqlType, String typeName) throws SQLException
145        {
146            registerOutParameter(parameterIndex, sqlType);
147        }
148        
149        public void registerOutParameter(String parameterName, int sqlType) throws SQLException
150        {
151            outParameterSetNamed.add(parameterName);
152        }
153        
154        public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException
155        {
156            registerOutParameter(parameterName, sqlType);
157        }
158        
159        public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException
160        {
161            registerOutParameter(parameterName, sqlType);
162        }
163            
164        public boolean wasNull() throws SQLException
165        {
166            return wasNull;
167        }
168    
169        public byte getByte(int parameterIndex) throws SQLException
170        {
171            Object value = getObject(parameterIndex);
172            if(null != value)
173            {
174                if(value instanceof Number) return ((Number)value).byteValue();
175                return new Byte(value.toString()).byteValue();
176            }
177            return 0;
178        }
179    
180        public double getDouble(int parameterIndex) throws SQLException
181        {
182            Object value = getObject(parameterIndex);
183            if(null != value)
184            {
185                if(value instanceof Number) return ((Number)value).doubleValue();
186                return new Double(value.toString()).doubleValue();
187            }
188            return 0;
189        }
190    
191        public float getFloat(int parameterIndex) throws SQLException
192        {
193            Object value = getObject(parameterIndex);
194            if(null != value)
195            {
196                if(value instanceof Number) return ((Number)value).floatValue();
197                return new Float(value.toString()).floatValue();
198            }
199            return 0;
200        }
201    
202        public int getInt(int parameterIndex) throws SQLException
203        {
204            Object value = getObject(parameterIndex);
205            if(null != value)
206            {
207                if(value instanceof Number) return ((Number)value).intValue();
208                return new Integer(value.toString()).intValue();
209            }
210            return 0;
211        }
212    
213        public long getLong(int parameterIndex) throws SQLException
214        {
215            Object value = getObject(parameterIndex);
216            if(null != value)
217            {
218                if(value instanceof Number) return ((Number)value).longValue();
219                return new Long(value.toString()).longValue();
220            }
221            return 0;
222        }
223    
224        public short getShort(int parameterIndex) throws SQLException
225        {
226            Object value = getObject(parameterIndex);
227            if(null != value)
228            {
229                if(value instanceof Number) return ((Number)value).shortValue();
230                return new Short(value.toString()).shortValue();
231            }
232            return 0;
233        }
234    
235        public boolean getBoolean(int parameterIndex) throws SQLException
236        {
237            Object value = getObject(parameterIndex);
238            if(null != value)
239            {
240                if(value instanceof Boolean) return ((Boolean)value).booleanValue();
241                return new Boolean(value.toString()).booleanValue();
242            }
243            return false;
244        }
245    
246        public byte[] getBytes(int parameterIndex) throws SQLException
247        {
248            Object value = getObject(parameterIndex);
249            if(null != value)
250            {
251                if(value instanceof byte[]) return (byte[])value;
252                return value.toString().getBytes();
253            }
254            return null;
255        }
256    
257        public Object getObject(int parameterIndex) throws SQLException
258        {
259            wasNull = false;
260            Map outParameter = getOutParameterMap();
261            Object returnValue = null;
262            if(null != outParameter)
263            {
264                returnValue = outParameter.get(new Integer(parameterIndex));
265            }
266            if(null == returnValue) wasNull = true;
267            return returnValue;
268        }
269    
270        public String getString(int parameterIndex) throws SQLException
271        {
272            Object value = getObject(parameterIndex);
273            if(null != value) return value.toString();
274            return null;
275        }
276        
277        public byte getByte(String parameterName) throws SQLException
278        {
279            Object value = getObject(parameterName);
280            if(null != value)
281            {
282                if(value instanceof Number) return ((Number)value).byteValue();
283                return new Byte(value.toString()).byteValue();
284            }
285            return 0;
286        }
287    
288        public double getDouble(String parameterName) throws SQLException
289        {
290            Object value = getObject(parameterName);
291            if(null != value)
292            {
293                if(value instanceof Number) return ((Number)value).doubleValue();
294                return new Double(value.toString()).doubleValue();
295            }
296            return 0;
297        }
298    
299        public float getFloat(String parameterName) throws SQLException
300        {
301            Object value = getObject(parameterName);
302            if(null != value)
303            {
304                if(value instanceof Number) return ((Number)value).floatValue();
305                return new Float(value.toString()).floatValue();
306            }
307            return 0;
308        }
309    
310        public int getInt(String parameterName) throws SQLException
311        {
312            Object value = getObject(parameterName);
313            if(null != value)
314            {
315                if(value instanceof Number) return ((Number)value).intValue();
316                return new Integer(value.toString()).intValue();
317            }
318            return 0;
319        }
320    
321        public long getLong(String parameterName) throws SQLException
322        {
323            Object value = getObject(parameterName);
324            if(null != value)
325            {
326                if(value instanceof Number) return ((Number)value).longValue();
327                return new Long(value.toString()).longValue();
328            }
329            return 0;
330        }
331    
332        public short getShort(String parameterName) throws SQLException
333        {
334            Object value = getObject(parameterName);
335            if(null != value)
336            {
337                if(value instanceof Number) return ((Number)value).shortValue();
338                return new Short(value.toString()).shortValue();
339            }
340            return 0;
341        }
342    
343        public boolean getBoolean(String parameterName) throws SQLException
344        {
345            Object value = getObject(parameterName);
346            if(null != value)
347            {
348                if(value instanceof Boolean) return ((Boolean)value).booleanValue();
349                return new Boolean(value.toString()).booleanValue();
350            }
351            return false;
352        }
353    
354        public byte[] getBytes(String parameterName) throws SQLException
355        {
356            Object value = getObject(parameterName);
357            if(null != value)
358            {
359                if(value instanceof byte[]) return (byte[])value;
360                return value.toString().getBytes();
361            }
362            return null;
363        }
364    
365        public void setByte(String parameterName, byte byteValue) throws SQLException
366        {
367            setObject(parameterName, new Byte(byteValue));
368        }
369    
370        public void setDouble(String parameterName, double doubleValue) throws SQLException
371        {
372            setObject(parameterName, new Double(doubleValue));
373        }
374    
375        public void setFloat(String parameterName, float floatValue) throws SQLException
376        {
377            setObject(parameterName, new Float(floatValue));
378        }
379    
380        public void setInt(String parameterName, int intValue) throws SQLException
381        {
382            setObject(parameterName, new Integer(intValue));
383        }
384    
385        public void setNull(String parameterName, int sqlType) throws SQLException
386        {
387            setObject(parameterName, null);
388        }
389    
390        public void setLong(String parameterName, long longValue) throws SQLException
391        {
392            setObject(parameterName, new Long(longValue));
393        }
394    
395        public void setShort(String parameterName, short shortValue) throws SQLException
396        {
397            setObject(parameterName, new Short(shortValue));
398        }
399    
400        public void setBoolean(String parameterName, boolean booleanValue) throws SQLException
401        {
402            setObject(parameterName, new Boolean(booleanValue));
403        }
404    
405        public void setBytes(String parameterName, byte[] byteArray) throws SQLException
406        {
407            setObject(parameterName, byteArray);
408        }
409    
410        public BigDecimal getBigDecimal(int parameterIndex) throws SQLException
411        {
412            Object value = getObject(parameterIndex);
413            if(null != value)
414            {
415                if(value instanceof Number) return new BigDecimal(((Number)value).doubleValue());
416                return new BigDecimal(value.toString());
417            }
418            return null;
419        }
420    
421        public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException
422        {
423            return getBigDecimal(parameterIndex);
424        }
425    
426        public URL getURL(int parameterIndex) throws SQLException
427        {
428            Object value = getObject(parameterIndex);
429            if(null != value)
430            {
431                if(value instanceof URL) return (URL)value;
432                try
433                {
434                    return new URL(value.toString());
435                }
436                catch(MalformedURLException exc)
437                {
438                
439                }
440            }
441            return null;
442        }
443    
444        public Array getArray(int parameterIndex) throws SQLException
445        {
446            Object value = getObject(parameterIndex);
447            if(null != value)
448            {
449                if(value instanceof Array) return (Array)value;
450                return new MockArray(value);
451            }
452            return null;
453        }
454    
455        public Blob getBlob(int parameterIndex) throws SQLException
456        {
457            Object value = getObject(parameterIndex);
458            if(null != value)
459            {
460                if(value instanceof Blob) return (Blob)value;
461                return new MockBlob(getBytes(parameterIndex));
462            }
463            return null;
464        }
465    
466        public Clob getClob(int parameterIndex) throws SQLException
467        {
468            Object value = getObject(parameterIndex);
469            if(null != value)
470            {
471                if(value instanceof Clob) return (Clob)value;
472                return new MockClob(getString(parameterIndex));
473            }
474            return null;
475        }
476    
477        public Date getDate(int parameterIndex) throws SQLException
478        {
479            Object value = getObject(parameterIndex);
480            if(null != value)
481            {
482                if(value instanceof Date) return (Date)value;
483                return Date.valueOf(value.toString());
484            }
485            return null;
486        }
487    
488        public Ref getRef(int parameterIndex) throws SQLException
489        {
490            Object value = getObject(parameterIndex);
491            if(null != value)
492            {
493                if(value instanceof Ref) return (Ref)value;
494                return new MockRef(value);
495            }
496            return null;
497        }
498    
499        public Time getTime(int parameterIndex) throws SQLException
500        {
501            Object value = getObject(parameterIndex);
502            if(null != value)
503            {
504                if(value instanceof Time) return (Time)value;
505                return Time.valueOf(value.toString());
506            }
507            return null;
508        }
509    
510        public Timestamp getTimestamp(int parameterIndex) throws SQLException
511        {
512            Object value = getObject(parameterIndex);
513            if(null != value)
514            {
515                if(value instanceof Timestamp) return (Timestamp)value;
516                return Timestamp.valueOf(value.toString());
517            }
518            return null;
519        }
520    
521        public void setAsciiStream(String parameterName, InputStream stream, int length) throws SQLException
522        {
523            setBinaryStream(parameterName, stream, length);
524        }
525    
526        public void setBinaryStream(String parameterName, InputStream stream, int length) throws SQLException
527        {
528            byte[] data = StreamUtil.getStreamAsByteArray(stream, length);
529            setObject(parameterName, new ByteArrayInputStream(data));
530        }
531    
532        public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException
533        {
534            String data = StreamUtil.getReaderAsString(reader, length);
535            setObject(parameterName, new StringReader(data));
536        }
537    
538        public Object getObject(String parameterName) throws SQLException
539        {
540            wasNull = false;
541            Map outParameter = getOutParameterMap();
542            Object returnValue = null;
543            if(null != outParameter)
544            {
545                returnValue = outParameter.get(parameterName);
546            }
547            if(null == returnValue) wasNull = true;
548            return returnValue;
549        }
550    
551        public void setObject(String parameterName, Object object) throws SQLException
552        {
553            paramObjects.put(parameterName, object);
554        }
555    
556        public void setObject(String parameterName, Object object, int targetSqlType) throws SQLException
557        {
558            setObject(parameterName, object);
559        }
560    
561        public void setObject(String parameterName, Object object, int targetSqlType, int scale) throws SQLException
562        {
563            setObject(parameterName, object);
564        }
565    
566        public Object getObject(int parameterIndex, Map map) throws SQLException
567        {
568            return getObject(parameterIndex);
569        }
570    
571        public String getString(String parameterName) throws SQLException
572        {
573            Object value = getObject(parameterName);
574            if(null != value) return value.toString();
575            return null;
576        }
577    
578        public void setNull(String parameterName, int sqlType, String typeName) throws SQLException
579        {
580            setNull(parameterName, sqlType);
581        }
582    
583        public void setString(String parameterName, String string) throws SQLException
584        {
585            setObject(parameterName, string);
586        }
587    
588        public BigDecimal getBigDecimal(String parameterName) throws SQLException
589        {
590            Object value = getObject(parameterName);
591            if(null != value)
592            {
593                if(value instanceof Number) return new BigDecimal(((Number)value).doubleValue());
594                return new BigDecimal(value.toString());
595            }
596            return null;
597        }
598    
599        public void setBigDecimal(String parameterName, BigDecimal bigDecimal) throws SQLException
600        {
601            setObject(parameterName, bigDecimal);
602        }
603    
604        public URL getURL(String parameterName) throws SQLException
605        {
606            Object value = getObject(parameterName);
607            if(null != value)
608            {
609                if(value instanceof URL) return (URL)value;
610                try
611                {
612                    return new URL(value.toString());
613                }
614                catch(MalformedURLException exc)
615                {
616                
617                }
618            }
619            return null;
620        }
621    
622        public void setURL(String parameterName, URL url) throws SQLException
623        {
624            setObject(parameterName, url);
625        }
626    
627        public Array getArray(String parameterName) throws SQLException
628        {
629            Object value = getObject(parameterName);
630            if(null != value)
631            {
632                if(value instanceof Array) return (Array)value;
633                return new MockArray(value);
634            }
635            return null;
636        }
637    
638        public Blob getBlob(String parameterName) throws SQLException
639        {
640            Object value = getObject(parameterName);
641            if(null != value)
642            {
643                if(value instanceof Blob) return (Blob)value;
644                return new MockBlob(getBytes(parameterName));
645            }
646            return null;
647        }
648    
649        public Clob getClob(String parameterName) throws SQLException
650        {
651            Object value = getObject(parameterName);
652            if(null != value)
653            {
654                if(value instanceof Clob) return (Clob)value;
655                return new MockClob(getString(parameterName));
656            }
657            return null;
658        }
659    
660        public Date getDate(String parameterName) throws SQLException
661        {
662            Object value = getObject(parameterName);
663            if(null != value)
664            {
665                if(value instanceof Date) return (Date)value;
666                return Date.valueOf(value.toString());
667            }
668            return null;
669        }
670    
671        public void setDate(String parameterName, Date date) throws SQLException
672        {
673            setObject(parameterName, date);
674        }
675    
676        public Date getDate(int parameterIndex, Calendar calendar) throws SQLException
677        {
678            return getDate(parameterIndex);
679        }
680    
681        public Ref getRef(String parameterName) throws SQLException
682        {
683            Object value = getObject(parameterName);
684            if(null != value)
685            {
686                if(value instanceof Ref) return (Ref)value;
687                return new MockRef(value);
688            }
689            return null;
690        }
691    
692        public Time getTime(String parameterName) throws SQLException
693        {
694            Object value = getObject(parameterName);
695            if(null != value)
696            {
697                if(value instanceof Time) return (Time)value;
698                return Time.valueOf(value.toString());
699            }
700            return null;
701        }
702    
703        public void setTime(String parameterName, Time time) throws SQLException
704        {
705            setObject(parameterName, time);
706        }
707    
708        public Time getTime(int parameterIndex, Calendar calendar) throws SQLException
709        {
710            return getTime(parameterIndex);
711        }
712    
713        public Timestamp getTimestamp(String parameterName) throws SQLException
714        {
715            Object value = getObject(parameterName);
716            if(null != value)
717            {
718                if(value instanceof Timestamp) return (Timestamp)value;
719                return Timestamp.valueOf(value.toString());
720            }
721            return null;
722        }
723    
724        public void setTimestamp(String parameterName, Timestamp timestamp) throws SQLException
725        {
726            setObject(parameterName, timestamp);
727        }
728    
729        public Timestamp getTimestamp(int parameterIndex, Calendar calendar) throws SQLException
730        {
731            return getTimestamp(parameterIndex);
732        }
733    
734        public Object getObject(String parameterName, Map map) throws SQLException
735        {
736            return getObject(parameterName);
737        }
738    
739        public Date getDate(String parameterName, Calendar calendar) throws SQLException
740        {
741            return getDate(parameterName);
742        }
743    
744        public Time getTime(String parameterName, Calendar calendar) throws SQLException
745        {
746            return getTime(parameterName);
747        }
748    
749        public Timestamp getTimestamp(String parameterName, Calendar calendar) throws SQLException
750        {
751            return getTimestamp(parameterName);
752        }
753    
754        public void setDate(String parameterName, Date date, Calendar calendar) throws SQLException
755        {
756            setDate(parameterName, date);
757        }
758    
759        public void setTime(String parameterName, Time time, Calendar calendar) throws SQLException
760        {
761            setTime(parameterName, time);
762        }
763    
764        public void setTimestamp(String parameterName, Timestamp timestamp, Calendar calendar) throws SQLException
765        {
766            setTimestamp(parameterName, timestamp);
767        }
768        
769        private Map getOutParameterMap()
770        {
771            Map outParameter = resultSetHandler.getOutParameter(getSQL(), getParameterMap());
772            if(null == outParameter)
773            {
774                outParameter = resultSetHandler.getOutParameter(getSQL());
775            }
776            if(null == outParameter)
777            {
778                outParameter = resultSetHandler.getGlobalOutParameter();
779            }
780            return outParameter;
781        }
782    }