6630

Build # 6630

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/e2e7fbdd5106cf8f36ebebcd7789ff0bb5b1aea7">e2e7fbdd5<a href="https://github.com/apache/carbondata/commit/e2e7fbdd5106cf8f36ebebcd7789ff0bb5b1aea7">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/7b26387c77646eeb013301e28eecf93d93a6c0a3">7b26387c7</a>">7b26387c7</a><a href="https://github.com/apache/carbondata/commit/e2e7fbdd5106cf8f36ebebcd7789ff0bb5b1aea7"> into 8b9c65540">8b9c65540</a>

Run Details

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

52646 of 70698 relevant lines covered (74.47%)

0.89 hits per line

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

75.65

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

import java.io.Serializable;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.carbondata.common.logging.LogService;
import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.constants.CarbonCommonConstants;

/*
  Prior to Carbon 1.3 the the loadMetaData @timestamp and @loadStartTime was stored as
  as date string format "dd-MM-yyyy HH:mm:ss:SSS". The date string value is specific
  to the timezone. SO the timestamp in long by the date string will not result into
  same value if converted to date in different timezone.
  Json Object of LoadMetaData before CarbonData 1.3
 |-------------------------------------------------------------------------------------------|
 | [{"timestamp":"15-12-2017 16:50:31:703","loadStatus":"Success","loadName":"0",            |
 | "partitionCount":"0","isDeleted":"FALSE","dataSize":"912","indexSize":"700",              |
 | "updateDeltaEndTimestamp":"","updateDeltaStartTimestamp":"","updateStatusFileName":"",    |
 | "loadStartTime":"15-12-2017 16:50:27:493","visibility":"true","fileFormat":"COLUMNAR_V3"}]|
 |-------------------------------------------------------------------------------------------|
  Fix: As the System.currentTimeMillis() returns the same value irrespective of timezone.
  So if Carbon stores the long value for @timestamp  and @loadStartTime value then the
  value will be same irrespective of the timezone.
  Json Object of LoadMetaData for CarbonData 1.3
 |-------------------------------------------------------------------------------------------|
 | [{"timestamp":"1513336827593","loadStatus":"Success","loadName":"0",                      |
 | "partitionCount":"0","isDeleted":"FALSE","dataSize":"912","indexSize":"700",              |
 | "updateDeltaEndTimestamp":"","updateDeltaStartTimestamp":"","updateStatusFileName":"",    |
 | "loadStartTime":"1513336827593","visibility":"true","fileFormat":"COLUMNAR_V3"}]          |
 |-------------------------------------------------------------------------------------------|
 */
public class LoadMetadataDetails implements Serializable {

  private static final long serialVersionUID = 1106104914918491724L;
  private String timestamp;

  // For backward compatibility, this member is required to read from JSON in the table_status file
  private SegmentStatus loadStatus;

  // name of the segment
  private String loadName;

  // partition count of this segment
  private String partitionCount;

  private String isDeleted = CarbonCommonConstants.KEYWORD_FALSE;
  private String dataSize;
  private String indexSize;

  public String getDataSize() {
    return dataSize;
  }

  public void setDataSize(String dataSize) {
    this.dataSize = dataSize;
  }

  public String getIndexSize() {
    return indexSize;
  }

  public void setIndexSize(String indexSize) {
    this.indexSize = indexSize;
  }

  // update delta end timestamp
  private String updateDeltaEndTimestamp = "";

  // update delta start timestamp
  private String updateDeltaStartTimestamp = "";

  // this will represent the update status file name at that point of time.
  private String updateStatusFileName = "";

  /**
   * LOGGER
   */
  private static final LogService LOGGER =
      LogServiceFactory.getLogService(LoadMetadataDetails.class.getName());

