10164

Build # 10164

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/553fe2d999f73a04fd8e0cec247de45f88695679">553fe2d99<a href="https://github.com/apache/carbondata/commit/553fe2d999f73a04fd8e0cec247de45f88695679">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/5e4de2c103a6cf2253aa3181eee82c796700fb12">5e4de2c10</a>">5e4de2c10</a><a href="https://github.com/apache/carbondata/commit/553fe2d999f73a04fd8e0cec247de45f88695679"> into bd752e9d5">bd752e9d5</a>

Run Details

61510 of 77817 relevant lines covered (79.04%)

1.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.41

/core/src/main/java/org/apache/carbondata/core/metadata/datatype/DecimalConverterFactory.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.carbondata.core.metadata.datatype;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;

import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
import org.apache.carbondata.core.scan.result.vector.ColumnVectorInfo;
import org.apache.carbondata.core.util.ByteUtil;
import org.apache.carbondata.core.util.DataTypeUtil;

/**
 * Decimal converter to keep the data compact.
 */
public final class DecimalConverterFactory {

  public static final DecimalConverterFactory INSTANCE = new DecimalConverterFactory();

  private int[] minBytesForPrecision = minBytesForPrecision();

  private DecimalConverterFactory() {

  }

  private int computeMinBytesForPrecision(int precision) {
    int numBytes = 1;
    while (Math.pow(2.0, 8 * numBytes - 1) < Math.pow(10.0, precision)) {
      numBytes += 1;
    }
    return numBytes;
  }

  private int[] minBytesForPrecision() {
    int[] data = new int[39];
    for (int i = 0; i < data.length; i++) {
      data[i] = computeMinBytesForPrecision(i);
    }
    return data;
  }

  public enum DecimalConverterType {
    DECIMAL_LV(-1), DECIMAL_INT(4), DECIMAL_LONG(8), DECIMAL_UNSCALED(-1);

    private int sizeInBytes;

    DecimalConverterType(int sizeInBytes) {
      this.sizeInBytes = sizeInBytes;
    }

    public int getSizeInBytes() {
      return sizeInBytes;
    }

  }

  public interface DecimalConverter {

    Object convert(BigDecimal decimal);

    BigDecimal getDecimal(Object valueToBeConverted);

    void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info, BitSet nullBitset,
        DataType pageType);

    int getSize();

