10567

Build # 10567

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/6eb6815c6f7d13f9160e81753e4e0d4ec38bef06">6eb6815c6<a href="https://github.com/apache/carbondata/commit/6eb6815c6f7d13f9160e81753e4e0d4ec38bef06">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/d4a6c8801abcea9e8c314d256e9f8971e2ac9cf8">d4a6c8801</a>">d4a6c8801</a><a href="https://github.com/apache/carbondata/commit/6eb6815c6f7d13f9160e81753e4e0d4ec38bef06"> into 0221526aa">0221526aa</a>

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

62491 of 78705 relevant lines covered (79.4%)

1.05 hits per line

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

96.23

/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.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> list = 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);
      SegmentProperties sourceSegProperties = getSourceSegmentProperties(listMetadata);
      // 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.isRestructured(listMetadata, carbonTable.getTableLastUpdatedTime())
              || !CarbonCompactionUtil.isSorted(listMetadata.get(0));
      for (String task : taskBlockListMapping) {
        list = taskBlockInfo.getTableBlockInfoList(task);
        Collections.sort(list);
        LOGGER.info(
            "for task -" + task + "- in segment id -" + segmentId + "- block size is -" + list
                .size());
        queryModel.setTableBlockInfos(list);
        if (sortingRequired) {
          resultList.get(CarbonCompactionUtil.UNSORTED_IDX).add(
              new RawResultIterator(executeBlockList(list, segmentId, task, configuration),
                  sourceSegProperties, destinationSegProperties, false));
        } else {
          resultList.get(CarbonCompactionUtil.SORTED_IDX).add(
              new RawResultIterator(executeBlockList(list, segmentId, task, configuration),
                  sourceSegProperties, destinationSegProperties, false));
        }
      }
    }
    return resultList;
  }

  /**
   * 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.stats.QueryStatistic;
45	import org.apache.carbondata.core.stats.QueryStatisticsConstants;
46	import org.apache.carbondata.core.stats.QueryStatisticsRecorder;
47	import org.apache.carbondata.core.util.CarbonProperties;
48	import org.apache.carbondata.core.util.CarbonTimeStatisticsFactory;
49	import org.apache.carbondata.core.util.CarbonUtil;
50	import org.apache.carbondata.core.util.DataTypeConverter;
51
52	import org.apache.hadoop.conf.Configuration;
53	import org.apache.log4j.Logger;
54
55	/**
56	* Executor class for executing the query on the selected segments to be merged.
57	* This will fire a select * query and get the raw result.
58	*/
59	public class CarbonCompactionExecutor {
60
61	private static final Logger LOGGER =	1✔
62	LogServiceFactory.getLogService(CarbonCompactionExecutor.class.getName());	1✔
63	private final Map<String, List<DataFileFooter>> dataFileMetadataSegMapping;
64	private final SegmentProperties destinationSegProperties;
65	private final Map<String, TaskBlockInfo> segmentMapping;
66	private List<QueryExecutor> queryExecutorList;
67	private List<QueryStatisticsRecorder> queryStatisticsRecorders =	1✔
68	new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
69	private CarbonTable carbonTable;
70	private QueryModel queryModel;
71
72	/**
73	* flag to check whether any restructured block exists in the blocks selected for compaction.
74	* Based on this decision will be taken whether complete data has to be sorted again
75	*/
76	private boolean restructuredBlockExists;
77
78	// converter for UTF8String and decimal conversion
79	private DataTypeConverter dataTypeConverter;
80
81	/**
82	* Constructor
83	*
84	* @param segmentMapping
85	* @param segmentProperties
86	* @param carbonTable
87	* @param dataFileMetadataSegMapping
88	* @param restructuredBlockExists
89	*/
90	public CarbonCompactionExecutor(Map<String, TaskBlockInfo> segmentMapping,
91	SegmentProperties segmentProperties, CarbonTable carbonTable,
92	Map<String, List<DataFileFooter>> dataFileMetadataSegMapping,
93	boolean restructuredBlockExists, DataTypeConverter dataTypeConverter) {	1✔
94	this.segmentMapping = segmentMapping;	1✔
95	this.destinationSegProperties = segmentProperties;	1✔
96	this.carbonTable = carbonTable;	1✔
97	this.dataFileMetadataSegMapping = dataFileMetadataSegMapping;	1✔
98	this.restructuredBlockExists = restructuredBlockExists;	1✔
99	this.queryExecutorList = new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);	1✔
100	this.dataTypeConverter = dataTypeConverter;	1✔
101	}	1✔
102
103	/**
104	* For processing of the table blocks.
105	*
106	* @return Map of String with Carbon iterators
107	* Map has 2 elements: UNSORTED and SORTED
108	* Map(UNSORTED) = List of Iterators which yield sorted data
109	* Map(Sorted) = List of Iterators which yield sorted data
110	*/
111	public Map<String, List<RawResultIterator>> processTableBlocks(Configuration configuration)
112	throws QueryExecutionException, IOException {
113
114	Map<String, List<RawResultIterator>> resultList = new HashMap<>(2);	1✔
115	resultList.put(CarbonCompactionUtil.UNSORTED_IDX,	1✔
116	new ArrayList<RawResultIterator>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE));
117	resultList.put(CarbonCompactionUtil.SORTED_IDX,	1✔
118	new ArrayList<RawResultIterator>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE));
119
120	List<TableBlockInfo> list = null;	1✔
121	QueryModelBuilder builder = new QueryModelBuilder(carbonTable)	1✔
122	.projectAllColumns()	1✔
123	.dataConverter(dataTypeConverter)	1✔
124	.enableForcedDetailRawQuery();	1✔
125	if (enablePageLevelReaderForCompaction()) {	1✔
126	builder.enableReadPageByPage();	1✔
127	}
128	queryModel = builder.build();	1✔
129	// iterate each seg ID
130	for (Map.Entry<String, TaskBlockInfo> taskMap : segmentMapping.entrySet()) {	1✔
131	String segmentId = taskMap.getKey();	1✔
132	List<DataFileFooter> listMetadata = dataFileMetadataSegMapping.get(segmentId);	1✔
133	SegmentProperties sourceSegProperties = getSourceSegmentProperties(listMetadata);	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.isRestructured(listMetadata, carbonTable.getTableLastUpdatedTime())	1✔
140	\|\| !CarbonCompactionUtil.isSorted(listMetadata.get(0));	1✔
141	for (String task : taskBlockListMapping) {	1✔
142	list = taskBlockInfo.getTableBlockInfoList(task);	1✔
143	Collections.sort(list);	1✔
144	LOGGER.info(	1✔
145	"for task -" + task + "- in segment id -" + segmentId + "- block size is -" + list
146	.size());	1✔
147	queryModel.setTableBlockInfos(list);	1✔
148	if (sortingRequired) {	1✔
149	resultList.get(CarbonCompactionUtil.UNSORTED_IDX).add(	1✔
150	new RawResultIterator(executeBlockList(list, segmentId, task, configuration),	1✔
151	sourceSegProperties, destinationSegProperties, false));
152	} else {
153	resultList.get(CarbonCompactionUtil.SORTED_IDX).add(	1✔
154	new RawResultIterator(executeBlockList(list, segmentId, task, configuration),	1✔
155	sourceSegProperties, destinationSegProperties, false));
156	}
157	}	1✔
158	}	1✔
159	return resultList;	1✔
160	}
161
162	/**
163	* This method will create the source segment properties based on restructured block existence
164	*
165	* @param listMetadata
166	* @return
167	*/
168	private SegmentProperties getSourceSegmentProperties(List<DataFileFooter> listMetadata) {
169	SegmentProperties sourceSegProperties = null;	1✔
170	if (restructuredBlockExists) {	1✔
171	// update cardinality of source segment according to new schema
172	Map<String, Integer> columnToCardinalityMap =	1✔
173	new HashMap<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
174	CarbonCompactionUtil	1✔
175	.addColumnCardinalityToMap(columnToCardinalityMap, listMetadata.get(0).getColumnInTable(),	1✔
176	listMetadata.get(0).getSegmentInfo().getColumnCardinality());	1✔
177	List<ColumnSchema> updatedColumnSchemaList =	1✔
178	new ArrayList<>(listMetadata.get(0).getColumnInTable().size());	1✔
179	int[] updatedColumnCardinalities = CarbonCompactionUtil	1✔
180	.updateColumnSchemaAndGetCardinality(columnToCardinalityMap, carbonTable,	1✔
181	updatedColumnSchemaList);
182	sourceSegProperties =	1✔
183	new SegmentProperties(updatedColumnSchemaList, updatedColumnCardinalities);
184	} else {	1✔
185	sourceSegProperties = new SegmentProperties(listMetadata.get(0).getColumnInTable(),	1✔
186	listMetadata.get(0).getSegmentInfo().getColumnCardinality());	1✔
187	}
188	return sourceSegProperties;	1✔
189	}
190
191	/**
192	* get executor and execute the query model.
193	*
194	* @param blockList
195	* @return
196	*/
197	private CarbonIterator<RowBatch> executeBlockList(List<TableBlockInfo> blockList,
198	String segmentId, String taskId, Configuration configuration)
199	throws QueryExecutionException, IOException {
200	queryModel.setTableBlockInfos(blockList);	1✔
201	QueryStatisticsRecorder executorRecorder = CarbonTimeStatisticsFactory	1✔
202	.createExecutorRecorder(queryModel.getQueryId() + "_" + segmentId + "_" + taskId);	1✔
203	queryStatisticsRecorders.add(executorRecorder);	1✔
204	queryModel.setStatisticsRecorder(executorRecorder);	1✔
205	QueryExecutor queryExecutor = QueryExecutorFactory.getQueryExecutor(queryModel, configuration);	1✔
206	queryExecutorList.add(queryExecutor);	1✔
207	return queryExecutor.execute(queryModel);	1✔
208	}
209
210	/**
211	* Below method will be used
212	* for cleanup
213	*/
214	public void close(List<RawResultIterator> rawResultIteratorList, long queryStartTime) {
215	try {
216	// close all the iterators. Iterators might not closed in case of compaction failure
217	// or if process is killed
218	if (null != rawResultIteratorList) {	1✔
219	for (RawResultIterator rawResultIterator : rawResultIteratorList) {	1✔
220	rawResultIterator.close();	1✔
221	}	1✔
222	}
223	for (QueryExecutor queryExecutor : queryExecutorList) {	1✔
224	queryExecutor.finish();	1✔
225	}	1✔
226	logStatistics(queryStartTime);	1✔
227	} catch (QueryExecutionException e) {	×
228	LOGGER.error("Problem while close. Ignoring the exception", e);	×
229	}	1✔
230	clearDictionaryFromQueryModel();	1✔
231	}	1✔
232
233	private void logStatistics(long queryStartTime) {
234	if (!queryStatisticsRecorders.isEmpty()) {	1✔
235	QueryStatistic queryStatistic = new QueryStatistic();	1✔
236	queryStatistic.addFixedTimeStatistic(QueryStatisticsConstants.EXECUTOR_PART,	1✔
237	System.currentTimeMillis() - queryStartTime);	1✔
238	for (QueryStatisticsRecorder recorder : queryStatisticsRecorders) {	1✔
239	recorder.recordStatistics(queryStatistic);	1✔
240	// print executor query statistics for each task_id
241	recorder.logStatistics();	1✔
242	}	1✔
243	}
244	}	1✔
245
246	/**
247	* This method will clear the dictionary access count after its usage is complete so
248	* that column can be deleted form LRU cache whenever memory reaches threshold
249	*/
250	private void clearDictionaryFromQueryModel() {
251	if (null != queryModel) {	1✔
252	Map<String, Dictionary> columnToDictionaryMapping = queryModel.getColumnToDictionaryMapping();	1✔
253	if (null != columnToDictionaryMapping) {	1✔
254	for (Map.Entry<String, Dictionary> entry : columnToDictionaryMapping.entrySet()) {	1✔
255	CarbonUtil.clearDictionaryCache(entry.getValue());	1✔
256	}	1✔
257	}
258	}
259	}	1✔
260
261	/**
262	* Whether to enable page level reader for compaction or not.
263	*/
264	private boolean enablePageLevelReaderForCompaction() {
265	String enablePageReaderProperty = CarbonProperties.getInstance()	1✔
266	.getProperty(CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION,	1✔
267	CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION_DEFAULT);
268	boolean enablePageReader;
269	try {
270	enablePageReader = Boolean.parseBoolean(enablePageReaderProperty);	1✔
271	} catch (Exception e) {	×
272	enablePageReader = Boolean.parseBoolean(	×
273	CarbonCommonConstants.CARBON_ENABLE_PAGE_LEVEL_READER_IN_COMPACTION_DEFAULT);
274	}	1✔
275	LOGGER.info("Page level reader is set to: " + enablePageReader);	1✔
276	return enablePageReader;	1✔
277	}
278
279	}

apache / carbondata / 10567

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