3821

Build # 3821

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/4aba6b98b854cf7ab08db8344c51194a51efb9d2">4aba6b98b<a href="https://github.com/apache/carbondata/commit/4aba6b98b854cf7ab08db8344c51194a51efb9d2">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/a166b143604d35166bc9d0950a3da352c3fa4619">a166b1436</a>">a166b1436</a><a href="https://github.com/apache/carbondata/commit/4aba6b98b854cf7ab08db8344c51194a51efb9d2"> into 581591a38">581591a38</a>

Run Details

64092 of 82887 relevant lines covered (77.32%)

1.01 hits per line

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

78.95

/core/src/main/java/org/apache/carbondata/core/datastore/chunk/store/ColumnPageWrapper.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.datastore.chunk.store;


import java.util.BitSet;

import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datastore.ColumnType;
import org.apache.carbondata.core.datastore.chunk.DimensionColumnPage;
import org.apache.carbondata.core.datastore.page.ColumnPage;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;
import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
import org.apache.carbondata.core.scan.result.vector.CarbonDictionary;
import org.apache.carbondata.core.scan.result.vector.ColumnVectorInfo;
import org.apache.carbondata.core.util.ByteUtil;
import org.apache.carbondata.core.util.CarbonUtil;
import org.apache.carbondata.core.util.DataTypeUtil;


public class ColumnPageWrapper implements DimensionColumnPage {

  private ColumnPage columnPage;

  private CarbonDictionary localDictionary;

  private boolean isAdaptivePrimitivePage;

  private int[] invertedIndex;

  private int[] invertedReverseIndex;

  private boolean isExplicitSorted;

  public ColumnPageWrapper(ColumnPage columnPage, CarbonDictionary localDictionary,
      int[] invertedIndex, int[] invertedReverseIndex, boolean isAdaptivePrimitivePage,
      boolean isExplicitSorted) {
    this.columnPage = columnPage;
    this.localDictionary = localDictionary;
    this.invertedIndex = invertedIndex;
    this.invertedReverseIndex = invertedReverseIndex;
    this.isAdaptivePrimitivePage = isAdaptivePrimitivePage;
    this.isExplicitSorted = isExplicitSorted;
  }

  @Override
  public int fillRawData(int rowId, int offset, byte[] data) {
    throw new UnsupportedOperationException("internal error");
  }

  @Override
  public int fillSurrogateKey(int rowId, int chunkIndex, int[] outputSurrogateKey) {
    throw new UnsupportedOperationException("internal error");
  }

