8178

Build # 8178

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/d4a732cdd7fec040b90e6912993db51e1271dc63">d4a732cdd<a href="https://github.com/apache/carbondata/commit/d4a732cdd7fec040b90e6912993db51e1271dc63">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/babc0d496e49f803422cbb84e3f63ca0ed54bab5">babc0d496</a>">babc0d496</a><a href="https://github.com/apache/carbondata/commit/d4a732cdd7fec040b90e6912993db51e1271dc63"> into de0f54516">de0f54516</a>

Run Details

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

57373 of 71165 relevant lines covered (80.62%)

1.07 hits per line

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

70.33

/core/src/main/java/org/apache/carbondata/core/util/SessionParams.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.util;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.carbondata.common.constants.LoggerAction;
import org.apache.carbondata.common.logging.LogService;
import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.cache.CacheProvider;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.constants.CarbonCommonConstantsInternal;
import org.apache.carbondata.core.constants.CarbonLoadOptionConstants;
import org.apache.carbondata.core.datamap.DataMapStoreManager;
import org.apache.carbondata.core.exception.InvalidConfigurationException;

import static org.apache.carbondata.core.constants.CarbonCommonConstants.CARBON_CUSTOM_BLOCK_DISTRIBUTION;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.CARBON_MAJOR_COMPACTION_SIZE;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.CARBON_SEARCH_MODE_ENABLE;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.COMPACTION_SEGMENT_LEVEL_THRESHOLD;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_OFFHEAP_SORT;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_UNSAFE_IN_QUERY_EXECUTION;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_UNSAFE_SORT;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_VECTOR_READER;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.NUM_CORES_COMPACTING;
import static org.apache.carbondata.core.constants.CarbonCommonConstants.NUM_CORES_LOADING;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORDS_ACTION;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORDS_LOGGER_ENABLE;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORD_PATH;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BATCH_SORT_SIZE_INMB;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_DATEFORMAT;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_GLOBAL_SORT_PARTITIONS;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_IS_EMPTY_DATA_BAD_RECORD;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_SERIALIZATION_NULL_FORMAT;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_SINGLE_PASS;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_SORT_SCOPE;
import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_TIMESTAMPFORMAT;
import static org.apache.carbondata.core.constants.CarbonV3DataFormatConstants.BLOCKLET_SIZE_IN_MB;

/**
 * This class maintains carbon session params
 */
public class SessionParams implements Serializable, Cloneable {

  private static final LogService LOGGER =
      LogServiceFactory.getLogService(CacheProvider.class.getName());
  private static final long serialVersionUID = -7801994600594915264L;

  private Map<String, String> sProps;
  private ConcurrentHashMap<String, String> addedProps;
  // below field to be used when we want the objects to be serialized
  private Map<String, Object> extraInfo;
  public SessionParams() {
    sProps = new HashMap<>();
    addedProps = new ConcurrentHashMap<>();
    extraInfo = new HashMap<>();
  }

  public void setExtraInfo(String key, Object value) {
    this.extraInfo.put(key, value);
  }

  public Object getExtraInfo(String key) {
    return this.extraInfo.get(key);
  }

  /**
   * This method will be used to get the properties value
   *
   * @param key
   * @return properties value
   */
  public String getProperty(String key) {
    return sProps.get(key);
  }

  public String getProperty(String key, String defaultValue) {
    if (!sProps.containsKey(key)) {
      return defaultValue;
    }
    return sProps.get(key);
  }

  /**
   * This method will be used to add a new property
   *
   * @param key
   * @return properties value
   */
  public SessionParams addProperty(String key, String value) throws InvalidConfigurationException {
    return addProperty(key, value, true);
  }

  /**
   * This method will be used to add a new property
   *
   * @param key
   * @return properties value
   */
  public SessionParams addProperty(String key, String value, Boolean doAuditing)
      throws InvalidConfigurationException {
    boolean isValidConf = validateKeyValue(key, value);
    if (isValidConf) {
      if (key.equals(CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORDS_ACTION)) {
        value = value.toUpperCase();
      }
      if (doAuditing) {
        LOGGER.audit("The key " + key + " with value " + value + " added in the session param");
      }
      sProps.put(key, value);
    }
    return this;
  }

  public Map<String, String> getAll() {
    return sProps;
  }

  public SessionParams addProps(Map<String, String> addedProps) {
    this.addedProps.putAll(addedProps);
    return this;
  }

  public Map<String, String> getAddedProps() {
    return addedProps;
  }

  /**
   * validate the key value to be set using set command
   * @param key
   * @param value
   * @return
   * @throws InvalidConfigurationException
   */
  private boolean validateKeyValue(String key, String value) throws InvalidConfigurationException {
    boolean isValid = false;
    switch (key) {
      case ENABLE_UNSAFE_SORT:
      case ENABLE_OFFHEAP_SORT:
      case CARBON_CUSTOM_BLOCK_DISTRIBUTION:
      case CARBON_OPTIONS_BAD_RECORDS_LOGGER_ENABLE:
      case CARBON_OPTIONS_IS_EMPTY_DATA_BAD_RECORD:
      case CARBON_OPTIONS_SINGLE_PASS:
      case CARBON_SEARCH_MODE_ENABLE:
      case ENABLE_VECTOR_READER:
      case ENABLE_UNSAFE_IN_QUERY_EXECUTION:
        isValid = CarbonUtil.validateBoolean(value);
        if (!isValid) {
          throw new InvalidConfigurationException("Invalid value " + value + " for key " + key);
        }
        break;
      case CARBON_OPTIONS_BAD_RECORDS_ACTION:
        try {
          LoggerAction.valueOf(value.toUpperCase());
          isValid = true;
        } catch (IllegalArgumentException iae) {
          throw new InvalidConfigurationException(
              "The key " + key + " can have only either FORCE or IGNORE or REDIRECT or FAIL.");
        }
        break;
      case CARBON_OPTIONS_SORT_SCOPE:
        isValid = CarbonUtil.isValidSortOption(value);
        if (!isValid) {
          throw new InvalidConfigurationException("The sort scope " + key
              + " can have only either BATCH_SORT or LOCAL_SORT or NO_SORT.");
        }
        break;
      case CARBON_OPTIONS_BATCH_SORT_SIZE_INMB:
      case CARBON_OPTIONS_GLOBAL_SORT_PARTITIONS:
      case NUM_CORES_LOADING:
      case NUM_CORES_COMPACTING:
      case BLOCKLET_SIZE_IN_MB:
      case CARBON_MAJOR_COMPACTION_SIZE:
        isValid = CarbonUtil.validateValidIntType(value);
        if (!isValid) {
          throw new InvalidConfigurationException(
              "The configured value for key " + key + " must be valid integer.");
        }
        break;
      case CARBON_OPTIONS_BAD_RECORD_PATH:
        isValid = CarbonUtil.isValidBadStorePath(value);
        if (!isValid) {
          throw new InvalidConfigurationException("Invalid bad records location.");
        }
        break;
      // no validation needed while set for CARBON_OPTIONS_DATEFORMAT
      case CARBON_OPTIONS_DATEFORMAT:
        isValid = true;
        break;
      // no validation needed while set for CARBON_OPTIONS_TIMESTAMPFORMAT
      case CARBON_OPTIONS_TIMESTAMPFORMAT:
        isValid = true;
        break;
      // no validation needed while set for CARBON_OPTIONS_SERIALIZATION_NULL_FORMAT
      case CARBON_OPTIONS_SERIALIZATION_NULL_FORMAT:
        isValid = true;
        break;
      case COMPACTION_SEGMENT_LEVEL_THRESHOLD:
        int[] values = CarbonProperties.getInstance().getIntArray(value);
        if (values.length != 2) {
          throw new InvalidConfigurationException(
              "Invalid COMPACTION_SEGMENT_LEVEL_THRESHOLD: " + value);
        }
        isValid = true;
        break;
      default:
        if (key.startsWith(CarbonCommonConstants.CARBON_INPUT_SEGMENTS)) {
          isValid = CarbonUtil.validateRangeOfSegmentList(value);
          if (!isValid) {
            throw new InvalidConfigurationException("Invalid CARBON_INPUT_SEGMENT_IDs");
          }
        } else if (key.startsWith(CarbonCommonConstants.VALIDATE_CARBON_INPUT_SEGMENTS)) {
          isValid = true;
        } else if (key.equalsIgnoreCase(CarbonCommonConstants.SUPPORT_DIRECT_QUERY_ON_DATAMAP)) {
          isValid = true;
        } else if (key.startsWith(CarbonCommonConstantsInternal.QUERY_ON_PRE_AGG_STREAMING)) {
          isValid = true;
        } else if (key.startsWith(CarbonCommonConstants.CARBON_DATAMAP_VISIBLE)) {
          String[] keyArray = key.split("\\.");
          isValid = DataMapStoreManager.getInstance().isDataMapExist(
              keyArray[keyArray.length - 3],
              keyArray[keyArray.length - 2],
              keyArray[keyArray.length - 1]);
          if (!isValid) {
            throw new InvalidConfigurationException(
                String.format("Invalid configuration of %s, datamap does not exist", key));
          }
        } else if (key.startsWith(CarbonCommonConstants.CARBON_LOAD_DATAMAPS_PARALLEL)) {
          isValid = CarbonUtil.validateBoolean(value);
          if (!isValid) {
            throw new InvalidConfigurationException("Invalid value " + value + " for key " + key);
          }
        } else {
          throw new InvalidConfigurationException(
              "The key " + key + " not supported for dynamic configuration.");
        }
    }
    return isValid;
  }

