11243

Build # 11243

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/2052a9faf4e34b58e027939206700141c0573aac">2052a9faf">&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/2052a9faf4e34b58e027939206700141c0573aac">2052a9faf</a><a href="https://github.com/apache/carbondata/commit/2052a9faf4e34b58e027939206700141c0573aac">&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/2052a9faf4e34b58e027939206700141c0573aac&quot;&gt;2052a9faf&lt;/a&gt;&lt;a href=&quot;https://github.com/apache/carbondata/commit/2052a9faf4e34b58e027939206700141c0573aac&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

24 of 24 new or added lines in 2 files covered. (100.0%)

63412 of 80042 relevant lines covered (79.22%)

1.05 hits per line

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

96.9

/processing/src/main/java/org/apache/carbondata/processing/merger/CarbonCompactionExecutor.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.processing.merger;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.carbondata.common.CarbonIterator;
import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.cache.dictionary.Dictionary;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datastore.block.SegmentProperties;
import org.apache.carbondata.core.datastore.block.TableBlockInfo;
import org.apache.carbondata.core.datastore.block.TaskBlockInfo;
import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
import org.apache.carbondata.core.metadata.schema.table.CarbonTable;
import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
import org.apache.carbondata.core.scan.executor.QueryExecutor;
import org.apache.carbondata.core.scan.executor.QueryExecutorFactory;
import org.apache.carbondata.core.scan.executor.exception.QueryExecutionException;
import org.apache.carbondata.core.scan.model.QueryModel;
import org.apache.carbondata.core.scan.model.QueryModelBuilder;
import org.apache.carbondata.core.scan.result.RowBatch;
import org.apache.carbondata.core.scan.result.iterator.RawResultIterator;
import org.apache.carbondata.core.scan.wrappers.IntArrayWrapper;
import org.apache.carbondata.core.stats.QueryStatistic;
import org.apache.carbondata.core.stats.QueryStatisticsConstants;
import org.apache.carbondata.core.stats.QueryStatisticsRecorder;
import org.apache.carbondata.core.util.CarbonProperties;
import org.apache.carbondata.core.util.CarbonTimeStatisticsFactory;
import org.apache.carbondata.core.util.CarbonUtil;
import org.apache.carbondata.core.util.DataTypeConverter;

import org.apache.hadoop.conf.Configuration;
import org.apache.log4j.Logger;

/**
 * Executor class for executing the query on the selected segments to be merged.
 * This will fire a select * query and get the raw result.
 */
public class CarbonCompactionExecutor {

  private static final Logger LOGGER =
      LogServiceFactory.getLogService(CarbonCompactionExecutor.class.getName());
  private final Map<String, List<DataFileFooter>> dataFileMetadataSegMapping;
  private final SegmentProperties destinationSegProperties;
  private final Map<String, TaskBlockInfo> segmentMapping;
  private List<QueryExecutor> queryExecutorList;
  private List<QueryStatisticsRecorder> queryStatisticsRecorders =
      new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
  private CarbonTable carbonTable;
  private QueryModel queryModel;

  /**
   * flag to check whether any restructured block exists in the blocks selected for compaction.
   * Based on this decision will be taken whether complete data has to be sorted again
   */
  private boolean restructuredBlockExists;

  // converter for UTF8String and decimal conversion
  private DataTypeConverter dataTypeConverter;

  /**
   * Constructor
   *
   * @param segmentMapping
   * @param segmentProperties
   * @param carbonTable
   * @param dataFileMetadataSegMapping
   * @param restructuredBlockExists
   */
  public CarbonCompactionExecutor(Map<String, TaskBlockInfo> segmentMapping,
      SegmentProperties segmentProperties, CarbonTable carbonTable,
      Map<String, List<DataFileFooter>> dataFileMetadataSegMapping,
      boolean restructuredBlockExists, DataTypeConverter dataTypeConverter) {
    this.segmentMapping = segmentMapping;
    this.destinationSegProperties = segmentProperties;
    this.carbonTable = carbonTable;
    this.dataFileMetadataSegMapping = dataFileMetadataSegMapping;
    this.restructuredBlockExists = restructuredBlockExists;
    this.queryExecutorList = new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
    this.dataTypeConverter = dataTypeConverter;
  }

