| /* |
| * 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.DataInput; |
| import java.io.DataOutput; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.apache.carbondata.core.metadata.blocklet.index.BlockletIndex; |
| |
| 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; |
| |
| 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 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 dimensionSize = dimensionChunkOffsets != null ? dimensionChunkOffsets.size() : 0; |
| output.writeShort(dimensionSize); |
| for (int i = 0; i < dimensionSize; i++) { |
| output.writeLong(dimensionChunkOffsets.get(i)); |
| } |
| for (int i = 0; i < dimensionSize; i++) { |
| output.writeInt(dimensionChunksLength.get(i)); |
| } |
| int measureSize = measureChunkOffsets != null ? measureChunkOffsets.size() : 0; |
| output.writeShort(measureSize); |
| for (int i = 0; i < measureSize; i++) { |
| output.writeLong(measureChunkOffsets.get(i)); |
| } |
| for (int i = 0; i < measureSize; i++) { |
| output.writeInt(measureChunksLength.get(i)); |
| } |
| |
| boolean isSortedPresent = (isSorted != null); |
| output.writeBoolean(isSortedPresent); |
| if (isSortedPresent) { |
| output.writeBoolean(isSorted); |
| } |
| if (null != getNumberOfRowsPerPage()) { |
| output.writeShort(getNumberOfRowsPerPage().length); |
| for (int i = 0; i < getNumberOfRowsPerPage().length; i++) { |
| output.writeInt(getNumberOfRowsPerPage()[i]); |
| } |
| } else { |
| //for old store |
| output.writeShort(0); |
| } |
| } |
| |
| @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()); |
| } |
| final boolean isSortedPresent = input.readBoolean(); |
| if (isSortedPresent) { |
| this.isSorted = input.readBoolean(); |
| } |
| short pageCount = input.readShort(); |
| if (pageCount != 0) { |
| // should set only for new store, old store will be set via setNumberOfRowsPerPage |
| numberOfRowsPerPage = new int[pageCount]; |
| for (int i = 0; i < numberOfRowsPerPage.length; i++) { |
| numberOfRowsPerPage[i] = input.readInt(); |
| } |
| } |
| } |
| |
| 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; |
| } |
| } |