9287

Build # 9287

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/5ee39914a439c751052a09957a4fac2f0988aece">5ee39914a<a href="https://github.com/apache/carbondata/commit/5ee39914a439c751052a09957a4fac2f0988aece">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/77608fbb5454edf00a962c0f285517b1cd699b33">77608fbb5</a>">77608fbb5</a><a href="https://github.com/apache/carbondata/commit/5ee39914a439c751052a09957a4fac2f0988aece"> into de6e98b08">de6e98b08</a>

Run Details

1259 of 1259 new or added lines in 50 files covered. (100.0%)

60635 of 76186 relevant lines covered (79.59%)

1.05 hits per line

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

91.94

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

import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datastore.chunk.store.DimensionChunkStoreFactory;
import org.apache.carbondata.core.datastore.chunk.store.DimensionChunkStoreFactory.DimensionStoreType;
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.ColumnVectorInfo;

/**
 * This class is gives access to fixed length dimension data chunk store
 */
public class FixedLengthDimensionColumnPage extends AbstractDimensionColumnPage {

  /**
   * Constructor
   *
   * @param dataChunk            data chunk
   * @param invertedIndex        inverted index
   * @param invertedIndexReverse reverse inverted index
   * @param numberOfRows         number of rows
   * @param columnValueSize      size of each column value
   */
  public FixedLengthDimensionColumnPage(byte[] dataChunk, int[] invertedIndex,
      int[] invertedIndexReverse, int numberOfRows, int columnValueSize) {
    boolean isExplicitSorted = isExplicitSorted(invertedIndex);
    long totalSize = isExplicitSorted ?
        dataChunk.length + (2 * numberOfRows * CarbonCommonConstants.INT_SIZE_IN_BYTE) :
        dataChunk.length;
    dataChunkStore = DimensionChunkStoreFactory.INSTANCE
        .getDimensionChunkStore(columnValueSize, isExplicitSorted, numberOfRows, totalSize,
            DimensionStoreType.FIXED_LENGTH, null, false);
    dataChunkStore.putArray(invertedIndex, invertedIndexReverse, dataChunk);
  }

  /**
   * Constructor
   *
   * @param dataChunk            data chunk
   * @param invertedIndex        inverted index
   * @param invertedIndexReverse reverse inverted index
   * @param numberOfRows         number of rows
   * @param columnValueSize      size of each column value
   * @param vectorInfo           vector to be filled with decoded column page.
   */
  public FixedLengthDimensionColumnPage(byte[] dataChunk, int[] invertedIndex,
      int[] invertedIndexReverse, int numberOfRows, int columnValueSize,
      ColumnVectorInfo vectorInfo) {
    boolean isExplicitSorted = isExplicitSorted(invertedIndex);
    long totalSize = isExplicitSorted ?
        dataChunk.length + (2 * numberOfRows * CarbonCommonConstants.INT_SIZE_IN_BYTE) :
        dataChunk.length;
    dataChunkStore = DimensionChunkStoreFactory.INSTANCE
        .getDimensionChunkStore(columnValueSize, isExplicitSorted, numberOfRows, totalSize,
            DimensionStoreType.FIXED_LENGTH, null, vectorInfo != null);
    if (vectorInfo == null) {
      dataChunkStore.putArray(invertedIndex, invertedIndexReverse, dataChunk);
    } else {
      dataChunkStore.fillVector(invertedIndex, invertedIndexReverse, dataChunk, vectorInfo);
    }
  }

  /**
   * Below method will be used to fill the data based on offset and row id
   *
   * @param rowId            row id of the chunk
   * @param offset           offset from which data need to be filed
   * @param data             data to filed
   * @return how many bytes was copied
   */
  @Override public int fillRawData(int rowId, int offset, byte[] data) {
    dataChunkStore.fillRow(rowId, data, offset);
    return dataChunkStore.getColumnValueSize();
  }

  /**
   * Converts to column dictionary integer value
   *
   * @param rowId
   * @param chunkIndex
   * @param outputSurrogateKey
   * @return
   */
  @Override public int fillSurrogateKey(int rowId, int chunkIndex, int[] outputSurrogateKey) {
    outputSurrogateKey[chunkIndex] = dataChunkStore.getSurrogate(rowId);
    return chunkIndex + 1;
  }

  /**
   * Fill the data to vector
   *
   * @param vectorInfo
   * @param chunkIndex
   * @return next column index
   */
  @Override public int fillVector(ColumnVectorInfo[] vectorInfo, int chunkIndex) {
    ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];
    int offset = columnVectorInfo.offset;
    int vectorOffset = columnVectorInfo.vectorOffset;
    int len = columnVectorInfo.size + offset;
    CarbonColumnVector vector = columnVectorInfo.vector;
    for (int j = offset; j < len; j++) {
      int dict = dataChunkStore.getSurrogate(j);
      if (columnVectorInfo.directDictionaryGenerator == null) {
        vector.putInt(vectorOffset++, dict);
      } else {
        Object valueFromSurrogate =
            columnVectorInfo.directDictionaryGenerator.getValueFromSurrogate(dict);
        if (valueFromSurrogate == null) {
          vector.putNull(vectorOffset++);
        } else {
          DataType dataType = columnVectorInfo.directDictionaryGenerator.getReturnType();
          if (dataType == DataTypes.INT) {
            vector.putInt(vectorOffset++, (int) valueFromSurrogate);
          } else if (dataType == DataTypes.LONG) {
            vector.putLong(vectorOffset++, (long) valueFromSurrogate);
          } else {
            throw new IllegalArgumentException("unsupported data type: " +
                columnVectorInfo.directDictionaryGenerator.getReturnType());
          }
        }
      }
    }
    return chunkIndex + 1;
  }

  /**
   * Fill the data to vector
   *
   * @param filteredRowId
   * @param vectorInfo
   * @param chunkIndex
   * @return next column index
   */
  @Override public int fillVector(int[] filteredRowId, ColumnVectorInfo[] vectorInfo,
      int chunkIndex) {
    ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];
    int offset = columnVectorInfo.offset;
    int vectorOffset = columnVectorInfo.vectorOffset;
    int len = columnVectorInfo.size + offset;
    CarbonColumnVector vector = columnVectorInfo.vector;
    for (int j = offset; j < len; j++) {
      int dict = dataChunkStore.getSurrogate(filteredRowId[j]);
      if (columnVectorInfo.directDictionaryGenerator == null) {
        vector.putInt(vectorOffset++, dict);
      } else {
        Object valueFromSurrogate =
            columnVectorInfo.directDictionaryGenerator.getValueFromSurrogate(dict);
        if (valueFromSurrogate == null) {
          vector.putNull(vectorOffset++);
        } else {
          DataType dataType = columnVectorInfo.directDictionaryGenerator.getReturnType();
          if (dataType == DataTypes.INT) {
            vector.putInt(vectorOffset++, (int) valueFromSurrogate);
          } else if (dataType == DataTypes.LONG) {
            vector.putLong(vectorOffset++, (long) valueFromSurrogate);
          } else {
            throw new IllegalArgumentException("unsupported data type: " +
                columnVectorInfo.directDictionaryGenerator.getReturnType());
          }
        }
      }
    }
    return chunkIndex + 1;
  }
}

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.datastore.chunk.impl;
18
19	import org.apache.carbondata.core.constants.CarbonCommonConstants;
20	import org.apache.carbondata.core.datastore.chunk.store.DimensionChunkStoreFactory;
21	import org.apache.carbondata.core.datastore.chunk.store.DimensionChunkStoreFactory.DimensionStoreType;
22	import org.apache.carbondata.core.metadata.datatype.DataType;
23	import org.apache.carbondata.core.metadata.datatype.DataTypes;
24	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
25	import org.apache.carbondata.core.scan.result.vector.ColumnVectorInfo;
26
27	/**
28	* This class is gives access to fixed length dimension data chunk store
29	*/
30	public class FixedLengthDimensionColumnPage extends AbstractDimensionColumnPage {
31
32	/**
33	* Constructor
34	*
35	* @param dataChunk data chunk
36	* @param invertedIndex inverted index
37	* @param invertedIndexReverse reverse inverted index
38	* @param numberOfRows number of rows
39	* @param columnValueSize size of each column value
40	*/
41	public FixedLengthDimensionColumnPage(byte[] dataChunk, int[] invertedIndex,
42	int[] invertedIndexReverse, int numberOfRows, int columnValueSize) {	2✔
43	boolean isExplicitSorted = isExplicitSorted(invertedIndex);	2✔
44	long totalSize = isExplicitSorted ?	2✔
45	dataChunk.length + (2 * numberOfRows * CarbonCommonConstants.INT_SIZE_IN_BYTE) :
46	dataChunk.length;
47	dataChunkStore = DimensionChunkStoreFactory.INSTANCE	2✔
48	.getDimensionChunkStore(columnValueSize, isExplicitSorted, numberOfRows, totalSize,	2✔
49	DimensionStoreType.FIXED_LENGTH, null, false);
50	dataChunkStore.putArray(invertedIndex, invertedIndexReverse, dataChunk);	2✔
51	}	2✔
52
53	/**
54	* Constructor
55	*
56	* @param dataChunk data chunk
57	* @param invertedIndex inverted index
58	* @param invertedIndexReverse reverse inverted index
59	* @param numberOfRows number of rows
60	* @param columnValueSize size of each column value
61	* @param vectorInfo vector to be filled with decoded column page.
62	*/
63	public FixedLengthDimensionColumnPage(byte[] dataChunk, int[] invertedIndex,
64	int[] invertedIndexReverse, int numberOfRows, int columnValueSize,
65	ColumnVectorInfo vectorInfo) {	1✔
66	boolean isExplicitSorted = isExplicitSorted(invertedIndex);	1✔
67	long totalSize = isExplicitSorted ?	1✔
68	dataChunk.length + (2 * numberOfRows * CarbonCommonConstants.INT_SIZE_IN_BYTE) :
69	dataChunk.length;
70	dataChunkStore = DimensionChunkStoreFactory.INSTANCE	1✔
71	.getDimensionChunkStore(columnValueSize, isExplicitSorted, numberOfRows, totalSize,	1✔
72	DimensionStoreType.FIXED_LENGTH, null, vectorInfo != null);
73	if (vectorInfo == null) {	1✔
74	dataChunkStore.putArray(invertedIndex, invertedIndexReverse, dataChunk);	1✔
75	} else {
76	dataChunkStore.fillVector(invertedIndex, invertedIndexReverse, dataChunk, vectorInfo);	×
77	}
78	}	1✔
79
80	/**
81	* Below method will be used to fill the data based on offset and row id
82	*
83	* @param rowId row id of the chunk
84	* @param offset offset from which data need to be filed
85	* @param data data to filed
86	* @return how many bytes was copied
87	*/
88	@Override public int fillRawData(int rowId, int offset, byte[] data) {
89	dataChunkStore.fillRow(rowId, data, offset);	2✔
90	return dataChunkStore.getColumnValueSize();	2✔
91	}
92
93	/**
94	* Converts to column dictionary integer value
95	*
96	* @param rowId
97	* @param chunkIndex
98	* @param outputSurrogateKey
99	* @return
100	*/
101	@Override public int fillSurrogateKey(int rowId, int chunkIndex, int[] outputSurrogateKey) {
102	outputSurrogateKey[chunkIndex] = dataChunkStore.getSurrogate(rowId);	2✔
103	return chunkIndex + 1;	2✔
104	}
105
106	/**
107	* Fill the data to vector
108	*
109	* @param vectorInfo
110	* @param chunkIndex
111	* @return next column index
112	*/
113	@Override public int fillVector(ColumnVectorInfo[] vectorInfo, int chunkIndex) {
114	ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];	1✔
115	int offset = columnVectorInfo.offset;	1✔
116	int vectorOffset = columnVectorInfo.vectorOffset;	1✔
117	int len = columnVectorInfo.size + offset;	1✔
118	CarbonColumnVector vector = columnVectorInfo.vector;	1✔
119	for (int j = offset; j < len; j++) {	1✔
120	int dict = dataChunkStore.getSurrogate(j);	1✔
121	if (columnVectorInfo.directDictionaryGenerator == null) {	1✔
122	vector.putInt(vectorOffset++, dict);	1✔
123	} else {
124	Object valueFromSurrogate =	1✔
125	columnVectorInfo.directDictionaryGenerator.getValueFromSurrogate(dict);	1✔
126	if (valueFromSurrogate == null) {	1✔
127	vector.putNull(vectorOffset++);	1✔
128	} else {
129	DataType dataType = columnVectorInfo.directDictionaryGenerator.getReturnType();	1✔
130	if (dataType == DataTypes.INT) {	1✔
131	vector.putInt(vectorOffset++, (int) valueFromSurrogate);	1✔
132	} else if (dataType == DataTypes.LONG) {	1✔
133	vector.putLong(vectorOffset++, (long) valueFromSurrogate);	1✔
134	} else {
135	throw new IllegalArgumentException("unsupported data type: " +	×
136	columnVectorInfo.directDictionaryGenerator.getReturnType());	×
137	}
138	}
139	}
140	}
141	return chunkIndex + 1;	1✔
142	}
143
144	/**
145	* Fill the data to vector
146	*
147	* @param filteredRowId
148	* @param vectorInfo
149	* @param chunkIndex
150	* @return next column index
151	*/
152	@Override public int fillVector(int[] filteredRowId, ColumnVectorInfo[] vectorInfo,
153	int chunkIndex) {
154	ColumnVectorInfo columnVectorInfo = vectorInfo[chunkIndex];	1✔
155	int offset = columnVectorInfo.offset;	1✔
156	int vectorOffset = columnVectorInfo.vectorOffset;	1✔
157	int len = columnVectorInfo.size + offset;	1✔
158	CarbonColumnVector vector = columnVectorInfo.vector;	1✔
159	for (int j = offset; j < len; j++) {	1✔
160	int dict = dataChunkStore.getSurrogate(filteredRowId[j]);	1✔
161	if (columnVectorInfo.directDictionaryGenerator == null) {	1✔
162	vector.putInt(vectorOffset++, dict);	1✔
163	} else {
164	Object valueFromSurrogate =	1✔
165	columnVectorInfo.directDictionaryGenerator.getValueFromSurrogate(dict);	1✔
166	if (valueFromSurrogate == null) {	1✔
167	vector.putNull(vectorOffset++);	1✔
168	} else {
169	DataType dataType = columnVectorInfo.directDictionaryGenerator.getReturnType();	1✔
170	if (dataType == DataTypes.INT) {	1✔
171	vector.putInt(vectorOffset++, (int) valueFromSurrogate);	1✔
172	} else if (dataType == DataTypes.LONG) {	1✔
173	vector.putLong(vectorOffset++, (long) valueFromSurrogate);	1✔
174	} else {
175	throw new IllegalArgumentException("unsupported data type: " +	×
176	columnVectorInfo.directDictionaryGenerator.getReturnType());	×
177	}
178	}
179	}
180	}
181	return chunkIndex + 1;	1✔
182	}
183	}

apache / carbondata / 9287

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