  public void removeProperty(String property) {
    sProps.remove(property);
  }

  public void removeExtraInfo(String key) {
    extraInfo.remove(key);
  }
  /**
   * clear the set properties
   */
  public void clear() {
    sProps.clear();
  }

  public SessionParams clone() throws CloneNotSupportedException {
    super.clone();
    SessionParams newObj = new SessionParams();
    newObj.addedProps.putAll(this.addedProps);
    newObj.sProps.putAll(this.sProps);
    newObj.extraInfo.putAll(this.extraInfo);
    return newObj;
  }
}

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.util;
19
20	import java.io.Serializable;
21	import java.util.HashMap;
22	import java.util.Map;
23	import java.util.concurrent.ConcurrentHashMap;
24
25	import org.apache.carbondata.common.constants.LoggerAction;
26	import org.apache.carbondata.common.logging.LogService;
27	import org.apache.carbondata.common.logging.LogServiceFactory;
28	import org.apache.carbondata.core.cache.CacheProvider;
29	import org.apache.carbondata.core.constants.CarbonCommonConstants;
30	import org.apache.carbondata.core.constants.CarbonCommonConstantsInternal;
31	import org.apache.carbondata.core.constants.CarbonLoadOptionConstants;
32	import org.apache.carbondata.core.datamap.DataMapStoreManager;
33	import org.apache.carbondata.core.exception.InvalidConfigurationException;
34
35	import static org.apache.carbondata.core.constants.CarbonCommonConstants.CARBON_CUSTOM_BLOCK_DISTRIBUTION;
36	import static org.apache.carbondata.core.constants.CarbonCommonConstants.CARBON_MAJOR_COMPACTION_SIZE;
37	import static org.apache.carbondata.core.constants.CarbonCommonConstants.CARBON_SEARCH_MODE_ENABLE;
38	import static org.apache.carbondata.core.constants.CarbonCommonConstants.COMPACTION_SEGMENT_LEVEL_THRESHOLD;
39	import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_OFFHEAP_SORT;
40	import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_UNSAFE_IN_QUERY_EXECUTION;
41	import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_UNSAFE_SORT;
42	import static org.apache.carbondata.core.constants.CarbonCommonConstants.ENABLE_VECTOR_READER;
43	import static org.apache.carbondata.core.constants.CarbonCommonConstants.NUM_CORES_COMPACTING;
44	import static org.apache.carbondata.core.constants.CarbonCommonConstants.NUM_CORES_LOADING;
45	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORDS_ACTION;
46	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORDS_LOGGER_ENABLE;
47	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORD_PATH;
48	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_BATCH_SORT_SIZE_INMB;
49	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_DATEFORMAT;
50	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_GLOBAL_SORT_PARTITIONS;
51	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_IS_EMPTY_DATA_BAD_RECORD;
52	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_SERIALIZATION_NULL_FORMAT;
53	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_SINGLE_PASS;
54	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_SORT_SCOPE;
55	import static org.apache.carbondata.core.constants.CarbonLoadOptionConstants.CARBON_OPTIONS_TIMESTAMPFORMAT;
56	import static org.apache.carbondata.core.constants.CarbonV3DataFormatConstants.BLOCKLET_SIZE_IN_MB;
57
58	/**
59	* This class maintains carbon session params
60	*/
61	public class SessionParams implements Serializable, Cloneable {
62
63	private static final LogService LOGGER =	2✔
64	LogServiceFactory.getLogService(CacheProvider.class.getName());	2✔
65	private static final long serialVersionUID = -7801994600594915264L;
66
67	private Map<String, String> sProps;
68	private ConcurrentHashMap<String, String> addedProps;
69	// below field to be used when we want the objects to be serialized
70	private Map<String, Object> extraInfo;
71	public SessionParams() {	2✔
72	sProps = new HashMap<>();	2✔
73	addedProps = new ConcurrentHashMap<>();	2✔
74	extraInfo = new HashMap<>();	2✔
75	}	2✔
76
77	public void setExtraInfo(String key, Object value) {
78	this.extraInfo.put(key, value);	1✔
79	}	1✔
80
81	public Object getExtraInfo(String key) {
82	return this.extraInfo.get(key);	1✔
83	}
84
85	/**
86	* This method will be used to get the properties value
87	*
88	* @param key
89	* @return properties value
90	*/
91	public String getProperty(String key) {
92	return sProps.get(key);	2✔
93	}
94
95	public String getProperty(String key, String defaultValue) {
96	if (!sProps.containsKey(key)) {	1✔
97	return defaultValue;	1✔
98	}
99	return sProps.get(key);	1✔
100	}
101
102	/**
103	* This method will be used to add a new property
104	*
105	* @param key
106	* @return properties value
107	*/
108	public SessionParams addProperty(String key, String value) throws InvalidConfigurationException {
109	return addProperty(key, value, true);	1✔
110	}
111
112	/**
113	* This method will be used to add a new property
114	*
115	* @param key
116	* @return properties value
117	*/
118	public SessionParams addProperty(String key, String value, Boolean doAuditing)
119	throws InvalidConfigurationException {
120	boolean isValidConf = validateKeyValue(key, value);	1✔
121	if (isValidConf) {	1✔
122	if (key.equals(CarbonLoadOptionConstants.CARBON_OPTIONS_BAD_RECORDS_ACTION)) {	1✔
123	value = value.toUpperCase();	×
124	}
125	if (doAuditing) {	1✔
126	LOGGER.audit("The key " + key + " with value " + value + " added in the session param");	1✔
127	}
128	sProps.put(key, value);	1✔
129	}
130	return this;	1✔
131	}
132
133	public Map<String, String> getAll() {
134	return sProps;	1✔
135	}
136
137	public SessionParams addProps(Map<String, String> addedProps) {
138	this.addedProps.putAll(addedProps);	1✔
139	return this;	1✔
140	}
141
142	public Map<String, String> getAddedProps() {
143	return addedProps;	1✔
144	}
145
146	/**
147	* validate the key value to be set using set command
148	* @param key
149	* @param value
150	* @return
151	* @throws InvalidConfigurationException
152	*/
153	private boolean validateKeyValue(String key, String value) throws InvalidConfigurationException {
154	boolean isValid = false;	1✔
155	switch (key) {	1✔
156	case ENABLE_UNSAFE_SORT:
157	case ENABLE_OFFHEAP_SORT:
158	case CARBON_CUSTOM_BLOCK_DISTRIBUTION:
159	case CARBON_OPTIONS_BAD_RECORDS_LOGGER_ENABLE:
160	case CARBON_OPTIONS_IS_EMPTY_DATA_BAD_RECORD:
161	case CARBON_OPTIONS_SINGLE_PASS:
162	case CARBON_SEARCH_MODE_ENABLE:
163	case ENABLE_VECTOR_READER:
164	case ENABLE_UNSAFE_IN_QUERY_EXECUTION:
165	isValid = CarbonUtil.validateBoolean(value);	1✔
166	if (!isValid) {	1✔
167	throw new InvalidConfigurationException("Invalid value " + value + " for key " + key);	1✔
168	}
169	break;
170	case CARBON_OPTIONS_BAD_RECORDS_ACTION:
171	try {
172	LoggerAction.valueOf(value.toUpperCase());	×
173	isValid = true;	×
174	} catch (IllegalArgumentException iae) {	×
175	throw new InvalidConfigurationException(	×
176	"The key " + key + " can have only either FORCE or IGNORE or REDIRECT or FAIL.");
177	}	×
178	break;
179	case CARBON_OPTIONS_SORT_SCOPE:
180	isValid = CarbonUtil.isValidSortOption(value);	1✔
181	if (!isValid) {	1✔
182	throw new InvalidConfigurationException("The sort scope " + key	1✔
183	+ " can have only either BATCH_SORT or LOCAL_SORT or NO_SORT.");
184	}
185	break;
186	case CARBON_OPTIONS_BATCH_SORT_SIZE_INMB:
187	case CARBON_OPTIONS_GLOBAL_SORT_PARTITIONS:
188	case NUM_CORES_LOADING:
189	case NUM_CORES_COMPACTING:
190	case BLOCKLET_SIZE_IN_MB:
191	case CARBON_MAJOR_COMPACTION_SIZE:
192	isValid = CarbonUtil.validateValidIntType(value);	1✔
193	if (!isValid) {	1✔
194	throw new InvalidConfigurationException(	1✔
195	"The configured value for key " + key + " must be valid integer.");
196	}
197	break;
198	case CARBON_OPTIONS_BAD_RECORD_PATH:
199	isValid = CarbonUtil.isValidBadStorePath(value);	×
200	if (!isValid) {	×
201	throw new InvalidConfigurationException("Invalid bad records location.");	×
202	}
203	break;
204	// no validation needed while set for CARBON_OPTIONS_DATEFORMAT
205	case CARBON_OPTIONS_DATEFORMAT:
206	isValid = true;	×
207	break;	×
208	// no validation needed while set for CARBON_OPTIONS_TIMESTAMPFORMAT
209	case CARBON_OPTIONS_TIMESTAMPFORMAT:
210	isValid = true;	×
211	break;	×
212	// no validation needed while set for CARBON_OPTIONS_SERIALIZATION_NULL_FORMAT
213	case CARBON_OPTIONS_SERIALIZATION_NULL_FORMAT:
214	isValid = true;	×
215	break;	×
216	case COMPACTION_SEGMENT_LEVEL_THRESHOLD:
217	int[] values = CarbonProperties.getInstance().getIntArray(value);	×
218	if (values.length != 2) {	×
219	throw new InvalidConfigurationException(	×
220	"Invalid COMPACTION_SEGMENT_LEVEL_THRESHOLD: " + value);
221	}
222	isValid = true;	×
223	break;	×
224	default:
225	if (key.startsWith(CarbonCommonConstants.CARBON_INPUT_SEGMENTS)) {	1✔
226	isValid = CarbonUtil.validateRangeOfSegmentList(value);	1✔
227	if (!isValid) {	1✔
228	throw new InvalidConfigurationException("Invalid CARBON_INPUT_SEGMENT_IDs");	×
229	}
230	} else if (key.startsWith(CarbonCommonConstants.VALIDATE_CARBON_INPUT_SEGMENTS)) {	1✔
231	isValid = true;	1✔
232	} else if (key.equalsIgnoreCase(CarbonCommonConstants.SUPPORT_DIRECT_QUERY_ON_DATAMAP)) {	1✔
233	isValid = true;	1✔
234	} else if (key.startsWith(CarbonCommonConstantsInternal.QUERY_ON_PRE_AGG_STREAMING)) {	1✔
235	isValid = true;	1✔
236	} else if (key.startsWith(CarbonCommonConstants.CARBON_DATAMAP_VISIBLE)) {	1✔
237	String[] keyArray = key.split("\\.");	1✔
238	isValid = DataMapStoreManager.getInstance().isDataMapExist(	1✔
239	keyArray[keyArray.length - 3],
240	keyArray[keyArray.length - 2],
241	keyArray[keyArray.length - 1]);
242	if (!isValid) {	1✔
243	throw new InvalidConfigurationException(	×
244	String.format("Invalid configuration of %s, datamap does not exist", key));	×
245	}
246	} else if (key.startsWith(CarbonCommonConstants.CARBON_LOAD_DATAMAPS_PARALLEL)) {	1✔
247	isValid = CarbonUtil.validateBoolean(value);	×
248	if (!isValid) {	×
249	throw new InvalidConfigurationException("Invalid value " + value + " for key " + key);	×
250	}
251	} else {
252	throw new InvalidConfigurationException(	×
253	"The key " + key + " not supported for dynamic configuration.");
254	}
255	}
256	return isValid;	1✔
257	}
258
259	public void removeProperty(String property) {
260	sProps.remove(property);	1✔
261	}	1✔
262
263	public void removeExtraInfo(String key) {
264	extraInfo.remove(key);	1✔
265	}	1✔
266	/**
267	* clear the set properties
268	*/
269	public void clear() {
270	sProps.clear();	1✔
271	}	1✔
272
273	public SessionParams clone() throws CloneNotSupportedException {
274	super.clone();	1✔
275	SessionParams newObj = new SessionParams();	1✔
276	newObj.addedProps.putAll(this.addedProps);	1✔
277	newObj.sProps.putAll(this.sProps);	1✔
278	newObj.extraInfo.putAll(this.extraInfo);	1✔
279	return newObj;	1✔
280	}
281	}

apache / carbondata / 8178

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