EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.impl.sql]

COVERAGE SUMMARY FOR SOURCE FILE [GenericParameter.java]

nameclass, %method, %block, %line, %
GenericParameter.java100% (1/1)100% (14/14)90%  (166/184)91%  (46.6/51)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class GenericParameter100% (1/1)100% (14/14)90%  (166/184)91%  (46.6/51)
<static initializer> 100% (1/1)100% (5/5)100% (2/2)
GenericParameter (GenericParameterValueSet, boolean): void 100% (1/1)100% (25/25)100% (7/7)
clear (): void 100% (1/1)100% (4/4)100% (2/2)
getClone (GenericParameterValueSet): GenericParameter 100% (1/1)100% (21/21)100% (4/4)
getJDBCParameterNumberStr (): String 100% (1/1)100% (6/6)100% (1/1)
getPrecision (): int 100% (1/1)100% (3/3)100% (1/1)
getScale (): int 100% (1/1)78%  (7/9)77%  (0.8/1)
getValue (): DataValueDescriptor 100% (1/1)100% (3/3)100% (1/1)
setOutParameter (int, int): void 100% (1/1)100% (30/30)100% (9/9)
setStorableDataValue (DataValueDescriptor, int, String): void 100% (1/1)100% (10/10)100% (4/4)
stuffObject (Object): void 100% (1/1)100% (8/8)100% (3/3)
throwInvalidOutParamMap (int): StandardException 100% (1/1)88%  (21/24)97%  (4.9/5)
toString (): String 100% (1/1)37%  (7/19)40%  (2/5)
validate (): void 100% (1/1)94%  (16/17)83%  (5/6)