  /**
   * For processing of the table blocks.
   *
   * @return Map of String with Carbon iterators
   * Map has 2 elements: UNSORTED and SORTED
   * Map(UNSORTED) = List of Iterators which yield sorted data
   * Map(Sorted) = List of Iterators which yield sorted data
   */
  public Map<String, List<RawResultIterator>> processTableBlocks(Configuration configuration)
      throws QueryExecutionException, IOException {

    Map<String, List<RawResultIterator>> resultList = new HashMap<>(2);
    resultList.put(CarbonCompactionUtil.UNSORTED_IDX,
        new ArrayList<RawResultIterator>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE));
    resultList.put(CarbonCompactionUtil.SORTED_IDX,
        new ArrayList<RawResultIterator>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE));

    List<TableBlockInfo> tableBlockInfos = null;
    QueryModelBuilder builder = new QueryModelBuilder(carbonTable)
        .projectAllColumns()
        .dataConverter(dataTypeConverter)
        .enableForcedDetailRawQuery();
    if (enablePageLevelReaderForCompaction()) {
      builder.enableReadPageByPage();
    }
    queryModel = builder.build();
    // iterate each seg ID
    for (Map.Entry<String, TaskBlockInfo> taskMap : segmentMapping.entrySet()) {
      String segmentId = taskMap.getKey();
      List<DataFileFooter> listMetadata = dataFileMetadataSegMapping.get(segmentId);
      // for each segment get taskblock info
      TaskBlockInfo taskBlockInfo = taskMap.getValue();
      Set<String> taskBlockListMapping = taskBlockInfo.getTaskSet();
      // Check if block needs sorting or not
      boolean sortingRequired =
          !CarbonCompactionUtil.isSortedByCurrentSortColumns(carbonTable, listMetadata.get(0));
      for (String task : taskBlockListMapping) {
        tableBlockInfos = taskBlockInfo.getTableBlockInfoList(task);
        // during update there may be a chance that the cardinality may change within the segment
        // which may lead to failure while converting the row, so get all the blocks present in a
        // task and then split into multiple lists of same column values and create separate
        // RawResultIterator for each tableBlockInfo of same column values. If all the blocks have
        // same column values, then make a single RawResultIterator for all the blocks
        List<List<TableBlockInfo>> listOfTableBlocksBasedOnKeyLength =
            getListOfTableBlocksBasedOnColumnValueSize(tableBlockInfos);
        for (List<TableBlockInfo> tableBlockInfoList : listOfTableBlocksBasedOnKeyLength) {
          Collections.sort(tableBlockInfoList);
          LOGGER.info("for task -" + task + "- in segment id -" + segmentId + "- block size is -"
              + tableBlockInfos.size());
          queryModel.setTableBlockInfos(tableBlockInfoList);
          if (sortingRequired) {
            resultList.get(CarbonCompactionUtil.UNSORTED_IDX).add(
                getRawResultIterator(configuration, segmentId, task, tableBlockInfoList));
          } else {
            resultList.get(CarbonCompactionUtil.SORTED_IDX).add(
                getRawResultIterator(configuration, segmentId, task, tableBlockInfoList));
          }
        }
      }
    }
    return resultList;
  }

  private RawResultIterator getRawResultIterator(Configuration configuration, String segmentId,
      String task, List<TableBlockInfo> tableBlockInfoList)
      throws QueryExecutionException, IOException {
    return new RawResultIterator(
        executeBlockList(tableBlockInfoList, segmentId, task, configuration),
        getSourceSegmentProperties(
            Collections.singletonList(tableBlockInfoList.get(0).getDataFileFooter())),
        destinationSegProperties, false);
  }

  /**
   * This method returns the List of TableBlockInfoList, where each listOfTableBlockInfos will have
   * same columnvalues
   * @param tableBlockInfos List of tableBlockInfos present in each task
   */
  private List<List<TableBlockInfo>> getListOfTableBlocksBasedOnColumnValueSize(
      List<TableBlockInfo> tableBlockInfos) {
    List<List<TableBlockInfo>> listOfTableBlockInfoListOnColumnvaluesSize = new ArrayList<>();
    Map<IntArrayWrapper, List<TableBlockInfo>> columnvalueSizeToTableBlockInfoMap = new HashMap<>();
    for (TableBlockInfo tableBlock : tableBlockInfos) {
      // get the columnValueSize for the dataFileFooter
      IntArrayWrapper columnValueSize = new IntArrayWrapper(
          getSourceSegmentProperties(Collections.singletonList(tableBlock.getDataFileFooter()))
              .getColumnsValueSize());
      List<TableBlockInfo> tempBlockInfoList =
          columnvalueSizeToTableBlockInfoMap.get(columnValueSize);
      if (tempBlockInfoList == null) {
        tempBlockInfoList = new ArrayList<>();
        columnvalueSizeToTableBlockInfoMap.put(columnValueSize, tempBlockInfoList);
      }
      tempBlockInfoList.add(tableBlock);
    }
    for (Map.Entry<IntArrayWrapper, List<TableBlockInfo>> taskMap :
        columnvalueSizeToTableBlockInfoMap.entrySet()) {
      listOfTableBlockInfoListOnColumnvaluesSize.add(taskMap.getValue());
    }
    return listOfTableBlockInfoListOnColumnvaluesSize;
  }

  /**
   * This method will create the source segment properties based on restructured block existence
   *
   * @param listMetadata
   * @return
   */
  private SegmentProperties getSourceSegmentProperties(List<DataFileFooter> listMetadata) {
    SegmentProperties sourceSegProperties = null;
    if (restructuredBlockExists) {
      // update cardinality of source segment according to new schema
      Map<String, Integer> columnToCardinalityMap =
          new HashMap<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
      CarbonCompactionUtil
          .addColumnCardinalityToMap(columnToCardinalityMap, listMetadata.get(0).getColumnInTable(),
              listMetadata.get(0).getSegmentInfo().getColumnCardinality());
      List<ColumnSchema> updatedColumnSchemaList =
          new ArrayList<>(listMetadata.get(0).getColumnInTable().size());
      int[] updatedColumnCardinalities = CarbonCompactionUtil
          .updateColumnSchemaAndGetCardinality(columnToCardinalityMap, carbonTable,
              updatedColumnSchemaList);
      sourceSegProperties =
          new SegmentProperties(updatedColumnSchemaList, updatedColumnCardinalities);
    } else {
      sourceSegProperties = new SegmentProperties(listMetadata.get(0).getColumnInTable(),
          listMetadata.get(0).getSegmentInfo().getColumnCardinality());
    }
    return sourceSegProperties;
  }

  /**
   * get executor and execute the query model.
   *
   * @param blockList
   * @return
   */
  private CarbonIterator<RowBatch> executeBlockList(List<TableBlockInfo> blockList,
      String segmentId, String taskId, Configuration configuration)
      throws QueryExecutionException, IOException {
    queryModel.setTableBlockInfos(blockList);
    QueryStatisticsRecorder executorRecorder = CarbonTimeStatisticsFactory
        .createExecutorRecorder(queryModel.getQueryId() + "_" + segmentId + "_" + taskId);
    queryStatisticsRecorders.add(executorRecorder);
    queryModel.setStatisticsRecorder(executorRecorder);
    QueryExecutor queryExecutor = QueryExecutorFactory.getQueryExecutor(queryModel, configuration);
    queryExecutorList.add(queryExecutor);
    return queryExecutor.execute(queryModel);
  }

  /**
   * Below method will be used
   * for cleanup
   */
  public void close(List<RawResultIterator> rawResultIteratorList, long queryStartTime) {
    try {
      // close all the iterators. Iterators might not closed in case of compaction failure
      // or if process is killed
      if (null != rawResultIteratorList) {
        for (RawResultIterator rawResultIterator : rawResultIteratorList) {
          rawResultIterator.close();
        }
      }
      for (QueryExecutor queryExecutor : queryExecutorList) {
        queryExecutor.finish();
      }
      logStatistics(queryStartTime);
    } catch (QueryExecutionException e) {
      LOGGER.error("Problem while close. Ignoring the exception", e);
    }
    clearDictionaryFromQueryModel();
  }

  private void logStatistics(long queryStartTime) {
    if (!queryStatisticsRecorders.isEmpty()) {
      QueryStatistic queryStatistic = new QueryStatistic();
      queryStatistic.addFixedTimeStatistic(QueryStatisticsConstants.EXECUTOR_PART,
          System.currentTimeMillis() - queryStartTime);
      for (QueryStatisticsRecorder recorder : queryStatisticsRecorders) {
        recorder.recordStatistics(queryStatistic);
        // print executor query statistics for each task_id
        recorder.logStatistics();
      }
    }
  }

  /**
   * This method will clear the dictionary access count after its usage is complete so
   * that column can be deleted form LRU cache whenever memory reaches threshold
   */
  private void clearDictionaryFromQueryModel() {
    if (null != queryModel) {
      Map<String, Dictionary> columnToDictionaryMapping = queryModel.getColumnToDictionaryMapping();
      if (null != columnToDictionaryMapping) {
        for (Map.Entry<String, Dictionary> entry : columnToDictionaryMapping.entrySet()) {
          CarbonUtil.clearDictionaryCache(entry.getValue());
        }
      }
    }
  }

  /**
   * Whether to enable page level reader for compaction or not.
   */
  private boolean enablePageLevelReaderForCompaction() {
    String enablePageReaderProperty = CarbonProperties.getInstance()
        .getProperty(CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION,
            CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION_DEFAULT);
    boolean enablePageReader;
    try {
      enablePageReader = Boolean.parseBoolean(enablePageReaderProperty);
    } catch (Exception e) {
      enablePageReader = Boolean.parseBoolean(
          CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION_DEFAULT);
    }
    LOGGER.info("Page level reader is set to: " + enablePageReader);
    return enablePageReader;
  }

}

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.processing.merger;
18
19	import java.io.IOException;
20	import java.util.ArrayList;
21	import java.util.Collections;
22	import java.util.HashMap;
23	import java.util.List;
24	import java.util.Map;
25	import java.util.Set;
26
27	import org.apache.carbondata.common.CarbonIterator;
28	import org.apache.carbondata.common.logging.LogServiceFactory;
29	import org.apache.carbondata.core.cache.dictionary.Dictionary;
30	import org.apache.carbondata.core.constants.CarbonCommonConstants;
31	import org.apache.carbondata.core.datastore.block.SegmentProperties;
32	import org.apache.carbondata.core.datastore.block.TableBlockInfo;
33	import org.apache.carbondata.core.datastore.block.TaskBlockInfo;
34	import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
35	import org.apache.carbondata.core.metadata.schema.table.CarbonTable;
36	import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
37	import org.apache.carbondata.core.scan.executor.QueryExecutor;
38	import org.apache.carbondata.core.scan.executor.QueryExecutorFactory;
39	import org.apache.carbondata.core.scan.executor.exception.QueryExecutionException;
40	import org.apache.carbondata.core.scan.model.QueryModel;
41	import org.apache.carbondata.core.scan.model.QueryModelBuilder;
42	import org.apache.carbondata.core.scan.result.RowBatch;
43	import org.apache.carbondata.core.scan.result.iterator.RawResultIterator;
44	import org.apache.carbondata.core.scan.wrappers.IntArrayWrapper;
45	import org.apache.carbondata.core.stats.QueryStatistic;
46	import org.apache.carbondata.core.stats.QueryStatisticsConstants;
47	import org.apache.carbondata.core.stats.QueryStatisticsRecorder;
48	import org.apache.carbondata.core.util.CarbonProperties;
49	import org.apache.carbondata.core.util.CarbonTimeStatisticsFactory;
50	import org.apache.carbondata.core.util.CarbonUtil;
51	import org.apache.carbondata.core.util.DataTypeConverter;
52
53	import org.apache.hadoop.conf.Configuration;
54	import org.apache.log4j.Logger;
55
56	/**
57	* Executor class for executing the query on the selected segments to be merged.
58	* This will fire a select * query and get the raw result.
59	*/
60	public class CarbonCompactionExecutor {
61
62	private static final Logger LOGGER =	1✔
63	LogServiceFactory.getLogService(CarbonCompactionExecutor.class.getName());	1✔
64	private final Map<String, List<DataFileFooter>> dataFileMetadataSegMapping;
65	private final SegmentProperties destinationSegProperties;
66	private final Map<String, TaskBlockInfo> segmentMapping;
67	private List<QueryExecutor> queryExecutorList;
68	private List<QueryStatisticsRecorder> queryStatisticsRecorders =	1✔
69	new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
70	private CarbonTable carbonTable;
71	private QueryModel queryModel;
72
73	/**
74	* flag to check whether any restructured block exists in the blocks selected for compaction.
75	* Based on this decision will be taken whether complete data has to be sorted again
76	*/
77	private boolean restructuredBlockExists;
78
79	// converter for UTF8String and decimal conversion
80	private DataTypeConverter dataTypeConverter;
81
82	/**
83	* Constructor
84	*
85	* @param segmentMapping
86	* @param segmentProperties
87	* @param carbonTable
88	* @param dataFileMetadataSegMapping
89	* @param restructuredBlockExists
90	*/
91	public CarbonCompactionExecutor(Map<String, TaskBlockInfo> segmentMapping,
92	SegmentProperties segmentProperties, CarbonTable carbonTable,
93	Map<String, List<DataFileFooter>> dataFileMetadataSegMapping,
94	boolean restructuredBlockExists, DataTypeConverter dataTypeConverter) {	1✔
95	this.segmentMapping = segmentMapping;	1✔
96	this.destinationSegProperties = segmentProperties;	1✔
97	this.carbonTable = carbonTable;	1✔
98	this.dataFileMetadataSegMapping = dataFileMetadataSegMapping;	1✔
99	this.restructuredBlockExists = restructuredBlockExists;	1✔
100	this.queryExecutorList = new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);	1✔
101	this.dataTypeConverter = dataTypeConverter;	1✔
102	}	1✔
103
104	/**
105	* For processing of the table blocks.
106	*
107	* @return Map of String with Carbon iterators
108	* Map has 2 elements: UNSORTED and SORTED
109	* Map(UNSORTED) = List of Iterators which yield sorted data
110	* Map(Sorted) = List of Iterators which yield sorted data
111	*/
112	public Map<String, List<RawResultIterator>> processTableBlocks(Configuration configuration)
113	throws QueryExecutionException, IOException {
114
115	Map<String, List<RawResultIterator>> resultList = new HashMap<>(2);	1✔
116	resultList.put(CarbonCompactionUtil.UNSORTED_IDX,	1✔
117	new ArrayList<RawResultIterator>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE));
118	resultList.put(CarbonCompactionUtil.SORTED_IDX,	1✔
119	new ArrayList<RawResultIterator>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE));
120
121	List<TableBlockInfo> tableBlockInfos = null;	1✔
122	QueryModelBuilder builder = new QueryModelBuilder(carbonTable)	1✔
123	.projectAllColumns()	1✔
124	.dataConverter(dataTypeConverter)	1✔
125	.enableForcedDetailRawQuery();	1✔
126	if (enablePageLevelReaderForCompaction()) {	1✔
127	builder.enableReadPageByPage();	1✔
128	}
129	queryModel = builder.build();	1✔
130	// iterate each seg ID
131	for (Map.Entry<String, TaskBlockInfo> taskMap : segmentMapping.entrySet()) {	1✔
132	String segmentId = taskMap.getKey();	1✔
133	List<DataFileFooter> listMetadata = dataFileMetadataSegMapping.get(segmentId);	1✔
134	// for each segment get taskblock info
135	TaskBlockInfo taskBlockInfo = taskMap.getValue();	1✔
136	Set<String> taskBlockListMapping = taskBlockInfo.getTaskSet();	1✔
137	// Check if block needs sorting or not
138	boolean sortingRequired =	1✔
139	!CarbonCompactionUtil.isSortedByCurrentSortColumns(carbonTable, listMetadata.get(0));	1✔
140	for (String task : taskBlockListMapping) {	1✔
141	tableBlockInfos = taskBlockInfo.getTableBlockInfoList(task);	1✔
142	// during update there may be a chance that the cardinality may change within the segment
143	// which may lead to failure while converting the row, so get all the blocks present in a
144	// task and then split into multiple lists of same column values and create separate
145	// RawResultIterator for each tableBlockInfo of same column values. If all the blocks have
146	// same column values, then make a single RawResultIterator for all the blocks
147	List<List<TableBlockInfo>> listOfTableBlocksBasedOnKeyLength =	1✔
148	getListOfTableBlocksBasedOnColumnValueSize(tableBlockInfos);	1✔
149	for (List<TableBlockInfo> tableBlockInfoList : listOfTableBlocksBasedOnKeyLength) {	1✔
150	Collections.sort(tableBlockInfoList);	1✔
151	LOGGER.info("for task -" + task + "- in segment id -" + segmentId + "- block size is -"	1✔
152	+ tableBlockInfos.size());	1✔
153	queryModel.setTableBlockInfos(tableBlockInfoList);	1✔
154	if (sortingRequired) {	1✔
155	resultList.get(CarbonCompactionUtil.UNSORTED_IDX).add(	1✔
156	getRawResultIterator(configuration, segmentId, task, tableBlockInfoList));	1✔
157	} else {
158	resultList.get(CarbonCompactionUtil.SORTED_IDX).add(	1✔
159	getRawResultIterator(configuration, segmentId, task, tableBlockInfoList));	1✔
160	}
161	}	1✔
162	}	1✔
163	}	1✔
164	return resultList;	1✔
165	}
166
167	private RawResultIterator getRawResultIterator(Configuration configuration, String segmentId,
168	String task, List<TableBlockInfo> tableBlockInfoList)
169	throws QueryExecutionException, IOException {
170	return new RawResultIterator(	1✔
171	executeBlockList(tableBlockInfoList, segmentId, task, configuration),	1✔
172	getSourceSegmentProperties(	1✔
173	Collections.singletonList(tableBlockInfoList.get(0).getDataFileFooter())),	1✔
174	destinationSegProperties, false);
175	}
176
177	/**
178	* This method returns the List of TableBlockInfoList, where each listOfTableBlockInfos will have
179	* same columnvalues
180	* @param tableBlockInfos List of tableBlockInfos present in each task
181	*/
182	private List<List<TableBlockInfo>> getListOfTableBlocksBasedOnColumnValueSize(
183	List<TableBlockInfo> tableBlockInfos) {
184	List<List<TableBlockInfo>> listOfTableBlockInfoListOnColumnvaluesSize = new ArrayList<>();	1✔
185	Map<IntArrayWrapper, List<TableBlockInfo>> columnvalueSizeToTableBlockInfoMap = new HashMap<>();	1✔
186	for (TableBlockInfo tableBlock : tableBlockInfos) {	1✔
187	// get the columnValueSize for the dataFileFooter
188	IntArrayWrapper columnValueSize = new IntArrayWrapper(	1✔
189	getSourceSegmentProperties(Collections.singletonList(tableBlock.getDataFileFooter()))	1✔
190	.getColumnsValueSize());	1✔
191	List<TableBlockInfo> tempBlockInfoList =	1✔
192	columnvalueSizeToTableBlockInfoMap.get(columnValueSize);	1✔
193	if (tempBlockInfoList == null) {	1✔
194	tempBlockInfoList = new ArrayList<>();	1✔
195	columnvalueSizeToTableBlockInfoMap.put(columnValueSize, tempBlockInfoList);	1✔
196	}
197	tempBlockInfoList.add(tableBlock);	1✔
198	}	1✔
199	for (Map.Entry<IntArrayWrapper, List<TableBlockInfo>> taskMap :
200	columnvalueSizeToTableBlockInfoMap.entrySet()) {	1✔
201	listOfTableBlockInfoListOnColumnvaluesSize.add(taskMap.getValue());	1✔
202	}	1✔
203	return listOfTableBlockInfoListOnColumnvaluesSize;	1✔
204	}
205
206	/**
207	* This method will create the source segment properties based on restructured block existence
208	*
209	* @param listMetadata
210	* @return
211	*/
212	private SegmentProperties getSourceSegmentProperties(List<DataFileFooter> listMetadata) {
213	SegmentProperties sourceSegProperties = null;	1✔
214	if (restructuredBlockExists) {	1✔
215	// update cardinality of source segment according to new schema
216	Map<String, Integer> columnToCardinalityMap =	1✔
217	new HashMap<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
218	CarbonCompactionUtil	1✔
219	.addColumnCardinalityToMap(columnToCardinalityMap, listMetadata.get(0).getColumnInTable(),	1✔
220	listMetadata.get(0).getSegmentInfo().getColumnCardinality());	1✔
221	List<ColumnSchema> updatedColumnSchemaList =	1✔
222	new ArrayList<>(listMetadata.get(0).getColumnInTable().size());	1✔
223	int[] updatedColumnCardinalities = CarbonCompactionUtil	1✔
224	.updateColumnSchemaAndGetCardinality(columnToCardinalityMap, carbonTable,	1✔
225	updatedColumnSchemaList);
226	sourceSegProperties =	1✔
227	new SegmentProperties(updatedColumnSchemaList, updatedColumnCardinalities);
228	} else {	1✔
229	sourceSegProperties = new SegmentProperties(listMetadata.get(0).getColumnInTable(),	1✔
230	listMetadata.get(0).getSegmentInfo().getColumnCardinality());	1✔
231	}
232	return sourceSegProperties;	1✔
233	}
234
235	/**
236	* get executor and execute the query model.
237	*
238	* @param blockList
239	* @return
240	*/
241	private CarbonIterator<RowBatch> executeBlockList(List<TableBlockInfo> blockList,
242	String segmentId, String taskId, Configuration configuration)
243	throws QueryExecutionException, IOException {
244	queryModel.setTableBlockInfos(blockList);	1✔
245	QueryStatisticsRecorder executorRecorder = CarbonTimeStatisticsFactory	1✔
246	.createExecutorRecorder(queryModel.getQueryId() + "_" + segmentId + "_" + taskId);	1✔
247	queryStatisticsRecorders.add(executorRecorder);	1✔
248	queryModel.setStatisticsRecorder(executorRecorder);	1✔
249	QueryExecutor queryExecutor = QueryExecutorFactory.getQueryExecutor(queryModel, configuration);	1✔
250	queryExecutorList.add(queryExecutor);	1✔
251	return queryExecutor.execute(queryModel);	1✔
252	}
253
254	/**
255	* Below method will be used
256	* for cleanup
257	*/
258	public void close(List<RawResultIterator> rawResultIteratorList, long queryStartTime) {
259	try {
260	// close all the iterators. Iterators might not closed in case of compaction failure
261	// or if process is killed
262	if (null != rawResultIteratorList) {	1✔
263	for (RawResultIterator rawResultIterator : rawResultIteratorList) {	1✔
264	rawResultIterator.close();	1✔
265	}	1✔
266	}
267	for (QueryExecutor queryExecutor : queryExecutorList) {	1✔
268	queryExecutor.finish();	1✔
269	}	1✔
270	logStatistics(queryStartTime);	1✔
271	} catch (QueryExecutionException e) {	×
272	LOGGER.error("Problem while close. Ignoring the exception", e);	×
273	}	1✔
274	clearDictionaryFromQueryModel();	1✔
275	}	1✔
276
277	private void logStatistics(long queryStartTime) {
278	if (!queryStatisticsRecorders.isEmpty()) {	1✔
279	QueryStatistic queryStatistic = new QueryStatistic();	1✔
280	queryStatistic.addFixedTimeStatistic(QueryStatisticsConstants.EXECUTOR_PART,	1✔
281	System.currentTimeMillis() - queryStartTime);	1✔
282	for (QueryStatisticsRecorder recorder : queryStatisticsRecorders) {	1✔
283	recorder.recordStatistics(queryStatistic);	1✔
284	// print executor query statistics for each task_id
285	recorder.logStatistics();	1✔
286	}	1✔
287	}
288	}	1✔
289
290	/**
291	* This method will clear the dictionary access count after its usage is complete so
292	* that column can be deleted form LRU cache whenever memory reaches threshold
293	*/
294	private void clearDictionaryFromQueryModel() {
295	if (null != queryModel) {	1✔
296	Map<String, Dictionary> columnToDictionaryMapping = queryModel.getColumnToDictionaryMapping();	1✔
297	if (null != columnToDictionaryMapping) {	1✔
298	for (Map.Entry<String, Dictionary> entry : columnToDictionaryMapping.entrySet()) {	1✔
299	CarbonUtil.clearDictionaryCache(entry.getValue());	1✔
300	}	1✔
301	}
302	}
303	}	1✔
304
305	/**
306	* Whether to enable page level reader for compaction or not.
307	*/
308	private boolean enablePageLevelReaderForCompaction() {
309	String enablePageReaderProperty = CarbonProperties.getInstance()	1✔
310	.getProperty(CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION,	1✔
311	CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION_DEFAULT);
312	boolean enablePageReader;
313	try {
314	enablePageReader = Boolean.parseBoolean(enablePageReaderProperty);	1✔
315	} catch (Exception e) {	×
316	enablePageReader = Boolean.parseBoolean(	×
317	CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION_DEFAULT);
318	}	1✔
319	LOGGER.info("Page level reader is set to: " + enablePageReader);	1✔
320	return enablePageReader;	1✔
321	}
322
323	}

apache / carbondata / 11243

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