  @Override
  public int fillVector(ColumnVectorInfo[] vectorInfo, int chunkIndex) {
    ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];
    CarbonColumnVector vector = columnVectorInfo.vector;
    int offset = columnVectorInfo.offset;
    int vectorOffset = columnVectorInfo.vectorOffset;
    int len = offset + columnVectorInfo.size;
    for (int i = offset; i < len; i++) {
      fillRow(i, vector, vectorOffset++);
    }
    return chunkIndex + 1;
  }

  @Override
  public int fillVector(int[] filteredRowId, ColumnVectorInfo[] vectorInfo, int chunkIndex) {
    ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];
    CarbonColumnVector vector = columnVectorInfo.vector;
    int offset = columnVectorInfo.offset;
    int vectorOffset = columnVectorInfo.vectorOffset;
    int len = offset + columnVectorInfo.size;
    for (int i = offset; i < len; i++) {
      fillRow(filteredRowId[i], vector, vectorOffset++);
    }
    return chunkIndex + 1;
  }

  @Override public byte[] getChunkData(int rowId) {
    byte[] nullBitSet = getNullBitSet(rowId, columnPage.getColumnSpec().getColumnType());
    if (nullBitSet != null) {
      // if this row is null, return default null represent in byte array
      return nullBitSet;
    } else {
      if (isExplicitSorted()) {
        rowId = getInvertedReverseIndex(rowId);
      }
      return getChunkDataInBytes(rowId);
    }
  }

  private byte[] getChunkDataInBytes(int rowId) {
    ColumnType columnType = columnPage.getColumnSpec().getColumnType();
    DataType srcDataType = columnPage.getColumnSpec().getSchemaDataType();
    DataType targetDataType = columnPage.getDataType();
    if (null != localDictionary) {
      return localDictionary
          .getDictionaryValue(CarbonUtil.getSurrogateInternal(columnPage.getBytes(rowId), 0, 3));
    } else if ((columnType == ColumnType.COMPLEX_PRIMITIVE && isAdaptiveEncoded()) || (
        columnType == ColumnType.PLAIN_VALUE && DataTypeUtil.isPrimitiveColumn(srcDataType))) {
      if (srcDataType == DataTypes.FLOAT) {
        float floatData = columnPage.getFloat(rowId);
        return ByteUtil.toXorBytes(floatData);
      } else if (srcDataType == DataTypes.DOUBLE) {
        double doubleData = columnPage.getDouble(rowId);
        return ByteUtil.toXorBytes(doubleData);
      } else if (DataTypes.isDecimal(srcDataType)) {
        throw new RuntimeException("unsupported type: " + srcDataType);
      } else if ((srcDataType == DataTypes.BYTE) || (srcDataType == DataTypes.BOOLEAN) || (
          srcDataType == DataTypes.SHORT) || (srcDataType == DataTypes.SHORT_INT) || (srcDataType
          == DataTypes.INT) || (srcDataType == DataTypes.LONG) || (srcDataType
          == DataTypes.TIMESTAMP)) {
        long longData = columnPage.getLong(rowId);
        if ((srcDataType == DataTypes.BYTE)) {
          byte out = (byte) longData;
          return new byte[] { out };
        } else if (srcDataType == DataTypes.BOOLEAN) {
          byte out = (byte) longData;
          return ByteUtil.toBytes(ByteUtil.toBoolean(out));
        } else if (srcDataType == DataTypes.SHORT) {
          short out = (short) longData;
          return ByteUtil.toXorBytes(out);
        } else if (srcDataType == DataTypes.SHORT_INT) {
          int out = (int) longData;
          return ByteUtil.toXorBytes(out);
        } else if (srcDataType == DataTypes.INT) {
          int out = (int) longData;
          return ByteUtil.toXorBytes(out);
        } else {
          // timestamp and long
          return ByteUtil.toXorBytes(longData);
        }
      } else if ((targetDataType == DataTypes.STRING) || (targetDataType == DataTypes.VARCHAR) || (
          targetDataType == DataTypes.BYTE_ARRAY)) {
        return columnPage.getBytes(rowId);
      } else {
        throw new RuntimeException("unsupported type: " + targetDataType);
      }
    } else if ((columnType == ColumnType.COMPLEX_PRIMITIVE && !isAdaptiveEncoded())) {
      if ((srcDataType == DataTypes.BYTE) || (srcDataType == DataTypes.BOOLEAN)) {
        byte[] out = new byte[1];
        out[0] = (columnPage.getByte(rowId));
        return ByteUtil.toBytes(ByteUtil.toBoolean(out));
      } else if (srcDataType == DataTypes.BYTE_ARRAY) {
        return columnPage.getBytes(rowId);
      } else if (srcDataType == DataTypes.DOUBLE) {
        return ByteUtil.toXorBytes(columnPage.getDouble(rowId));
      } else if (srcDataType == DataTypes.FLOAT) {
        return ByteUtil.toXorBytes(columnPage.getFloat(rowId));
      } else if (srcDataType == targetDataType) {
        return columnPage.getBytes(rowId);
      } else {
        throw new RuntimeException("unsupported type: " + targetDataType);
      }
    } else {
      return columnPage.getBytes(rowId);
    }
  }

  private byte[] getNullBitSet(int rowId, ColumnType columnType) {
    if (columnPage.getNullBits().get(rowId) && columnType == ColumnType.COMPLEX_PRIMITIVE) {
      // if this row is null, return default null represent in byte array
      return CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY;
    }
    if (columnPage.getNullBits().get(rowId)) {
      // if this row is null, return default null represent in byte array
      return CarbonCommonConstants.EMPTY_BYTE_ARRAY;
    }
    return null;
  }

  /**
   * Fill the data to the vector
   *
   * @param rowId
   * @param vector
   * @param vectorRow
   */
  private void fillRow(int rowId, CarbonColumnVector vector, int vectorRow) {
    if (columnPage.getNullBits().get(rowId)) {
      vector.putNull(vectorRow);
    } else {
      if (isExplicitSorted) {
        rowId = invertedReverseIndex[rowId];
      }
      DataType dt = vector.getType();
      long longData = columnPage.getLong(rowId);
      if (dt == DataTypes.BOOLEAN) {
        vector.putBoolean(vectorRow, ByteUtil.toBoolean((byte) longData));
      } else if (dt == DataTypes.BYTE) {
        vector.putByte(vectorRow, (byte) longData);
      } else if (dt == DataTypes.SHORT) {
        vector.putShort(vectorRow, (short) longData);
      } else if (dt == DataTypes.INT) {
        vector.putInt(vectorRow, (int) longData);
      } else if (dt == DataTypes.LONG) {
        // retrieving the data after change in data type restructure operation
        if (vector.getBlockDataType() == DataTypes.INT) {
          vector.putLong(vectorRow, (int) longData);
        } else if (vector.getBlockDataType() == DataTypes.LONG) {
          vector.putLong(vectorRow, longData);
        }
      } else if (dt == DataTypes.TIMESTAMP) {
        vector.putLong(vectorRow, longData * 1000L);
      } else {
        throw new RuntimeException("unsupported type: " + dt);
      }
    }
  }

  @Override
  public int getInvertedIndex(int rowId) {
    return invertedIndex[rowId];
  }

  @Override
  public int getInvertedReverseIndex(int rowId) {
    return invertedReverseIndex[rowId];
  }

  @Override
  public boolean isNoDicitionaryColumn() {
    return true;
  }

  @Override
  public boolean isExplicitSorted() {
    return isExplicitSorted;
  }

  @Override
  public int compareTo(int rowId, byte[] compareValue) {
    // rowId is the inverted index, but the null bitset is based on actual data
    int nullBitSetRowId = rowId;
    if (isExplicitSorted()) {
      nullBitSetRowId = getInvertedIndex(rowId);
    }
    byte[] nullBitSet = getNullBitSet(nullBitSetRowId, columnPage.getColumnSpec().getColumnType());
    if (nullBitSet != null
        && ByteUtil.UnsafeComparer.INSTANCE.compareTo(nullBitSet, compareValue) == 0) {
      // check if the compare value is a null value
      // if the compare value is null and the data is also null we can directly return 0
      return 0;
    } else {
      byte[] chunkData;
      if (nullBitSet != null && nullBitSet.length == 0) {
        chunkData = nullBitSet;
      } else {
        chunkData = this.getChunkDataInBytes(rowId);
      }
      return ByteUtil.UnsafeComparer.INSTANCE.compareTo(chunkData, compareValue);
    }
  }

  @Override
  public void freeMemory() {
    if (null != columnPage) {
      columnPage.freeMemory();
      columnPage = null;
    }
  }

  @Override public boolean isAdaptiveEncoded() {
    return isAdaptivePrimitivePage;
  }

  @Override public BitSet getNullBits() {
    return columnPage.getNullBits();
  }

}

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
18	package org.apache.carbondata.core.datastore.chunk.store;
19
20
21	import java.util.BitSet;
22
23	import org.apache.carbondata.core.constants.CarbonCommonConstants;
24	import org.apache.carbondata.core.datastore.ColumnType;
25	import org.apache.carbondata.core.datastore.chunk.DimensionColumnPage;
26	import org.apache.carbondata.core.datastore.page.ColumnPage;
27	import org.apache.carbondata.core.metadata.datatype.DataType;
28	import org.apache.carbondata.core.metadata.datatype.DataTypes;
29	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
30	import org.apache.carbondata.core.scan.result.vector.CarbonDictionary;
31	import org.apache.carbondata.core.scan.result.vector.ColumnVectorInfo;
32	import org.apache.carbondata.core.util.ByteUtil;
33	import org.apache.carbondata.core.util.CarbonUtil;
34	import org.apache.carbondata.core.util.DataTypeUtil;
35
36
37	public class ColumnPageWrapper implements DimensionColumnPage {
38
39	private ColumnPage columnPage;
40
41	private CarbonDictionary localDictionary;
42
43	private boolean isAdaptivePrimitivePage;
44
45	private int[] invertedIndex;
46
47	private int[] invertedReverseIndex;
48
49	private boolean isExplicitSorted;
50
51	public ColumnPageWrapper(ColumnPage columnPage, CarbonDictionary localDictionary,
52	int[] invertedIndex, int[] invertedReverseIndex, boolean isAdaptivePrimitivePage,
53	boolean isExplicitSorted) {	1✔
54	this.columnPage = columnPage;	1✔
55	this.localDictionary = localDictionary;	1✔
56	this.invertedIndex = invertedIndex;	1✔
57	this.invertedReverseIndex = invertedReverseIndex;	1✔
58	this.isAdaptivePrimitivePage = isAdaptivePrimitivePage;	1✔
59	this.isExplicitSorted = isExplicitSorted;	1✔
60	}	1✔
61
62	@Override
63	public int fillRawData(int rowId, int offset, byte[] data) {
64	throw new UnsupportedOperationException("internal error");	×
65	}
66
67	@Override
68	public int fillSurrogateKey(int rowId, int chunkIndex, int[] outputSurrogateKey) {
69	throw new UnsupportedOperationException("internal error");	×
70	}
71
72	@Override
73	public int fillVector(ColumnVectorInfo[] vectorInfo, int chunkIndex) {
74	ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];	1✔
75	CarbonColumnVector vector = columnVectorInfo.vector;	1✔
76	int offset = columnVectorInfo.offset;	1✔
77	int vectorOffset = columnVectorInfo.vectorOffset;	1✔
78	int len = offset + columnVectorInfo.size;	1✔
79	for (int i = offset; i < len; i++) {	1✔
80	fillRow(i, vector, vectorOffset++);	1✔
81	}
82	return chunkIndex + 1;	1✔
83	}
84
85	@Override
86	public int fillVector(int[] filteredRowId, ColumnVectorInfo[] vectorInfo, int chunkIndex) {
87	ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];	1✔
88	CarbonColumnVector vector = columnVectorInfo.vector;	1✔
89	int offset = columnVectorInfo.offset;	1✔
90	int vectorOffset = columnVectorInfo.vectorOffset;	1✔
91	int len = offset + columnVectorInfo.size;	1✔
92	for (int i = offset; i < len; i++) {	1✔
93	fillRow(filteredRowId[i], vector, vectorOffset++);	1✔
94	}
95	return chunkIndex + 1;	1✔
96	}
97
98	@Override public byte[] getChunkData(int rowId) {
99	byte[] nullBitSet = getNullBitSet(rowId, columnPage.getColumnSpec().getColumnType());	1✔
100	if (nullBitSet != null) {	1✔
101	// if this row is null, return default null represent in byte array
102	return nullBitSet;	1✔
103	} else {
104	if (isExplicitSorted()) {	1✔
105	rowId = getInvertedReverseIndex(rowId);	×
106	}
107	return getChunkDataInBytes(rowId);	1✔
108	}
109	}
110
111	private byte[] getChunkDataInBytes(int rowId) {
112	ColumnType columnType = columnPage.getColumnSpec().getColumnType();	1✔
113	DataType srcDataType = columnPage.getColumnSpec().getSchemaDataType();	1✔
114	DataType targetDataType = columnPage.getDataType();	1✔
115	if (null != localDictionary) {	1✔
116	return localDictionary	1✔
117	.getDictionaryValue(CarbonUtil.getSurrogateInternal(columnPage.getBytes(rowId), 0, 3));	1✔
118	} else if ((columnType == ColumnType.COMPLEX_PRIMITIVE && isAdaptiveEncoded()) \|\| (	1✔
119	columnType == ColumnType.PLAIN_VALUE && DataTypeUtil.isPrimitiveColumn(srcDataType))) {	1✔
120	if (srcDataType == DataTypes.FLOAT) {	1✔
121	float floatData = columnPage.getFloat(rowId);	×
122	return ByteUtil.toXorBytes(floatData);	×
123	} else if (srcDataType == DataTypes.DOUBLE) {	1✔
124	double doubleData = columnPage.getDouble(rowId);	1✔
125	return ByteUtil.toXorBytes(doubleData);	1✔
126	} else if (DataTypes.isDecimal(srcDataType)) {	1✔
127	throw new RuntimeException("unsupported type: " + srcDataType);	×
128	} else if ((srcDataType == DataTypes.BYTE) \|\| (srcDataType == DataTypes.BOOLEAN) \|\| (	1✔
129	srcDataType == DataTypes.SHORT) \|\| (srcDataType == DataTypes.SHORT_INT) \|\| (srcDataType
130	== DataTypes.INT) \|\| (srcDataType == DataTypes.LONG) \|\| (srcDataType
131	== DataTypes.TIMESTAMP)) {
132	long longData = columnPage.getLong(rowId);	1✔
133	if ((srcDataType == DataTypes.BYTE)) {	1✔
134	byte out = (byte) longData;	×
135	return new byte[] { out };	×
136	} else if (srcDataType == DataTypes.BOOLEAN) {	1✔
137	byte out = (byte) longData;	1✔
138	return ByteUtil.toBytes(ByteUtil.toBoolean(out));	1✔
139	} else if (srcDataType == DataTypes.SHORT) {	1✔
140	short out = (short) longData;	1✔
141	return ByteUtil.toXorBytes(out);	1✔
142	} else if (srcDataType == DataTypes.SHORT_INT) {	1✔
143	int out = (int) longData;	×
144	return ByteUtil.toXorBytes(out);	×
145	} else if (srcDataType == DataTypes.INT) {	1✔
146	int out = (int) longData;	1✔
147	return ByteUtil.toXorBytes(out);	1✔
148	} else {
149	// timestamp and long
150	return ByteUtil.toXorBytes(longData);	1✔
151	}
152	} else if ((targetDataType == DataTypes.STRING) \|\| (targetDataType == DataTypes.VARCHAR) \|\| (	×
153	targetDataType == DataTypes.BYTE_ARRAY)) {
154	return columnPage.getBytes(rowId);	×
155	} else {
156	throw new RuntimeException("unsupported type: " + targetDataType);	×
157	}
158	} else if ((columnType == ColumnType.COMPLEX_PRIMITIVE && !isAdaptiveEncoded())) {	1✔
159	if ((srcDataType == DataTypes.BYTE) \|\| (srcDataType == DataTypes.BOOLEAN)) {	1✔
160	byte[] out = new byte[1];	×
161	out[0] = (columnPage.getByte(rowId));	×
162	return ByteUtil.toBytes(ByteUtil.toBoolean(out));	×
163	} else if (srcDataType == DataTypes.BYTE_ARRAY) {	1✔
164	return columnPage.getBytes(rowId);	1✔
165	} else if (srcDataType == DataTypes.DOUBLE) {	1✔
166	return ByteUtil.toXorBytes(columnPage.getDouble(rowId));	1✔
167	} else if (srcDataType == DataTypes.FLOAT) {	×
168	return ByteUtil.toXorBytes(columnPage.getFloat(rowId));	×
169	} else if (srcDataType == targetDataType) {	×
170	return columnPage.getBytes(rowId);	×
171	} else {
172	throw new RuntimeException("unsupported type: " + targetDataType);	×
173	}
174	} else {
175	return columnPage.getBytes(rowId);	1✔
176	}
177	}
178
179	private byte[] getNullBitSet(int rowId, ColumnType columnType) {
180	if (columnPage.getNullBits().get(rowId) && columnType == ColumnType.COMPLEX_PRIMITIVE) {	1✔
181	// if this row is null, return default null represent in byte array
182	return CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY;	1✔
183	}
184	if (columnPage.getNullBits().get(rowId)) {	1✔
185	// if this row is null, return default null represent in byte array
186	return CarbonCommonConstants.EMPTY_BYTE_ARRAY;	1✔
187	}
188	return null;	1✔
189	}
190
191	/**
192	* Fill the data to the vector
193	*
194	* @param rowId
195	* @param vector
196	* @param vectorRow
197	*/
198	private void fillRow(int rowId, CarbonColumnVector vector, int vectorRow) {
199	if (columnPage.getNullBits().get(rowId)) {	1✔
200	vector.putNull(vectorRow);	1✔
201	} else {
202	if (isExplicitSorted) {	1✔
203	rowId = invertedReverseIndex[rowId];	×
204	}
205	DataType dt = vector.getType();	1✔
206	long longData = columnPage.getLong(rowId);	1✔
207	if (dt == DataTypes.BOOLEAN) {	1✔
208	vector.putBoolean(vectorRow, ByteUtil.toBoolean((byte) longData));	×
209	} else if (dt == DataTypes.BYTE) {	1✔
210	vector.putByte(vectorRow, (byte) longData);	×
211	} else if (dt == DataTypes.SHORT) {	1✔
212	vector.putShort(vectorRow, (short) longData);	1✔
213	} else if (dt == DataTypes.INT) {	1✔
214	vector.putInt(vectorRow, (int) longData);	1✔
215	} else if (dt == DataTypes.LONG) {	1✔
216	// retrieving the data after change in data type restructure operation
217	if (vector.getBlockDataType() == DataTypes.INT) {	1✔
218	vector.putLong(vectorRow, (int) longData);	1✔
219	} else if (vector.getBlockDataType() == DataTypes.LONG) {	1✔
220	vector.putLong(vectorRow, longData);	1✔
221	}
222	} else if (dt == DataTypes.TIMESTAMP) {	1✔
223	vector.putLong(vectorRow, longData * 1000L);	1✔
224	} else {
225	throw new RuntimeException("unsupported type: " + dt);	×
226	}
227	}
228	}	1✔
229
230	@Override
231	public int getInvertedIndex(int rowId) {
232	return invertedIndex[rowId];	×
233	}
234
235	@Override
236	public int getInvertedReverseIndex(int rowId) {
237	return invertedReverseIndex[rowId];	×
238	}
239
240	@Override
241	public boolean isNoDicitionaryColumn() {
242	return true;	1✔
243	}
244
245	@Override
246	public boolean isExplicitSorted() {
247	return isExplicitSorted;	1✔
248	}
249
250	@Override
251	public int compareTo(int rowId, byte[] compareValue) {
252	// rowId is the inverted index, but the null bitset is based on actual data
253	int nullBitSetRowId = rowId;	1✔
254	if (isExplicitSorted()) {	1✔
255	nullBitSetRowId = getInvertedIndex(rowId);	×
256	}
257	byte[] nullBitSet = getNullBitSet(nullBitSetRowId, columnPage.getColumnSpec().getColumnType());	1✔
258	if (nullBitSet != null	1✔
259	&& ByteUtil.UnsafeComparer.INSTANCE.compareTo(nullBitSet, compareValue) == 0) {	1✔
260	// check if the compare value is a null value
261	// if the compare value is null and the data is also null we can directly return 0
262	return 0;	1✔
263	} else {
264	byte[] chunkData;
265	if (nullBitSet != null && nullBitSet.length == 0) {	1✔
266	chunkData = nullBitSet;	1✔
267	} else {
268	chunkData = this.getChunkDataInBytes(rowId);	1✔
269	}
270	return ByteUtil.UnsafeComparer.INSTANCE.compareTo(chunkData, compareValue);	1✔
271	}
272	}
273
274	@Override
275	public void freeMemory() {
276	if (null != columnPage) {	1✔
277	columnPage.freeMemory();	1✔
278	columnPage = null;	1✔
279	}
280	}	1✔
281
282	@Override public boolean isAdaptiveEncoded() {
283	return isAdaptivePrimitivePage;	1✔
284	}
285
286	@Override public BitSet getNullBits() {
287	return columnPage.getNullBits();	1✔
288	}
289
290	}

apache / carbondata / 3821

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