1/*
2 
3   Derby - Class org.apache.derby.impl.sql.GenericParameter
4 
5   Copyright 1999, 2004 The Apache Software Foundation or its licensors, as applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19 */
20 
21package org.apache.derby.impl.sql;
22 
23import org.apache.derby.iapi.services.loader.ClassInspector;
24 
25import org.apache.derby.iapi.sql.ParameterValueSet;
26 
27import org.apache.derby.iapi.types.DataValueDescriptor;
28import org.apache.derby.iapi.types.BooleanDataValue;
29import org.apache.derby.iapi.types.BitDataValue;
30import org.apache.derby.iapi.types.DateTimeDataValue;
31import org.apache.derby.iapi.types.NumberDataValue;
32import org.apache.derby.iapi.types.StringDataValue;
33import org.apache.derby.iapi.types.UserDataValue;
34import org.apache.derby.iapi.types.TypeId;
35import org.apache.derby.iapi.types.DataTypeDescriptor;
36import org.apache.derby.iapi.types.*;
37 
38import org.apache.derby.iapi.reference.SQLState;
39 
40import org.apache.derby.iapi.reference.JDBC30Translation;
41 
42import org.apache.derby.iapi.error.StandardException;
43 
44import org.apache.derby.iapi.services.sanity.SanityManager;
45 
46import org.apache.derby.iapi.types.*;
47import org.apache.derby.iapi.types.*;
48 
49import java.sql.Types;
50 
51import java.lang.reflect.Array;
52 
53/**
54 * A parameter.  Originally lifted from ParameterValueSet.
55 *
56 * @author jamie 
57 */
58final class GenericParameter
59{
60 
61        // These defaults match the Network Server/ JCC max precision and
62        // The JCC "guessed" scale. They are used as the defaults for 
63        // Decimal out params.
64        private static int DECIMAL_PARAMETER_DEFAULT_PRECISION = 31;
65        private static int DECIMAL_PARAMETER_DEFAULT_SCALE = 15;
66 
67 
68        /*
69        ** The parameter set we are part of
70        */
71        private final GenericParameterValueSet                pvs;
72 
73        /**
74        ** Our value
75        */
76        private DataValueDescriptor                                value;
77 
78        /**
79                Compile time JDBC type identifier.
80        */
81        int                                                                jdbcTypeId;
82 
83        /**
84                Compile time Java class name.
85        */
86        String                                                        declaredClassName;
87 
88        /**
89                Mode of the parameter, from ParameterMetaData
90        */
91        short                                                        parameterMode;
92 
93        /*
94        ** If we are set
95        */
96        boolean                                                        isSet;
97 
98        /*
99        ** Output parameter values
100         */
101        private final boolean                                        isReturnOutputParameter;
102 
103        /**
104                Type that has been registered.
105        */
106        int        registerOutType = Types.NULL;
107        /**
108                Scale that has been registered.
109        */
110        int registerOutScale = -1;
111 
112        /**
113         * When a decimal output parameter is registered we give it a 
114         * precision
115         */
116 
117        int registerOutPrecision = -1;
118 
119        /**
120         * Constructor for a Parameter
121         *
122         * @param pvs the parameter set that this is part of
123         * @param isReturnOutputParameter true if this is a return output parameter
124         */
125        GenericParameter
126        (
127                GenericParameterValueSet        pvs,
128                boolean                                                isReturnOutputParameter
129        )
130        {
131                this.pvs = pvs;
132                parameterMode = (this.isReturnOutputParameter = isReturnOutputParameter)
133                        ? (short) JDBC30Translation.PARAMETER_MODE_OUT : (short) JDBC30Translation.PARAMETER_MODE_IN;
134        }
135 
136        /**
137         * Clone myself.  It is a shallow copy for everything but
138         * the underlying data wrapper and its value -- e.g. for
139         * everything but the underlying SQLInt and its int.
140         *
141         * @param pvs the parameter value set
142         *
143         * @return a new generic parameter.
144         */
145        public GenericParameter getClone(GenericParameterValueSet pvs)
146        {
147                GenericParameter gpClone = new GenericParameter(pvs, isReturnOutputParameter);
148                gpClone.initialize(this.getValue().getClone(), jdbcTypeId, declaredClassName);
149                gpClone.isSet = true;
150 
151                return gpClone;
152        }
153 
154        /**
155         * Set the DataValueDescriptor and type information for this parameter
156         *
157         */
158        void initialize(DataValueDescriptor value, int jdbcTypeId, String className)
159        {
160                this.value = value;
161                this.jdbcTypeId = jdbcTypeId;
162                this.declaredClassName = className;
163        }
164 
165 
166        /**
167         * Clear the parameter, unless it is a return
168         * output parameter
169         */
170        void clear()
171        {
172                isSet = false;
173        }
174 
175 
176        /**
177         * Get the parameter value.  Doesn't check to
178         * see if it has been initialized or not.
179         *
180         * @return the parameter value, may return null
181         */
182        DataValueDescriptor getValue()
183        {
184                return value;
185        }
186 
187 
188        //////////////////////////////////////////////////////////////////
189        //
190        // CALLABLE STATEMENT
191        //
192        //////////////////////////////////////////////////////////////////
193 
194        /**
195         * Mark the parameter as an output parameter.
196         *
197         * @param sqlType        A type from java.sql.Types
198         * @param scale                scale, -1 if no scale arg
199         *
200         * @exception StandardException on error
201         */
202        void setOutParameter(int sqlType, int scale)
203                throws StandardException
204        {
205                // fast case duplicate registrations.
206                if (registerOutType == sqlType) {
207                        if (scale == registerOutScale)
208                                return;
209                }
210 
211                switch (parameterMode) {
212                case JDBC30Translation.PARAMETER_MODE_IN:
213                case JDBC30Translation.PARAMETER_MODE_UNKNOWN:
214                default:
215                        throw StandardException.newException(SQLState.LANG_NOT_OUT_PARAM, getJDBCParameterNumberStr());
216 
217                case JDBC30Translation.PARAMETER_MODE_IN_OUT:
218                case JDBC30Translation.PARAMETER_MODE_OUT:
219                        // Declared/Java procedure parameter.
220                        if (!DataTypeDescriptor.isJDBCTypeEquivalent(jdbcTypeId, sqlType))
221                                throw throwInvalidOutParamMap(sqlType);
222                        break;
223 
224                }
225 
226                registerOutType = sqlType;
227                
228        }
229 
230        private StandardException throwInvalidOutParamMap(int sqlType) {
231 
232                //TypeId typeId = TypeId.getBuiltInTypeId(sqlType);
233                // String sqlTypeName = typeId == null ? "OTHER" : typeId.getSQLTypeName();
234 
235 
236                String jdbcTypesName = org.apache.derby.impl.jdbc.Util.typeName(sqlType);
237 
238                TypeId typeId = TypeId.getBuiltInTypeId(jdbcTypeId);
239                String thisTypeName = typeId == null ? declaredClassName : typeId.getSQLTypeName();
240                                
241                StandardException e = StandardException.newException(SQLState.LANG_INVALID_OUT_PARAM_MAP,
242                                        getJDBCParameterNumberStr(),
243                                        jdbcTypesName, thisTypeName);
244 
245                return e;
246        }
247 
248 
249 
250        /**
251         * Validate the parameters.  This is done for situations where
252         * we cannot validate everything in the setXXX() calls.  In
253         * particular, before we do an execute() on a CallableStatement,
254         * we need to go through the parameters and make sure that
255         * all parameters are set up properly.  The motivator for this
256         * is that setXXX() can be called either before or after
257         * registerOutputParamter(), we cannot be sure we have the types
258         * correct until we get to execute().
259         *
260         * @exception StandardException if the parameters aren't valid
261         */
262        void validate() throws StandardException
263        {
264                switch (parameterMode) {
265                case JDBC30Translation.PARAMETER_MODE_UNKNOWN:
266                        break;
267                case JDBC30Translation.PARAMETER_MODE_IN:
268                        break;
269                case JDBC30Translation.PARAMETER_MODE_IN_OUT:
270                case JDBC30Translation.PARAMETER_MODE_OUT:
271                        if (registerOutType == Types.NULL) {
272                                throw StandardException.newException(SQLState.NEED_TO_REGISTER_PARAM,
273                                        getJDBCParameterNumberStr(),
274                                         org.apache.derby.catalog.types.RoutineAliasInfo.parameterMode(parameterMode));
275                        }
276                        break;
277                }
278        }
279 
280        /**
281         * Return the scale of the parameter.
282         *
283         * @return scale
284         */
285        int getScale()
286        {
287                //when the user doesn't pass any scale, the registerOutScale gets set to -1
288                return (registerOutScale == -1 ? 0 : registerOutScale);
289        }
290 
291 
292        int getPrecision()
293        {
294                return registerOutPrecision;
295                
296        }
297 
298        ////////////////////////////////////////////////////
299        //
300        // CLASS IMPLEMENTATION
301        //
302        ////////////////////////////////////////////////////
303 
304        /**
305         * get string for param number
306         */
307        String getJDBCParameterNumberStr()
308        {
309                return Integer.toString(pvs.getParameterNumber(this));
310        }
311 
312        public String toString()
313        {
314                /* This method is used for debugging.
315                 * It is called when derby.language.logStatementText=true,
316                 * so there is no check of SanityManager.DEBUG.
317                 * Anyway, we need to call value.getString() instead of
318                 * value.toString() because the user may have done a
319                 * a setStream() on the parameter.  (toString() could get
320                 * an assertion failure in that case as it would be in an
321                 * unexpected state since this is a very weird codepath.)
322                 * getString() can throw an exception which we eat and
323                 * and reflect in the returned string.
324                 */
325                if (value == null)
326                {
327                        return "null";
328                }
329                else
330                {
331                        try
332                        {
333                                return value.getString();
334                        }
335                        catch (StandardException se)
336                        {
337                                return "unexpected exception from getString() - " + se;
338                        }
339                }
340        }
341}

[all classes][org.apache.derby.impl.sql]
EMMA 2.0.5312 (C) Vladimir Roubtsov