|
1 package com.quadcap.sql.types;
2
3
40
41 import java.io.Externalizable  ;
42 import java.io.IOException ;
43 import java.io.ObjectInput ;
44 import java.io.ObjectOutput ;
45
46 import java.sql.Types ;
47
48 import com.quadcap.util.Debug;
49 import com.quadcap.sql.io.ExternalizeProxy;
50
51
56 public class ValueDouble extends Value implements Externalizable , ExternalizeProxy {
57 double val;
58
59 public ValueDouble() {}
60
61 public ValueDouble(double val) {
62 this.val = val;
63 }
64
65 public ValueDouble(String s) throws ValueException {
66 try {
67 this.val = Double.parseDouble(s);
71 } catch (NumberFormatException ne) {
73 throw new ValueException("DOUBLE format error");
74 }
75 }
76
77 public final double doubleValue() { return val; }
78
79 public Value unop(int op) throws ValueException {
80 switch (op) {
81 case Op.NULL:
82 return ValueBoolean.falseBoolean;
83 case Op.PLUS:
84 return this;
85 case Op.MINUS:
86 return new ValueDouble(0.0 - val);
87 default:
88 throw new ValueException("Unary op: " + Op.toString(op) +
89 " not implemented for this type");
90 }
91 }
92
93 public Value binop(int op, Value l) throws ValueException {
94 return l.binop(op, this);
95 }
96
97 public Value binop(int op, ValueFloat r) throws ValueException {
98 return ValueDouble.binop(op, this, new ValueDouble(r.val));
99 }
100
101 public Value binop(int op, ValueDouble r) throws ValueException {
102 return ValueDouble.binop(op, this, r);
103 }
104
105 public Value binop(int op, ValueInteger r) throws ValueException {
106 return Value.binop(op, this, new ValueDouble(r.val));
107 }
108
109 public Value binop(int op, ValueShort r) throws ValueException {
110 return Value.binop(op, this, new ValueDouble(r.val));
111 }
112
113 public Value binop(int op, ValueByte r) throws ValueException {
114 return Value.binop(op, this, new ValueDouble(r.val));
115 }
116
117 public Value binop(int op, ValueLong r) throws ValueException {
118 return Value.binop(op, this, new ValueDouble(r.val));
119 }
120
121 public Value binop(int op, ValueScaledInteger r) throws ValueException {
122 return ValueDouble.binop(op, this, new ValueDouble(r.doubleValue()));
123 }
124
125 public Value binop(int op, ValueNull r) throws ValueException {
126 switch (op) {
127 case Op.EQ:
128 case Op.NE:
129 case Op.LT:
130 case Op.LE:
131 case Op.GT:
132 case Op.GE:
133 return ValueUnknown.valueUnknown;
134 case Op.PLUS:
135 case Op.MINUS:
136 case Op.TIMES:
137 case Op.DIVIDE:
138 case Op.EXP:
139 return r;
140 case Op.COMPARE:
141 return r.valCmpNull();
142 default:
143 throw badBinop(op, r);
144 }
145 }
146
147
148 public static final Value binop(int op, ValueDouble e, ValueDouble f)
149 throws ValueException
150 {
151 switch (op) {
152 case Op.DIVIDE:
153 try {
154 return new ValueDouble(e.val / f.val);
155 } catch (ArithmeticException ae) {
156 throw new ValueException(ae.toString());
157 }
158 case Op.EQ:
159 return new ValueBoolean(e.val == f.val);
160 case Op.EXP:
161 return new ValueDouble((Math.pow(e.val, f.val)));
162 case Op.GE:
163 return new ValueBoolean(e.val >= f.val);
164 case Op.GT:
165 return new ValueBoolean(e.val > f.val);
166 case Op.LE:
167 return new ValueBoolean(e.val <= f.val);
168 case Op.LT:
169 return new ValueBoolean(e.val < f.val);
170 case Op.MINUS:
171 return new ValueDouble(e.val - f.val);
172 case Op.NE:
173 return new ValueBoolean(e.val != f.val);
174 case Op.PLUS:
175 return new ValueDouble(e.val + f.val);
176 case Op.TIMES:
177 return new ValueDouble(e.val * f.val);
178 case Op.COMPARE:
179 if (e.val < f.val) return ValueInteger.MINUS_ONE;
180 if (e.val > f.val) return ValueInteger.PLUS_ONE;
181 return ValueInteger.ZERO;
182
183 default:
184 throw badBinop(op, e, f);
185 }
186 }
187
188 public Object asJavaObject() {
189 return new Double (val);
190 }
191
192 public void fromJavaObject(Object obj) throws ValueException {
193 if (obj instanceof Double ) {
194 val = ((Double )obj).doubleValue();
195 } else {
196 throw new ValueException("bad type: " + obj);
197 }
198 }
199
200 public void readExternal(ObjectInput in) throws IOException {
201 val = in.readDouble();
202 }
203
204 public void writeExternal(ObjectOutput out)
205 throws IOException
206 {
207 out.writeDouble(val);
208 }
209
210 public Object readObject(ObjectInput in)
211 throws IOException , ClassNotFoundException
212 {
213 ValueDouble v = new ValueDouble();
214 v.readExternal(in);
215 return v;
216 }
217
218 public void writeObject(ObjectOutput out, Object object)
219 throws IOException
220 {
221 ((ValueDouble)object).writeExternal(out);
222 }
223
224 public Value convert(TypeTinyInt type) throws ValueException {
225 return TypeTinyInt.convertNumber(val);
226 }
227
228 public Value convert(TypeSmallInt type) throws ValueException {
229 return TypeSmallInt.convertNumber(val);
230 }
231
232 public Value convert(TypeInt type) throws ValueException {
233 return TypeInt.convertNumber(val);
234 }
235
236 public Value convert(TypeBigInt type) throws ValueException {
237 return TypeBigInt.convertNumber(val);
238 }
239
240 public Value convert(TypeDecimal type) throws ValueException {
241 ValueScaledInteger vs = new ValueScaledInteger(val);
242 if (type.getPrecision() >= 0) {
243 if (vs.requiredPrecision() > type.getPrecision()) {
244 throw new ValueException("Too large: " + val +
245 ", precision = " +
246 vs.requiredPrecision() +
247 ", type precision = " +
248 type.getPrecision());
249 }
250 vs.setScale(type.getScale());
251 }
252 return vs;
253 }
254
255 public Value convert(TypeReal type) throws ValueException {
256 if (type.getPrecision() > 31) {
257 return this;
258 } else {
259 return new ValueFloat((float)val);
260 }
261 }
262
263 public Type getType() {
264 return TypeReal.typeDouble;
265 }
266
267 public void serializeKey(KeyStream out) throws IOException {
268 out.writeDouble(val);
269 }
270
271 public String toString() {
272 return String.valueOf(val);
273 }
274 }
275 |
Popular Tags |
Java API By Example, From Geeks To Geeks.