tool
/
atlas
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ATLAS-3892 : Basic search enhanced Feature - Search history 

Signed-off-by: kevalbhatt <kbhatt@apache.org>
This commit is contained in:
chaitali borole 2020-08-10 20:01:00 +05:30 committed by kevalbhatt
parent 83e9c21f78
commit 1b41b98041
5 changed files with 468 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common/src/main/java/org/apache/atlas/repository/Constants.java
View File

@ -188,6 +188,7 @@ public final class Constants {
public static final String TERM_ASSIGNMENT_LABEL = "r:AtlasGlossarySemanticAssignment";
public static final String ATTRIBUTE_INDEX_PROPERTY_KEY = encodePropertyKey(INTERNAL_PROPERTY_KEY_PREFIX + "index");
public static final String ATTRIBUTE_KEY_PROPERTY_KEY = encodePropertyKey(INTERNAL_PROPERTY_KEY_PREFIX + "key");
public static final String ATTRIBUTE_VALUE_DELIMITER = ",";
public static final String VERTEX_ID_IN_IMPORT_KEY = "__vIdInImport";
public static final String EDGE_ID_IN_IMPORT_KEY = "__eIdInImport";

5
intg/src/main/java/org/apache/atlas/model/discovery/SearchParameters.java
View File

@ -443,6 +443,10 @@ public class SearchParameters implements Serializable {
* Logical comparision operators can only be used with numbers or dates
* IN, LIKE, startsWith, endsWith, CONTAINS can only be used with strings or text
*/
/**
* NOTE : The names added in the String array should always contain first value in lower case
*/
public enum Operator {
LT(new String[]{"<", "lt"}),
GT(new String[]{">", "gt"}),
@ -460,6 +464,7 @@ public class SearchParameters implements Serializable {
CONTAINS_ALL(new String[]{"containsAll", "CONTAINSALL", "contains_all", "CONTAINS_ALL"}),
IS_NULL(new String[]{"isNull", "ISNULL", "is_null", "IS_NULL"}),
NOT_NULL(new String[]{"notNull", "NOTNULL", "not_null", "NOT_NULL"}),
TIME_RANGE(new String[]{"timerange", "TIMERANGE","time_range","TIME_RANGE"})
;
static final Map<String, Operator> operatorsMap = new HashMap<>();

181
repository/src/main/java/org/apache/atlas/discovery/SearchProcessor.java
View File

@ -17,6 +17,7 @@
*/
package org.apache.atlas.discovery;
import com.google.common.annotations.VisibleForTesting;
import org.apache.atlas.ApplicationProperties;
import org.apache.atlas.AtlasException;
import org.apache.atlas.SortOrder;
@ -46,6 +47,8 @@ import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Pattern;
@ -121,6 +124,9 @@ public abstract class SearchProcessor {
OPERATOR_MAP.put(SearchParameters.Operator.NOT_NULL, INDEX_SEARCH_PREFIX + "\"%s\":[* TO *]");
OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.NOT_NULL, getNotNullPredicateGenerator());
OPERATOR_MAP.put(SearchParameters.Operator.TIME_RANGE, INDEX_SEARCH_PREFIX + "\"%s\": [%s TO %s]");
OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.TIME_RANGE, getInRangePredicateGenerator());
}
protected final SearchContext context;
@ -523,6 +529,9 @@ public abstract class SearchProcessor {
}
} else if (StringUtils.isNotEmpty(criteria.getAttributeName())) {
try {
if (criteria.getOperator() == SearchParameters.Operator.TIME_RANGE) {
criteria = processDateRange(criteria);
}
ArrayList<String> orExpQuery = new ArrayList<>();
for (AtlasStructType structType : structTypes) {
String name = structType.getVertexPropertyName(criteria.getAttributeName());
@ -584,6 +593,10 @@ public abstract class SearchProcessor {
String attrValue = criteria.getAttributeValue();
SearchParameters.Operator operator = criteria.getOperator();
if (operator == SearchParameters.Operator.TIME_RANGE) {
FilterCriteria processedRangeCriteria = processDateRange(criteria);
attrValue = processedRangeCriteria.getAttributeValue();
}
//process attribute value and attribute operator for pipeSeperated fields
if (isPipeSeparatedSystemAttribute(attrName)) {
FilterCriteria processedCriteria = processPipeSeperatedSystemAttribute(attrName, operator, attrValue);
@ -610,6 +623,115 @@ public abstract class SearchProcessor {
return null;
}
@VisibleForTesting
public FilterCriteria processDateRange(FilterCriteria criteria) {
String attrName = criteria.getAttributeName();
SearchParameters.Operator op = criteria.getOperator();
String attrVal = criteria.getAttributeValue();
FilterCriteria ret = new FilterCriteria();
final LocalDateTime now = LocalDateTime.now();
final LocalDateTime startTime;
final LocalDateTime endTime;
switch (attrVal) {
case "LAST_7_DAYS":
startTime = now.minusDays(6).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusDays(7).minusNanos(1);
break;
case "LAST_30_DAYS":
startTime = now.minusDays(29).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusDays(30).minusNanos(1);
break;
case "LAST_MONTH":
startTime = now.minusMonths(1).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(1).minusNanos(1);
break;
case "THIS_MONTH":
startTime = now.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(1).minusNanos(1);
break;
case "TODAY":
startTime = now.withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusDays(1).minusNanos(1);
break;
case "YESTERDAY":
startTime = now.minusDays(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusDays(1).minusNanos(1);
break;
case "THIS_YEAR":
startTime = now.withDayOfYear(1).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusYears(1).minusNanos(1);
break;
case "LAST_YEAR":
startTime = now.minusYears(1).withDayOfYear(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusYears(1).minusNanos(1);
break;
case "THIS_QUARTER":
startTime = now.minusMonths(1).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(3).minusNanos(1);
break;
case "LAST_QUARTER":
startTime = now.minusMonths(4).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(3).minusNanos(1);
break;
case "LAST_3_MONTHS":
startTime = now.minusMonths(3).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(3).minusNanos(1);
break;
case "LAST_6_MONTHS":
startTime = now.minusMonths(6).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(6).minusNanos(1);
break;
case "LAST_12_MONTHS":
startTime = now.minusMonths(12).withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
endTime = startTime.plusMonths(12).minusNanos(1);
break;
default:
startTime = null;
endTime = null;
break;
}
if (startTime == null || endTime == null) {
String[] rangeAttr = attrVal.split(ATTRIBUTE_VALUE_DELIMITER);
boolean numeric = true;
if (rangeAttr.length != 2) {
LOG.error("Separator invalid");
} else {
try {
Long parsestartTime = Long.parseLong(String.valueOf(rangeAttr[0]));
Long parseendTime = Long.parseLong(String.valueOf(rangeAttr[1]));
} catch (NumberFormatException e) {
numeric = false;
if (!numeric) {
LOG.error("Attributes passed need to be LONG");
}
}
}
}else {
attrVal = Timestamp.valueOf(startTime).getTime() + ATTRIBUTE_VALUE_DELIMITER + Timestamp.valueOf(endTime).getTime();
}
ret.setAttributeName(attrName);
ret.setOperator(op);
ret.setAttributeValue(attrVal);
return ret;
}
private FilterCriteria processPipeSeperatedSystemAttribute(String attrName, SearchParameters.Operator op, String attrVal) {
FilterCriteria ret = new FilterCriteria();
@ -648,20 +770,32 @@ public abstract class SearchProcessor {
return ret;
}
private String toIndexExpression(AtlasStructType type, String attrName, SearchParameters.Operator op, String attrVal) {
private String toIndexExpression(AtlasStructType type, String attrName, SearchParameters.Operator op, String attrVal) throws AtlasBaseException{
String ret = EMPTY_STRING;
try {
if (OPERATOR_MAP.get(op) != null) {
String qualifiedName = type.getVertexPropertyName(attrName);
String escapeIndexQueryValue = AtlasAttribute.escapeIndexQueryValue(attrVal);
// map '__customAttributes' 'CONTAINS' operator to 'EQ' operator (solr limitation for json serialized string search)
// map '__customAttributes' value from 'key1=value1' to '\"key1\":\"value1\"' (escape special characters and surround with quotes)
if (attrName.equals(CUSTOM_ATTRIBUTES_PROPERTY_KEY) && op == SearchParameters.Operator.CONTAINS) {
ret = String.format(OPERATOR_MAP.get(op), qualifiedName, getCustomAttributeIndexQueryValue(escapeIndexQueryValue, false));
String rangeStart = "";
String rangeEnd = "";
String qualifiedName = type.getVertexPropertyName(attrName);
if (op == SearchParameters.Operator.TIME_RANGE) {
String[] parts = attrVal.split(ATTRIBUTE_VALUE_DELIMITER);
if (parts.length == 2) {
rangeStart = parts[0];
rangeEnd = parts[1];
String rangeStartIndexQueryValue = AtlasAttribute.escapeIndexQueryValue(rangeStart);
String rangeEndIndexQueryValue = AtlasAttribute.escapeIndexQueryValue(rangeEnd);
ret = String.format(OPERATOR_MAP.get(op), qualifiedName, rangeStartIndexQueryValue, rangeEndIndexQueryValue);
}
} else {
ret = String.format(OPERATOR_MAP.get(op), qualifiedName, escapeIndexQueryValue);
// map '__customAttributes' 'CONTAINS' operator to 'EQ' operator (solr limitation for json serialized string search)
// map '__customAttributes' value from 'key1=value1' to '\"key1\":\"value1\"' (escape special characters and surround with quotes)
String escapeIndexQueryValue = AtlasAttribute.escapeIndexQueryValue(attrVal);
if (attrName.equals(CUSTOM_ATTRIBUTES_PROPERTY_KEY) && op == SearchParameters.Operator.CONTAINS) {
ret = String.format(OPERATOR_MAP.get(op), qualifiedName, getCustomAttributeIndexQueryValue(escapeIndexQueryValue, false));
} else {
ret = String.format(OPERATOR_MAP.get(op), qualifiedName, escapeIndexQueryValue);
}
}
}
} catch (AtlasBaseException ex) {
@ -695,7 +829,6 @@ public abstract class SearchProcessor {
private Predicate toInMemoryPredicate(AtlasStructType type, String attrName, SearchParameters.Operator op, String attrVal) {
Predicate ret = null;
AtlasAttribute attribute = type.getAttribute(attrName);
ElementAttributePredicateGenerator predicate = OPERATOR_PREDICATE_MAP.get(op);
@ -703,6 +836,7 @@ public abstract class SearchProcessor {
final AtlasType attrType = attribute.getAttributeType();
final Class attrClass;
final Object attrValue;
Object attrValue2 = null;
// Some operators support null comparison, thus the parsing has to be conditional
switch (attrType.getTypeName()) {
@ -733,7 +867,21 @@ public abstract class SearchProcessor {
case AtlasBaseTypeDef.ATLAS_TYPE_LONG:
case AtlasBaseTypeDef.ATLAS_TYPE_DATE:
attrClass = Long.class;
attrValue = StringUtils.isEmpty(attrVal) ? null : Long.parseLong(attrVal);
String rangeStart = "";
String rangeEnd = "";
if (op == SearchParameters.Operator.TIME_RANGE) {
String[] parts = attrVal.split(ATTRIBUTE_VALUE_DELIMITER);
if (parts.length == 2) {
rangeStart = parts[0];
rangeEnd = parts[1];
}
}
if (StringUtils.isNotEmpty(rangeStart) && StringUtils.isNotEmpty(rangeEnd)) {
attrValue = Long.parseLong(rangeStart);
attrValue2 = Long.parseLong(rangeEnd);
} else {
attrValue = StringUtils.isEmpty(attrVal) ? null : Long.parseLong(attrVal);
}
break;
case AtlasBaseTypeDef.ATLAS_TYPE_FLOAT:
attrClass = Float.class;
@ -761,9 +909,14 @@ public abstract class SearchProcessor {
}
String vertexPropertyName = attribute.getVertexPropertyName();
ret = predicate.generatePredicate(
StringUtils.isEmpty(vertexPropertyName) ? attribute.getQualifiedName() : vertexPropertyName,
attrValue, attrClass);
if (attrValue != null && attrValue2 != null) {
ret = predicate.generatePredicate(StringUtils.isEmpty(vertexPropertyName) ? attribute.getQualifiedName() : vertexPropertyName,
attrValue, attrValue2, attrClass);
} else {
ret = predicate.generatePredicate(
StringUtils.isEmpty(vertexPropertyName) ? attribute.getQualifiedName() : vertexPropertyName,
attrValue, attrClass);
}
}
return ret;

58
repository/src/main/java/org/apache/atlas/util/SearchPredicateUtil.java
View File

@ -179,6 +179,40 @@ public class SearchPredicateUtil {
return ret;
}
public static ElementAttributePredicateGenerator getInRangePredicateGenerator() {
if (LOG.isDebugEnabled()) {
LOG.debug("==> getInRangePredicateGenerator");
}
ElementAttributePredicateGenerator ret = new ElementAttributePredicateGenerator() {
@Override
public Predicate generatePredicate(String attrName, Object attrVal, Class attrClass) {
return generatePredicate(attrName, attrVal, attrVal, attrClass);
}
@Override
public Predicate generatePredicate(String attrName, Object attrVal, Object attrVal2, Class attrClass) {
final Predicate ret;
if (attrName == null || attrClass == null || attrVal == null || attrVal2 == null) {
ret = ALWAYS_FALSE;
} else if (Long.class.isAssignableFrom(attrClass)) {
ret = LongPredicate.getInRangePredicate(attrName, attrClass, (Long) attrVal, (Long) attrVal2);
} else {
ret = ALWAYS_FALSE;
}
return ret;
}
};
if (LOG.isDebugEnabled()) {
LOG.debug("<== getInRangePredicateGenerator");
}
return ret;
}
public static ElementAttributePredicateGenerator getGTEPredicateGenerator() {
if (LOG.isDebugEnabled()) {
LOG.debug("==> getGTEPredicateGenerator");
@ -768,6 +802,9 @@ public class SearchPredicateUtil {
public interface ElementAttributePredicateGenerator {
Predicate generatePredicate(String attrName, Object attrVal, Class attrClass);
default Predicate generatePredicate(String attrName, Object attrVal, Object attrVal2, Class attrClass) {
return generatePredicate(attrName, attrVal, attrClass);
}
}
static abstract class ElementAttributePredicate implements Predicate {
@ -969,16 +1006,27 @@ public class SearchPredicateUtil {
static abstract class LongPredicate extends ElementAttributePredicate {
final Long value;
final Long value2;
LongPredicate(String attrName, Class attrClass, Long value) {
super(attrName, attrClass);
this.value = value;
this.value2 = null;
}
LongPredicate(String attrName, Class attrClass, Long value, Long value2, boolean isNullValid) {
super(attrName, attrClass, isNullValid);
this.value = value;
this.value2 = value2;
}
LongPredicate(String attrName, Class attrClass, Long value, boolean isNullValid) {
super(attrName, attrClass, isNullValid);
this.value = value;
this.value = value;
this.value2 = null;
}
static ElementAttributePredicate getEQPredicate(String attrName, Class attrClass, Long value) {
@ -1028,6 +1076,14 @@ public class SearchPredicateUtil {
}
};
}
static ElementAttributePredicate getInRangePredicate(String attrName, Class attrClass, Long rangeStart, Long rangeEnd) {
return new LongPredicate(attrName, attrClass, rangeStart, rangeEnd, false) {
protected boolean compareValue(Object vertexAttrVal) {
return ((Long) vertexAttrVal).compareTo(value) >= 0 && ((Long) vertexAttrVal).compareTo(value2) <= 0;
}
};
}
}
static abstract class FloatPredicate extends ElementAttributePredicate {

238
repository/src/test/java/org/apache/atlas/discovery/EntitySearchProcessorTest.java
View File

@ -35,16 +35,23 @@ import org.testng.annotations.Guice;
import org.testng.annotations.Test;
import javax.inject.Inject;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Calendar;
import java.util.GregorianCalendar;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
@Guice(modules = TestModules.TestOnlyModule.class)
public class EntitySearchProcessorTest extends BasicTestSetup {
private static final Logger LOG = LoggerFactory.getLogger(EntitySearchProcessorTest.class);
private final SimpleDateFormat formattedDate = new SimpleDateFormat("dd-MMM-yyyy");
@Inject
private AtlasGraph graph;
@ -360,4 +367,235 @@ public class EntitySearchProcessorTest extends BasicTestSetup {
AtlasGraphProvider.cleanup();
}
@Test
public void testLast7Days() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_7_DAYS",typeRegistry,graph);
ret.setAttributeName("createTime");
GregorianCalendar startDate = new GregorianCalendar();
GregorianCalendar endDate = new GregorianCalendar();
startDate.add(Calendar.DATE, -6);
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(startDate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(endDate.getTime()));
}
@Test
public void testLastMonth() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_MONTH", typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.MONTH, -1);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.MONTH, -1);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testLast30Days() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_30_DAYS", typeRegistry,graph);
GregorianCalendar startDate = new GregorianCalendar();
GregorianCalendar endDate = new GregorianCalendar();
startDate.add(Calendar.DATE, -29);
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(startDate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(endDate.getTime()));
}
@Test
public void testYesterday() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("YESTERDAY", typeRegistry,graph);
GregorianCalendar yesterdayDate = new GregorianCalendar();
yesterdayDate.add(Calendar.DATE, -1);
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(yesterdayDate.getTime()));
}
@Test
public void testThisMonth() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("THIS_MONTH", typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testThisQuarter() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("THIS_QUARTER", typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.MONTH, -1);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.MONTH, 1);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testLastQuarter() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_QUARTER", typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.MONTH, -4);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.MONTH, -2);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testLast3Months() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_3_MONTHS", typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.MONTH, -3);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.MONTH, -1);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testThisYear() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("THIS_YEAR",typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.set(Calendar.MONTH, 0);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.set(Calendar.MONTH, 11);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testLastYear() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_YEAR",typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.YEAR, -1);
originalstartdate.set(Calendar.MONTH, 0);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.YEAR, -1);
originalenddate.set(Calendar.MONTH, 11);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testLast12Months() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_12_MONTHS",typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.MONTH, -12);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.MONTH, -1);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
@Test
public void testLast6Months() throws AtlasBaseException {
SearchParameters.FilterCriteria ret = filtercriteriaDateRange("LAST_6_MONTHS",typeRegistry,graph);
Calendar originalstartdate = Calendar.getInstance();
Calendar originalenddate = Calendar.getInstance();
originalstartdate.add(Calendar.MONTH, -6);
originalstartdate.set(Calendar.DAY_OF_MONTH, originalstartdate.getActualMinimum(Calendar.DAY_OF_MONTH));
originalenddate.add(Calendar.MONTH, -1);
originalenddate.set(Calendar.DAY_OF_MONTH, originalenddate.getActualMaximum(Calendar.DAY_OF_MONTH));
String[] dates = ret.getAttributeValue().split(",");
String attrValue1 = dates[0];
String attrValue2 = dates[1];
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue1)))), formattedDate.format(originalstartdate.getTime()));
assertEquals(formattedDate.format(new Date((Long.parseLong(attrValue2)))), formattedDate.format(originalenddate.getTime()));
}
private static SearchParameters.FilterCriteria filtercriteriaDateRange(String attributeValue, AtlasTypeRegistry typeRegistry, AtlasGraph graph) throws AtlasBaseException {
SearchParameters params = new SearchParameters();
params.setTypeName(HIVE_TABLE_TYPE);
SearchParameters.FilterCriteria filterCriteria = new SearchParameters.FilterCriteria();
params.setEntityFilters(filterCriteria);
params.setLimit(20);
SearchContext context = new SearchContext(params, typeRegistry, graph, Collections.<String>emptySet());
EntitySearchProcessor processor = new EntitySearchProcessor(context);
filterCriteria.setCondition(SearchParameters.FilterCriteria.Condition.AND);
filterCriteria.setOperator(SearchParameters.Operator.TIME_RANGE);
filterCriteria.setAttributeValue(attributeValue);
SearchParameters.FilterCriteria ret = processor.processDateRange(filterCriteria);
return ret;
}
}