    DecimalConverterType getDecimalConverterType();

  }

  public static class DecimalIntConverter implements DecimalConverter {

    protected int scale;

    DecimalIntConverter(int scale) {
      this.scale = scale;
    }

    @Override public Object convert(BigDecimal decimal) {
      long longValue = decimal.unscaledValue().longValue();
      return (int) longValue;
    }

    @Override public BigDecimal getDecimal(Object valueToBeConverted) {
      return BigDecimal.valueOf((Long) valueToBeConverted, scale);
    }

    @Override public void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info,
        BitSet nullBitset, DataType pageType) {
      // TODO we need to find way to directly set to vector with out conversion. This way is very
      // inefficient.
      CarbonColumnVector vector = info.vector;
      int precision = info.measure.getMeasure().getPrecision();
      int newMeasureScale = info.measure.getMeasure().getScale();
      if (!(valuesToBeConverted instanceof byte[])) {
        throw new UnsupportedOperationException("This object type " + valuesToBeConverted.getClass()
            + " is not supported in this method");
      }
      byte[] data = (byte[]) valuesToBeConverted;
      if (pageType == DataTypes.BYTE) {
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigDecimal value = BigDecimal.valueOf(data[i], scale);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      } else if (pageType == DataTypes.SHORT) {
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigDecimal value = BigDecimal
                .valueOf(ByteUtil.toShortLittleEndian(data, i * DataTypes.SHORT.getSizeInBytes()),
                    scale);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      } else if (pageType == DataTypes.SHORT_INT) {
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigDecimal value = BigDecimal
                .valueOf(ByteUtil.valueOf3Bytes(data, i * DataTypes.SHORT_INT.getSizeInBytes()),
                    scale);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      } else if (pageType == DataTypes.INT) {
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigDecimal value = BigDecimal
                .valueOf(ByteUtil.toIntLittleEndian(data, i * DataTypes.INT.getSizeInBytes()),
                    scale);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      } else if (pageType == DataTypes.LONG) {
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigDecimal value = BigDecimal
                .valueOf(ByteUtil.toLongLittleEndian(data, i * DataTypes.LONG.getSizeInBytes()),
                    scale);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      }
    }

    @Override public int getSize() {
      return 4;
    }

    @Override public DecimalConverterType getDecimalConverterType() {
      return DecimalConverterType.DECIMAL_INT;
    }
  }

  public static class DecimalLongConverter extends DecimalIntConverter {

    DecimalLongConverter(int scale) {
      super(scale);
    }

    @Override public Object convert(BigDecimal decimal) {
      return decimal.unscaledValue().longValue();
    }

    @Override public BigDecimal getDecimal(Object valueToBeConverted) {
      return BigDecimal.valueOf((Long) valueToBeConverted, scale);
    }

    @Override public int getSize() {
      return 8;
    }

    @Override public DecimalConverterType getDecimalConverterType() {
      return DecimalConverterType.DECIMAL_LONG;
    }
  }

  public class DecimalUnscaledConverter implements DecimalConverter {

    private int scale;

    private int numBytes;

    private byte[] decimalBuffer = new byte[minBytesForPrecision[38]];

    DecimalUnscaledConverter(int precision, int scale) {
      this.scale = scale;
      this.numBytes = minBytesForPrecision[precision];
    }

    @Override public Object convert(BigDecimal decimal) {
      byte[] bytes = decimal.unscaledValue().toByteArray();
      byte[] fixedLengthBytes = null;
      if (bytes.length == numBytes) {
        // If the length of the underlying byte array of the unscaled `BigInteger` happens to be
        // `numBytes`, just reuse it, so that we don't bother copying it to `decimalBuffer`.
        fixedLengthBytes = bytes;
      } else {
        // Otherwise, the length must be less than `numBytes`.  In this case we copy contents of
        // the underlying bytes with padding sign bytes to `decimalBuffer` to form the result
        // fixed-length byte array.
        byte signByte = 0;
        if (bytes[0] < 0) {
          signByte = (byte) -1;
        } else {
          signByte = (byte) 0;
        }
        Arrays.fill(decimalBuffer, 0, numBytes - bytes.length, signByte);
        System.arraycopy(bytes, 0, decimalBuffer, numBytes - bytes.length, bytes.length);
        fixedLengthBytes = decimalBuffer;
      }
      byte[] value = new byte[numBytes];
      System.arraycopy(fixedLengthBytes, 0, value, 0, numBytes);
      return value;
    }

    @Override public BigDecimal getDecimal(Object valueToBeConverted) {
      BigInteger bigInteger = new BigInteger((byte[]) valueToBeConverted);
      return new BigDecimal(bigInteger, scale);
    }

    @Override public void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info,
        BitSet nullBitset, DataType pageType) {
      CarbonColumnVector vector = info.vector;
      int precision = info.measure.getMeasure().getPrecision();
      int newMeasureScale = info.measure.getMeasure().getScale();
      if (scale < newMeasureScale) {
        scale = newMeasureScale;
      }
      if (valuesToBeConverted instanceof byte[][]) {
        byte[][] data = (byte[][]) valuesToBeConverted;
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigInteger bigInteger = new BigInteger(data[i]);
            BigDecimal value = new BigDecimal(bigInteger, scale);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      }
    }

    @Override public int getSize() {
      return numBytes;
    }

    @Override public DecimalConverterType getDecimalConverterType() {
      return DecimalConverterType.DECIMAL_UNSCALED;
    }
  }

  public static class LVBytesDecimalConverter implements DecimalConverter {

    public static LVBytesDecimalConverter INSTANCE = new LVBytesDecimalConverter();

    @Override public Object convert(BigDecimal decimal) {
      return DataTypeUtil.bigDecimalToByte(decimal);
    }

    @Override public BigDecimal getDecimal(Object valueToBeConverted) {
      return DataTypeUtil.byteToBigDecimal((byte[]) valueToBeConverted);
    }

    @Override public void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info,
        BitSet nullBitset, DataType pageType) {
      CarbonColumnVector vector = info.vector;
      int precision = info.measure.getMeasure().getPrecision();
      int newMeasureScale = info.measure.getMeasure().getScale();
      if (valuesToBeConverted instanceof byte[][]) {
        byte[][] data = (byte[][]) valuesToBeConverted;
        for (int i = 0; i < size; i++) {
          if (nullBitset.get(i)) {
            vector.putNull(i);
          } else {
            BigDecimal value = DataTypeUtil.byteToBigDecimal(data[i]);
            if (value.scale() < newMeasureScale) {
              value = value.setScale(newMeasureScale);
            }
            vector.putDecimal(i, value, precision);
          }
        }
      }
    }

    @Override public int getSize() {
      return -1;
    }

    @Override public DecimalConverterType getDecimalConverterType() {
      return DecimalConverterType.DECIMAL_LV;
    }
  }

  public DecimalConverter getDecimalConverter(int precision, int scale) {
    if (precision < 0) {
      return new LVBytesDecimalConverter();
    } else if (precision <= 9) {
      return new DecimalIntConverter(scale);
    } else if (precision <= 18) {
      return new DecimalLongConverter(scale);
    } else {
      return new DecimalUnscaledConverter(precision, scale);
    }
  }

}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17	package org.apache.carbondata.core.metadata.datatype;
18
19	import java.math.BigDecimal;
20	import java.math.BigInteger;
21	import java.util.Arrays;
22	import java.util.BitSet;
23
24	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
25	import org.apache.carbondata.core.scan.result.vector.ColumnVectorInfo;
26	import org.apache.carbondata.core.util.ByteUtil;
27	import org.apache.carbondata.core.util.DataTypeUtil;
28
29	/**
30	* Decimal converter to keep the data compact.
31	*/
32	public final class DecimalConverterFactory {
33
34	public static final DecimalConverterFactory INSTANCE = new DecimalConverterFactory();	2✔
35
36	private int[] minBytesForPrecision = minBytesForPrecision();	2✔
37
38	private DecimalConverterFactory() {	2✔
39
40	}	2✔
41
42	private int computeMinBytesForPrecision(int precision) {
43	int numBytes = 1;	2✔
44	while (Math.pow(2.0, 8 * numBytes - 1) < Math.pow(10.0, precision)) {	2✔
45	numBytes += 1;	2✔
46	}
47	return numBytes;	2✔
48	}
49
50	private int[] minBytesForPrecision() {
51	int[] data = new int[39];	2✔
52	for (int i = 0; i < data.length; i++) {	2✔
53	data[i] = computeMinBytesForPrecision(i);	2✔
54	}
55	return data;	2✔
56	}
57
58	public enum DecimalConverterType {	1✔
59	DECIMAL_LV(-1), DECIMAL_INT(4), DECIMAL_LONG(8), DECIMAL_UNSCALED(-1);	1✔
60
61	private int sizeInBytes;
62
63	DecimalConverterType(int sizeInBytes) {	1✔
64	this.sizeInBytes = sizeInBytes;	1✔
65	}	1✔
66
67	public int getSizeInBytes() {
68	return sizeInBytes;	×
69	}
70
71	}
72
73	public interface DecimalConverter {
74
75	Object convert(BigDecimal decimal);
76
77	BigDecimal getDecimal(Object valueToBeConverted);
78
79	void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info, BitSet nullBitset,
80	DataType pageType);
81
82	int getSize();
83
84	DecimalConverterType getDecimalConverterType();
85
86	}
87
88	public static class DecimalIntConverter implements DecimalConverter {
89
90	protected int scale;
91
92	DecimalIntConverter(int scale) {	1✔
93	this.scale = scale;	1✔
94	}	1✔
95
96	@Override public Object convert(BigDecimal decimal) {
97	long longValue = decimal.unscaledValue().longValue();	1✔
98	return (int) longValue;	1✔
99	}
100
101	@Override public BigDecimal getDecimal(Object valueToBeConverted) {
102	return BigDecimal.valueOf((Long) valueToBeConverted, scale);	1✔
103	}
104
105	@Override public void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info,
106	BitSet nullBitset, DataType pageType) {
107	// TODO we need to find way to directly set to vector with out conversion. This way is very
108	// inefficient.
109	CarbonColumnVector vector = info.vector;	1✔
110	int precision = info.measure.getMeasure().getPrecision();	1✔
111	int newMeasureScale = info.measure.getMeasure().getScale();	1✔
112	if (!(valuesToBeConverted instanceof byte[])) {	1✔
113	throw new UnsupportedOperationException("This object type " + valuesToBeConverted.getClass()	×
114	+ " is not supported in this method");
115	}
116	byte[] data = (byte[]) valuesToBeConverted;	1✔
117	if (pageType == DataTypes.BYTE) {	1✔
118	for (int i = 0; i < size; i++) {	1✔
119	if (nullBitset.get(i)) {	1✔
120	vector.putNull(i);	1✔
121	} else {
122	BigDecimal value = BigDecimal.valueOf(data[i], scale);	1✔
123	if (value.scale() < newMeasureScale) {	1✔
124	value = value.setScale(newMeasureScale);	1✔
125	}
126	vector.putDecimal(i, value, precision);	1✔
127	}
128	}
129	} else if (pageType == DataTypes.SHORT) {	1✔
130	for (int i = 0; i < size; i++) {	1✔
131	if (nullBitset.get(i)) {	1✔
132	vector.putNull(i);	1✔
133	} else {
134	BigDecimal value = BigDecimal	1✔
135	.valueOf(ByteUtil.toShortLittleEndian(data, i * DataTypes.SHORT.getSizeInBytes()),	1✔
136	scale);
137	if (value.scale() < newMeasureScale) {	1✔
138	value = value.setScale(newMeasureScale);	×
139	}
140	vector.putDecimal(i, value, precision);	1✔
141	}
142	}
143	} else if (pageType == DataTypes.SHORT_INT) {	1✔
144	for (int i = 0; i < size; i++) {	1✔
145	if (nullBitset.get(i)) {	1✔
146	vector.putNull(i);	1✔
147	} else {
148	BigDecimal value = BigDecimal	1✔
149	.valueOf(ByteUtil.valueOf3Bytes(data, i * DataTypes.SHORT_INT.getSizeInBytes()),	1✔
150	scale);
151	if (value.scale() < newMeasureScale) {	1✔
152	value = value.setScale(newMeasureScale);	×
153	}
154	vector.putDecimal(i, value, precision);	1✔
155	}
156	}
157	} else if (pageType == DataTypes.INT) {	1✔
158	for (int i = 0; i < size; i++) {	1✔
159	if (nullBitset.get(i)) {	1✔
160	vector.putNull(i);	×
161	} else {
162	BigDecimal value = BigDecimal	1✔
163	.valueOf(ByteUtil.toIntLittleEndian(data, i * DataTypes.INT.getSizeInBytes()),	1✔
164	scale);
165	if (value.scale() < newMeasureScale) {	1✔
166	value = value.setScale(newMeasureScale);	×
167	}
168	vector.putDecimal(i, value, precision);	1✔
169	}
170	}
171	} else if (pageType == DataTypes.LONG) {	1✔
172	for (int i = 0; i < size; i++) {	1✔
173	if (nullBitset.get(i)) {	1✔
174	vector.putNull(i);	×
175	} else {
176	BigDecimal value = BigDecimal	1✔
177	.valueOf(ByteUtil.toLongLittleEndian(data, i * DataTypes.LONG.getSizeInBytes()),	1✔
178	scale);
179	if (value.scale() < newMeasureScale) {	1✔
180	value = value.setScale(newMeasureScale);	×
181	}
182	vector.putDecimal(i, value, precision);	1✔
183	}
184	}
185	}
186	}	1✔
187
188	@Override public int getSize() {
189	return 4;	×
190	}
191
192	@Override public DecimalConverterType getDecimalConverterType() {
193	return DecimalConverterType.DECIMAL_INT;	1✔
194	}
195	}
196
197	public static class DecimalLongConverter extends DecimalIntConverter {
198
199	DecimalLongConverter(int scale) {
200	super(scale);	1✔
201	}	1✔
202
203	@Override public Object convert(BigDecimal decimal) {
204	return decimal.unscaledValue().longValue();	1✔
205	}
206
207	@Override public BigDecimal getDecimal(Object valueToBeConverted) {
208	return BigDecimal.valueOf((Long) valueToBeConverted, scale);	1✔
209	}
210
211	@Override public int getSize() {
212	return 8;	×
213	}
214
215	@Override public DecimalConverterType getDecimalConverterType() {
216	return DecimalConverterType.DECIMAL_LONG;	1✔
217	}
218	}
219
220	public class DecimalUnscaledConverter implements DecimalConverter {
221
222	private int scale;
223
224	private int numBytes;
225
226	private byte[] decimalBuffer = new byte[minBytesForPrecision[38]];	1✔
227
228	DecimalUnscaledConverter(int precision, int scale) {	1✔
229	this.scale = scale;	1✔
230	this.numBytes = minBytesForPrecision[precision];	1✔
231	}	1✔
232
233	@Override public Object convert(BigDecimal decimal) {
234	byte[] bytes = decimal.unscaledValue().toByteArray();	1✔
235	byte[] fixedLengthBytes = null;	1✔
236	if (bytes.length == numBytes) {	1✔
237	// If the length of the underlying byte array of the unscaled `BigInteger` happens to be
238	// `numBytes`, just reuse it, so that we don't bother copying it to `decimalBuffer`.
239	fixedLengthBytes = bytes;	1✔
240	} else {
241	// Otherwise, the length must be less than `numBytes`. In this case we copy contents of
242	// the underlying bytes with padding sign bytes to `decimalBuffer` to form the result
243	// fixed-length byte array.
244	byte signByte = 0;	1✔
245	if (bytes[0] < 0) {	1✔
246	signByte = (byte) -1;	1✔
247	} else {
248	signByte = (byte) 0;	1✔
249	}
250	Arrays.fill(decimalBuffer, 0, numBytes - bytes.length, signByte);	1✔
251	System.arraycopy(bytes, 0, decimalBuffer, numBytes - bytes.length, bytes.length);	1✔
252	fixedLengthBytes = decimalBuffer;	1✔
253	}
254	byte[] value = new byte[numBytes];	1✔
255	System.arraycopy(fixedLengthBytes, 0, value, 0, numBytes);	1✔
256	return value;	1✔
257	}
258
259	@Override public BigDecimal getDecimal(Object valueToBeConverted) {
260	BigInteger bigInteger = new BigInteger((byte[]) valueToBeConverted);	1✔
261	return new BigDecimal(bigInteger, scale);	1✔
262	}
263
264	@Override public void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info,
265	BitSet nullBitset, DataType pageType) {
266	CarbonColumnVector vector = info.vector;	1✔
267	int precision = info.measure.getMeasure().getPrecision();	1✔
268	int newMeasureScale = info.measure.getMeasure().getScale();	1✔
269	if (scale < newMeasureScale) {	1✔
270	scale = newMeasureScale;	×
271	}
272	if (valuesToBeConverted instanceof byte[][]) {	1✔
273	byte[][] data = (byte[][]) valuesToBeConverted;	1✔
274	for (int i = 0; i < size; i++) {	1✔
275	if (nullBitset.get(i)) {	1✔
276	vector.putNull(i);	1✔
277	} else {
278	BigInteger bigInteger = new BigInteger(data[i]);	1✔
279	BigDecimal value = new BigDecimal(bigInteger, scale);	1✔
280	if (value.scale() < newMeasureScale) {	1✔
281	value = value.setScale(newMeasureScale);	×
282	}
283	vector.putDecimal(i, value, precision);	1✔
284	}
285	}
286	}
287	}	1✔
288
289	@Override public int getSize() {
290	return numBytes;	1✔
291	}
292
293	@Override public DecimalConverterType getDecimalConverterType() {
294	return DecimalConverterType.DECIMAL_UNSCALED;	1✔
295	}
296	}
297
298	public static class LVBytesDecimalConverter implements DecimalConverter {	2✔
299
300	public static LVBytesDecimalConverter INSTANCE = new LVBytesDecimalConverter();	2✔
301
302	@Override public Object convert(BigDecimal decimal) {
303	return DataTypeUtil.bigDecimalToByte(decimal);	×
304	}
305
306	@Override public BigDecimal getDecimal(Object valueToBeConverted) {
307	return DataTypeUtil.byteToBigDecimal((byte[]) valueToBeConverted);	×
308	}
309
310	@Override public void fillVector(Object valuesToBeConverted, int size, ColumnVectorInfo info,
311	BitSet nullBitset, DataType pageType) {
312	CarbonColumnVector vector = info.vector;	×
313	int precision = info.measure.getMeasure().getPrecision();	×
314	int newMeasureScale = info.measure.getMeasure().getScale();	×
315	if (valuesToBeConverted instanceof byte[][]) {	×
316	byte[][] data = (byte[][]) valuesToBeConverted;	×
317	for (int i = 0; i < size; i++) {	×
318	if (nullBitset.get(i)) {	×
319	vector.putNull(i);	×
320	} else {
321	BigDecimal value = DataTypeUtil.byteToBigDecimal(data[i]);	×
322	if (value.scale() < newMeasureScale) {	×
323	value = value.setScale(newMeasureScale);	×
324	}
325	vector.putDecimal(i, value, precision);	×
326	}
327	}
328	}
329	}	×
330
331	@Override public int getSize() {
332	return -1;	×
333	}
334
335	@Override public DecimalConverterType getDecimalConverterType() {
336	return DecimalConverterType.DECIMAL_LV;	×
337	}
338	}
339
340	public DecimalConverter getDecimalConverter(int precision, int scale) {
341	if (precision < 0) {	2✔
342	return new LVBytesDecimalConverter();	2✔
343	} else if (precision <= 9) {	1✔
344	return new DecimalIntConverter(scale);	1✔
345	} else if (precision <= 18) {	1✔
346	return new DecimalLongConverter(scale);	1✔
347	} else {
348	return new DecimalUnscaledConverter(precision, scale);	1✔
349	}
350	}
351
352	}

apache / carbondata / 10164

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous