9967

Build # 9967

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/67bffe49f462ac265f1c3afa19785912bde91adc">67bffe49f<a href="https://github.com/apache/carbondata/commit/67bffe49f462ac265f1c3afa19785912bde91adc">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/8540be678301760bb003812557d6b9788b16751e">8540be678</a>">8540be678</a><a href="https://github.com/apache/carbondata/commit/67bffe49f462ac265f1c3afa19785912bde91adc"> into f599cb114">f599cb114</a>

Run Details

43 of 43 new or added lines in 9 files covered. (100.0%)

61668 of 77542 relevant lines covered (79.53%)

1.05 hits per line

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

57.14

/core/src/main/java/org/apache/carbondata/core/scan/result/vector/impl/CarbonColumnVectorImpl.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.scan.result.vector.impl;

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

import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;
import org.apache.carbondata.core.metadata.datatype.DecimalType;
import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
import org.apache.carbondata.core.scan.result.vector.CarbonDictionary;
import org.apache.carbondata.core.scan.scanner.LazyPageLoader;

public class CarbonColumnVectorImpl implements CarbonColumnVector {

  private Object[] data;

  private int[] ints;

  private long[] longs;

  private BigDecimal[] decimals;

  private byte[] byteArr;

  private byte[][] bytes;

  private float[] floats;

  private double[] doubles;

  private short[] shorts;

  protected BitSet nullBytes;

  private DataType dataType;

  private DataType blockDataType;

  private int[] lengths;

  private int[] offsets;

  private int batchSize;

  /**
   * True if there is at least one NULL byte set. This is an optimization for the writer, to skip
   * having to clear NULL bits.
   */
  protected boolean anyNullsSet;

  private CarbonDictionary carbonDictionary;

  private CarbonColumnVector dictionaryVector;

  private LazyPageLoader lazyPage;

  private boolean loaded;