  // dont remove static as the write will fail.
  private static final SimpleDateFormat parser =
      new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP_MILLIS);
  /**
   * Segment modification or deletion time stamp
   */
  private String modificationOrdeletionTimesStamp;
  private String loadStartTime;

  private String mergedLoadName;
  /**
   * visibility is used to determine whether to the load is visible or not.
   */
  private String visibility = "true";

  /**
   * To know if the segment is a major compacted segment or not.
   */
  private String majorCompacted;

  /**
   * the file format of this segment
   */
  private FileFormat fileFormat = FileFormat.COLUMNAR_V3;

  /**
   * Segment file name where it has the information of partition information.
   */
  private String segmentFile;

  public String getPartitionCount() {
    return partitionCount;
  }

  @Deprecated
  public void setPartitionCount(String partitionCount) {
    this.partitionCount = partitionCount;
  }

  public long getLoadEndTime() {
    if (timestamp == null) {
      return CarbonCommonConstants.SEGMENT_LOAD_TIME_DEFAULT;
    }
    return convertTimeStampToLong(timestamp);
  }

  public void setLoadEndTime(long timestamp) {
    this.timestamp = Long.toString(timestamp);
  }

  public SegmentStatus getSegmentStatus() {
    return loadStatus;
  }

  public void setSegmentStatus(SegmentStatus segmentStatus) {
    this.loadStatus = segmentStatus;
  }

  public String getLoadName() {
    return loadName;
  }

  public void setLoadName(String loadName) {
    this.loadName = loadName;
  }

  /**
   * @return the modificationOrdeletionTimesStamp
   */
  public long getModificationOrdeletionTimesStamp() {
    if (null == modificationOrdeletionTimesStamp) {
      return 0;
    }
    return convertTimeStampToLong(modificationOrdeletionTimesStamp);
  }

  /**
   * @param modificationOrdeletionTimesStamp the modificationOrdeletionTimesStamp to set
   */
  public void setModificationOrdeletionTimesStamp(long modificationOrdeletionTimesStamp) {
    this.modificationOrdeletionTimesStamp =
        Long.toString(modificationOrdeletionTimesStamp);
  }

  /* (non-Javadoc)
   * @see java.lang.Object#hashCode()
   */
  @Override public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((loadName == null) ? 0 : loadName.hashCode());
    return result;
  }

  /* (non-Javadoc)
   * @see java.lang.Object#equals(java.lang.Object)
   */
  @Override public boolean equals(Object obj) {
    if (obj == null) {
      return false;

    }
    if (!(obj instanceof LoadMetadataDetails)) {
      return false;
    }
    LoadMetadataDetails other = (LoadMetadataDetails) obj;
    if (loadName == null) {
      if (other.loadName != null) {
        return false;
      }
    } else if (!loadName.equals(other.loadName)) {
      return false;
    }
    return true;
  }

  /**
   * @return the startLoadTime
   */
  public long getLoadStartTime() {
    if (loadStartTime == null) {
      return CarbonCommonConstants.SEGMENT_LOAD_TIME_DEFAULT;
    }
    return convertTimeStampToLong(loadStartTime);
  }

  /**
   * return loadStartTime
   *
   * @return
   */
  public long getLoadStartTimeAsLong() {
    if (!loadStartTime.isEmpty()) {
      Long time = getTimeStamp(loadStartTime);
      if (null != time) {
        return time;
      }
    }
    return 0;
  }

  /**
   * This method will convert a given timestamp to long value and then to string back
   *
   * @param factTimeStamp
   * @return Long    TimeStamp value is milliseconds
   */
  private long convertTimeStampToLong(String factTimeStamp) {
    try {
      return Long.parseLong(factTimeStamp);
    } catch (NumberFormatException nf) {
      SimpleDateFormat parser = new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP_MILLIS);
      // it is the processing for existing table before carbon 1.3
      Date dateToStr = null;
      try {
        dateToStr = parser.parse(factTimeStamp);
        return dateToStr.getTime();
      } catch (ParseException e) {
        LOGGER
            .error("Cannot convert" + factTimeStamp + " to Time/Long type value" + e.getMessage());
        parser = new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP);
        try {
          // if the load is in progress, factTimeStamp will be null, so use current time
          if (null == factTimeStamp) {
            return System.currentTimeMillis();
          }
          dateToStr = parser.parse(factTimeStamp);
          return dateToStr.getTime();
        } catch (ParseException e1) {
          LOGGER.error(
              "Cannot convert" + factTimeStamp + " to Time/Long type value" + e1.getMessage());
          return 0;
        }
      }
    }
  }

  /**
   * returns load start time as long value
   *
   * @param loadStartTime
   * @return Long  TimeStamp value is nanoseconds
   */
  public Long getTimeStamp(String loadStartTime) {
    try {
      return Long.parseLong(loadStartTime) * 1000L;
    } catch (NumberFormatException nf) {
      // it is the processing for existing table before carbon 1.3
      Date dateToStr = null;
      try {
        dateToStr = parser.parse(loadStartTime);
        return dateToStr.getTime() * 1000;
      } catch (ParseException e) {
        LOGGER.error("Cannot convert" + loadStartTime +
            " to Time/Long type value" + e.getMessage());
        return null;
      }
    }
  }

  /**
   * @param loadStartTime
   */
  public void setLoadStartTime(long loadStartTime) {
    this.loadStartTime = Long.toString(loadStartTime);
  }

  /**
   * @return the mergedLoadName
   */
  public String getMergedLoadName() {
    return mergedLoadName;
  }

  /**
   * @param mergedLoadName the mergedLoadName to set
   */
  public void setMergedLoadName(String mergedLoadName) {
    this.mergedLoadName = mergedLoadName;
  }

  /**
   * @return the visibility
   */
  public String getVisibility() {
    return visibility;
  }

  /**
   * @param visibility the visibility to set
   */
  public void setVisibility(String visibility) {
    this.visibility = visibility;
  }

  /**
   * Return true if it is a major compacted segment.
   * @return majorCompacted
   */
  public String isMajorCompacted() {
    return majorCompacted;
  }

  /**
   * Set true if it is a major compacted segment.
   *
   * @param majorCompacted
   */
  public void setMajorCompacted(String majorCompacted) {
    this.majorCompacted = majorCompacted;
  }

  /**
   * To set isDeleted property.
   *
   * @param isDeleted
   */
  public void setIsDeleted(String isDeleted) {
    this.isDeleted = isDeleted;
  }

  /**
   * To get the update delta end timestamp
   *
   * @return updateDeltaEndTimestamp
   */
  public String getUpdateDeltaEndTimestamp() {
    return updateDeltaEndTimestamp;
  }

  /**
   * To set the update delta end timestamp
   *
   * @param updateDeltaEndTimestamp
   */
  public void setUpdateDeltaEndTimestamp(String updateDeltaEndTimestamp) {
    this.updateDeltaEndTimestamp = updateDeltaEndTimestamp;
  }

  /**
   * To get the update delta start timestamp
   *
   * @return updateDeltaStartTimestamp
   */
  public String getUpdateDeltaStartTimestamp() {
    return updateDeltaStartTimestamp;
  }

  /**
   * To set the update delta start timestamp
   *
   * @param updateDeltaStartTimestamp
   */
  public void setUpdateDeltaStartTimestamp(String updateDeltaStartTimestamp) {
    this.updateDeltaStartTimestamp = updateDeltaStartTimestamp;
  }

  /**
   * To get the updateStatusFileName
   *
   * @return updateStatusFileName
   */
  public String getUpdateStatusFileName() {
    return updateStatusFileName;
  }

  /**
   * To set the updateStatusFileName
   *
   * @param updateStatusFileName
   */
  public void setUpdateStatusFileName(String updateStatusFileName) {
    this.updateStatusFileName = updateStatusFileName;
  }

  public FileFormat getFileFormat() {
    return fileFormat;
  }

  public void setFileFormat(FileFormat fileFormat) {
    this.fileFormat = fileFormat;
  }

  public String getSegmentFile() {
    return segmentFile;
  }

  public void setSegmentFile(String segmentFile) {
    this.segmentFile = segmentFile;
  }

  @Override public String toString() {
    return "LoadMetadataDetails{" + "loadStatus=" + loadStatus + ", loadName='" + loadName + '\''
        + ", loadStartTime='" + loadStartTime + '\'' + ", segmentFile='" + segmentFile + '\'' + '}';
  }
}

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.statusmanager;
19
20	import java.io.Serializable;
21	import java.text.ParseException;
22	import java.text.SimpleDateFormat;
23	import java.util.Date;
24
25	import org.apache.carbondata.common.logging.LogService;
26	import org.apache.carbondata.common.logging.LogServiceFactory;
27	import org.apache.carbondata.core.constants.CarbonCommonConstants;
28
29	/*
30	Prior to Carbon 1.3 the the loadMetaData @timestamp and @loadStartTime was stored as
31	as date string format "dd-MM-yyyy HH:mm:ss:SSS". The date string value is specific
32	to the timezone. SO the timestamp in long by the date string will not result into
33	same value if converted to date in different timezone.
34	Json Object of LoadMetaData before CarbonData 1.3
35	\|-------------------------------------------------------------------------------------------\|
36	\| [{"timestamp":"15-12-2017 16:50:31:703","loadStatus":"Success","loadName":"0", \|
37	\| "partitionCount":"0","isDeleted":"FALSE","dataSize":"912","indexSize":"700", \|
38	\| "updateDeltaEndTimestamp":"","updateDeltaStartTimestamp":"","updateStatusFileName":"", \|
39	\| "loadStartTime":"15-12-2017 16:50:27:493","visibility":"true","fileFormat":"COLUMNAR_V3"}]\|
40	\|-------------------------------------------------------------------------------------------\|
41	Fix: As the System.currentTimeMillis() returns the same value irrespective of timezone.
42	So if Carbon stores the long value for @timestamp and @loadStartTime value then the
43	value will be same irrespective of the timezone.
44	Json Object of LoadMetaData for CarbonData 1.3
45	\|-------------------------------------------------------------------------------------------\|
46	\| [{"timestamp":"1513336827593","loadStatus":"Success","loadName":"0", \|
47	\| "partitionCount":"0","isDeleted":"FALSE","dataSize":"912","indexSize":"700", \|
48	\| "updateDeltaEndTimestamp":"","updateDeltaStartTimestamp":"","updateStatusFileName":"", \|
49	\| "loadStartTime":"1513336827593","visibility":"true","fileFormat":"COLUMNAR_V3"}] \|
50	\|-------------------------------------------------------------------------------------------\|
51	*/
52	public class LoadMetadataDetails implements Serializable {	2✔
53
54	private static final long serialVersionUID = 1106104914918491724L;
55	private String timestamp;
56
57	// For backward compatibility, this member is required to read from JSON in the table_status file
58	private SegmentStatus loadStatus;
59
60	// name of the segment
61	private String loadName;
62
63	// partition count of this segment
64	private String partitionCount;
65
66	private String isDeleted = CarbonCommonConstants.KEYWORD_FALSE;	2✔
67	private String dataSize;
68	private String indexSize;
69
70	public String getDataSize() {
71	return dataSize;	1✔
72	}
73
74	public void setDataSize(String dataSize) {
75	this.dataSize = dataSize;	1✔
76	}	1✔
77
78	public String getIndexSize() {
79	return indexSize;	1✔
80	}
81
82	public void setIndexSize(String indexSize) {
83	this.indexSize = indexSize;	1✔
84	}	1✔
85
86	// update delta end timestamp
87	private String updateDeltaEndTimestamp = "";	2✔
88
89	// update delta start timestamp
90	private String updateDeltaStartTimestamp = "";	2✔
91
92	// this will represent the update status file name at that point of time.
93	private String updateStatusFileName = "";	2✔
94
95	/**
96	* LOGGER
97	*/
98	private static final LogService LOGGER =	2✔
99	LogServiceFactory.getLogService(LoadMetadataDetails.class.getName());	2✔
100
101	// dont remove static as the write will fail.
102	private static final SimpleDateFormat parser =	2✔
103	new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP_MILLIS);
104	/**
105	* Segment modification or deletion time stamp
106	*/
107	private String modificationOrdeletionTimesStamp;
108	private String loadStartTime;
109
110	private String mergedLoadName;
111	/**
112	* visibility is used to determine whether to the load is visible or not.
113	*/
114	private String visibility = "true";	2✔
115
116	/**
117	* To know if the segment is a major compacted segment or not.
118	*/
119	private String majorCompacted;
120
121	/**
122	* the file format of this segment
123	*/
124	private FileFormat fileFormat = FileFormat.COLUMNAR_V3;	2✔
125
126	/**
127	* Segment file name where it has the information of partition information.
128	*/
129	private String segmentFile;
130
131	public String getPartitionCount() {
132	return partitionCount;	×
133	}
134
135	@Deprecated
136	public void setPartitionCount(String partitionCount) {
137	this.partitionCount = partitionCount;	1✔
138	}	1✔
139
140	public long getLoadEndTime() {
141	if (timestamp == null) {	1✔
142	return CarbonCommonConstants.SEGMENT_LOAD_TIME_DEFAULT;	1✔
143	}
144	return convertTimeStampToLong(timestamp);	1✔
145	}
146
147	public void setLoadEndTime(long timestamp) {
148	this.timestamp = Long.toString(timestamp);	1✔
149	}	1✔
150
151	public SegmentStatus getSegmentStatus() {
152	return loadStatus;	1✔
153	}
154
155	public void setSegmentStatus(SegmentStatus segmentStatus) {
156	this.loadStatus = segmentStatus;	1✔
157	}	1✔
158
159	public String getLoadName() {
160	return loadName;	1✔
161	}
162
163	public void setLoadName(String loadName) {
164	this.loadName = loadName;	2✔
165	}	2✔
166
167	/**
168	* @return the modificationOrdeletionTimesStamp
169	*/
170	public long getModificationOrdeletionTimesStamp() {
171	if (null == modificationOrdeletionTimesStamp) {	1✔
172	return 0;	1✔
173	}
174	return convertTimeStampToLong(modificationOrdeletionTimesStamp);	1✔
175	}
176
177	/**
178	* @param modificationOrdeletionTimesStamp the modificationOrdeletionTimesStamp to set
179	*/
180	public void setModificationOrdeletionTimesStamp(long modificationOrdeletionTimesStamp) {
181	this.modificationOrdeletionTimesStamp =	1✔
182	Long.toString(modificationOrdeletionTimesStamp);	1✔
183	}	1✔
184
185	/* (non-Javadoc)
186	* @see java.lang.Object#hashCode()
187	*/
188	@Override public int hashCode() {
189	final int prime = 31;	2✔
190	int result = 1;	2✔
191	result = prime * result + ((loadName == null) ? 0 : loadName.hashCode());	2✔
192	return result;	2✔
193	}
194
195	/* (non-Javadoc)
196	* @see java.lang.Object#equals(java.lang.Object)
197	*/
198	@Override public boolean equals(Object obj) {
199	if (obj == null) {	2✔
200	return false;	×
201
202	}
203	if (!(obj instanceof LoadMetadataDetails)) {	2✔
204	return false;	2✔
205	}
206	LoadMetadataDetails other = (LoadMetadataDetails) obj;	2✔
207	if (loadName == null) {	2✔
208	if (other.loadName != null) {	2✔
209	return false;	2✔
210	}
211	} else if (!loadName.equals(other.loadName)) {	2✔
212	return false;	2✔
213	}
214	return true;	2✔
215	}
216
217	/**
218	* @return the startLoadTime
219	*/
220	public long getLoadStartTime() {
221	if (loadStartTime == null) {	2✔
222	return CarbonCommonConstants.SEGMENT_LOAD_TIME_DEFAULT;	×
223	}
224	return convertTimeStampToLong(loadStartTime);	2✔
225	}
226
227	/**
228	* return loadStartTime
229	*
230	* @return
231	*/
232	public long getLoadStartTimeAsLong() {
233	if (!loadStartTime.isEmpty()) {	1✔
234	Long time = getTimeStamp(loadStartTime);	1✔
235	if (null != time) {	1✔
236	return time;	1✔
237	}
238	}
239	return 0;	×
240	}
241
242	/**
243	* This method will convert a given timestamp to long value and then to string back
244	*
245	* @param factTimeStamp
246	* @return Long TimeStamp value is milliseconds
247	*/
248	private long convertTimeStampToLong(String factTimeStamp) {
249	try {
250	return Long.parseLong(factTimeStamp);	2✔
251	} catch (NumberFormatException nf) {	×
252	SimpleDateFormat parser = new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP_MILLIS);	×
253	// it is the processing for existing table before carbon 1.3
254	Date dateToStr = null;	×
255	try {
256	dateToStr = parser.parse(factTimeStamp);	×
257	return dateToStr.getTime();	×
258	} catch (ParseException e) {	×
259	LOGGER	×
260	.error("Cannot convert" + factTimeStamp + " to Time/Long type value" + e.getMessage());	×
261	parser = new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP);	×
262	try {
263	// if the load is in progress, factTimeStamp will be null, so use current time
264	if (null == factTimeStamp) {	×
265	return System.currentTimeMillis();	×
266	}
267	dateToStr = parser.parse(factTimeStamp);	×
268	return dateToStr.getTime();	×
269	} catch (ParseException e1) {	×
270	LOGGER.error(	×
271	"Cannot convert" + factTimeStamp + " to Time/Long type value" + e1.getMessage());	×
272	return 0;	×
273	}
274	}
275	}
276	}
277
278	/**
279	* returns load start time as long value
280	*
281	* @param loadStartTime
282	* @return Long TimeStamp value is nanoseconds
283	*/
284	public Long getTimeStamp(String loadStartTime) {
285	try {
286	return Long.parseLong(loadStartTime) * 1000L;	1✔
287	} catch (NumberFormatException nf) {	2✔
288	// it is the processing for existing table before carbon 1.3
289	Date dateToStr = null;	2✔
290	try {
291	dateToStr = parser.parse(loadStartTime);	2✔
292	return dateToStr.getTime() * 1000;	2✔
293	} catch (ParseException e) {	×
294	LOGGER.error("Cannot convert" + loadStartTime +	×
295	" to Time/Long type value" + e.getMessage());	×
296	return null;	×
297	}
298	}
299	}
300
301	/**
302	* @param loadStartTime
303	*/
304	public void setLoadStartTime(long loadStartTime) {
305	this.loadStartTime = Long.toString(loadStartTime);	2✔
306	}	2✔
307
308	/**
309	* @return the mergedLoadName
310	*/
311	public String getMergedLoadName() {
312	return mergedLoadName;	1✔
313	}
314
315	/**
316	* @param mergedLoadName the mergedLoadName to set
317	*/
318	public void setMergedLoadName(String mergedLoadName) {
319	this.mergedLoadName = mergedLoadName;	1✔
320	}	1✔
321
322	/**
323	* @return the visibility
324	*/
325	public String getVisibility() {
326	return visibility;	1✔
327	}
328
329	/**
330	* @param visibility the visibility to set
331	*/
332	public void setVisibility(String visibility) {
333	this.visibility = visibility;	1✔
334	}	1✔
335
336	/**
337	* Return true if it is a major compacted segment.
338	* @return majorCompacted
339	*/
340	public String isMajorCompacted() {
341	return majorCompacted;	1✔
342	}
343
344	/**
345	* Set true if it is a major compacted segment.
346	*
347	* @param majorCompacted
348	*/
349	public void setMajorCompacted(String majorCompacted) {
350	this.majorCompacted = majorCompacted;	1✔
351	}	1✔
352
353	/**
354	* To set isDeleted property.
355	*
356	* @param isDeleted
357	*/
358	public void setIsDeleted(String isDeleted) {
359	this.isDeleted = isDeleted;	1✔
360	}	1✔
361
362	/**
363	* To get the update delta end timestamp
364	*
365	* @return updateDeltaEndTimestamp
366	*/
367	public String getUpdateDeltaEndTimestamp() {
368	return updateDeltaEndTimestamp;	1✔
369	}
370
371	/**
372	* To set the update delta end timestamp
373	*
374	* @param updateDeltaEndTimestamp
375	*/
376	public void setUpdateDeltaEndTimestamp(String updateDeltaEndTimestamp) {
377	this.updateDeltaEndTimestamp = updateDeltaEndTimestamp;	1✔
378	}	1✔
379
380	/**
381	* To get the update delta start timestamp
382	*
383	* @return updateDeltaStartTimestamp
384	*/
385	public String getUpdateDeltaStartTimestamp() {
386	return updateDeltaStartTimestamp;	1✔
387	}
388
389	/**
390	* To set the update delta start timestamp
391	*
392	* @param updateDeltaStartTimestamp
393	*/
394	public void setUpdateDeltaStartTimestamp(String updateDeltaStartTimestamp) {
395	this.updateDeltaStartTimestamp = updateDeltaStartTimestamp;	1✔
396	}	1✔
397
398	/**
399	* To get the updateStatusFileName
400	*
401	* @return updateStatusFileName
402	*/
403	public String getUpdateStatusFileName() {
404	return updateStatusFileName;	1✔
405	}
406
407	/**
408	* To set the updateStatusFileName
409	*
410	* @param updateStatusFileName
411	*/
412	public void setUpdateStatusFileName(String updateStatusFileName) {
413	this.updateStatusFileName = updateStatusFileName;	1✔
414	}	1✔
415
416	public FileFormat getFileFormat() {
417	return fileFormat;	1✔
418	}
419
420	public void setFileFormat(FileFormat fileFormat) {
421	this.fileFormat = fileFormat;	×
422	}	×
423
424	public String getSegmentFile() {
425	return segmentFile;	1✔
426	}
427
428	public void setSegmentFile(String segmentFile) {
429	this.segmentFile = segmentFile;	1✔
430	}	1✔
431
432	@Override public String toString() {
433	return "LoadMetadataDetails{" + "loadStatus=" + loadStatus + ", loadName='" + loadName + '\''	×
434	+ ", loadStartTime='" + loadStartTime + '\'' + ", segmentFile='" + segmentFile + '\'' + '}';
435	}
436	}

apache / carbondata / 6630

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