10939

Build # 10939

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/carbondata/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/carbondata/commit/<a class="double-link" href="https://git"><a class=hub.com/apache/carbondata/commit/48d9f395f9208ed7671028a5c6eca793c88de298">48d9f395f">&lt;a href=&quot;https://github.com/apache/carbondata/commit/</a><a class="double-link" href="https://github.com/apache/carbondata/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/carbondata/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/carbondata/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/carbondata/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/apache/carbondata/commit/48d9f395f9208ed7671028a5c6eca793c88de298">48d9f395f</a><a href="https://github.com/apache/carbondata/commit/48d9f395f9208ed7671028a5c6eca793c88de298">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/apache/carbondata/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/apache/carbondata/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/carbondata/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/carbondata/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/carbondata/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/apache/carbondata/commit/48d9f395f9208ed7671028a5c6eca793c88de298&quot;&gt;48d9f395f&lt;/a&gt;&lt;a href=&quot;https://github.com/apache/carbondata/commit/48d9f395f9208ed7671028a5c6eca793c88de298&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/apache/carbondata/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/apache/carbondata/commit/&amp;amp;lt;a ... (continued)

Run Details

5 of 5 new or added lines in 3 files covered. (100.0%)

62783 of 79211 relevant lines covered (79.26%)

1.05 hits per line

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

76.61

/core/src/main/java/org/apache/carbondata/core/metadata/blocklet/BlockletInfo.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.blocklet;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.apache.carbondata.core.metadata.blocklet.datachunk.DataChunk;
import org.apache.carbondata.core.metadata.blocklet.index.BlockletIndex;

import org.apache.commons.io.input.ClassLoaderObjectInputStream;
import org.apache.hadoop.io.Writable;

/**
 * class to store the information about the blocklet
 */
public class BlockletInfo implements Serializable, Writable {

  /**
   * serialization id
   */
  private static final long serialVersionUID = 1873135459695635381L;

  /**
   * Number of rows in this blocklet
   */
  private int numberOfRows;

  /**
   * Information about dimension chunk of all dimensions in this blocklet
   */
  private List<DataChunk> dimensionColumnChunk;

  /**
   * Information about measure chunk of all measures in this blocklet
   */
  private List<DataChunk> measureColumnChunk;

  private List<Long> dimensionChunkOffsets;

  private List<Integer> dimensionChunksLength;

  private List<Long> measureChunkOffsets;

  private List<Integer> measureChunksLength;

  /**
   * to store the index like min max and start and end key of each column of the blocklet
   */
  private BlockletIndex blockletIndex;

  /**
   * last dimension end offset
   */
  private long dimensionOffset;

  /**
   * last measure end offsets
   */
  private long measureOffsets;

  /**
   * number of pages in blocklet
   * default value is one for V1 and V2 version
   */
  private int numberOfPages = 1;

  private int[] numberOfRowsPerPage;

  private Boolean isSorted = true;

  /**
   * @return the numberOfRows
   */
  public int getNumberOfRows() {
    return numberOfRows;
  }

  /**
   * @param numberOfRows the numberOfRows to set
   */
  public void setNumberOfRows(int numberOfRows) {
    this.numberOfRows = numberOfRows;
  }

  /**
   * @return the dimensionColumnChunk
   */
  public List<DataChunk> getDimensionColumnChunk() {
    return dimensionColumnChunk;
  }

  /**
   * @param dimensionColumnChunk the dimensionColumnChunk to set
   */
  public void setDimensionColumnChunk(List<DataChunk> dimensionColumnChunk) {
    this.dimensionColumnChunk = dimensionColumnChunk;
  }

  /**
   * @return the measureColumnChunk
   */
  public List<DataChunk> getMeasureColumnChunk() {
    return measureColumnChunk;
  }

  /**
   * @param measureColumnChunk the measureColumnChunk to set
   */
  public void setMeasureColumnChunk(List<DataChunk> measureColumnChunk) {
    this.measureColumnChunk = measureColumnChunk;
  }

  /**
   * @return the blockletIndex
   */
  public BlockletIndex getBlockletIndex() {
    return blockletIndex;
  }

  /**
   * @param blockletIndex the blockletIndex to set
   */
  public void setBlockletIndex(BlockletIndex blockletIndex) {
    this.blockletIndex = blockletIndex;
  }

  public List<Long> getDimensionChunkOffsets() {
    return dimensionChunkOffsets;
  }

  public void setDimensionChunkOffsets(List<Long> dimensionChunkOffsets) {
    this.dimensionChunkOffsets = dimensionChunkOffsets;
  }

  public List<Integer> getDimensionChunksLength() {
    return dimensionChunksLength;
  }

  public void setDimensionChunksLength(List<Integer> dimensionChunksLength) {
    this.dimensionChunksLength = dimensionChunksLength;
  }

  public List<Long> getMeasureChunkOffsets() {
    return measureChunkOffsets;
  }

  public void setMeasureChunkOffsets(List<Long> measureChunkOffsets) {
    this.measureChunkOffsets = measureChunkOffsets;
  }

  public List<Integer> getMeasureChunksLength() {
    return measureChunksLength;
  }

  public void setMeasureChunksLength(List<Integer> measureChunksLength) {
    this.measureChunksLength = measureChunksLength;
  }

  public long getDimensionOffset() {
    return dimensionOffset;
  }

  public void setDimensionOffset(long dimensionOffset) {
    this.dimensionOffset = dimensionOffset;
  }

  public long getMeasureOffsets() {
    return measureOffsets;
  }

  public void setMeasureOffsets(long measureOffsets) {
    this.measureOffsets = measureOffsets;
  }

  public int getNumberOfPages() {
    return numberOfPages;
  }

  public void setNumberOfPages(int numberOfPages) {
    this.numberOfPages = numberOfPages;
  }

  @Override public void write(DataOutput output) throws IOException {
    output.writeLong(dimensionOffset);
    output.writeLong(measureOffsets);
    int dsize = dimensionChunkOffsets != null ? dimensionChunkOffsets.size() : 0;
    output.writeShort(dsize);
    for (int i = 0; i < dsize; i++) {
      output.writeLong(dimensionChunkOffsets.get(i));
    }
    for (int i = 0; i < dsize; i++) {
      output.writeInt(dimensionChunksLength.get(i));
    }
    int mSize = measureChunkOffsets != null ? measureChunkOffsets.size() : 0;
    output.writeShort(mSize);
    for (int i = 0; i < mSize; i++) {
      output.writeLong(measureChunkOffsets.get(i));
    }
    for (int i = 0; i < mSize; i++) {
      output.writeInt(measureChunksLength.get(i));
    }
    writeChunkInfoForOlderVersions(output);

    boolean isSortedPresent = (isSorted != null);
    output.writeBoolean(isSortedPresent);
    if (isSortedPresent) {
      output.writeBoolean(isSorted);
    }
  }

  /**
   * Serialize datachunks as well for older versions like V1 and V2
   */
  private void writeChunkInfoForOlderVersions(DataOutput output) throws IOException {
    int dimChunksSize = dimensionColumnChunk != null ? dimensionColumnChunk.size() : 0;
    output.writeShort(dimChunksSize);
    for (int i = 0; i < dimChunksSize; i++) {
      byte[] bytes = serializeDataChunk(dimensionColumnChunk.get(i));
      output.writeInt(bytes.length);
      output.write(bytes);
    }
    int msrChunksSize = measureColumnChunk != null ? measureColumnChunk.size() : 0;
    output.writeShort(msrChunksSize);
    for (int i = 0; i < msrChunksSize; i++) {
      byte[] bytes = serializeDataChunk(measureColumnChunk.get(i));
      output.writeInt(bytes.length);
      output.write(bytes);
    }
  }

  private byte[] serializeDataChunk(DataChunk chunk) throws IOException {
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    ObjectOutputStream outputStream = new ObjectOutputStream(stream);
    outputStream.writeObject(chunk);
    outputStream.close();
    return stream.toByteArray();
  }

  private DataChunk deserializeDataChunk(byte[] bytes) throws IOException {
    ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
    ObjectInputStream inputStream =
        new ClassLoaderObjectInputStream(Thread.currentThread().getContextClassLoader(), stream);
    DataChunk dataChunk = null;
    try {
      dataChunk = (DataChunk) inputStream.readObject();
    } catch (ClassNotFoundException e) {
      throw new IOException(e);
    }
    inputStream.close();
    return dataChunk;
  }

  @Override public void readFields(DataInput input) throws IOException {
    dimensionOffset = input.readLong();
    measureOffsets = input.readLong();
    int dimensionChunkOffsetsSize = input.readShort();
    dimensionChunkOffsets = new ArrayList<>(dimensionChunkOffsetsSize);
    for (int i = 0; i < dimensionChunkOffsetsSize; i++) {
      dimensionChunkOffsets.add(input.readLong());
    }
    dimensionChunksLength = new ArrayList<>(dimensionChunkOffsetsSize);
    for (int i = 0; i < dimensionChunkOffsetsSize; i++) {
      dimensionChunksLength.add(input.readInt());
    }

    short measureChunkOffsetsSize = input.readShort();
    measureChunkOffsets = new ArrayList<>(measureChunkOffsetsSize);
    for (int i = 0; i < measureChunkOffsetsSize; i++) {
      measureChunkOffsets.add(input.readLong());
    }
    measureChunksLength = new ArrayList<>(measureChunkOffsetsSize);
    for (int i = 0; i < measureChunkOffsetsSize; i++) {
      measureChunksLength.add(input.readInt());
    }
    readChunkInfoForOlderVersions(input);
    final boolean isSortedPresent = input.readBoolean();
    if (isSortedPresent) {
      this.isSorted = input.readBoolean();
    }
  }

  /**
   * Deserialize datachunks as well for older versions like V1 and V2
   */
  private void readChunkInfoForOlderVersions(DataInput input) throws IOException {
    short dimChunksSize = input.readShort();
    dimensionColumnChunk = new ArrayList<>(dimChunksSize);
    for (int i = 0; i < dimChunksSize; i++) {
      byte[] bytes = new byte[input.readInt()];
      input.readFully(bytes);
      dimensionColumnChunk.add(deserializeDataChunk(bytes));
    }
    short msrChunksSize = input.readShort();
    measureColumnChunk = new ArrayList<>(msrChunksSize);
    for (int i = 0; i < msrChunksSize; i++) {
      byte[] bytes = new byte[input.readInt()];
      input.readFully(bytes);
      measureColumnChunk.add(deserializeDataChunk(bytes));
    }
  }

  public int[] getNumberOfRowsPerPage() {
    return numberOfRowsPerPage;
  }

  public void setNumberOfRowsPerPage(int[] numberOfRowsPerPage) {
    this.numberOfRowsPerPage = numberOfRowsPerPage;
  }

  public Boolean isSorted() {
    return isSorted;
  }

  public void setSorted(Boolean sorted) {
    isSorted = sorted;
  }
}

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.metadata.blocklet;
19
20	import java.io.ByteArrayInputStream;
21	import java.io.ByteArrayOutputStream;
22	import java.io.DataInput;
23	import java.io.DataOutput;
24	import java.io.IOException;
25	import java.io.ObjectInputStream;
26	import java.io.ObjectOutputStream;
27	import java.io.Serializable;
28	import java.util.ArrayList;
29	import java.util.List;
30
31	import org.apache.carbondata.core.metadata.blocklet.datachunk.DataChunk;
32	import org.apache.carbondata.core.metadata.blocklet.index.BlockletIndex;
33
34	import org.apache.commons.io.input.ClassLoaderObjectInputStream;
35	import org.apache.hadoop.io.Writable;
36
37	/**
38	* class to store the information about the blocklet
39	*/
40	public class BlockletInfo implements Serializable, Writable {	2✔
41
42	/**
43	* serialization id
44	*/
45	private static final long serialVersionUID = 1873135459695635381L;
46
47	/**
48	* Number of rows in this blocklet
49	*/
50	private int numberOfRows;
51
52	/**
53	* Information about dimension chunk of all dimensions in this blocklet
54	*/
55	private List<DataChunk> dimensionColumnChunk;
56
57	/**
58	* Information about measure chunk of all measures in this blocklet
59	*/
60	private List<DataChunk> measureColumnChunk;
61
62	private List<Long> dimensionChunkOffsets;
63
64	private List<Integer> dimensionChunksLength;
65
66	private List<Long> measureChunkOffsets;
67
68	private List<Integer> measureChunksLength;
69
70	/**
71	* to store the index like min max and start and end key of each column of the blocklet
72	*/
73	private BlockletIndex blockletIndex;
74
75	/**
76	* last dimension end offset
77	*/
78	private long dimensionOffset;
79
80	/**
81	* last measure end offsets
82	*/
83	private long measureOffsets;
84
85	/**
86	* number of pages in blocklet
87	* default value is one for V1 and V2 version
88	*/
89	private int numberOfPages = 1;	2✔
90
91	private int[] numberOfRowsPerPage;
92
93	private Boolean isSorted = true;	2✔
94
95	/**
96	* @return the numberOfRows
97	*/
98	public int getNumberOfRows() {
99	return numberOfRows;	1✔
100	}
101
102	/**
103	* @param numberOfRows the numberOfRows to set
104	*/
105	public void setNumberOfRows(int numberOfRows) {
106	this.numberOfRows = numberOfRows;	2✔
107	}	2✔
108
109	/**
110	* @return the dimensionColumnChunk
111	*/
112	public List<DataChunk> getDimensionColumnChunk() {
113	return dimensionColumnChunk;	×
114	}
115
116	/**
117	* @param dimensionColumnChunk the dimensionColumnChunk to set
118	*/
119	public void setDimensionColumnChunk(List<DataChunk> dimensionColumnChunk) {
120	this.dimensionColumnChunk = dimensionColumnChunk;	2✔
121	}	2✔
122
123	/**
124	* @return the measureColumnChunk
125	*/
126	public List<DataChunk> getMeasureColumnChunk() {
127	return measureColumnChunk;	×
128	}
129
130	/**
131	* @param measureColumnChunk the measureColumnChunk to set
132	*/
133	public void setMeasureColumnChunk(List<DataChunk> measureColumnChunk) {
134	this.measureColumnChunk = measureColumnChunk;	2✔
135	}	2✔
136
137	/**
138	* @return the blockletIndex
139	*/
140	public BlockletIndex getBlockletIndex() {
141	return blockletIndex;	1✔
142	}
143
144	/**
145	* @param blockletIndex the blockletIndex to set
146	*/
147	public void setBlockletIndex(BlockletIndex blockletIndex) {
148	this.blockletIndex = blockletIndex;	2✔
149	}	2✔
150
151	public List<Long> getDimensionChunkOffsets() {
152	return dimensionChunkOffsets;	1✔
153	}
154
155	public void setDimensionChunkOffsets(List<Long> dimensionChunkOffsets) {
156	this.dimensionChunkOffsets = dimensionChunkOffsets;	1✔
157	}	1✔
158
159	public List<Integer> getDimensionChunksLength() {
160	return dimensionChunksLength;	1✔
161	}
162
163	public void setDimensionChunksLength(List<Integer> dimensionChunksLength) {
164	this.dimensionChunksLength = dimensionChunksLength;	1✔
165	}	1✔
166
167	public List<Long> getMeasureChunkOffsets() {
168	return measureChunkOffsets;	1✔
169	}
170
171	public void setMeasureChunkOffsets(List<Long> measureChunkOffsets) {
172	this.measureChunkOffsets = measureChunkOffsets;	1✔
173	}	1✔
174
175	public List<Integer> getMeasureChunksLength() {
176	return measureChunksLength;	1✔
177	}
178
179	public void setMeasureChunksLength(List<Integer> measureChunksLength) {
180	this.measureChunksLength = measureChunksLength;	1✔
181	}	1✔
182
183	public long getDimensionOffset() {
184	return dimensionOffset;	1✔
185	}
186
187	public void setDimensionOffset(long dimensionOffset) {
188	this.dimensionOffset = dimensionOffset;	1✔
189	}	1✔
190
191	public long getMeasureOffsets() {
192	return measureOffsets;	1✔
193	}
194
195	public void setMeasureOffsets(long measureOffsets) {
196	this.measureOffsets = measureOffsets;	1✔
197	}	1✔
198
199	public int getNumberOfPages() {
200	return numberOfPages;	1✔
201	}
202
203	public void setNumberOfPages(int numberOfPages) {
204	this.numberOfPages = numberOfPages;	1✔
205	}	1✔
206
207	@Override public void write(DataOutput output) throws IOException {
208	output.writeLong(dimensionOffset);	1✔
209	output.writeLong(measureOffsets);	1✔
210	int dsize = dimensionChunkOffsets != null ? dimensionChunkOffsets.size() : 0;	1✔
211	output.writeShort(dsize);	1✔
212	for (int i = 0; i < dsize; i++) {	1✔
213	output.writeLong(dimensionChunkOffsets.get(i));	1✔
214	}
215	for (int i = 0; i < dsize; i++) {	1✔
216	output.writeInt(dimensionChunksLength.get(i));	1✔
217	}
218	int mSize = measureChunkOffsets != null ? measureChunkOffsets.size() : 0;	1✔
219	output.writeShort(mSize);	1✔
220	for (int i = 0; i < mSize; i++) {	1✔
221	output.writeLong(measureChunkOffsets.get(i));	1✔
222	}
223	for (int i = 0; i < mSize; i++) {	1✔
224	output.writeInt(measureChunksLength.get(i));	1✔
225	}
226	writeChunkInfoForOlderVersions(output);	1✔
227
228	boolean isSortedPresent = (isSorted != null);	1✔
229	output.writeBoolean(isSortedPresent);	1✔
230	if (isSortedPresent) {	1✔
231	output.writeBoolean(isSorted);	1✔
232	}
233	}	1✔
234
235	/**
236	* Serialize datachunks as well for older versions like V1 and V2
237	*/
238	private void writeChunkInfoForOlderVersions(DataOutput output) throws IOException {
239	int dimChunksSize = dimensionColumnChunk != null ? dimensionColumnChunk.size() : 0;	1✔
240	output.writeShort(dimChunksSize);	1✔
241	for (int i = 0; i < dimChunksSize; i++) {	1✔
242	byte[] bytes = serializeDataChunk(dimensionColumnChunk.get(i));	×
243	output.writeInt(bytes.length);	×
244	output.write(bytes);	×
245	}
246	int msrChunksSize = measureColumnChunk != null ? measureColumnChunk.size() : 0;	1✔
247	output.writeShort(msrChunksSize);	1✔
248	for (int i = 0; i < msrChunksSize; i++) {	1✔
249	byte[] bytes = serializeDataChunk(measureColumnChunk.get(i));	×
250	output.writeInt(bytes.length);	×
251	output.write(bytes);	×
252	}
253	}	1✔
254
255	private byte[] serializeDataChunk(DataChunk chunk) throws IOException {
256	ByteArrayOutputStream stream = new ByteArrayOutputStream();	×
257	ObjectOutputStream outputStream = new ObjectOutputStream(stream);	×
258	outputStream.writeObject(chunk);	×
259	outputStream.close();	×
260	return stream.toByteArray();	×
261	}
262
263	private DataChunk deserializeDataChunk(byte[] bytes) throws IOException {
264	ByteArrayInputStream stream = new ByteArrayInputStream(bytes);	×
265	ObjectInputStream inputStream =	×
266	new ClassLoaderObjectInputStream(Thread.currentThread().getContextClassLoader(), stream);	×
267	DataChunk dataChunk = null;	×
268	try {
269	dataChunk = (DataChunk) inputStream.readObject();	×
270	} catch (ClassNotFoundException e) {	×
271	throw new IOException(e);	×
272	}	×
273	inputStream.close();	×
274	return dataChunk;	×
275	}
276
277	@Override public void readFields(DataInput input) throws IOException {
278	dimensionOffset = input.readLong();	1✔
279	measureOffsets = input.readLong();	1✔
280	int dimensionChunkOffsetsSize = input.readShort();	1✔
281	dimensionChunkOffsets = new ArrayList<>(dimensionChunkOffsetsSize);	1✔
282	for (int i = 0; i < dimensionChunkOffsetsSize; i++) {	1✔
283	dimensionChunkOffsets.add(input.readLong());	1✔
284	}
285	dimensionChunksLength = new ArrayList<>(dimensionChunkOffsetsSize);	1✔
286	for (int i = 0; i < dimensionChunkOffsetsSize; i++) {	1✔
287	dimensionChunksLength.add(input.readInt());	1✔
288	}
289
290	short measureChunkOffsetsSize = input.readShort();	1✔
291	measureChunkOffsets = new ArrayList<>(measureChunkOffsetsSize);	1✔
292	for (int i = 0; i < measureChunkOffsetsSize; i++) {	1✔
293	measureChunkOffsets.add(input.readLong());	1✔
294	}
295	measureChunksLength = new ArrayList<>(measureChunkOffsetsSize);	1✔
296	for (int i = 0; i < measureChunkOffsetsSize; i++) {	1✔
297	measureChunksLength.add(input.readInt());	1✔
298	}
299	readChunkInfoForOlderVersions(input);	1✔
300	final boolean isSortedPresent = input.readBoolean();	1✔
301	if (isSortedPresent) {	1✔
302	this.isSorted = input.readBoolean();	1✔
303	}
304	}	1✔
305
306	/**
307	* Deserialize datachunks as well for older versions like V1 and V2
308	*/
309	private void readChunkInfoForOlderVersions(DataInput input) throws IOException {
310	short dimChunksSize = input.readShort();	1✔
311	dimensionColumnChunk = new ArrayList<>(dimChunksSize);	1✔
312	for (int i = 0; i < dimChunksSize; i++) {	1✔
313	byte[] bytes = new byte[input.readInt()];	×
314	input.readFully(bytes);	×
315	dimensionColumnChunk.add(deserializeDataChunk(bytes));	×
316	}
317	short msrChunksSize = input.readShort();	1✔
318	measureColumnChunk = new ArrayList<>(msrChunksSize);	1✔
319	for (int i = 0; i < msrChunksSize; i++) {	1✔
320	byte[] bytes = new byte[input.readInt()];	×
321	input.readFully(bytes);	×
322	measureColumnChunk.add(deserializeDataChunk(bytes));	×
323	}
324	}	1✔
325
326	public int[] getNumberOfRowsPerPage() {
327	return numberOfRowsPerPage;	1✔
328	}
329
330	public void setNumberOfRowsPerPage(int[] numberOfRowsPerPage) {
331	this.numberOfRowsPerPage = numberOfRowsPerPage;	1✔
332	}	1✔
333
334	public Boolean isSorted() {
335	return isSorted;	1✔
336	}
337
338	public void setSorted(Boolean sorted) {
339	isSorted = sorted;	1✔
340	}	1✔
341	}

apache / carbondata / 10939

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