atlas-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mad...@apache.org
Subject atlas git commit: ATLAS-2044: In-memory filtering for correctness after index query
Date Thu, 17 Aug 2017 01:30:36 GMT
Repository: atlas
Updated Branches:
  refs/heads/0.8-incubating 8967f0cf6 -> b285e93c9


ATLAS-2044: In-memory filtering for correctness after index query

(cherry picked from commit fae00825291dd79b54867b7b7d0c2a233ce163fd)


Project: http://git-wip-us.apache.org/repos/asf/atlas/repo
Commit: http://git-wip-us.apache.org/repos/asf/atlas/commit/b285e93c
Tree: http://git-wip-us.apache.org/repos/asf/atlas/tree/b285e93c
Diff: http://git-wip-us.apache.org/repos/asf/atlas/diff/b285e93c

Branch: refs/heads/0.8-incubating
Commit: b285e93c98a1d2d7ca5585f69e621167f53982b3
Parents: 8967f0c
Author: apoorvnaik <apoorvnaik@apache.org>
Authored: Sun Aug 13 00:53:38 2017 -0700
Committer: Madhan Neethiraj <madhan@apache.org>
Committed: Wed Aug 16 18:30:23 2017 -0700

----------------------------------------------------------------------
 .../ClassificationSearchProcessor.java          |   19 +-
 .../atlas/discovery/EntitySearchProcessor.java  |   23 +-
 .../discovery/FullTextSearchProcessor.java      |   14 +-
 .../apache/atlas/discovery/SearchProcessor.java |  171 ++-
 .../apache/atlas/util/SearchPredicateUtil.java  | 1039 ++++++++++++++++++
 5 files changed, 1218 insertions(+), 48 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/atlas/blob/b285e93c/repository/src/main/java/org/apache/atlas/discovery/ClassificationSearchProcessor.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/discovery/ClassificationSearchProcessor.java b/repository/src/main/java/org/apache/atlas/discovery/ClassificationSearchProcessor.java
index 74197ca..29670bc 100644
--- a/repository/src/main/java/org/apache/atlas/discovery/ClassificationSearchProcessor.java
+++ b/repository/src/main/java/org/apache/atlas/discovery/ClassificationSearchProcessor.java
@@ -87,6 +87,8 @@ public class ClassificationSearchProcessor extends SearchProcessor {
             indexQueryString = STRAY_ELIPSIS_PATTERN.matcher(indexQueryString).replaceAll("");
 
             this.indexQuery = graph.indexQuery(Constants.VERTEX_INDEX, indexQueryString);
+
+            constructInMemoryPredicate(classificationType, filterCriteria, indexAttributes);
         } else {
             indexQuery = null;
         }
@@ -184,6 +186,9 @@ public class ClassificationSearchProcessor extends SearchProcessor {
                     getVertices(queryResult, classificationVertices);
                 }
 