  public CarbonColumnVectorImpl(int batchSize, DataType dataType) {
    this.batchSize = batchSize;
    nullBytes = new BitSet(batchSize);
    this.dataType = dataType;
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      byteArr = new byte[batchSize];
    } else if (dataType == DataTypes.SHORT) {
      shorts = new short[batchSize];
    } else if (dataType == DataTypes.INT || dataType == DataTypes.DATE) {
      ints = new int[batchSize];
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      longs = new long[batchSize];
    } else if (dataType == DataTypes.FLOAT) {
      floats = new float[batchSize];
    } else if (dataType == DataTypes.DOUBLE) {
      doubles = new double[batchSize];
    } else if (dataType instanceof DecimalType) {
      decimals = new BigDecimal[batchSize];
    } else if (dataType == DataTypes.STRING || dataType == DataTypes.BYTE_ARRAY
        || dataType == DataTypes.VARCHAR) {
      dictionaryVector = new CarbonColumnVectorImpl(batchSize, DataTypes.INT);
      bytes = new byte[batchSize][];
    } else {
      data = new Object[batchSize];
    }

  }

  @Override public void putBoolean(int rowId, boolean value) {
    byteArr[rowId] =  (byte)((value) ? 1 : 0);
  }

  @Override public void putFloat(int rowId, float value) {
    floats[rowId] = value;
  }

  @Override public void putShort(int rowId, short value) {
    shorts[rowId] = value;
  }

  @Override public void putShorts(int rowId, int count, short value) {
    for (int i = 0; i < count; ++i) {
      shorts[i + rowId] = value;
    }
  }

  @Override public void putInt(int rowId, int value) {
    ints[rowId] = value;
  }

  @Override public void putInts(int rowId, int count, int value) {
    for (int i = 0; i < count; ++i) {
      ints[i + rowId] = value;
    }
  }

  @Override public void putLong(int rowId, long value) {
    longs[rowId] = value;
  }

  @Override public void putLongs(int rowId, int count, long value) {
    for (int i = 0; i < count; ++i) {
      longs[i + rowId] = value;
    }
  }

  @Override public void putDecimal(int rowId, BigDecimal  value, int precision) {
    decimals[rowId] = value;
  }

  @Override public void putDecimals(int rowId, int count, BigDecimal value, int precision) {
    for (int i = 0; i < count; ++i) {
      decimals[i + rowId] = value;
    }
  }

  @Override public void putDouble(int rowId, double value) {
    doubles[rowId] = value;
  }

  @Override public void putDoubles(int rowId, int count, double value) {
    for (int i = 0; i < count; ++i) {
      doubles[i + rowId] = value;
    }
  }

  @Override public void putByteArray(int rowId, byte[] value) {
    bytes[rowId] = value;
  }

  @Override public void putByte(int rowId, byte value) {
    byteArr[rowId] = value;
  }

  @Override public void putByteArray(int rowId, int count, byte[] value) {
    for (int i = 0; i < count; ++i) {
      bytes[i + rowId] = value;
    }
  }

  @Override public void putByteArray(int rowId, int offset, int length, byte[] value) {
    bytes[rowId] = new byte[length];
    System.arraycopy(value, offset, bytes[rowId], 0, length);
  }

  @Override public void putNull(int rowId) {
    nullBytes.set(rowId);
    anyNullsSet = true;
  }

  @Override public void putNulls(int rowId, int count) {
    for (int i = 0; i < count; ++i) {
      nullBytes.set(rowId + i);
    }
    anyNullsSet = true;
  }

  @Override public void putNotNull(int rowId) {

  }

  @Override public void putNotNull(int rowId, int count) {

  }

  public boolean isNullAt(int rowId) {
    return nullBytes.get(rowId);
  }


  @Override public boolean isNull(int rowId) {
    return nullBytes.get(rowId);
  }

  @Override public void putObject(int rowId, Object obj) {
    data[rowId] = obj;
  }

  @Override public Object getData(int rowId) {
    if (!loaded) {
      loadPage();
    }
    if (nullBytes.get(rowId)) {
      return null;
    }
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      return  byteArr[rowId];
    } else if (dataType == DataTypes.SHORT) {
      return shorts[rowId];
    } else if (dataType == DataTypes.INT || dataType == DataTypes.DATE) {
      return ints[rowId];
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      return longs[rowId];
    } else if (dataType == DataTypes.FLOAT) {
      return floats[rowId];
    } else if (dataType == DataTypes.DOUBLE) {
      return doubles[rowId];
    } else if (dataType instanceof DecimalType) {
      return decimals[rowId];
    } else if (dataType == DataTypes.STRING || dataType == DataTypes.BYTE_ARRAY
        || dataType == DataTypes.VARCHAR) {
      if (null != carbonDictionary) {
        int dictKey = (Integer) dictionaryVector.getData(rowId);
        return carbonDictionary.getDictionaryValue(dictKey);
      } else if (byteArr != null) {
        byte[] bytes = new byte[lengths[rowId]];
        System.arraycopy(byteArr, offsets[rowId], bytes, 0, bytes.length);
        return bytes;
      } else {
        return bytes[rowId];
      }
    } else {
      return data[rowId];
    }
  }

  public Object getDataArray() {
    if (!loaded) {
      loadPage();
    }
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      return  byteArr;
    } else if (dataType == DataTypes.SHORT) {
      return shorts;
    } else if (dataType == DataTypes.INT) {
      return ints;
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      return longs;
    } else if (dataType == DataTypes.FLOAT) {
      return floats;
    } else if (dataType == DataTypes.DOUBLE) {
      return doubles;
    } else if (dataType instanceof DecimalType) {
      return decimals;
    } else if (dataType == DataTypes.STRING || dataType == DataTypes.BYTE_ARRAY || dataType ==
        DataTypes.VARCHAR) {
      if (null != carbonDictionary) {
        return ints;
      }
      return bytes;
    } else {
      return data;
    }
  }

  @Override public void reset() {
    nullBytes.clear();
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      Arrays.fill(byteArr, (byte) 0);
    } else if (dataType == DataTypes.SHORT) {
      Arrays.fill(shorts, (short) 0);
    } else if (dataType == DataTypes.INT || dataType == DataTypes.DATE) {
      Arrays.fill(ints, 0);
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      Arrays.fill(longs, 0);
    } else if (dataType == DataTypes.FLOAT) {
      Arrays.fill(floats, 0);
    } else if (dataType == DataTypes.DOUBLE) {
      Arrays.fill(doubles, 0);
    } else if (dataType instanceof DecimalType) {
      Arrays.fill(decimals, null);
    } else if (dataType == DataTypes.STRING || dataType == DataTypes.BYTE_ARRAY
        || dataType == DataTypes.VARCHAR) {
      Arrays.fill(bytes, null);
      this.dictionaryVector.reset();
    } else {
      Arrays.fill(data, null);
    }
    loaded = false;

  }

  @Override public DataType getType() {
    return dataType;
  }

  @Override
  public DataType getBlockDataType() {
    return blockDataType;
  }

  @Override
  public void setBlockDataType(DataType blockDataType) {
    this.blockDataType = blockDataType;
  }

  @Override public void setFilteredRowsExist(boolean filteredRowsExist) {

  }

  @Override public void setDictionary(CarbonDictionary dictionary) {
    this.carbonDictionary = dictionary;
  }

  @Override public boolean hasDictionary() {
    return null != this.carbonDictionary;
  }

  @Override public CarbonColumnVector getDictionaryVector() {
    return dictionaryVector;
  }

  /**
   * Returns true if any of the nulls indicator are set for this column. This can be used
   * as an optimization to prevent setting nulls.
   */
  public final boolean anyNullsSet() { return anyNullsSet; }

  @Override public void putFloats(int rowId, int count, float[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      floats[rowId ++] = src[i];
    }
  }

  @Override public void putShorts(int rowId, int count, short[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      shorts[rowId ++] = src[i];
    }
  }

  @Override public void putInts(int rowId, int count, int[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      ints[rowId ++] = src[i];
    }
  }

  @Override public void putLongs(int rowId, int count, long[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      longs[rowId ++] = src[i];
    }
  }

  @Override public void putDoubles(int rowId, int count, double[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      doubles[rowId ++] = src[i];
    }
  }

  @Override public void putBytes(int rowId, int count, byte[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      byteArr[rowId ++] = src[i];
    }
  }

  @Override public void setLazyPage(LazyPageLoader lazyPage) {
    this.lazyPage = lazyPage;
  }

  public void loadPage() {
    if (lazyPage != null) {
      lazyPage.loadPage();
    }
    loaded = true;
  }

  @Override public void putArray(int rowId, int offset, int length) {
    if (offsets == null) {
      offsets = new int[batchSize];
      lengths = new int[batchSize];
    }
    offsets[rowId] = offset;
    lengths[rowId] = length;
  }

  @Override public void putAllByteArray(byte[] data, int offset, int length) {
    byteArr = data;
  }

  public int[] getLengths() {
    return lengths;
  }

  public int[] getOffsets() {
    return offsets;
  }
}

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.scan.result.vector.impl;
18
19	import java.math.BigDecimal;
20	import java.util.Arrays;
21	import java.util.BitSet;
22
23	import org.apache.carbondata.core.metadata.datatype.DataType;
24	import org.apache.carbondata.core.metadata.datatype.DataTypes;
25	import org.apache.carbondata.core.metadata.datatype.DecimalType;
26	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
27	import org.apache.carbondata.core.scan.result.vector.CarbonDictionary;
28	import org.apache.carbondata.core.scan.scanner.LazyPageLoader;
29
30	public class CarbonColumnVectorImpl implements CarbonColumnVector {
31
32	private Object[] data;
33
34	private int[] ints;
35
36	private long[] longs;
37
38	private BigDecimal[] decimals;
39
40	private byte[] byteArr;
41
42	private byte[][] bytes;
43
44	private float[] floats;
45
46	private double[] doubles;
47
48	private short[] shorts;
49
50	protected BitSet nullBytes;
51
52	private DataType dataType;
53
54	private DataType blockDataType;
55
56	private int[] lengths;
57
58	private int[] offsets;
59
60	private int batchSize;
61
62	/**
63	* True if there is at least one NULL byte set. This is an optimization for the writer, to skip
64	* having to clear NULL bits.
65	*/
66	protected boolean anyNullsSet;
67
68	private CarbonDictionary carbonDictionary;
69
70	private CarbonColumnVector dictionaryVector;
71
72	private LazyPageLoader lazyPage;
73
74	private boolean loaded;
75
76	public CarbonColumnVectorImpl(int batchSize, DataType dataType) {	1✔
77	this.batchSize = batchSize;	1✔
78	nullBytes = new BitSet(batchSize);	1✔
79	this.dataType = dataType;	1✔
80	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	1✔
81	byteArr = new byte[batchSize];	1✔
82	} else if (dataType == DataTypes.SHORT) {	1✔
83	shorts = new short[batchSize];	1✔
84	} else if (dataType == DataTypes.INT \|\| dataType == DataTypes.DATE) {	1✔
85	ints = new int[batchSize];	1✔
86	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	1✔
87	longs = new long[batchSize];	1✔
88	} else if (dataType == DataTypes.FLOAT) {	1✔
89	floats = new float[batchSize];	1✔
90	} else if (dataType == DataTypes.DOUBLE) {	1✔
91	doubles = new double[batchSize];	1✔
92	} else if (dataType instanceof DecimalType) {	1✔
93	decimals = new BigDecimal[batchSize];	1✔
94	} else if (dataType == DataTypes.STRING \|\| dataType == DataTypes.BYTE_ARRAY	1✔
95	\|\| dataType == DataTypes.VARCHAR) {
96	dictionaryVector = new CarbonColumnVectorImpl(batchSize, DataTypes.INT);	1✔
97	bytes = new byte[batchSize][];	1✔
98	} else {
99	data = new Object[batchSize];	×
100	}
101
102	}	1✔
103
104	@Override public void putBoolean(int rowId, boolean value) {
105	byteArr[rowId] = (byte)((value) ? 1 : 0);	×
106	}	×
107
108	@Override public void putFloat(int rowId, float value) {
109	floats[rowId] = value;	1✔
110	}	1✔
111
112	@Override public void putShort(int rowId, short value) {
113	shorts[rowId] = value;	1✔
114	}	1✔
115
116	@Override public void putShorts(int rowId, int count, short value) {
117	for (int i = 0; i < count; ++i) {	×
118	shorts[i + rowId] = value;	×
119	}
120	}	×
121
122	@Override public void putInt(int rowId, int value) {
123	ints[rowId] = value;	1✔
124	}	1✔
125
126	@Override public void putInts(int rowId, int count, int value) {
127	for (int i = 0; i < count; ++i) {	×
128	ints[i + rowId] = value;	×
129	}
130	}	×
131
132	@Override public void putLong(int rowId, long value) {
133	longs[rowId] = value;	1✔
134	}	1✔
135
136	@Override public void putLongs(int rowId, int count, long value) {
137	for (int i = 0; i < count; ++i) {	×
138	longs[i + rowId] = value;	×
139	}
140	}	×
141
142	@Override public void putDecimal(int rowId, BigDecimal value, int precision) {
143	decimals[rowId] = value;	1✔
144	}	1✔
145
146	@Override public void putDecimals(int rowId, int count, BigDecimal value, int precision) {
147	for (int i = 0; i < count; ++i) {	×
148	decimals[i + rowId] = value;	×
149	}
150	}	×
151
152	@Override public void putDouble(int rowId, double value) {
153	doubles[rowId] = value;	1✔
154	}	1✔
155
156	@Override public void putDoubles(int rowId, int count, double value) {
157	for (int i = 0; i < count; ++i) {	×
158	doubles[i + rowId] = value;	×
159	}
160	}	×
161
162	@Override public void putByteArray(int rowId, byte[] value) {
163	bytes[rowId] = value;	×
164	}	×
165
166	@Override public void putByte(int rowId, byte value) {
167	byteArr[rowId] = value;	×
168	}	×
169
170	@Override public void putByteArray(int rowId, int count, byte[] value) {
171	for (int i = 0; i < count; ++i) {	×
172	bytes[i + rowId] = value;	×
173	}
174	}	×
175
176	@Override public void putByteArray(int rowId, int offset, int length, byte[] value) {
177	bytes[rowId] = new byte[length];	1✔
178	System.arraycopy(value, offset, bytes[rowId], 0, length);	1✔
179	}	1✔
180
181	@Override public void putNull(int rowId) {
182	nullBytes.set(rowId);	1✔
183	anyNullsSet = true;	1✔
184	}	1✔
185
186	@Override public void putNulls(int rowId, int count) {
187	for (int i = 0; i < count; ++i) {	×
188	nullBytes.set(rowId + i);	×
189	}
190	anyNullsSet = true;	×
191	}	×
192
193	@Override public void putNotNull(int rowId) {
194
195	}	×
196
197	@Override public void putNotNull(int rowId, int count) {
198
199	}	×
200
201	public boolean isNullAt(int rowId) {
202	return nullBytes.get(rowId);	×
203	}
204
205
206	@Override public boolean isNull(int rowId) {
207	return nullBytes.get(rowId);	×
208	}
209
210	@Override public void putObject(int rowId, Object obj) {
211	data[rowId] = obj;	×
212	}	×
213
214	@Override public Object getData(int rowId) {
215	if (!loaded) {	1✔
216	loadPage();	1✔
217	}
218	if (nullBytes.get(rowId)) {	1✔
219	return null;	1✔
220	}
221	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	1✔
222	return byteArr[rowId];	1✔
223	} else if (dataType == DataTypes.SHORT) {	1✔
224	return shorts[rowId];	1✔
225	} else if (dataType == DataTypes.INT \|\| dataType == DataTypes.DATE) {	1✔
226	return ints[rowId];	1✔
227	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	1✔
228	return longs[rowId];	1✔
229	} else if (dataType == DataTypes.FLOAT) {	1✔
230	return floats[rowId];	1✔
231	} else if (dataType == DataTypes.DOUBLE) {	1✔
232	return doubles[rowId];	1✔
233	} else if (dataType instanceof DecimalType) {	1✔
234	return decimals[rowId];	1✔
235	} else if (dataType == DataTypes.STRING \|\| dataType == DataTypes.BYTE_ARRAY	1✔
236	\|\| dataType == DataTypes.VARCHAR) {
237	if (null != carbonDictionary) {	1✔
238	int dictKey = (Integer) dictionaryVector.getData(rowId);	×
239	return carbonDictionary.getDictionaryValue(dictKey);	×
240	} else if (byteArr != null) {	1✔
241	byte[] bytes = new byte[lengths[rowId]];	1✔
242	System.arraycopy(byteArr, offsets[rowId], bytes, 0, bytes.length);	1✔
243	return bytes;	1✔
244	} else {
245	return bytes[rowId];	1✔
246	}
247	} else {
248	return data[rowId];	×
249	}
250	}
251
252	public Object getDataArray() {
253	if (!loaded) {	×
254	loadPage();	×
255	}
256	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	×
257	return byteArr;	×
258	} else if (dataType == DataTypes.SHORT) {	×
259	return shorts;	×
260	} else if (dataType == DataTypes.INT) {	×
261	return ints;	×
262	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	×
263	return longs;	×
264	} else if (dataType == DataTypes.FLOAT) {	×
265	return floats;	×
266	} else if (dataType == DataTypes.DOUBLE) {	×
267	return doubles;	×
268	} else if (dataType instanceof DecimalType) {	×
269	return decimals;	×
270	} else if (dataType == DataTypes.STRING \|\| dataType == DataTypes.BYTE_ARRAY \|\| dataType ==	×
271	DataTypes.VARCHAR) {
272	if (null != carbonDictionary) {	×
273	return ints;	×
274	}
275	return bytes;	×
276	} else {
277	return data;	×
278	}
279	}
280
281	@Override public void reset() {
282	nullBytes.clear();	1✔
283	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	1✔
284	Arrays.fill(byteArr, (byte) 0);	1✔
285	} else if (dataType == DataTypes.SHORT) {	1✔
286	Arrays.fill(shorts, (short) 0);	1✔
287	} else if (dataType == DataTypes.INT \|\| dataType == DataTypes.DATE) {	1✔
288	Arrays.fill(ints, 0);	1✔
289	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	1✔
290	Arrays.fill(longs, 0);	1✔
291	} else if (dataType == DataTypes.FLOAT) {	1✔
292	Arrays.fill(floats, 0);	1✔
293	} else if (dataType == DataTypes.DOUBLE) {	1✔
294	Arrays.fill(doubles, 0);	1✔
295	} else if (dataType instanceof DecimalType) {	1✔
296	Arrays.fill(decimals, null);	1✔
297	} else if (dataType == DataTypes.STRING \|\| dataType == DataTypes.BYTE_ARRAY	1✔
298	\|\| dataType == DataTypes.VARCHAR) {
299	Arrays.fill(bytes, null);	1✔
300	this.dictionaryVector.reset();	1✔
301	} else {
302	Arrays.fill(data, null);	×
303	}
304	loaded = false;	1✔
305
306	}	1✔
307
308	@Override public DataType getType() {
309	return dataType;	1✔
310	}
311
312	@Override
313	public DataType getBlockDataType() {
314	return blockDataType;	1✔
315	}
316
317	@Override
318	public void setBlockDataType(DataType blockDataType) {
319	this.blockDataType = blockDataType;	1✔
320	}	1✔
321
322	@Override public void setFilteredRowsExist(boolean filteredRowsExist) {
323
324	}	×
325
326	@Override public void setDictionary(CarbonDictionary dictionary) {
327	this.carbonDictionary = dictionary;	1✔
328	}	1✔
329
330	@Override public boolean hasDictionary() {
331	return null != this.carbonDictionary;	×
332	}
333
334	@Override public CarbonColumnVector getDictionaryVector() {
335	return dictionaryVector;	×
336	}
337
338	/**
339	* Returns true if any of the nulls indicator are set for this column. This can be used
340	* as an optimization to prevent setting nulls.
341	*/
342	public final boolean anyNullsSet() { return anyNullsSet; }	×
343
344	@Override public void putFloats(int rowId, int count, float[] src, int srcIndex) {
345	for (int i = srcIndex; i < count; i++) {	×
346	floats[rowId ++] = src[i];	×
347	}
348	}	×
349
350	@Override public void putShorts(int rowId, int count, short[] src, int srcIndex) {
351	for (int i = srcIndex; i < count; i++) {	×
352	shorts[rowId ++] = src[i];	×
353	}
354	}	×
355
356	@Override public void putInts(int rowId, int count, int[] src, int srcIndex) {
357	for (int i = srcIndex; i < count; i++) {	×
358	ints[rowId ++] = src[i];	×
359	}
360	}	×
361
362	@Override public void putLongs(int rowId, int count, long[] src, int srcIndex) {
363	for (int i = srcIndex; i < count; i++) {	×
364	longs[rowId ++] = src[i];	×
365	}
366	}	×
367
368	@Override public void putDoubles(int rowId, int count, double[] src, int srcIndex) {
369	for (int i = srcIndex; i < count; i++) {	×
370	doubles[rowId ++] = src[i];	×
371	}
372	}	×
373
374	@Override public void putBytes(int rowId, int count, byte[] src, int srcIndex) {
375	for (int i = srcIndex; i < count; i++) {	1✔
376	byteArr[rowId ++] = src[i];	1✔
377	}
378	}	1✔
379
380	@Override public void setLazyPage(LazyPageLoader lazyPage) {
381	this.lazyPage = lazyPage;	1✔
382	}	1✔
383
384	public void loadPage() {
385	if (lazyPage != null) {	1✔
386	lazyPage.loadPage();	1✔
387	}
388	loaded = true;	1✔
389	}	1✔
390
391	@Override public void putArray(int rowId, int offset, int length) {
392	if (offsets == null) {	1✔
393	offsets = new int[batchSize];	1✔
394	lengths = new int[batchSize];	1✔
395	}
396	offsets[rowId] = offset;	1✔
397	lengths[rowId] = length;	1✔
398	}	1✔
399
400	@Override public void putAllByteArray(byte[] data, int offset, int length) {
401	byteArr = data;	1✔
402	}	1✔
403
404	public int[] getLengths() {
405	return lengths;	×
406	}
407
408	public int[] getOffsets() {
409	return offsets;	×
410	}
411	}

apache / carbondata / 9967

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