apache / carbondata / 994

Build # 994

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/4eb6c8a4808e1110869d9e6ea1de01d5b7c05e00">4eb6c8a48<a href="https://github.com/apache/carbondata/commit/4eb6c8a4808e1110869d9e6ea1de01d5b7c05e00">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/3ec788d41bdd02117e187fa951e0193187415926">3ec788d41</a>">3ec788d41</a><a href="https://github.com/apache/carbondata/commit/4eb6c8a4808e1110869d9e6ea1de01d5b7c05e00"> into 15d38260c">15d38260c</a>

Run Details

57 of 57 new or added lines in 4 files covered. (100.0%)

60658 of 75260 relevant lines covered (80.6%)

1.06 hits per line

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

87.59

/core/src/main/java/org/apache/carbondata/core/scan/model/QueryModel.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.scan.model;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.carbondata.core.cache.dictionary.Dictionary;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.datastore.block.TableBlockInfo;
import org.apache.carbondata.core.metadata.AbsoluteTableIdentifier;
import org.apache.carbondata.core.metadata.schema.table.CarbonTable;
import org.apache.carbondata.core.metadata.schema.table.column.CarbonColumn;
import org.apache.carbondata.core.metadata.schema.table.column.CarbonDimension;
import org.apache.carbondata.core.metadata.schema.table.column.CarbonMeasure;
import org.apache.carbondata.core.mutate.UpdateVO;
import org.apache.carbondata.core.scan.expression.ColumnExpression;
import org.apache.carbondata.core.scan.expression.Expression;
import org.apache.carbondata.core.scan.expression.UnknownExpression;
import org.apache.carbondata.core.scan.expression.conditional.ConditionalExpression;
import org.apache.carbondata.core.scan.filter.resolver.FilterResolverIntf;
import org.apache.carbondata.core.stats.QueryStatisticsRecorder;
import org.apache.carbondata.core.util.CarbonUtil;
import org.apache.carbondata.core.util.DataTypeConverter;

/**
 * Query model which will have all the detail
 * about the query, This will be sent from driver to executor '
 * This will be refereed to executing the query.
 */
public class QueryModel {

  /**
   * this will hold the information about the dictionary dimension
   * which to
   */
  private transient Map<String, Dictionary> columnToDictionaryMapping;
  /**
   * list of projection columns in query
   */
  private QueryProjection projection;
  /**
   * query id
   */
  private String queryId;
  /**
   * filter tree
   */
  private FilterResolverIntf filterExpressionResolverTree;

  /**
   * filter expression tree
   */
  private Expression filterExpression;

  /**
   * table block information in which query will be executed
   */
  private List<TableBlockInfo> tableBlockInfos;
  /**
   * To handle most of the computation in query engines like spark and hive, carbon should give
   * raw detailed records to it.
   */
  private boolean forcedDetailRawQuery;
  /**
   * table on which query will be executed
   * TODO need to remove this ad pass only the path
   * and carbon metadata will load the table from metadata file
   */
  private CarbonTable table;

  private QueryStatisticsRecorder statisticsRecorder;

  private boolean vectorReader;

  private DataTypeConverter converter;

