8284

Build # 8284

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/75658a0086fb68d82990584aaa3e7ab42766c62d">75658a008<a href="https://github.com/apache/carbondata/commit/75658a0086fb68d82990584aaa3e7ab42766c62d">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/63d1dd0a73d791a714526edd41264485837b66da">63d1dd0a7</a>">63d1dd0a7</a><a href="https://github.com/apache/carbondata/commit/75658a0086fb68d82990584aaa3e7ab42766c62d"> into 526e3bfa1">526e3bfa1</a>

Run Details

355 of 355 new or added lines in 12 files covered. (100.0%)

57787 of 71683 relevant lines covered (80.61%)

1.07 hits per line

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

88.46

/core/src/main/java/org/apache/carbondata/core/indexstore/blockletindex/BlockletDataMap.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.indexstore.blockletindex;

import java.io.ByteArrayOutputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.List;

import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datamap.dev.DataMapModel;
import org.apache.carbondata.core.datastore.block.SegmentProperties;
import org.apache.carbondata.core.datastore.block.SegmentPropertiesAndSchemaHolder;
import org.apache.carbondata.core.datastore.block.TableBlockInfo;
import org.apache.carbondata.core.indexstore.BlockMetaInfo;
import org.apache.carbondata.core.indexstore.BlockletDetailInfo;
import org.apache.carbondata.core.indexstore.ExtendedBlocklet;
import org.apache.carbondata.core.indexstore.row.DataMapRow;
import org.apache.carbondata.core.indexstore.row.DataMapRowImpl;
import org.apache.carbondata.core.indexstore.schema.CarbonRowSchema;
import org.apache.carbondata.core.memory.MemoryException;
import org.apache.carbondata.core.metadata.blocklet.BlockletInfo;
import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
import org.apache.carbondata.core.metadata.blocklet.index.BlockletMinMaxIndex;
import org.apache.carbondata.core.metadata.schema.table.column.CarbonColumn;
import org.apache.carbondata.core.util.BlockletDataMapUtil;

/**
 * Datamap implementation for blocklet.
 */
public class BlockletDataMap extends BlockDataMap implements Serializable {

  private static final long serialVersionUID = -2170289352240810993L;

  @Override
  public void init(DataMapModel dataMapModel) throws IOException, MemoryException {
    super.init(dataMapModel);
  }

  /**
   * Method to check the cache level and load metadata based on that information
   *
   * @param blockletDataMapInfo
   * @param indexInfo
   * @throws IOException
   * @throws MemoryException
   */
  @Override
  protected DataMapRowImpl loadMetadata(CarbonRowSchema[] taskSummarySchema,
      SegmentProperties segmentProperties, BlockletDataMapModel blockletDataMapInfo,
      List<DataFileFooter> indexInfo) throws IOException, MemoryException {
    if (isLegacyStore) {
      return loadBlockInfoForOldStore(taskSummarySchema, segmentProperties, blockletDataMapInfo,
          indexInfo);
    } else {
      return loadBlockletMetaInfo(taskSummarySchema, segmentProperties, blockletDataMapInfo,
          indexInfo);
    }
  }

  @Override
  protected CarbonRowSchema[] getTaskSummarySchema() {
    if (isLegacyStore) {
      return super.getTaskSummarySchema();
    }
    SegmentPropertiesAndSchemaHolder.SegmentPropertiesWrapper segmentPropertiesWrapper =
        SegmentPropertiesAndSchemaHolder.getInstance()
            .getSegmentPropertiesWrapper(segmentPropertiesIndex);
    try {
      return segmentPropertiesWrapper.getTaskSummarySchema(false, isFilePathStored);
    } catch (MemoryException e) {
      throw new RuntimeException(e);
    }
  }

  @Override
  protected CarbonRowSchema[] getFileFooterEntrySchema() {
    if (isLegacyStore) {
      return super.getFileFooterEntrySchema();
    }
    return SegmentPropertiesAndSchemaHolder.getInstance()
        .getSegmentPropertiesWrapper(segmentPropertiesIndex).getBlockletFileFooterEntrySchema();
  }

