View Javadoc

1   /*
2    * Copyright (c) 2010.  The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with 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  package org.apache.hadoop.hbase.hbql.io;
22  
23  import org.apache.hadoop.hbase.hbql.client.HBqlException;
24  import org.apache.hadoop.hbase.hbql.mapping.FieldType;
25  
26  import java.io.ByteArrayInputStream;
27  import java.io.ByteArrayOutputStream;
28  import java.io.IOException;
29  import java.io.ObjectInputStream;
30  import java.io.ObjectOutputStream;
31  import java.io.Serializable;
32  import java.lang.reflect.Array;
33  
34  public class JavaSerialization extends Serialization {
35  
36      public Object getScalarFromBytes(final FieldType fieldType, final byte[] b) throws HBqlException {
37  
38          if (b == null || b.length == 0)
39              return null;
40  
41          ObjectInputStream ois = null;
42  
43          try {
44  
45              final ByteArrayInputStream bais = new ByteArrayInputStream(b);
46              ois = new ObjectInputStream(bais);
47  
48              switch (fieldType) {
49  
50                  case BooleanType:
51                      return ois.readBoolean();
52  
53                  case ByteType:
54                      return ois.readByte();
55  
56                  case CharType:
57                      return ois.readByte();
58  
59                  case ShortType:
60                      return ois.readShort();
61  
62                  case IntegerType:
63                      return ois.readInt();
64  
65                  case LongType:
66                      return ois.readLong();
67  
68                  case FloatType:
69                      return ois.readFloat();
70  
71                  case DoubleType:
72                      return ois.readDouble();
73  
74                  case KeyType:
75                  case StringType:
76                      return ois.readUTF();
77  
78                  case DateType:
79                  case ObjectType:
80                      return ois.readObject();
81  
82                  default:
83                      throw new HBqlException("Unknown type in getScalarFromBytes() " + fieldType);
84              }
85          }
86          catch (IOException e) {
87              throw new HBqlException(getExceptionMessage("getScalarFromBytes()", e));
88          }
89          catch (ClassNotFoundException e) {
90              throw new HBqlException(getExceptionMessage("getScalarFromBytes()", e));
91          }
92          finally {
93              if (ois != null) {
94                  try {
95                      ois.close();
96                  }
97                  catch (IOException e) {
98                      e.printStackTrace();
99                  }
100             }
101         }
102     }
103 
104     public byte[] getScalarAsBytes(final FieldType fieldType, final Object obj) throws HBqlException {
105 
106         if (obj == null)
107             return null;
108 
109         try {
110             final ByteArrayOutputStream baos = new ByteArrayOutputStream();
111             final ObjectOutputStream oos = new ObjectOutputStream(baos);
112 
113             switch (fieldType) {
114 
115                 case BooleanType:
116                     oos.writeBoolean((Boolean)obj);
117                     break;
118 
119                 case ByteType:
120                     oos.writeByte((Byte)obj);
121                     break;
122 
123                 case CharType:
124                     oos.writeByte((Character)obj);
125                     break;
126 
127                 case ShortType:
128                     oos.writeShort((Short)obj);
129                     break;
130 
131                 case IntegerType:
132                     oos.writeInt((Integer)obj);
133                     break;
134 
135                 case LongType:
136                     oos.writeLong((Long)obj);
137                     break;
138 
139                 case FloatType:
140                     oos.writeFloat((Float)obj);
141                     break;
142 
143                 case DoubleType:
144                     oos.writeDouble((Double)obj);
145                     break;
146 
147                 case KeyType:
148                 case StringType:
149                     oos.writeUTF((String)obj);
150                     break;
151 
152                 case DateType:
153                 case ObjectType:
154                     oos.writeObject((Serializable)obj);
155                     break;
156 
157                 default:
158                     throw new HBqlException("Unknown type in getScalarAsBytes() - " + fieldType);
159             }
160 
161             oos.flush();
162             return baos.toByteArray();
163         }
164         catch (IOException e) {
165             throw new HBqlException(getExceptionMessage("getScalarAsBytes()", e));
166         }
167     }
168 
169     public Object getArrayFromBytes(final FieldType fieldType, final Class clazz, final byte[] b) throws HBqlException {
170 
171         if (b == null || b.length == 0)
172             return null;
173 
174         if (fieldType == FieldType.CharType) {
175             final String s = new String(b);
176             return s.toCharArray();
177         }
178 
179         ObjectInputStream ois = null;
180 
181         try {
182             final ByteArrayInputStream bais = new ByteArrayInputStream(b);
183             ois = new ObjectInputStream(bais);
184 
185             // Read length
186             final int length = ois.readInt();
187             final Object array = Array.newInstance(clazz, length);
188 
189             switch (fieldType) {
190 
191                 case BooleanType:
192                     for (int i = 0; i < length; i++)
193                         Array.set(array, i, ois.readBoolean());
194                     return array;
195 
196                 case ByteType:
197                     for (int i = 0; i < length; i++)
198                         Array.set(array, i, ois.readByte());
199                     return array;
200 
201                 case CharType:
202                     // See above
203                     return null;
204 
205                 case ShortType:
206                     for (int i = 0; i < length; i++)
207                         Array.set(array, i, ois.readShort());
208                     return array;
209 
210                 case IntegerType:
211                     for (int i = 0; i < length; i++)
212                         Array.set(array, i, ois.readInt());
213                     return array;
214 
215                 case LongType:
216                     for (int i = 0; i < length; i++)
217                         Array.set(array, i, ois.readLong());
218                     return array;
219 
220                 case FloatType:
221                     for (int i = 0; i < length; i++)
222                         Array.set(array, i, ois.readFloat());
223                     return array;
224 
225                 case DoubleType:
226                     for (int i = 0; i < length; i++)
227                         Array.set(array, i, ois.readDouble());
228                     return array;
229 
230                 case StringType:
231                     for (int i = 0; i < length; i++)
232                         Array.set(array, i, ois.readUTF());
233                     return array;
234 
235                 case DateType:
236                 case ObjectType:
237                     for (int i = 0; i < length; i++)
238                         Array.set(array, i, ois.readObject());
239                     return array;
240 
241                 default:
242                     throw new HBqlException("Unknown type in getScalarfromBytes() - " + fieldType);
243             }
244         }
245 
246         catch (IOException e) {
247             throw new HBqlException(getExceptionMessage("getScalarFromBytes()", e));
248         }
249         catch (ClassNotFoundException e) {
250             throw new HBqlException(getExceptionMessage("getScalarFromBytes()", e));
251         }
252         finally {
253             if (ois != null) {
254                 try {
255                     ois.close();
256                 }
257                 catch (IOException e) {
258                     e.printStackTrace();
259                 }
260             }
261         }
262     }
263 
264     public byte[] getArrayAsBytes(final FieldType fieldType, final Object obj) throws HBqlException {
265 
266         if (obj == null)
267             return null;
268 
269         if (fieldType == FieldType.CharType) {
270             final String s = new String((char[])obj);
271             return s.getBytes();
272         }
273 
274         try {
275             final ByteArrayOutputStream baos = new ByteArrayOutputStream();
276             final ObjectOutputStream oos = new ObjectOutputStream(baos);
277 
278             switch (fieldType) {
279 
280                 case BooleanType:
281                     oos.writeInt(((boolean[])obj).length);
282                     for (final boolean val : (boolean[])obj)
283                         oos.writeBoolean(val);
284                     break;
285 
286                 case ByteType:
287                     oos.writeInt(((byte[])obj).length);
288                     for (final byte val : (byte[])obj)
289                         oos.write(val);
290                     break;
291 
292                 case CharType:
293                     // See above
294                     break;
295 
296                 case ShortType:
297                     oos.writeInt(((short[])obj).length);
298                     for (final short val : (short[])obj)
299                         oos.writeShort(val);
300                     break;
301 
302                 case IntegerType:
303                     oos.writeInt(((int[])obj).length);
304                     for (final int val : (int[])obj)
305                         oos.writeInt(val);
306                     break;
307 
308                 case LongType:
309                     oos.writeInt(((long[])obj).length);
310                     for (final long val : (long[])obj)
311                         oos.writeLong(val);
312                     break;
313 
314                 case FloatType:
315                     oos.writeInt(((float[])obj).length);
316                     for (final float val : (float[])obj)
317                         oos.writeFloat(val);
318                     break;
319 
320                 case DoubleType:
321                     oos.writeInt(((double[])obj).length);
322                     for (final double val : (double[])obj)
323                         oos.writeDouble(val);
324                     break;
325 
326                 case StringType:
327                     oos.writeInt(((String[])obj).length);
328                     for (final String val : (String[])obj)
329                         oos.writeUTF(val);
330                     break;
331 
332                 case DateType:
333                 case ObjectType:
334                     oos.writeInt(((Object[])obj).length);
335                     for (final Object val : (Object[])obj)
336                         oos.writeObject((Serializable)val);
337                     break;
338 
339                 default:
340                     throw new HBqlException("Unknown type in getArrayAsBytes() - " + fieldType);
341             }
342             oos.flush();
343             return baos.toByteArray();
344         }
345         catch (IOException e) {
346             throw new HBqlException(getExceptionMessage("getArrayAsBytes()", e));
347         }
348     }
349 }