  /**
   * Invalid table blocks, which need to be removed from
   * memory, invalid blocks can be segment which are deleted
   * or compacted
   */
  private List<String> invalidSegmentIds;
  private Map<String, UpdateVO> invalidSegmentBlockIdMap =
      new HashMap<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);

  private boolean[] isFilterDimensions;
  private boolean[] isFilterMeasures;

  /**
   * Read the data from carbondata file page by page instead of whole blocklet.
   */
  private boolean readPageByPage;

  /**
   * whether it require to output the row id
   */
  private boolean requiredRowId;

  /**
   * whether it is FG with search mode
   */
  private boolean isFG;

  // whether to clear/free unsafe memory or not
  private boolean freeUnsafeMemory = true;

  private boolean preFetchData = true;

  /**
   * It fills the vector directly from decoded column page with out any staging and conversions
   */
  private boolean isDirectVectorFill;

  private QueryModel(CarbonTable carbonTable) {
    tableBlockInfos = new ArrayList<TableBlockInfo>();
    invalidSegmentIds = new ArrayList<>();
    this.table = carbonTable;
    this.queryId = String.valueOf(System.nanoTime());
  }

  public static QueryModel newInstance(CarbonTable carbonTable) {
    return new QueryModel(carbonTable);
  }

  public static void processFilterExpression(FilterProcessVO processVO, Expression filterExpression,
      final boolean[] isFilterDimensions, final boolean[] isFilterMeasures) {
    if (null != filterExpression) {
      if (null != filterExpression.getChildren() && filterExpression.getChildren().size() == 0) {
        if (filterExpression instanceof ConditionalExpression) {
          List<ColumnExpression> listOfCol =
              ((ConditionalExpression) filterExpression).getColumnList();
          for (ColumnExpression expression : listOfCol) {
            setDimAndMsrColumnNode(processVO, expression, isFilterDimensions, isFilterMeasures);
          }
        }
      }
      for (Expression expression : filterExpression.getChildren()) {
        if (expression instanceof ColumnExpression) {
          setDimAndMsrColumnNode(processVO, (ColumnExpression) expression, isFilterDimensions,
              isFilterMeasures);
        } else if (expression instanceof UnknownExpression) {
          UnknownExpression exp = ((UnknownExpression) expression);
          List<ColumnExpression> listOfColExpression = exp.getAllColumnList();
          for (ColumnExpression col : listOfColExpression) {
            setDimAndMsrColumnNode(processVO, col, isFilterDimensions, isFilterMeasures);
          }
        } else {
          processFilterExpression(processVO, expression, isFilterDimensions, isFilterMeasures);
        }
      }
    }

  }

  private static CarbonMeasure getCarbonMetadataMeasure(String name, List<CarbonMeasure> measures) {
    for (CarbonMeasure measure : measures) {
      if (measure.getColName().equalsIgnoreCase(name)) {
        return measure;
      }
    }
    return null;
  }

  private static void setDimAndMsrColumnNode(FilterProcessVO processVO, ColumnExpression col,
      boolean[] isFilterDimensions, boolean[] isFilterMeasures) {
    CarbonDimension dim;
    CarbonMeasure msr;
    String columnName;
    columnName = col.getColumnName();
    col.reset();
    dim = CarbonUtil
        .findDimension(processVO.getCarbonDimensions(), columnName);
    msr = getCarbonMetadataMeasure(columnName, processVO.getCarbonMeasures());

    if (null != dim) {
      // Dimension Column
      col.setCarbonColumn(dim);
      col.setDimension(dim);
      col.setDimension(true);
      if (null != isFilterDimensions) {
        isFilterDimensions[dim.getOrdinal()] = true;
      }
    } else if (msr != null) {
      col.setCarbonColumn(msr);
      col.setMeasure(msr);
      col.setMeasure(true);
      if (null != isFilterMeasures) {
        isFilterMeasures[msr.getOrdinal()] = true;
      }
    } else {
      // check if this is an implicit dimension
      dim = CarbonUtil
          .findDimension(processVO.getImplicitDimensions(), columnName);
      col.setCarbonColumn(dim);
      col.setDimension(dim);
      col.setDimension(true);
    }
  }

  /**
   * It gets the projection columns
   */
  public CarbonColumn[] getProjectionColumns() {
    CarbonColumn[] carbonColumns =
        new CarbonColumn[getProjectionDimensions().size() + getProjectionMeasures().size()];
    for (ProjectionDimension dimension : getProjectionDimensions()) {
      carbonColumns[dimension.getOrdinal()] = dimension.getDimension();
    }
    for (ProjectionMeasure msr : getProjectionMeasures()) {
      carbonColumns[msr.getOrdinal()] = msr.getMeasure();
    }
    return carbonColumns;
  }

  public void setProjection(QueryProjection projection) {
    this.projection = projection;
  }

  public List<ProjectionDimension> getProjectionDimensions() {
    return projection.getDimensions();
  }

  public List<ProjectionMeasure> getProjectionMeasures() {
    return projection.getMeasures();
  }

  /**
   * @return the queryId
   */
  public String getQueryId() {
    return queryId;
  }

  public void setQueryId(String queryId) {
    this.queryId = queryId;
  }

  /**
   * @return the tableBlockInfos
   */
  public List<TableBlockInfo> getTableBlockInfos() {
    return tableBlockInfos;
  }

  /**
   * @param tableBlockInfos the tableBlockInfos to set
   */
  public void setTableBlockInfos(List<TableBlockInfo> tableBlockInfos) {
    this.tableBlockInfos = tableBlockInfos;
  }

  /**
   * @return the filterEvaluatorTree
   */
  public FilterResolverIntf getFilterExpressionResolverTree() {
    return filterExpressionResolverTree;
  }

  public void setFilterExpressionResolverTree(FilterResolverIntf filterExpressionResolverTree) {
    this.filterExpressionResolverTree = filterExpressionResolverTree;
  }

  public Expression getFilterExpression() {
    return filterExpression;
  }

  public void setFilterExpression(Expression filterExpression) {
    this.filterExpression = filterExpression;
  }

  /**
   * @return the absoluteTableIdentifier
   */
  public AbsoluteTableIdentifier getAbsoluteTableIdentifier() {
    return table.getAbsoluteTableIdentifier();
  }

  /**
   * @return the table
   */
  public CarbonTable getTable() {
    return table;
  }

  public boolean isForcedDetailRawQuery() {
    return forcedDetailRawQuery;
  }

  public void setForcedDetailRawQuery(boolean forcedDetailRawQuery) {
    this.forcedDetailRawQuery = forcedDetailRawQuery;
  }

  /**
   * @return
   */
  public Map<String, Dictionary> getColumnToDictionaryMapping() {
    return columnToDictionaryMapping;
  }

  /**
   * @param columnToDictionaryMapping
   */
  public void setColumnToDictionaryMapping(Map<String, Dictionary> columnToDictionaryMapping) {
    this.columnToDictionaryMapping = columnToDictionaryMapping;
  }

  public QueryStatisticsRecorder getStatisticsRecorder() {
    return statisticsRecorder;
  }

  public void setStatisticsRecorder(QueryStatisticsRecorder statisticsRecorder) {
    this.statisticsRecorder = statisticsRecorder;
  }

  public List<String> getInvalidSegmentIds() {
    return invalidSegmentIds;
  }

  public void setInvalidSegmentIds(List<String> invalidSegmentIds) {
    this.invalidSegmentIds = invalidSegmentIds;
  }

  public boolean isVectorReader() {
    return vectorReader;
  }

  public void setVectorReader(boolean vectorReader) {
    this.vectorReader = vectorReader;
  }
  public void setInvalidBlockForSegmentId(List<UpdateVO> invalidSegmentTimestampList) {
    for (UpdateVO anUpdateVO : invalidSegmentTimestampList) {
      this.invalidSegmentBlockIdMap.put(anUpdateVO.getSegmentId(), anUpdateVO);
    }
  }

  public Map<String,UpdateVO>  getInvalidBlockVOForSegmentId() {
    return  invalidSegmentBlockIdMap;
  }

  public DataTypeConverter getConverter() {
    return converter;
  }

  public void setConverter(DataTypeConverter converter) {
    this.converter = converter;
  }

  public boolean[] getIsFilterDimensions() {
    return isFilterDimensions;
  }

  public void setIsFilterDimensions(boolean[] isFilterDimensions) {
    this.isFilterDimensions = isFilterDimensions;
  }

  public boolean[] getIsFilterMeasures() {
    return isFilterMeasures;
  }

  public void setIsFilterMeasures(boolean[] isFilterMeasures) {
    this.isFilterMeasures = isFilterMeasures;
  }

  public boolean isReadPageByPage() {
    return readPageByPage;
  }

  public void setReadPageByPage(boolean readPageByPage) {
    this.readPageByPage = readPageByPage;
  }

  public boolean isRequiredRowId() {
    return requiredRowId;
  }

  public void setRequiredRowId(boolean requiredRowId) {
    this.requiredRowId = requiredRowId;
  }

  public boolean isFG() {
    return isFG;
  }

  public void setFG(boolean FG) {
    isFG = FG;
  }

  public boolean isPreFetchData() {
    return preFetchData;
  }

  public void setPreFetchData(boolean preFetchData) {
    this.preFetchData = preFetchData;
  }

  public boolean isDirectVectorFill() {
    return isDirectVectorFill;
  }

  public void setDirectVectorFill(boolean directVectorFill) {
    isDirectVectorFill = directVectorFill;
  }

  @Override
  public String toString() {
    return String.format("scan on table %s.%s, %d projection columns with filter (%s)",
        table.getDatabaseName(), table.getTableName(),
        projection.getDimensions().size() + projection.getMeasures().size(),
        filterExpressionResolverTree.getFilterExpression().toString());
  }

  public boolean isFreeUnsafeMemory() {
    return freeUnsafeMemory;
  }

  public void setFreeUnsafeMemory(boolean freeUnsafeMemory) {
    this.freeUnsafeMemory = freeUnsafeMemory;
  }

  public static class FilterProcessVO {

    private List<CarbonDimension> carbonDimensions;

    private List<CarbonMeasure> carbonMeasures;

    private List<CarbonDimension> implicitDimensions;

    public FilterProcessVO(List<CarbonDimension> carbonDimensions,
        List<CarbonMeasure> carbonMeasures, List<CarbonDimension> implicitDimensions) {
      this.carbonDimensions = carbonDimensions;
      this.carbonMeasures = carbonMeasures;
      this.implicitDimensions = implicitDimensions;
    }

    public List<CarbonDimension> getCarbonDimensions() {
      return carbonDimensions;
    }

    public List<CarbonMeasure> getCarbonMeasures() {
      return carbonMeasures;
    }

    public List<CarbonDimension> getImplicitDimensions() {
      return implicitDimensions;
    }
  }
}

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.scan.model;
19
20	import java.util.ArrayList;
21	import java.util.HashMap;
22	import java.util.List;
23	import java.util.Map;
24
25	import org.apache.carbondata.core.cache.dictionary.Dictionary;
26	import org.apache.carbondata.core.constants.CarbonCommonConstants;
27	import org.apache.carbondata.core.datastore.block.TableBlockInfo;
28	import org.apache.carbondata.core.metadata.AbsoluteTableIdentifier;
29	import org.apache.carbondata.core.metadata.schema.table.CarbonTable;
30	import org.apache.carbondata.core.metadata.schema.table.column.CarbonColumn;
31	import org.apache.carbondata.core.metadata.schema.table.column.CarbonDimension;
32	import org.apache.carbondata.core.metadata.schema.table.column.CarbonMeasure;
33	import org.apache.carbondata.core.mutate.UpdateVO;
34	import org.apache.carbondata.core.scan.expression.ColumnExpression;
35	import org.apache.carbondata.core.scan.expression.Expression;
36	import org.apache.carbondata.core.scan.expression.UnknownExpression;
37	import org.apache.carbondata.core.scan.expression.conditional.ConditionalExpression;
38	import org.apache.carbondata.core.scan.filter.resolver.FilterResolverIntf;
39	import org.apache.carbondata.core.stats.QueryStatisticsRecorder;
40	import org.apache.carbondata.core.util.CarbonUtil;
41	import org.apache.carbondata.core.util.DataTypeConverter;
42
43	/**
44	* Query model which will have all the detail
45	* about the query, This will be sent from driver to executor '
46	* This will be refereed to executing the query.
47	*/
48	public class QueryModel {
49
50	/**
51	* this will hold the information about the dictionary dimension
52	* which to
53	*/
54	private transient Map<String, Dictionary> columnToDictionaryMapping;
55	/**
56	* list of projection columns in query
57	*/
58	private QueryProjection projection;
59	/**
60	* query id
61	*/
62	private String queryId;
63	/**
64	* filter tree
65	*/
66	private FilterResolverIntf filterExpressionResolverTree;
67
68	/**
69	* filter expression tree
70	*/
71	private Expression filterExpression;
72
73	/**
74	* table block information in which query will be executed
75	*/
76	private List<TableBlockInfo> tableBlockInfos;
77	/**
78	* To handle most of the computation in query engines like spark and hive, carbon should give
79	* raw detailed records to it.
80	*/
81	private boolean forcedDetailRawQuery;
82	/**
83	* table on which query will be executed
84	* TODO need to remove this ad pass only the path
85	* and carbon metadata will load the table from metadata file
86	*/
87	private CarbonTable table;
88
89	private QueryStatisticsRecorder statisticsRecorder;
90
91	private boolean vectorReader;
92
93	private DataTypeConverter converter;
94
95	/**
96	* Invalid table blocks, which need to be removed from
97	* memory, invalid blocks can be segment which are deleted
98	* or compacted
99	*/
100	private List<String> invalidSegmentIds;
101	private Map<String, UpdateVO> invalidSegmentBlockIdMap =	1✔
102	new HashMap<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
103
104	private boolean[] isFilterDimensions;
105	private boolean[] isFilterMeasures;
106
107	/**
108	* Read the data from carbondata file page by page instead of whole blocklet.
109	*/
110	private boolean readPageByPage;
111
112	/**
113	* whether it require to output the row id
114	*/
115	private boolean requiredRowId;
116
117	/**
118	* whether it is FG with search mode
119	*/
120	private boolean isFG;
121
122	// whether to clear/free unsafe memory or not
123	private boolean freeUnsafeMemory = true;	1✔
124
125	private boolean preFetchData = true;	1✔
126
127	/**
128	* It fills the vector directly from decoded column page with out any staging and conversions
129	*/
130	private boolean isDirectVectorFill;
131
132	private QueryModel(CarbonTable carbonTable) {	1✔
133	tableBlockInfos = new ArrayList<TableBlockInfo>();	1✔
134	invalidSegmentIds = new ArrayList<>();	1✔
135	this.table = carbonTable;	1✔
136	this.queryId = String.valueOf(System.nanoTime());	1✔
137	}	1✔
138
139	public static QueryModel newInstance(CarbonTable carbonTable) {
140	return new QueryModel(carbonTable);	1✔
141	}
142
143	public static void processFilterExpression(FilterProcessVO processVO, Expression filterExpression,
144	final boolean[] isFilterDimensions, final boolean[] isFilterMeasures) {
145	if (null != filterExpression) {	1✔
146	if (null != filterExpression.getChildren() && filterExpression.getChildren().size() == 0) {	1✔
147	if (filterExpression instanceof ConditionalExpression) {	1✔
148	List<ColumnExpression> listOfCol =	×
149	((ConditionalExpression) filterExpression).getColumnList();	×
150	for (ColumnExpression expression : listOfCol) {	×
151	setDimAndMsrColumnNode(processVO, expression, isFilterDimensions, isFilterMeasures);	×
152	}	×
153	}
154	}
155	for (Expression expression : filterExpression.getChildren()) {	1✔
156	if (expression instanceof ColumnExpression) {	1✔
157	setDimAndMsrColumnNode(processVO, (ColumnExpression) expression, isFilterDimensions,	1✔
158	isFilterMeasures);
159	} else if (expression instanceof UnknownExpression) {	1✔
160	UnknownExpression exp = ((UnknownExpression) expression);	1✔
161	List<ColumnExpression> listOfColExpression = exp.getAllColumnList();	1✔
162	for (ColumnExpression col : listOfColExpression) {	1✔
163	setDimAndMsrColumnNode(processVO, col, isFilterDimensions, isFilterMeasures);	1✔
164	}	1✔
165	} else {	1✔
166	processFilterExpression(processVO, expression, isFilterDimensions, isFilterMeasures);	1✔
167	}
168	}	1✔
169	}
170
171	}	1✔
172
173	private static CarbonMeasure getCarbonMetadataMeasure(String name, List<CarbonMeasure> measures) {
174	for (CarbonMeasure measure : measures) {	1✔
175	if (measure.getColName().equalsIgnoreCase(name)) {	1✔
176	return measure;	1✔
177	}
178	}	1✔
179	return null;	1✔
180	}
181
182	private static void setDimAndMsrColumnNode(FilterProcessVO processVO, ColumnExpression col,
183	boolean[] isFilterDimensions, boolean[] isFilterMeasures) {
184	CarbonDimension dim;
185	CarbonMeasure msr;
186	String columnName;
187	columnName = col.getColumnName();	1✔
188	col.reset();	1✔
189	dim = CarbonUtil	1✔
190	.findDimension(processVO.getCarbonDimensions(), columnName);	1✔
191	msr = getCarbonMetadataMeasure(columnName, processVO.getCarbonMeasures());	1✔
192
193	if (null != dim) {	1✔
194	// Dimension Column
195	col.setCarbonColumn(dim);	1✔
196	col.setDimension(dim);	1✔
197	col.setDimension(true);	1✔
198	if (null != isFilterDimensions) {	1✔
199	isFilterDimensions[dim.getOrdinal()] = true;	1✔
200	}
201	} else if (msr != null) {	1✔
202	col.setCarbonColumn(msr);	1✔
203	col.setMeasure(msr);	1✔
204	col.setMeasure(true);	1✔
205	if (null != isFilterMeasures) {	1✔
206	isFilterMeasures[msr.getOrdinal()] = true;	1✔
207	}
208	} else {
209	// check if this is an implicit dimension
210	dim = CarbonUtil	×
211	.findDimension(processVO.getImplicitDimensions(), columnName);	×
212	col.setCarbonColumn(dim);	×
213	col.setDimension(dim);	×
214	col.setDimension(true);	×
215	}
216	}	1✔
217
218	/**
219	* It gets the projection columns
220	*/
221	public CarbonColumn[] getProjectionColumns() {
222	CarbonColumn[] carbonColumns =	1✔
223	new CarbonColumn[getProjectionDimensions().size() + getProjectionMeasures().size()];	1✔
224	for (ProjectionDimension dimension : getProjectionDimensions()) {	1✔
225	carbonColumns[dimension.getOrdinal()] = dimension.getDimension();	1✔
226	}	1✔
227	for (ProjectionMeasure msr : getProjectionMeasures()) {	1✔
228	carbonColumns[msr.getOrdinal()] = msr.getMeasure();	1✔
229	}	1✔
230	return carbonColumns;	1✔
231	}
232
233	public void setProjection(QueryProjection projection) {
234	this.projection = projection;	1✔
235	}	1✔
236
237	public List<ProjectionDimension> getProjectionDimensions() {
238	return projection.getDimensions();	1✔
239	}
240
241	public List<ProjectionMeasure> getProjectionMeasures() {
242	return projection.getMeasures();	1✔
243	}
244
245	/**
246	* @return the queryId
247	*/
248	public String getQueryId() {
249	return queryId;	1✔
250	}
251
252	public void setQueryId(String queryId) {
253	this.queryId = queryId;	1✔
254	}	1✔
255
256	/**
257	* @return the tableBlockInfos
258	*/
259	public List<TableBlockInfo> getTableBlockInfos() {
260	return tableBlockInfos;	1✔
261	}
262
263	/**
264	* @param tableBlockInfos the tableBlockInfos to set
265	*/
266	public void setTableBlockInfos(List<TableBlockInfo> tableBlockInfos) {
267	this.tableBlockInfos = tableBlockInfos;	1✔
268	}	1✔
269
270	/**
271	* @return the filterEvaluatorTree
272	*/
273	public FilterResolverIntf getFilterExpressionResolverTree() {
274	return filterExpressionResolverTree;	1✔
275	}
276
277	public void setFilterExpressionResolverTree(FilterResolverIntf filterExpressionResolverTree) {
278	this.filterExpressionResolverTree = filterExpressionResolverTree;	1✔
279	}	1✔
280
281	public Expression getFilterExpression() {
282	return filterExpression;	1✔
283	}
284
285	public void setFilterExpression(Expression filterExpression) {
286	this.filterExpression = filterExpression;	1✔
287	}	1✔
288
289	/**
290	* @return the absoluteTableIdentifier
291	*/
292	public AbsoluteTableIdentifier getAbsoluteTableIdentifier() {
293	return table.getAbsoluteTableIdentifier();	1✔
294	}
295
296	/**
297	* @return the table
298	*/
299	public CarbonTable getTable() {
300	return table;	1✔
301	}
302
303	public boolean isForcedDetailRawQuery() {
304	return forcedDetailRawQuery;	1✔
305	}
306
307	public void setForcedDetailRawQuery(boolean forcedDetailRawQuery) {
308	this.forcedDetailRawQuery = forcedDetailRawQuery;	1✔
309	}	1✔
310
311	/**
312	* @return
313	*/
314	public Map<String, Dictionary> getColumnToDictionaryMapping() {
315	return columnToDictionaryMapping;	1✔
316	}
317
318	/**
319	* @param columnToDictionaryMapping
320	*/
321	public void setColumnToDictionaryMapping(Map<String, Dictionary> columnToDictionaryMapping) {
322	this.columnToDictionaryMapping = columnToDictionaryMapping;	1✔
323	}	1✔
324
325	public QueryStatisticsRecorder getStatisticsRecorder() {
326	return statisticsRecorder;	1✔
327	}
328
329	public void setStatisticsRecorder(QueryStatisticsRecorder statisticsRecorder) {
330	this.statisticsRecorder = statisticsRecorder;	1✔
331	}	1✔
332
333	public List<String> getInvalidSegmentIds() {
334	return invalidSegmentIds;	×
335	}
336
337	public void setInvalidSegmentIds(List<String> invalidSegmentIds) {
338	this.invalidSegmentIds = invalidSegmentIds;	1✔
339	}	1✔
340
341	public boolean isVectorReader() {
342	return vectorReader;	1✔
343	}
344
345	public void setVectorReader(boolean vectorReader) {
346	this.vectorReader = vectorReader;	1✔
347	}	1✔
348	public void setInvalidBlockForSegmentId(List<UpdateVO> invalidSegmentTimestampList) {
349	for (UpdateVO anUpdateVO : invalidSegmentTimestampList) {	×
350	this.invalidSegmentBlockIdMap.put(anUpdateVO.getSegmentId(), anUpdateVO);	×
351	}	×
352	}	×
353
354	public Map<String,UpdateVO> getInvalidBlockVOForSegmentId() {
355	return invalidSegmentBlockIdMap;	×
356	}
357
358	public DataTypeConverter getConverter() {
359	return converter;	1✔
360	}
361
362	public void setConverter(DataTypeConverter converter) {
363	this.converter = converter;	1✔
364	}	1✔
365
366	public boolean[] getIsFilterDimensions() {
367	return isFilterDimensions;	1✔
368	}
369
370	public void setIsFilterDimensions(boolean[] isFilterDimensions) {
371	this.isFilterDimensions = isFilterDimensions;	1✔
372	}	1✔
373
374	public boolean[] getIsFilterMeasures() {
375	return isFilterMeasures;	1✔
376	}
377
378	public void setIsFilterMeasures(boolean[] isFilterMeasures) {
379	this.isFilterMeasures = isFilterMeasures;	1✔
380	}	1✔
381
382	public boolean isReadPageByPage() {
383	return readPageByPage;	1✔
384	}
385
386	public void setReadPageByPage(boolean readPageByPage) {
387	this.readPageByPage = readPageByPage;	1✔
388	}	1✔
389
390	public boolean isRequiredRowId() {
391	return requiredRowId;	1✔
392	}
393
394	public void setRequiredRowId(boolean requiredRowId) {
395	this.requiredRowId = requiredRowId;	1✔
396	}	1✔
397
398	public boolean isFG() {
399	return isFG;	1✔
400	}
401
402	public void setFG(boolean FG) {
403	isFG = FG;	1✔
404	}	1✔
405
406	public boolean isPreFetchData() {
407	return preFetchData;	1✔
408	}
409
410	public void setPreFetchData(boolean preFetchData) {
411	this.preFetchData = preFetchData;	1✔
412	}	1✔
413
414	public boolean isDirectVectorFill() {
415	return isDirectVectorFill;	×
416	}
417
418	public void setDirectVectorFill(boolean directVectorFill) {
419	isDirectVectorFill = directVectorFill;	1✔
420	}	1✔
421
422	@Override
423	public String toString() {
424	return String.format("scan on table %s.%s, %d projection columns with filter (%s)",	1✔
425	table.getDatabaseName(), table.getTableName(),	1✔
426	projection.getDimensions().size() + projection.getMeasures().size(),	1✔
427	filterExpressionResolverTree.getFilterExpression().toString());	1✔
428	}
429
430	public boolean isFreeUnsafeMemory() {
431	return freeUnsafeMemory;	1✔
432	}
433
434	public void setFreeUnsafeMemory(boolean freeUnsafeMemory) {
435	this.freeUnsafeMemory = freeUnsafeMemory;	1✔
436	}	1✔
437
438	public static class FilterProcessVO {
439
440	private List<CarbonDimension> carbonDimensions;
441
442	private List<CarbonMeasure> carbonMeasures;
443
444	private List<CarbonDimension> implicitDimensions;
445
446	public FilterProcessVO(List<CarbonDimension> carbonDimensions,
447	List<CarbonMeasure> carbonMeasures, List<CarbonDimension> implicitDimensions) {	1✔
448	this.carbonDimensions = carbonDimensions;	1✔
449	this.carbonMeasures = carbonMeasures;	1✔
450	this.implicitDimensions = implicitDimensions;	1✔
451	}	1✔
452
453	public List<CarbonDimension> getCarbonDimensions() {
454	return carbonDimensions;	1✔
455	}
456
457	public List<CarbonMeasure> getCarbonMeasures() {
458	return carbonMeasures;	1✔
459	}
460
461	public List<CarbonDimension> getImplicitDimensions() {
462	return implicitDimensions;	×
463	}
464	}
465	}

apache / carbondata / 994

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