  /**
   * Method to load blocklet metadata information
   *
   * @param blockletDataMapInfo
   * @param indexInfo
   * @throws IOException
   * @throws MemoryException
   */
  private DataMapRowImpl loadBlockletMetaInfo(CarbonRowSchema[] taskSummarySchema,
      SegmentProperties segmentProperties, BlockletDataMapModel blockletDataMapInfo,
      List<DataFileFooter> indexInfo) throws IOException, MemoryException {
    String tempFilePath = null;
    DataMapRowImpl summaryRow = null;
    CarbonRowSchema[] schema = getFileFooterEntrySchema();
    // Relative blocklet ID is the id assigned to a blocklet within a part file
    int relativeBlockletId = 0;
    for (DataFileFooter fileFooter : indexInfo) {
      TableBlockInfo blockInfo = fileFooter.getBlockInfo().getTableBlockInfo();
      BlockMetaInfo blockMetaInfo =
          blockletDataMapInfo.getBlockMetaInfoMap().get(blockInfo.getFilePath());
      // Here it loads info about all blocklets of index
      // Only add if the file exists physically. There are scenarios which index file exists inside
      // merge index but related carbondata files are deleted. In that case we first check whether
      // the file exists physically or not
      if (blockMetaInfo != null) {
        // this case is for CACHE_LEVEL = BLOCKLET
        // blocklet ID will start from 0 again only when part file path is changed
        if (null == tempFilePath || !tempFilePath.equals(blockInfo.getFilePath())) {
          tempFilePath = blockInfo.getFilePath();
          relativeBlockletId = 0;
        }
        summaryRow = loadToUnsafe(schema, taskSummarySchema, fileFooter, segmentProperties,
            getMinMaxCacheColumns(), blockInfo.getFilePath(), summaryRow,
            blockMetaInfo, relativeBlockletId);
        // this is done because relative blocklet id need to be incremented based on the
        // total number of blocklets
        relativeBlockletId += fileFooter.getBlockletList().size();
      }
    }
    return summaryRow;
  }