+                // Do in-memory filtering before the graph query
+                CollectionUtils.filter(classificationVertices, inMemoryPredicate);
+
                 for (AtlasVertex classificationVertex : classificationVertices) {
                     Iterable<AtlasEdge> edges = classificationVertex.getEdges(AtlasEdgeDirection.IN);
 
@@ -208,19 +213,7 @@ public class ClassificationSearchProcessor extends SearchProcessor {
 
                 super.filter(entityVertices);
 
-                for (AtlasVertex entityVertex : entityVertices) {
-                    resultIdx++;
-
-                    if (resultIdx <= startIdx) {
-                        continue;
-                    }
-
-                    ret.add(entityVertex);
-
-                    if (ret.size() == limit) {
-                        break;
-                    }
-                }
+                resultIdx = collectResultVertices(ret, startIdx, limit, resultIdx, entityVertices);
             }
         } finally {
             AtlasPerfTracer.log(perf);

http://git-wip-us.apache.org/repos/asf/atlas/blob/b285e93c/repository/src/main/java/org/apache/atlas/discovery/EntitySearchProcessor.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/discovery/EntitySearchProcessor.java b/repository/src/main/java/org/apache/atlas/discovery/EntitySearchProcessor.java
index 9cd83fb..f4ac8ab 100644
--- a/repository/src/main/java/org/apache/atlas/discovery/EntitySearchProcessor.java
+++ b/repository/src/main/java/org/apache/atlas/discovery/EntitySearchProcessor.java
@@ -71,6 +71,8 @@ public class EntitySearchProcessor extends SearchProcessor {
 
         if (attrSearchByIndex) {
             constructFilterQuery(indexQuery, entityType, filterCriteria, indexAttributes);
+
+            constructInMemoryPredicate(entityType, filterCriteria, indexAttributes);
         } else {
             graphAttributes.addAll(indexAttributes);
         }
@@ -165,11 +167,10 @@ public class EntitySearchProcessor extends SearchProcessor {
                         break;
                     }
 
-                    while (idxQueryResult.hasNext()) {
-                        AtlasVertex vertex = idxQueryResult.next().getVertex();
+                    getVerticesFromIndexQueryResult(idxQueryResult, entityVertices);
 
-                        entityVertices.add(vertex);
-                    }
+                    // Do in-memory filtering before the graph query
+                    CollectionUtils.filter(entityVertices, inMemoryPredicate);
 
                     if (graphQuery != null) {
                         AtlasGraphQuery guidQuery = context.getGraph().query().in(Constants.GUID_PROPERTY_KEY, getGuids(entityVertices));
@@ -191,19 +192,7 @@ public class EntitySearchProcessor extends SearchProcessor {
 
                 super.filter(entityVertices);
 
-                for (AtlasVertex entityVertex : entityVertices) {
-                    resultIdx++;
-
-                    if (resultIdx <= startIdx) {
-                        continue;
-                    }
-
-                    ret.add(entityVertex);
-
-                    if (ret.size() == limit) {
-                        break;
-                    }
-                }
+                resultIdx = collectResultVertices(ret, startIdx, limit, resultIdx, entityVertices);
             }
         } finally {
             AtlasPerfTracer.log(perf);

http://git-wip-us.apache.org/repos/asf/atlas/blob/b285e93c/repository/src/main/java/org/apache/atlas/discovery/FullTextSearchProcessor.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/discovery/FullTextSearchProcessor.java b/repository/src/main/java/org/apache/atlas/discovery/FullTextSearchProcessor.java
index d556bf1..95372d3 100644
--- a/repository/src/main/java/org/apache/atlas/discovery/FullTextSearchProcessor.java
+++ b/repository/src/main/java/org/apache/atlas/discovery/FullTextSearchProcessor.java
@@ -141,19 +141,7 @@ public class FullTextSearchProcessor extends SearchProcessor {
 
                 super.filter(entityVertices);
 
-                for (AtlasVertex entityVertex : entityVertices) {
-                    resultIdx++;
-
-                    if (resultIdx <= startIdx) {
-                        continue;
-                    }
-
-                    ret.add(entityVertex);
-
-                    if (ret.size() == limit) {
-                        break;
-                    }
-                }
+                resultIdx = collectResultVertices(ret, startIdx, limit, resultIdx, entityVertices);
             }
         } finally {
             AtlasPerfTracer.log(perf);

http://git-wip-us.apache.org/repos/asf/atlas/blob/b285e93c/repository/src/main/java/org/apache/atlas/discovery/SearchProcessor.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/discovery/SearchProcessor.java b/repository/src/main/java/org/apache/atlas/discovery/SearchProcessor.java
index b209ecb..15564fc 100644
--- a/repository/src/main/java/org/apache/atlas/discovery/SearchProcessor.java
+++ b/repository/src/main/java/org/apache/atlas/discovery/SearchProcessor.java
@@ -23,22 +23,38 @@ import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.model.discovery.SearchParameters;
 import org.apache.atlas.model.discovery.SearchParameters.FilterCriteria;
 import org.apache.atlas.model.discovery.SearchParameters.FilterCriteria.Condition;
-import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
 import org.apache.atlas.repository.Constants;
-import org.apache.atlas.repository.graphdb.*;
+import org.apache.atlas.repository.graphdb.AtlasGraphQuery;
+import org.apache.atlas.repository.graphdb.AtlasIndexQuery;
+import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1;
 import org.apache.atlas.type.AtlasEntityType;
 import org.apache.atlas.type.AtlasStructType;
 import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
 import org.apache.atlas.util.AtlasGremlinQueryProvider;
+import org.apache.atlas.util.SearchPredicateUtil.VertexAttributePredicateGenerator;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.Predicate;
+import org.apache.commons.collections.PredicateUtils;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.*;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.regex.Pattern;
 
+import static org.apache.atlas.util.SearchPredicateUtil.*;
+
 public abstract class SearchProcessor {
     private static final Logger LOG = LoggerFactory.getLogger(SearchProcessor.class);
 
@@ -54,25 +70,48 @@ public abstract class SearchProcessor {
     public static final String  BRACE_OPEN_STR  = "(";
     public static final String  BRACE_CLOSE_STR = ")";
 
-    private static final Map<SearchParameters.Operator, String> OPERATOR_MAP = new HashMap<>();
+    private static final Map<SearchParameters.Operator, String>                            OPERATOR_MAP           = new HashMap<>();
+    private static final Map<SearchParameters.Operator, VertexAttributePredicateGenerator> OPERATOR_PREDICATE_MAP = new HashMap<>();
 
     static
     {
         OPERATOR_MAP.put(SearchParameters.Operator.LT,"v.\"%s\": [* TO %s}");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.LT, getLTPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.GT,"v.\"%s\": {%s TO *]");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.GT, getGTPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.LTE,"v.\"%s\": [* TO %s]");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.LTE, getLTEPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.GTE,"v.\"%s\": [%s TO *]");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.GTE, getGTEPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.EQ,"v.\"%s\": %s");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.EQ, getEQPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.NEQ,"-" + "v.\"%s\": %s");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.NEQ, getNEQPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.IN, "v.\"%s\": (%s)"); // this should be a list of quoted strings
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.IN, getINPredicateGenerator()); // this should be a list of quoted strings
+
         OPERATOR_MAP.put(SearchParameters.Operator.LIKE, "v.\"%s\": (%s)"); // this should be regex pattern
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.LIKE, getLIKEPredicateGenerator()); // this should be regex pattern
+
         OPERATOR_MAP.put(SearchParameters.Operator.STARTS_WITH, "v.\"%s\": (%s*)");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.STARTS_WITH, getStartsWithPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.ENDS_WITH, "v.\"%s\": (*%s)");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.ENDS_WITH, getEndsWithPredicateGenerator());