  private DataMapRowImpl loadToUnsafe(CarbonRowSchema[] schema, CarbonRowSchema[] taskSummarySchema,
      DataFileFooter fileFooter, SegmentProperties segmentProperties,
      List<CarbonColumn> minMaxCacheColumns, String filePath, DataMapRowImpl summaryRow,
      BlockMetaInfo blockMetaInfo, int relativeBlockletId) {
    List<BlockletInfo> blockletList = fileFooter.getBlockletList();
    // Add one row to maintain task level min max for segment pruning
    if (!blockletList.isEmpty() && summaryRow == null) {
      summaryRow = new DataMapRowImpl(taskSummarySchema);
    }
    for (int index = 0; index < blockletList.size(); index++) {
      DataMapRow row = new DataMapRowImpl(schema);
      int ordinal = 0;
      int taskMinMaxOrdinal = 0;
      BlockletInfo blockletInfo = blockletList.get(index);
      BlockletMinMaxIndex minMaxIndex = blockletInfo.getBlockletIndex().getMinMaxIndex();
      // get min max values for columns to be cached
      byte[][] minValuesForColumnsToBeCached = BlockletDataMapUtil
          .getMinMaxForColumnsToBeCached(segmentProperties, minMaxCacheColumns,
              minMaxIndex.getMinValues());
      byte[][] maxValuesForColumnsToBeCached = BlockletDataMapUtil
          .getMinMaxForColumnsToBeCached(segmentProperties, minMaxCacheColumns,
              minMaxIndex.getMaxValues());
      row.setRow(addMinMax(schema[ordinal], minValuesForColumnsToBeCached), ordinal);
      // compute and set task level min values
      addTaskMinMaxValues(summaryRow, taskSummarySchema, taskMinMaxOrdinal,
          minValuesForColumnsToBeCached, TASK_MIN_VALUES_INDEX, true);
      ordinal++;
      taskMinMaxOrdinal++;
      row.setRow(addMinMax(schema[ordinal], maxValuesForColumnsToBeCached), ordinal);
      // compute and set task level max values
      addTaskMinMaxValues(summaryRow, taskSummarySchema, taskMinMaxOrdinal,
          maxValuesForColumnsToBeCached, TASK_MAX_VALUES_INDEX, false);
      ordinal++;
      row.setInt(blockletInfo.getNumberOfRows(), ordinal++);
      // add file name
      byte[] filePathBytes =
          getFileNameFromPath(filePath).getBytes(CarbonCommonConstants.DEFAULT_CHARSET_CLASS);
      row.setByteArray(filePathBytes, ordinal++);
      // add version number
      row.setShort(fileFooter.getVersionId().number(), ordinal++);
      // add schema updated time
      row.setLong(fileFooter.getSchemaUpdatedTimeStamp(), ordinal++);
      byte[] serializedData;
      try {
        // Add block footer offset, it is used if we need to read footer of block
        row.setLong(fileFooter.getBlockInfo().getTableBlockInfo().getBlockOffset(), ordinal++);
        setLocations(blockMetaInfo.getLocationInfo(), row, ordinal++);
        // Store block size
        row.setLong(blockMetaInfo.getSize(), ordinal++);
        // add blocklet info
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        DataOutput dataOutput = new DataOutputStream(stream);
        blockletInfo.write(dataOutput);
        serializedData = stream.toByteArray();
        row.setByteArray(serializedData, ordinal++);
        // add pages
        row.setShort((short) blockletInfo.getNumberOfPages(), ordinal++);
        // for relative blocklet id i.e blocklet id that belongs to a particular carbondata file
        row.setShort((short) relativeBlockletId++, ordinal);
        memoryDMStore.addIndexRow(schema, row);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
    return summaryRow;
  }

  @Override
  public ExtendedBlocklet getDetailedBlocklet(String blockletId) {
    if (isLegacyStore) {
      return super.getDetailedBlocklet(blockletId);
    }
    int absoluteBlockletId = Integer.parseInt(blockletId);
    DataMapRow safeRow = memoryDMStore.getDataMapRow(getFileFooterEntrySchema(), absoluteBlockletId)
        .convertToSafeRow();
    short relativeBlockletId = safeRow.getShort(BLOCKLET_ID_INDEX);
    String filePath = getFilePath();
    return createBlocklet(safeRow, getFileNameWithFilePath(safeRow, filePath), relativeBlockletId,
        false);
  }

  @Override
  protected short getBlockletId(DataMapRow dataMapRow) {
    if (isLegacyStore) {
      return super.getBlockletId(dataMapRow);
    }
    return dataMapRow.getShort(BLOCKLET_ID_INDEX);
  }

  @Override
  protected ExtendedBlocklet createBlocklet(DataMapRow row, String fileName, short blockletId,
      boolean useMinMaxForPruning) {
    if (isLegacyStore) {
      return super.createBlocklet(row, fileName, blockletId, useMinMaxForPruning);
    }
    ExtendedBlocklet blocklet = new ExtendedBlocklet(fileName, blockletId + "");
    BlockletDetailInfo detailInfo = getBlockletDetailInfo(row, blockletId, blocklet);
    detailInfo.setColumnSchemas(getColumnSchema());
    detailInfo.setBlockletInfoBinary(row.getByteArray(BLOCKLET_INFO_INDEX));
    detailInfo.setPagesCount(row.getShort(BLOCKLET_PAGE_COUNT_INDEX));
    detailInfo.setUseMinMaxForPruning(useMinMaxForPruning);
    blocklet.setDetailInfo(detailInfo);
    return blocklet;
  }

  @Override
  protected short getBlockletNumOfEntry(int index) {
    if (isLegacyStore) {
      return super.getBlockletNumOfEntry(index);
    } else {
      //in blocklet datamap, each entry contains info of one blocklet
      return 1;
    }
  }

  @Override
  protected int getTotalBlocklets() {
    if (isLegacyStore) {
      return super.getTotalBlocklets();
    } else {
      return memoryDMStore.getRowCount();
    }
  }

}

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.indexstore.blockletindex;
18
19	import java.io.ByteArrayOutputStream;
20	import java.io.DataOutput;
21	import java.io.DataOutputStream;
22	import java.io.IOException;
23	import java.io.Serializable;
24	import java.util.List;
25
26	import org.apache.carbondata.core.constants.CarbonCommonConstants;
27	import org.apache.carbondata.core.datamap.dev.DataMapModel;
28	import org.apache.carbondata.core.datastore.block.SegmentProperties;
29	import org.apache.carbondata.core.datastore.block.SegmentPropertiesAndSchemaHolder;
30	import org.apache.carbondata.core.datastore.block.TableBlockInfo;
31	import org.apache.carbondata.core.indexstore.BlockMetaInfo;
32	import org.apache.carbondata.core.indexstore.BlockletDetailInfo;
33	import org.apache.carbondata.core.indexstore.ExtendedBlocklet;
34	import org.apache.carbondata.core.indexstore.row.DataMapRow;
35	import org.apache.carbondata.core.indexstore.row.DataMapRowImpl;
36	import org.apache.carbondata.core.indexstore.schema.CarbonRowSchema;
37	import org.apache.carbondata.core.memory.MemoryException;
38	import org.apache.carbondata.core.metadata.blocklet.BlockletInfo;
39	import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
40	import org.apache.carbondata.core.metadata.blocklet.index.BlockletMinMaxIndex;
41	import org.apache.carbondata.core.metadata.schema.table.column.CarbonColumn;
42	import org.apache.carbondata.core.util.BlockletDataMapUtil;
43
44	/**
45	* Datamap implementation for blocklet.
46	*/
47	public class BlockletDataMap extends BlockDataMap implements Serializable {	2✔
48
49	private static final long serialVersionUID = -2170289352240810993L;
50
51	@Override
52	public void init(DataMapModel dataMapModel) throws IOException, MemoryException {
53	super.init(dataMapModel);	1✔
54	}	1✔
55
56	/**
57	* Method to check the cache level and load metadata based on that information
58	*
59	* @param blockletDataMapInfo
60	* @param indexInfo
61	* @throws IOException
62	* @throws MemoryException
63	*/
64	@Override
65	protected DataMapRowImpl loadMetadata(CarbonRowSchema[] taskSummarySchema,
66	SegmentProperties segmentProperties, BlockletDataMapModel blockletDataMapInfo,
67	List<DataFileFooter> indexInfo) throws IOException, MemoryException {
68	if (isLegacyStore) {	1✔
69	return loadBlockInfoForOldStore(taskSummarySchema, segmentProperties, blockletDataMapInfo,	×
70	indexInfo);
71	} else {
72	return loadBlockletMetaInfo(taskSummarySchema, segmentProperties, blockletDataMapInfo,	1✔
73	indexInfo);
74	}
75	}
76
77	@Override
78	protected CarbonRowSchema[] getTaskSummarySchema() {
79	if (isLegacyStore) {	1✔
80	return super.getTaskSummarySchema();	×
81	}
82	SegmentPropertiesAndSchemaHolder.SegmentPropertiesWrapper segmentPropertiesWrapper =
83	SegmentPropertiesAndSchemaHolder.getInstance()	1✔
84	.getSegmentPropertiesWrapper(segmentPropertiesIndex);	1✔
85	try {
86	return segmentPropertiesWrapper.getTaskSummarySchema(false, isFilePathStored);	1✔
87	} catch (MemoryException e) {	×
88	throw new RuntimeException(e);	×
89	}
90	}
91
92	@Override
93	protected CarbonRowSchema[] getFileFooterEntrySchema() {
94	if (isLegacyStore) {	1✔
95	return super.getFileFooterEntrySchema();	×
96	}
97	return SegmentPropertiesAndSchemaHolder.getInstance()	1✔
98	.getSegmentPropertiesWrapper(segmentPropertiesIndex).getBlockletFileFooterEntrySchema();	1✔
99	}
100
101	/**
102	* Method to load blocklet metadata information
103	*
104	* @param blockletDataMapInfo
105	* @param indexInfo
106	* @throws IOException
107	* @throws MemoryException
108	*/
109	private DataMapRowImpl loadBlockletMetaInfo(CarbonRowSchema[] taskSummarySchema,
110	SegmentProperties segmentProperties, BlockletDataMapModel blockletDataMapInfo,
111	List<DataFileFooter> indexInfo) throws IOException, MemoryException {
112	String tempFilePath = null;	1✔
113	DataMapRowImpl summaryRow = null;	1✔
114	CarbonRowSchema[] schema = getFileFooterEntrySchema();	1✔
115	// Relative blocklet ID is the id assigned to a blocklet within a part file
116	int relativeBlockletId = 0;	1✔
117	for (DataFileFooter fileFooter : indexInfo) {	1✔
118	TableBlockInfo blockInfo = fileFooter.getBlockInfo().getTableBlockInfo();	1✔
119	BlockMetaInfo blockMetaInfo =	1✔
120	blockletDataMapInfo.getBlockMetaInfoMap().get(blockInfo.getFilePath());	1✔
121	// Here it loads info about all blocklets of index
122	// Only add if the file exists physically. There are scenarios which index file exists inside
123	// merge index but related carbondata files are deleted. In that case we first check whether
124	// the file exists physically or not
125	if (blockMetaInfo != null) {	1✔
126	// this case is for CACHE_LEVEL = BLOCKLET
127	// blocklet ID will start from 0 again only when part file path is changed
128	if (null == tempFilePath \|\| !tempFilePath.equals(blockInfo.getFilePath())) {	1✔
129	tempFilePath = blockInfo.getFilePath();	1✔
130	relativeBlockletId = 0;	1✔
131	}
132	summaryRow = loadToUnsafe(schema, taskSummarySchema, fileFooter, segmentProperties,	1✔
133	getMinMaxCacheColumns(), blockInfo.getFilePath(), summaryRow,	1✔
134	blockMetaInfo, relativeBlockletId);
135	// this is done because relative blocklet id need to be incremented based on the
136	// total number of blocklets
137	relativeBlockletId += fileFooter.getBlockletList().size();	1✔
138	}
139	}	1✔
140	return summaryRow;	1✔
141	}
142
143	private DataMapRowImpl loadToUnsafe(CarbonRowSchema[] schema, CarbonRowSchema[] taskSummarySchema,
144	DataFileFooter fileFooter, SegmentProperties segmentProperties,
145	List<CarbonColumn> minMaxCacheColumns, String filePath, DataMapRowImpl summaryRow,
146	BlockMetaInfo blockMetaInfo, int relativeBlockletId) {
147	List<BlockletInfo> blockletList = fileFooter.getBlockletList();	1✔
148	// Add one row to maintain task level min max for segment pruning
149	if (!blockletList.isEmpty() && summaryRow == null) {	1✔
150	summaryRow = new DataMapRowImpl(taskSummarySchema);	1✔
151	}
152	for (int index = 0; index < blockletList.size(); index++) {	1✔
153	DataMapRow row = new DataMapRowImpl(schema);	1✔
154	int ordinal = 0;	1✔
155	int taskMinMaxOrdinal = 0;	1✔
156	BlockletInfo blockletInfo = blockletList.get(index);	1✔
157	BlockletMinMaxIndex minMaxIndex = blockletInfo.getBlockletIndex().getMinMaxIndex();	1✔
158	// get min max values for columns to be cached
159	byte[][] minValuesForColumnsToBeCached = BlockletDataMapUtil	1✔
160	.getMinMaxForColumnsToBeCached(segmentProperties, minMaxCacheColumns,	1✔
161	minMaxIndex.getMinValues());	1✔
162	byte[][] maxValuesForColumnsToBeCached = BlockletDataMapUtil	1✔
163	.getMinMaxForColumnsToBeCached(segmentProperties, minMaxCacheColumns,	1✔
164	minMaxIndex.getMaxValues());	1✔
165	row.setRow(addMinMax(schema[ordinal], minValuesForColumnsToBeCached), ordinal);	1✔
166	// compute and set task level min values
167	addTaskMinMaxValues(summaryRow, taskSummarySchema, taskMinMaxOrdinal,	1✔
168	minValuesForColumnsToBeCached, TASK_MIN_VALUES_INDEX, true);
169	ordinal++;	1✔
170	taskMinMaxOrdinal++;	1✔
171	row.setRow(addMinMax(schema[ordinal], maxValuesForColumnsToBeCached), ordinal);	1✔
172	// compute and set task level max values
173	addTaskMinMaxValues(summaryRow, taskSummarySchema, taskMinMaxOrdinal,	1✔
174	maxValuesForColumnsToBeCached, TASK_MAX_VALUES_INDEX, false);
175	ordinal++;	1✔
176	row.setInt(blockletInfo.getNumberOfRows(), ordinal++);	1✔
177	// add file name
178	byte[] filePathBytes =	1✔
179	getFileNameFromPath(filePath).getBytes(CarbonCommonConstants.DEFAULT_CHARSET_CLASS);	1✔
180	row.setByteArray(filePathBytes, ordinal++);	1✔
181	// add version number
182	row.setShort(fileFooter.getVersionId().number(), ordinal++);	1✔
183	// add schema updated time
184	row.setLong(fileFooter.getSchemaUpdatedTimeStamp(), ordinal++);	1✔
185	byte[] serializedData;
186	try {
187	// Add block footer offset, it is used if we need to read footer of block
188	row.setLong(fileFooter.getBlockInfo().getTableBlockInfo().getBlockOffset(), ordinal++);	1✔
189	setLocations(blockMetaInfo.getLocationInfo(), row, ordinal++);	1✔
190	// Store block size
191	row.setLong(blockMetaInfo.getSize(), ordinal++);	1✔
192	// add blocklet info
193	ByteArrayOutputStream stream = new ByteArrayOutputStream();	1✔
194	DataOutput dataOutput = new DataOutputStream(stream);	1✔
195	blockletInfo.write(dataOutput);	1✔
196	serializedData = stream.toByteArray();	1✔
197	row.setByteArray(serializedData, ordinal++);	1✔
198	// add pages
199	row.setShort((short) blockletInfo.getNumberOfPages(), ordinal++);	1✔
200	// for relative blocklet id i.e blocklet id that belongs to a particular carbondata file
201	row.setShort((short) relativeBlockletId++, ordinal);	1✔
202	memoryDMStore.addIndexRow(schema, row);	1✔
203	} catch (Exception e) {	×
204	throw new RuntimeException(e);	×
205	}	1✔
206	}
207	return summaryRow;	1✔
208	}
209
210	@Override
211	public ExtendedBlocklet getDetailedBlocklet(String blockletId) {
212	if (isLegacyStore) {	1✔
213	return super.getDetailedBlocklet(blockletId);	×
214	}
215	int absoluteBlockletId = Integer.parseInt(blockletId);	1✔
216	DataMapRow safeRow = memoryDMStore.getDataMapRow(getFileFooterEntrySchema(), absoluteBlockletId)	1✔
217	.convertToSafeRow();	1✔
218	short relativeBlockletId = safeRow.getShort(BLOCKLET_ID_INDEX);	1✔
219	String filePath = getFilePath();	1✔
220	return createBlocklet(safeRow, getFileNameWithFilePath(safeRow, filePath), relativeBlockletId,	1✔
221	false);
222	}
223
224	@Override
225	protected short getBlockletId(DataMapRow dataMapRow) {
226	if (isLegacyStore) {	1✔
227	return super.getBlockletId(dataMapRow);	×
228	}
229	return dataMapRow.getShort(BLOCKLET_ID_INDEX);	1✔
230	}
231
232	@Override
233	protected ExtendedBlocklet createBlocklet(DataMapRow row, String fileName, short blockletId,
234	boolean useMinMaxForPruning) {
235	if (isLegacyStore) {	1✔
236	return super.createBlocklet(row, fileName, blockletId, useMinMaxForPruning);	×
237	}
238	ExtendedBlocklet blocklet = new ExtendedBlocklet(fileName, blockletId + "");	1✔
239	BlockletDetailInfo detailInfo = getBlockletDetailInfo(row, blockletId, blocklet);	1✔
240	detailInfo.setColumnSchemas(getColumnSchema());	1✔
241	detailInfo.setBlockletInfoBinary(row.getByteArray(BLOCKLET_INFO_INDEX));	1✔
242	detailInfo.setPagesCount(row.getShort(BLOCKLET_PAGE_COUNT_INDEX));	1✔
243	detailInfo.setUseMinMaxForPruning(useMinMaxForPruning);	1✔
244	blocklet.setDetailInfo(detailInfo);	1✔
245	return blocklet;	1✔
246	}
247
248	@Override
249	protected short getBlockletNumOfEntry(int index) {
250	if (isLegacyStore) {	1✔
251	return super.getBlockletNumOfEntry(index);	×
252	} else {
253	//in blocklet datamap, each entry contains info of one blocklet
254	return 1;	1✔
255	}
256	}
257
258	@Override
259	protected int getTotalBlocklets() {
260	if (isLegacyStore) {	1✔
261	return super.getTotalBlocklets();	×
262	} else {
263	return memoryDMStore.getRowCount();	1✔
264	}
265	}
266
267	}

apache / carbondata / 8284

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