+
         OPERATOR_MAP.put(SearchParameters.Operator.CONTAINS, "v.\"%s\": (*%s*)");
+        OPERATOR_PREDICATE_MAP.put(SearchParameters.Operator.CONTAINS, getContainsPredicateGenerator());
     }
 
     protected final SearchContext   context;
     protected       SearchProcessor nextProcessor;
+    protected       Predicate       inMemoryPredicate;
 
 
     protected SearchProcessor(SearchContext context) {
@@ -89,6 +128,24 @@ public abstract class SearchProcessor {
 
     public abstract List<AtlasVertex> execute();
 
+    protected int collectResultVertices(final List<AtlasVertex> ret, final int startIdx, final int limit, int resultIdx, final List<AtlasVertex> entityVertices) {
+        for (AtlasVertex entityVertex : entityVertices) {
+            resultIdx++;
+
+            if (resultIdx <= startIdx) {
+                continue;
+            }
+
+            ret.add(entityVertex);
+
+            if (ret.size() == limit) {
+                break;
+            }
+        }
+
+        return resultIdx;
+    }
+
     public void filter(List<AtlasVertex> entityVertices) {
         if (nextProcessor != null && CollectionUtils.isNotEmpty(entityVertices)) {
             nextProcessor.filter(entityVertices);
@@ -194,7 +251,9 @@ public abstract class SearchProcessor {
 
     protected void constructFilterQuery(StringBuilder indexQuery, AtlasStructType type, FilterCriteria filterCriteria, Set<String> indexAttributes) {
         if (filterCriteria != null) {
-            LOG.debug("Processing Filters");
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("Processing Filters");
+            }
 
             String filterQuery = toIndexQuery(type, filterCriteria, indexAttributes, 0);
 
@@ -208,6 +267,16 @@ public abstract class SearchProcessor {
         }
     }
 
+    protected void constructInMemoryPredicate(AtlasStructType type, FilterCriteria filterCriteria, Set<String> indexAttributes) {
+        if (filterCriteria != null) {
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("Processing Filters");
+            }
+
+            inMemoryPredicate = toInMemoryPredicate(type, filterCriteria, indexAttributes);
+        }
+    }
+
     protected void constructGremlinFilterQuery(StringBuilder gremlinQuery, Map<String, Object> queryBindings, AtlasStructType structType, FilterCriteria filterCriteria) {
         if (filterCriteria != null) {
             FilterCriteria.Condition condition = filterCriteria.getCondition();
@@ -291,6 +360,32 @@ public abstract class SearchProcessor {
         }
     }
 
+    private Predicate toInMemoryPredicate(AtlasStructType type, FilterCriteria criteria, Set<String> indexAttributes) {
+        if (criteria.getCondition() != null && CollectionUtils.isNotEmpty(criteria.getCriterion())) {
+            List<Predicate> predicates = new ArrayList<>();
+
+            for (FilterCriteria filterCriteria : criteria.getCriterion()) {
+                Predicate predicate = toInMemoryPredicate(type, filterCriteria, indexAttributes);
+
+                if (predicate != null) {
+                    predicates.add(predicate);
+                }
+            }
+
+            if (CollectionUtils.isNotEmpty(predicates)) {
+                if (criteria.getCondition() == Condition.AND) {
+                    return PredicateUtils.allPredicate(predicates);
+                } else {
+                    return PredicateUtils.anyPredicate(predicates);
+                }
+            }
+        } else if (indexAttributes.contains(criteria.getAttributeName())){
+            return toInMemoryPredicate(type, criteria.getAttributeName(), criteria.getOperator(), criteria.getAttributeValue());
+        }
+
+        return null;
+    }
+
     private String toIndexExpression(AtlasStructType type, String attrName, SearchParameters.Operator op, String attrVal) {
         String ret = EMPTY_STRING;
 
@@ -307,6 +402,71 @@ public abstract class SearchProcessor {
         return ret;
     }
 
+    private Predicate toInMemoryPredicate(AtlasStructType type, String attrName, SearchParameters.Operator op, String attrVal) {
+        Predicate ret = null;
+
+        AtlasAttribute                    attribute = type.getAttribute(attrName);
+        VertexAttributePredicateGenerator predicate = OPERATOR_PREDICATE_MAP.get(op);
+
+        if (attribute != null && predicate != null) {
+            final String attributeType = attribute.getAttributeType().getTypeName().toLowerCase();
+            final Class  attrClass;
+            final Object attrValue;
+
+            switch (attributeType) {
+                case "string":
+                    attrClass = String.class;
+                    attrValue = attrVal;
+                    break;
+                case "short":
+                    attrClass = Short.class;
+                    attrValue = Short.parseShort(attrVal);
+                    break;
+                case "int":
+                    attrClass = Integer.class;
+                    attrValue = Integer.parseInt(attrVal);
+                    break;
+                case "biginteger":
+                    attrClass = BigInteger.class;
+                    attrValue = new BigInteger(attrVal);
+                    break;
+                case "boolean":
+                    attrClass = Boolean.class;
+                    attrValue = Boolean.parseBoolean(attrVal);
+                    break;
+                case "byte":
+                    attrClass = Byte.class;
+                    attrValue = Byte.parseByte(attrVal);
+                    break;
+                case "long":
+                case "date":
+                    attrClass = Long.class;
+                    attrValue = Long.parseLong(attrVal);
+                    break;
+                case "float":
+                    attrClass = Float.class;
+                    attrValue = Float.parseFloat(attrVal);
+                    break;
+                case "double":
+                    attrClass = Double.class;
+                    attrValue = Double.parseDouble(attrVal);
+                    break;
+                case "bigdecimal":
+                    attrClass = BigDecimal.class;
+                    attrValue = new BigDecimal(attrVal);
+                    break;
+                default:
+                    attrClass = Object.class;
+                    attrValue = attrVal;
+                    break;
+            }
+
+            ret = predicate.generatePredicate(attribute.getQualifiedName(), attrValue, attrClass);
+        }
+
+        return ret;
+    }
+
     protected AtlasGraphQuery toGraphFilterQuery(AtlasStructType type, FilterCriteria criteria, Set<String> graphAttributes, AtlasGraphQuery query) {
         if (criteria != null) {
             if (criteria.getCondition() != null) {
@@ -493,4 +653,5 @@ public abstract class SearchProcessor {
 
         return defaultValue;
     }
+
 }

http://git-wip-us.apache.org/repos/asf/atlas/blob/b285e93c/repository/src/main/java/org/apache/atlas/util/SearchPredicateUtil.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/util/SearchPredicateUtil.java b/repository/src/main/java/org/apache/atlas/util/SearchPredicateUtil.java
new file mode 100644
index 0000000..fc973e6
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/util/SearchPredicateUtil.java
@@ -0,0 +1,1039 @@
+/**
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.atlas.util;
+
+import org.apache.atlas.repository.graphdb.AtlasVertex;
+import org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1;
+import org.apache.commons.collections.Predicate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.List;
+
+public class SearchPredicateUtil {
+    private static final Logger LOG = LoggerFactory.getLogger(SearchPredicateUtil.class);
+
+    private static Predicate ALWAYS_FALSE = new Predicate() {
+        @Override
+        public boolean evaluate(final Object object) {
+            return false;
+        }
+    };
+
+    public static VertexAttributePredicateGenerator getLTPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getLTPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (Short.class.isAssignableFrom(attrClass)) {
+                    ret = ShortPredicate.getLTPredicate(attrName, attrClass, (Short)attrVal);
+                } else if (Integer.class.isAssignableFrom(attrClass)) {
+                    ret = IntegerPredicate.getLTPredicate(attrName, attrClass, (Integer)attrVal);
+                } else if (Long.class.isAssignableFrom(attrClass)) {
+                    ret = LongPredicate.getLTPredicate(attrName, attrClass, (Long)attrVal);
+                } else if (Float.class.isAssignableFrom(attrClass)) {
+                    ret = FloatPredicate.getLTPredicate(attrName, attrClass, (Float)attrVal);
+                } else if (Double.class.isAssignableFrom(attrClass)) {
+                    ret = DoublePredicate.getLTPredicate(attrName, attrClass, (Double)attrVal);
+                } else if (Byte.class.isAssignableFrom(attrClass)) {
+                    ret = BytePredicate.getLTPredicate(attrName, attrClass, (Byte)attrVal);
+                } else if (BigInteger.class.isAssignableFrom(attrClass)) {
+                    ret = BigIntegerPredicate.getLTPredicate(attrName, attrClass, (BigInteger)attrVal);
+                } else if (BigDecimal.class.isAssignableFrom(attrClass)) {
+                    ret = BigDecimalPredicate.getLTPredicate(attrName, attrClass, (BigDecimal)attrVal);
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getLTPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getLTPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getGTPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getGTPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (Short.class.isAssignableFrom(attrClass)) {
+                    ret = ShortPredicate.getGTPredicate(attrName, attrClass, (Short)attrVal);
+                } else if (Integer.class.isAssignableFrom(attrClass)) {
+                    ret = IntegerPredicate.getGTPredicate(attrName, attrClass, (Integer)attrVal);
+                } else if (Long.class.isAssignableFrom(attrClass)) {
+                    ret = LongPredicate.getGTPredicate(attrName, attrClass, (Long)attrVal);
+                } else if (Float.class.isAssignableFrom(attrClass)) {
+                    ret = FloatPredicate.getGTPredicate(attrName, attrClass, (Float)attrVal);
+                } else if (Double.class.isAssignableFrom(attrClass)) {
+                    ret = DoublePredicate.getGTPredicate(attrName, attrClass, (Double)attrVal);
+                } else if (Byte.class.isAssignableFrom(attrClass)) {
+                    ret = BytePredicate.getGTPredicate(attrName, attrClass, (Byte)attrVal);
+                } else if (BigInteger.class.isAssignableFrom(attrClass)) {
+                    ret = BigIntegerPredicate.getGTPredicate(attrName, attrClass, (BigInteger)attrVal);
+                } else if (BigDecimal.class.isAssignableFrom(attrClass)) {
+                    ret = BigDecimalPredicate.getGTPredicate(attrName, attrClass, (BigDecimal)attrVal);
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getGTPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getGTPredicateGenerator");
+        }
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getLTEPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getLTEPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (Short.class.isAssignableFrom(attrClass)) {
+                    ret = ShortPredicate.getLTEPredicate(attrName, attrClass, (Short)attrVal);
+                } else if (Integer.class.isAssignableFrom(attrClass)) {
+                    ret = IntegerPredicate.getLTEPredicate(attrName, attrClass, (Integer)attrVal);
+                } else if (Long.class.isAssignableFrom(attrClass)) {
+                    ret = LongPredicate.getLTEPredicate(attrName, attrClass, (Long)attrVal);
+                } else if (Float.class.isAssignableFrom(attrClass)) {
+                    ret = FloatPredicate.getLTEPredicate(attrName, attrClass, (Float)attrVal);
+                } else if (Double.class.isAssignableFrom(attrClass)) {
+                    ret = DoublePredicate.getLTEPredicate(attrName, attrClass, (Double)attrVal);
+                } else if (Byte.class.isAssignableFrom(attrClass)) {
+                    ret = BytePredicate.getLTEPredicate(attrName, attrClass, (Byte)attrVal);
+                } else if (BigInteger.class.isAssignableFrom(attrClass)) {
+                    ret = BigIntegerPredicate.getLTEPredicate(attrName, attrClass, (BigInteger)attrVal);
+                } else if (BigDecimal.class.isAssignableFrom(attrClass)) {
+                    ret = BigDecimalPredicate.getLTEPredicate(attrName, attrClass, (BigDecimal)attrVal);
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getLTEPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getLTEPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getGTEPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getGTEPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (Short.class.isAssignableFrom(attrClass)) {
+                    ret = ShortPredicate.getGTEPredicate(attrName, attrClass, (Short)attrVal);
+                } else if (Integer.class.isAssignableFrom(attrClass)) {
+                    ret = IntegerPredicate.getGTEPredicate(attrName, attrClass, (Integer)attrVal);
+                } else if (Long.class.isAssignableFrom(attrClass)) {
+                    ret = LongPredicate.getGTEPredicate(attrName, attrClass, (Long)attrVal);
+                } else if (Float.class.isAssignableFrom(attrClass)) {
+                    ret = FloatPredicate.getGTEPredicate(attrName, attrClass, (Float)attrVal);
+                } else if (Double.class.isAssignableFrom(attrClass)) {
+                    ret = DoublePredicate.getGTEPredicate(attrName, attrClass, (Double)attrVal);
+                } else if (Byte.class.isAssignableFrom(attrClass)) {
+                    ret = BytePredicate.getGTEPredicate(attrName, attrClass, (Byte)attrVal);
+                } else if (BigInteger.class.isAssignableFrom(attrClass)) {
+                    ret = BigIntegerPredicate.getGTEPredicate(attrName, attrClass, (BigInteger)attrVal);
+                } else if (BigDecimal.class.isAssignableFrom(attrClass)) {
+                    ret = BigDecimalPredicate.getGTEPredicate(attrName, attrClass, (BigDecimal)attrVal);
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getGTEPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<- getGTEPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getEQPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getEQPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (Short.class.isAssignableFrom(attrClass)) {
+                    ret = ShortPredicate.getEQPredicate(attrName, attrClass, (Short)attrVal);
+                } else if (Integer.class.isAssignableFrom(attrClass)) {
+                    ret = IntegerPredicate.getEQPredicate(attrName, attrClass, (Integer)attrVal);
+                } else if (Long.class.isAssignableFrom(attrClass)) {
+                    ret = LongPredicate.getEQPredicate(attrName, attrClass, (Long)attrVal);
+                } else if (Float.class.isAssignableFrom(attrClass)) {
+                    ret = FloatPredicate.getEQPredicate(attrName, attrClass, (Float)attrVal);
+                } else if (Double.class.isAssignableFrom(attrClass)) {
+                    ret = DoublePredicate.getEQPredicate(attrName, attrClass, (Double)attrVal);
+                } else if (Byte.class.isAssignableFrom(attrClass)) {
+                    ret = BytePredicate.getEQPredicate(attrName, attrClass, (Byte)attrVal);
+                } else if (BigInteger.class.isAssignableFrom(attrClass)) {
+                    ret = BigIntegerPredicate.getEQPredicate(attrName, attrClass, (BigInteger)attrVal);
+                } else if (BigDecimal.class.isAssignableFrom(attrClass)) {
+                    ret = BigDecimalPredicate.getEQPredicate(attrName, attrClass, (BigDecimal)attrVal);
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getEQPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getEQPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getNEQPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getNEQPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (Short.class.isAssignableFrom(attrClass)) {
+                    ret = ShortPredicate.getNEQPredicate(attrName, attrClass, (Short)attrVal);
+                } else if (Integer.class.isAssignableFrom(attrClass)) {
+                    ret = IntegerPredicate.getNEQPredicate(attrName, attrClass, (Integer)attrVal);
+                } else if (Long.class.isAssignableFrom(attrClass)) {
+                    ret = LongPredicate.getNEQPredicate(attrName, attrClass, (Long)attrVal);
+                } else if (Float.class.isAssignableFrom(attrClass)) {
+                    ret = FloatPredicate.getNEQPredicate(attrName, attrClass, (Float)attrVal);
+                } else if (Double.class.isAssignableFrom(attrClass)) {
+                    ret = DoublePredicate.getNEQPredicate(attrName, attrClass, (Double)attrVal);
+                } else if (Byte.class.isAssignableFrom(attrClass)) {
+                    ret = BytePredicate.getNEQPredicate(attrName, attrClass, (Byte)attrVal);
+                } else if (BigInteger.class.isAssignableFrom(attrClass)) {
+                    ret = BigIntegerPredicate.getNEQPredicate(attrName, attrClass, (BigInteger)attrVal);
+                } else if (BigDecimal.class.isAssignableFrom(attrClass)) {
+                    ret = BigDecimalPredicate.getNEQPredicate(attrName, attrClass, (BigDecimal)attrVal);
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getNEQPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getNEQPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getINPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getINPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else {
+                    ret = new VertexAttributePredicate(attrName, attrClass) {
+                        @Override
+                        public boolean compareValue(final Object value) {
+                            return (value instanceof List) ? ((List) value).contains(attrVal) : false;
+                        }
+                    };
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getINPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getLIKEPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getLIKEPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getContainsPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getLIKEPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getStartsWithPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getStartsWithPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getStartsWithPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getStartsWithPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getEndsWithPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getEndsWithPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getEndsWithPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getEndsWithPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public static VertexAttributePredicateGenerator getContainsPredicateGenerator() {
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("==> getContainsPredicateGenerator");
+        }
+
+        VertexAttributePredicateGenerator ret = new VertexAttributePredicateGenerator() {
+            @Override
+            public Predicate generatePredicate(final String attrName, final Object attrVal, final Class attrClass) {
+                final Predicate ret;
+
+                if (attrName == null || attrClass == null || attrVal == null) {
+                    ret = ALWAYS_FALSE;
+                } else if (String.class.isAssignableFrom(attrClass)) {
+                    ret = StringPredicate.getContainsPredicate(attrName, attrClass, (String)attrVal);
+                } else {
+                    ret = ALWAYS_FALSE;
+                }
+
+                return ret;
+            }
+        };
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("<== getContainsPredicateGenerator");
+        }
+
+        return ret;
+    }
+
+    public interface VertexAttributePredicateGenerator {
+        Predicate generatePredicate(String attrName, Object attrVal, Class attrClass);
+    }
+
+    static abstract class VertexAttributePredicate implements Predicate {
+        final String attrName;
+        final Class  attrClass;
+
+        VertexAttributePredicate(String attrName, Class attrClass) {
+            this.attrName  = attrName;
+            this.attrClass = attrClass;
+        }
+
+        @Override
+        public boolean evaluate(final Object object) {
+            final boolean ret;
+
+            AtlasVertex vertex = (object instanceof AtlasVertex) ? (AtlasVertex)object : null;
+
+            if (vertex != null) {
+                Object attrValue = AtlasGraphUtilsV1.getProperty(vertex, attrName, attrClass);
+
+                if (attrValue != null) {
+                    ret = compareValue(attrValue);
+                } else {
+                    ret = false;
+                }
+            } else {
+                ret = false;
+            }
+
+            return ret;
+        }
+
+        protected abstract boolean compareValue(Object value);
+    }
+
+    static abstract class ShortPredicate extends VertexAttributePredicate {
+        final Short value;
+
+        ShortPredicate(String attrName, Class attrClass, Short value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, Short value) {
+            return new ShortPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Short)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, Short value) {
+            return new ShortPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Short)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, Short value) {
+            return new ShortPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Short)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, Short value) {
+            return new ShortPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Short)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, Short value) {
+            return new ShortPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Short)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, Short value) {
+            return new ShortPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Short)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class IntegerPredicate extends VertexAttributePredicate {
+        final Integer value;
+
+        IntegerPredicate(String attrName, Class attrClass, Integer value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, Integer value) {
+            return new IntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Integer)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, Integer value) {
+            return new IntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Integer)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, Integer value) {
+            return new IntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Integer)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, Integer value) {
+            return new IntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Integer)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, Integer value) {
+            return new IntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Integer)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, Integer value) {
+            return new IntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Integer)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class LongPredicate extends VertexAttributePredicate {
+        final Long value;
+
+        LongPredicate(String attrName, Class attrClass, Long value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, Long value) {
+            return new LongPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Long)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, Long value) {
+            return new LongPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Long)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, Long value) {
+            return new LongPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Long)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, Long value) {
+            return new LongPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Long)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, Long value) {
+            return new LongPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Long)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, Long value) {
+            return new LongPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Long)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class FloatPredicate extends VertexAttributePredicate {
+        final Float value;
+
+        FloatPredicate(String attrName, Class attrClass, Float value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, Float value) {
+            return new FloatPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Float)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, Float value) {
+            return new FloatPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Float)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, Float value) {
+            return new FloatPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Float)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, Float value) {
+            return new FloatPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Float)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, Float value) {
+            return new FloatPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Float)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, Float value) {
+            return new FloatPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Float)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class DoublePredicate extends VertexAttributePredicate {
+        final Double value;
+
+        DoublePredicate(String attrName, Class attrClass, Double value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, Double value) {
+            return new DoublePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Double)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, Double value) {
+            return new DoublePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Double)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, Double value) {
+            return new DoublePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Double)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, Double value) {
+            return new DoublePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Double)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, Double value) {
+            return new DoublePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Double)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, Double value) {
+            return new DoublePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Double)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class BytePredicate extends VertexAttributePredicate {
+        final Byte value;
+
+        BytePredicate(String attrName, Class attrClass, Byte value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, Byte value) {
+            return new BytePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Byte)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, Byte value) {
+            return new BytePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Byte)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, Byte value) {
+            return new BytePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Byte)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, Byte value) {
+            return new BytePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Byte)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, Byte value) {
+            return new BytePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Byte)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, Byte value) {
+            return new BytePredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((Byte)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class BigIntegerPredicate extends VertexAttributePredicate {
+        final BigInteger value;
+
+        BigIntegerPredicate(String attrName, Class attrClass, BigInteger value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, BigInteger value) {
+            return new BigIntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigInteger)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, BigInteger value) {
+            return new BigIntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigInteger)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, BigInteger value) {
+            return new BigIntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigInteger)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, BigInteger value) {
+            return new BigIntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigInteger)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, BigInteger value) {
+            return new BigIntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigInteger)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, BigInteger value) {
+            return new BigIntegerPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigInteger)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class BigDecimalPredicate extends VertexAttributePredicate {
+        final BigDecimal value;
+
+        BigDecimalPredicate(String attrName, Class attrClass, BigDecimal value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, BigDecimal value) {
+            return new BigDecimalPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigDecimal)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, BigDecimal value) {
+            return new BigDecimalPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigDecimal)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, BigDecimal value) {
+            return new BigDecimalPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigDecimal)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, BigDecimal value) {
+            return new BigDecimalPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigDecimal)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, BigDecimal value) {
+            return new BigDecimalPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigDecimal)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, BigDecimal value) {
+            return new BigDecimalPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((BigDecimal)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+    }
+
+    static abstract class StringPredicate extends VertexAttributePredicate {
+        final String value;
+
+        StringPredicate(String attrName, Class attrClass, String value) {
+            super(attrName, attrClass);
+
+            this.value = value;
+        }
+
+        static VertexAttributePredicate getEQPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).compareTo(this.value) == 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getNEQPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).compareTo(this.value) != 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).compareTo(this.value) < 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getLTEPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).compareTo(this.value) <= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).compareTo(this.value) > 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getGTEPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).compareTo(this.value) >= 0;
+                }
+            };
+        }
+
+        static VertexAttributePredicate getContainsPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).contains(this.value);
+                }
+            };
+        }
+
+        static VertexAttributePredicate getStartsWithPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).startsWith(this.value);
+                }
+            };
+        }
+
+        static VertexAttributePredicate getEndsWithPredicate(String attrName, Class attrClass, String value) {
+            return new StringPredicate(attrName, attrClass, value) {
+                protected boolean compareValue(Object value) {
+                    return ((String)value).endsWith(this.value);
+                }
+            };
+        }
+    }
+}


Mime
View raw message