You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by ma...@apache.org on 2017/11/12 18:14:43 UTC
[34/42] atlas git commit: ATLAS-2251: Remove TypeSystem and related
implementation, to avoid unncessary duplicate of type details in cache
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/GremlinExpressionFactory.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/GremlinExpressionFactory.java b/repository/src/main/java/org/apache/atlas/gremlin/GremlinExpressionFactory.java
deleted file mode 100644
index d603150..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/GremlinExpressionFactory.java
+++ /dev/null
@@ -1,658 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS_METHOD 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.gremlin;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.atlas.AtlasException;
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.ArithmeticExpression;
-import org.apache.atlas.groovy.ArithmeticExpression.ArithmeticOperator;
-import org.apache.atlas.groovy.CastExpression;
-import org.apache.atlas.groovy.ClosureExpression;
-import org.apache.atlas.groovy.FieldExpression;
-import org.apache.atlas.groovy.FunctionCallExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-import org.apache.atlas.groovy.IdentifierExpression;
-import org.apache.atlas.groovy.ListExpression;
-import org.apache.atlas.groovy.LiteralExpression;
-import org.apache.atlas.groovy.TraversalStepType;
-import org.apache.atlas.groovy.TypeCoersionExpression;
-import org.apache.atlas.groovy.VariableAssignmentExpression;
-import org.apache.atlas.query.GraphPersistenceStrategies;
-import org.apache.atlas.query.IntSequence;
-import org.apache.atlas.query.TypeUtils.FieldInfo;
-import org.apache.atlas.repository.graph.AtlasGraphProvider;
-import org.apache.atlas.repository.graphdb.AtlasEdgeDirection;
-import org.apache.atlas.repository.graphdb.GremlinVersion;
-import org.apache.atlas.typesystem.types.IDataType;
-import org.apache.atlas.typesystem.types.TypeSystem;
-import org.apache.atlas.typesystem.types.cache.TypeCache.TYPE_FILTER;
-import org.apache.atlas.util.AtlasRepositoryConfiguration;
-
-import com.google.common.collect.ImmutableList;
-
-/**
- * Factory to generate Groovy expressions representing Gremlin syntax that that
- * are independent of the specific version of Gremlin that is being used.
- *
- */
-public abstract class GremlinExpressionFactory {
-
- private static final String G_VARIABLE = "g";
- private static final String IT_VARIABLE = "it";
-
- protected static final String SET_CLASS = "Set";
-
-
- private static final String OBJECT_FIELD = "object";
-
- protected static final String V_METHOD = "V";
- protected static final String FILTER_METHOD = "filter";
- private static final String PATH_METHOD = "path";
- private static final String AS_METHOD = "as";
- private static final String IN_OPERATOR = "in";
- protected static final String HAS_METHOD = "has";
- protected static final String TO_LOWER_CASE_METHOD = "toLowerCase";
- protected static final String SELECT_METHOD = "select";
- protected static final String ORDER_METHOD = "order";
- protected static final String FILL_METHOD = "fill";
- protected static final String MATCHES = "matches";
-
- public static final GremlinExpressionFactory INSTANCE = AtlasGraphProvider.getGraphInstance()
- .getSupportedGremlinVersion() == GremlinVersion.THREE ? new Gremlin3ExpressionFactory()
- : new Gremlin2ExpressionFactory();
-
- /**
- * Returns the unqualified name of the class used in this version of gremlin to
- * represent Gremlin queries as they are being generated.
- * @return
- */
- public abstract String getTraversalExpressionClass();
-
- /**
- * Gets the expression to use as the parent when translating the loop
- * expression in a loop
- *
- * @param inputQry
- * the
- * @return
- */
- public abstract GroovyExpression getLoopExpressionParent(GroovyExpression inputQry);
-
- /**
- * Generates a loop expression.
- *
- * @param parent
- * the parent of the loop expression
- * @param emitExpr
- * Expression with the value that should be emitted by the loop
- * expression.
- * @param loopExpr
- * the query expression that is being executed repeatedly
- * executed in a loop
- * @param alias
- * The alias of the expression being looped over
- * @param times
- * the number of times to repeat, or null if a times condition
- * should not be used.
- * @return
- */
- public abstract GroovyExpression generateLoopExpression(GroovyExpression parent, GraphPersistenceStrategies s, IDataType dataType,
- GroovyExpression loopExpr, String alias, Integer times);
-
-
- /**
- * Generates a logical (and/or) expression with the given operands.
- * @param parent
- * @param operator
- * @param operands
- * @return
- */
- public abstract GroovyExpression generateLogicalExpression(GroovyExpression parent, String operator,
- List<GroovyExpression> operands);
-
- /**
- * Generates a back reference expression that refers to the given alias.
- *
- * @param parent
- * @param inSelect
- * @param alias
- * @return
- */
- public abstract GroovyExpression generateBackReferenceExpression(GroovyExpression parent, boolean inSelect,
- String alias);
-
- /**
- * Generates a select expression
- *
- * @param parent
- * @param sourceNames
- * the names of the select fields
- * @param srcExprs
- * the corresponding values to return
- * @return
- */
- public abstract GroovyExpression generateSelectExpression(GroovyExpression parent,
- List<LiteralExpression> sourceNames, List<GroovyExpression> srcExprs);
-
- /**
- * Generates a an expression that gets the value of the given property from the
- * vertex presented by the parent.
- *
- * @param parent
- * @param fInfo
- * @param propertyName
- * @param inSelect
- * @return
- */
- public abstract GroovyExpression generateFieldExpression(GroovyExpression parent, FieldInfo fInfo,
- String propertyName, boolean inSelect);
-
- /**
- * Generates a has expression that checks whether the vertices match a specific condition
- *
- * @param s
- * @param parent the object that we should call apply the "has" condition to.
- * @param propertyName the name of the property whose value we are comparing
- * @param symbol comparsion operator symbol ('=','<', etc.)
- * @param requiredValue the value to compare against
- * @param fInfo info about the field whose value we are checking
- * @return
- * @throws AtlasException
- */
- public abstract GroovyExpression generateHasExpression(GraphPersistenceStrategies s, GroovyExpression parent,
- String propertyName, String symbol, GroovyExpression requiredValue, FieldInfo fInfo) throws AtlasException;
-
- public abstract GroovyExpression generateLikeExpressionUsingFilter(GroovyExpression parent, String propertyName,
- GroovyExpression propertyValue) throws AtlasException;
-
- /**
- * Generates a range expression
- *
- * @param parent
- * @param startIndex
- * @param endIndex
- * @return
- */
- public abstract GroovyExpression generateRangeExpression(GroovyExpression parent, int startIndex, int endIndex);
-
- /**
- * Determines if the specified expression is a range method call.
- *
- * @param expr
- * @return
- */
- public abstract boolean isRangeExpression(GroovyExpression expr);
-
- /**
- * Set the start index and end index of a range expression
- *
- * @param expr
- * @param startIndex
- * @param endIndex
- */
- public abstract void setRangeParameters(GroovyExpression expr, int startIndex, int endIndex);
-
- /**
- * If the specified function expression is a range expression, returns the start and end index parameters
- * otherwise returns null.
- *
- * @param expr
- * @return int array with two elements - element 0 is start index, element 1 is end index
- */
- public abstract int[] getRangeParameters(AbstractFunctionExpression expr);
-
- /**
- * Generates an order by expression
- *
- * @param parent
- * @param translatedOrderBy
- * @param isAscending
- * @return
- */
- public abstract GroovyExpression generateOrderByExpression(GroovyExpression parent,
- List<GroovyExpression> translatedOrderBy, boolean isAscending);
-
- /**
- * Determines if specified expression is an order method call
- *
- * @param expr
- * @return
- */
- public boolean isOrderExpression(GroovyExpression expr) {
- if (expr instanceof FunctionCallExpression) {
- FunctionCallExpression functionCallExpression = (FunctionCallExpression) expr;
- if (functionCallExpression.getFunctionName().equals(ORDER_METHOD)) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Returns the Groovy expressions that should be used as the parents when
- * translating an order by expression. This is needed because Gremlin 2 and
- * 3 handle order by expressions very differently.
- *
- */
- public abstract List<GroovyExpression> getOrderFieldParents();
-
- /**
- * Returns the expression that represents an anonymous graph traversal.
- *
- * @return
- */
- public abstract GroovyExpression getAnonymousTraversalExpression();
-
- public boolean isLeafAnonymousTraversalExpression(GroovyExpression expr) {
- if(!(expr instanceof FunctionCallExpression)) {
- return false;
- }
- FunctionCallExpression functionCallExpr = (FunctionCallExpression)expr;
- if(functionCallExpr.getCaller() != null) {
- return false;
- }
- return functionCallExpr.getFunctionName().equals("_") & functionCallExpr.getArguments().size() == 0;
- }
-
- /**
- * Returns an expression representing
- *
- * @return
- */
- public abstract GroovyExpression getFieldInSelect();
-
- /**
- * Generates the expression the serves as the root of the Gremlin query.
- * @param varExpr variable containing the vertices to traverse
- * @return
- */
- protected abstract GroovyExpression initialExpression(GroovyExpression varExpr, GraphPersistenceStrategies s);
-
-
- /**
- * Generates an expression that tests whether the vertex represented by the 'toTest'
- * expression represents an instance of the specified type, checking both the type
- * and super type names.
- *
- * @param s
- * @param typeName
- * @param itRef
- * @return
- */
- protected abstract GroovyExpression typeTestExpression(GraphPersistenceStrategies s, String typeName,
- GroovyExpression vertexExpr);
-
- /**
- /**
- * Generates a sequence of groovy expressions that filter the vertices to only
- * those that match the specified type. If GraphPersistenceStrategies.collectTypeInstancesIntoVar()
- * is set and the gremlin optimizer is disabled, the vertices are put into a variable whose name is generated
- * from the specified IntSequence. The last item in the result will be a graph traversal restricted to only
- * the matching vertices.
- */
- public List<GroovyExpression> generateTypeTestExpression(GraphPersistenceStrategies s, GroovyExpression parent,
- String typeName, IntSequence intSeq) throws AtlasException {
-
- if(AtlasRepositoryConfiguration.isGremlinOptimizerEnabled()) {
- GroovyExpression superTypeAttributeNameExpr = new LiteralExpression(s.superTypeAttributeName());
- GroovyExpression typeNameExpr = new LiteralExpression(typeName);
- GroovyExpression superTypeMatchesExpr = new FunctionCallExpression(TraversalStepType.FILTER, HAS_METHOD, superTypeAttributeNameExpr,
- typeNameExpr);
-
- GroovyExpression typeAttributeNameExpr = new LiteralExpression(s.typeAttributeName());
-
- GroovyExpression typeMatchesExpr = new FunctionCallExpression(TraversalStepType.FILTER, HAS_METHOD, typeAttributeNameExpr,
- typeNameExpr);
- GroovyExpression result = new FunctionCallExpression(TraversalStepType.FILTER, parent, "or", typeMatchesExpr, superTypeMatchesExpr);
- return Collections.singletonList(result);
- }
- else {
- if (s.filterBySubTypes()) {
- return typeTestExpressionUsingInFilter(s, parent, typeName);
- } else if (s.collectTypeInstancesIntoVar()) {
- return typeTestExpressionMultiStep(s, typeName, intSeq);
- } else {
- return typeTestExpressionUsingFilter(s, parent, typeName);
- }
- }
- }
-
- private List<GroovyExpression> typeTestExpressionUsingInFilter(GraphPersistenceStrategies s, GroovyExpression parent,
- final String typeName) throws AtlasException {
- List<GroovyExpression> typeNames = new ArrayList<>();
- typeNames.add(new LiteralExpression(typeName));
-
- Map<TYPE_FILTER, String> filters = new HashMap<TYPE_FILTER, String>() {{
- put(TYPE_FILTER.SUPERTYPE, typeName);
- }};
-
- ImmutableList<String> subTypes = TypeSystem.getInstance().getTypeNames(filters);
-
- if (!subTypes.isEmpty()) {
- for (String subType : subTypes) {
- typeNames.add(new LiteralExpression(subType));
- }
- }
-
- GroovyExpression inFilterExpr = generateHasExpression(s, parent, s.typeAttributeName(), IN_OPERATOR,
- new ListExpression(typeNames), null);
-
- return Collections.singletonList(inFilterExpr);
- }
-
- private List<GroovyExpression> typeTestExpressionMultiStep(GraphPersistenceStrategies s, String typeName,
- IntSequence intSeq) {
-
- String varName = "_var_" + intSeq.next();
- GroovyExpression varExpr = new IdentifierExpression(varName);
- List<GroovyExpression> result = new ArrayList<>();
-
- result.add(newSetVar(varName));
- result.add(fillVarWithTypeInstances(s, typeName, varName));
- result.add(fillVarWithSubTypeInstances(s, typeName, varName));
- result.add(initialExpression(varExpr, s));
-
- return result;
- }
-
- private GroovyExpression newSetVar(String varName) {
- GroovyExpression castExpr = new TypeCoersionExpression(new ListExpression(), SET_CLASS);
- return new VariableAssignmentExpression(varName, castExpr);
- }
-
- private GroovyExpression fillVarWithTypeInstances(GraphPersistenceStrategies s, String typeName, String fillVar) {
- GroovyExpression graphExpr = getAllVerticesExpr();
- GroovyExpression typeAttributeNameExpr = new LiteralExpression(s.typeAttributeName());
- GroovyExpression typeNameExpr = new LiteralExpression(typeName);
- GroovyExpression hasExpr = new FunctionCallExpression(graphExpr, HAS_METHOD, typeAttributeNameExpr, typeNameExpr);
- GroovyExpression fillExpr = new FunctionCallExpression(hasExpr, FILL_METHOD, new IdentifierExpression(fillVar));
- return fillExpr;
- }
-
- private GroovyExpression fillVarWithSubTypeInstances(GraphPersistenceStrategies s, String typeName,
- String fillVar) {
- GroovyExpression graphExpr = getAllVerticesExpr();
- GroovyExpression superTypeAttributeNameExpr = new LiteralExpression(s.superTypeAttributeName());
- GroovyExpression typeNameExpr = new LiteralExpression(typeName);
- GroovyExpression hasExpr = new FunctionCallExpression(graphExpr, HAS_METHOD, superTypeAttributeNameExpr, typeNameExpr);
- GroovyExpression fillExpr = new FunctionCallExpression(hasExpr, FILL_METHOD, new IdentifierExpression(fillVar));
- return fillExpr;
- }
-
-
- private List<GroovyExpression> typeTestExpressionUsingFilter(GraphPersistenceStrategies s, GroovyExpression parent,
- String typeName) {
- GroovyExpression itExpr = getItVariable();
- GroovyExpression typeTestExpr = typeTestExpression(s, typeName, itExpr);
- GroovyExpression closureExpr = new ClosureExpression(typeTestExpr);
- GroovyExpression filterExpr = new FunctionCallExpression(parent, FILTER_METHOD, closureExpr);
- return Collections.singletonList(filterExpr);
- }
-
- /**
- * Generates an expression which checks whether the vertices in the query have
- * a field with the given name.
- *
- * @param parent
- * @param fieldName
- * @return
- */
- public GroovyExpression generateUnaryHasExpression(GroovyExpression parent, String fieldName) {
- return new FunctionCallExpression(TraversalStepType.FILTER, parent, HAS_METHOD, new LiteralExpression(fieldName));
- }
-
- /**
- * Generates a path expression
- *
- * @param parent
- * @return
- */
- public GroovyExpression generatePathExpression(GroovyExpression parent) {
- return new FunctionCallExpression(TraversalStepType.MAP_TO_VALUE, parent, PATH_METHOD);
- }
-
- /**
- * Generates the emit expression used in loop expressions.
- * @param s
- * @param dataType
- * @return
- */
- protected GroovyExpression generateLoopEmitExpression(GraphPersistenceStrategies s, IDataType dataType) {
- return typeTestExpression(s, dataType.getName(), getCurrentObjectExpression());
- }
-
- /**
- * Generates an alias expression
- *
- * @param parent
- * @param alias
- * @return
- */
- public GroovyExpression generateAliasExpression(GroovyExpression parent, String alias) {
- return new FunctionCallExpression(TraversalStepType.SIDE_EFFECT, parent, AS_METHOD, new LiteralExpression(alias));
- }
-
- /**
- * Generates an expression that gets the vertices adjacent to the vertex in 'parent'
- * in the specified direction.
- *
- * @param parent
- * @param dir
- * @return
- */
- public GroovyExpression generateAdjacentVerticesExpression(GroovyExpression parent, AtlasEdgeDirection dir) {
- return new FunctionCallExpression(TraversalStepType.FLAT_MAP_TO_ELEMENTS, parent, getGremlinFunctionName(dir));
- }
-
- private String getGremlinFunctionName(AtlasEdgeDirection dir) {
- switch(dir) {
- case IN:
- return "in";
- case OUT:
- return "out";
- case BOTH:
- return "both";
- default:
- throw new RuntimeException("Unknown Atlas Edge Direction: " + dir);
- }
- }
-
- /**
- * Generates an expression that gets the vertices adjacent to the vertex in 'parent'
- * in the specified direction, following only edges with the given label.
- *
- * @param parent
- * @param dir
- * @return
- */
- public GroovyExpression generateAdjacentVerticesExpression(GroovyExpression parent, AtlasEdgeDirection dir,
- String label) {
- return new FunctionCallExpression(TraversalStepType.FLAT_MAP_TO_ELEMENTS, parent, getGremlinFunctionName(dir), new LiteralExpression(label));
- }
-
- /**
- * Generates an arithmetic expression, e.g. a + b
- *
- */
- public GroovyExpression generateArithmeticExpression(GroovyExpression left, String operator,
- GroovyExpression right) throws AtlasException {
- ArithmeticOperator op = ArithmeticOperator.lookup(operator);
- return new ArithmeticExpression(left, op, right);
- }
-
- public abstract GroovyExpression generateGroupByExpression(GroovyExpression parent, GroovyExpression groupByExpression, GroovyExpression aggregationFunction);
-
- protected GroovyExpression getItVariable() {
- return new IdentifierExpression(IT_VARIABLE);
- }
-
- protected GroovyExpression getAllVerticesExpr() {
- GroovyExpression gExpr = getGraphExpression();
- return new FunctionCallExpression(TraversalStepType.START, gExpr, V_METHOD);
- }
-
- protected IdentifierExpression getGraphExpression() {
- return new IdentifierExpression(TraversalStepType.SOURCE, G_VARIABLE);
- }
-
-
- protected GroovyExpression getCurrentObjectExpression() {
- return new FieldExpression(getItVariable(), OBJECT_FIELD);
- }
-
- //assumes cast already performed
- public GroovyExpression generateCountExpression(GroovyExpression itExpr) {
- GroovyExpression collectionExpr = new CastExpression(itExpr,"Collection");
- return new FunctionCallExpression(collectionExpr, "size");
- }
-
- public GroovyExpression generateMinExpression(GroovyExpression itExpr, GroovyExpression mapFunction) {
- return getAggregrationExpression(itExpr, mapFunction, "min");
- }
-
- public GroovyExpression generateMaxExpression(GroovyExpression itExpr, GroovyExpression mapFunction) {
- return getAggregrationExpression(itExpr, mapFunction, "max");
- }
-
- public GroovyExpression generateSumExpression(GroovyExpression itExpr, GroovyExpression mapFunction) {
- return getAggregrationExpression(itExpr, mapFunction, "sum");
- }
-
- private GroovyExpression getAggregrationExpression(GroovyExpression itExpr,
- GroovyExpression mapFunction, String functionName) {
- GroovyExpression collectionExpr = new CastExpression(itExpr,"Collection");
- ClosureExpression collectFunction = new ClosureExpression(mapFunction);
- GroovyExpression transformedList = new FunctionCallExpression(collectionExpr, "collect", collectFunction);
- return new FunctionCallExpression(transformedList, functionName);
- }
-
- public GroovyExpression getClosureArgumentValue() {
- return getItVariable();
- }
-
- /**
- * Specifies the parent to use when translating the select list in
- * a group by statement.
- *
- * @return
- */
- public abstract GroovyExpression getGroupBySelectFieldParent();
-
- public GroovyExpression generateFillExpression(GroovyExpression parent, GroovyExpression variable) {
- return new FunctionCallExpression(TraversalStepType.END,parent , "fill", variable);
- }
-
- /**
- * Generates an anonymous graph traversal initialized with the specified value. In Gremlin 3, we need
- * to use a different syntax for this when the object is a map, so that information needs to be provided
- * to this method so that the correct syntax is used.
- *
- * @param isMap true if the value contains Map instances, false if it contains Vertex instances
- * @param valueCollection the source objects to start the traversal from.
- */
- public abstract GroovyExpression generateSeededTraversalExpresssion(boolean isMap, GroovyExpression valueCollection);
-
- /**
- * Returns the current value of the traverser. This is used when generating closure expressions that
- * need to operate on the current value in the graph graversal.
- *
- * @param traverser
- * @return
- */
- public abstract GroovyExpression getCurrentTraverserObject(GroovyExpression traverser);
-
- /**
- * Generates an expression that transforms the current value of the traverser by
- * applying the function specified
- *
- * @param parent
- * @param closureExpression
- * @return
- */
- public abstract GroovyExpression generateMapExpression(GroovyExpression parent, ClosureExpression closureExpression);
-
- /**
- * Returns whether a select statement generates a map (or Gremlin 2 "Row") when it contains the specified
- * number of aliases.
- *
- */
- public abstract boolean isSelectGeneratesMap(int aliasCount);
-
- /**
- * Generates an expression to get the value of the value from the row map
- * generated by select() with the specified key.
- *
- */
- public abstract GroovyExpression generateGetSelectedValueExpression(LiteralExpression key,
- GroovyExpression rowMapExpr);
-
- public GroovyExpression removeExtraMapFromPathInResult(GroovyExpression parent) {
- GroovyExpression listItem = getItVariable();
- GroovyExpression tailExpr = new FunctionCallExpression(listItem, "tail");
- return new FunctionCallExpression(parent, "collect", new ClosureExpression(tailExpr));
-
- }
-
- /**
- * Generates a toList expression to execute the gremlin query and
- * store the result in a new list.
- *
- * @param expr
- * @return
- */
- public GroovyExpression generateToListExpression(GroovyExpression expr) {
- return new FunctionCallExpression(TraversalStepType.END, expr, "toList");
- }
-
- /**
- * Finds aliases that absolutely must be brought along with this expression into
- * the output expression and cannot just be recreated there. For example, in the
- * Gremlin 2 loop expression, the loop semantics break of the alias is simply recreated
- * in the output expression.
- * @param expr
- * @return
- */
- public abstract List<String> getAliasesRequiredByExpression(GroovyExpression expr);
-
-
- /**
- * Checks if the given expression is an alias expression, and if so
- * returns the alias from the expression. Otherwise, null is
- * returned.
- */
- public String getAliasNameIfRelevant(GroovyExpression expr) {
- if(!(expr instanceof FunctionCallExpression)) {
- return null;
- }
- FunctionCallExpression fc = (FunctionCallExpression)expr;
- if(! fc.getFunctionName().equals(AS_METHOD)) {
- return null;
- }
- LiteralExpression aliasName = (LiteralExpression)fc.getArguments().get(0);
- return aliasName.getValue().toString();
-
- }
-
- public abstract boolean isRepeatExpression(GroovyExpression expr);
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/AliasFinder.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/AliasFinder.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/AliasFinder.java
deleted file mode 100644
index 3e6c39a..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/AliasFinder.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.FunctionCallExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-import org.apache.atlas.groovy.LiteralExpression;
-import org.apache.atlas.groovy.TraversalStepType;
-
-/**
- * Finds all aliases in the expression.
- */
-public class AliasFinder implements CallHierarchyVisitor {
-
- private List<LiteralExpression> foundAliases = new ArrayList<>();
-
- //Whether a final alias is needed. A final alias is needed
- //if there are transformation steps after the last alias in
- //the expression. We initialize this to false since a final
- //alias is not needed if there are no aliases.
- private boolean finalAliasNeeded = false;
-
- @Override
- public boolean preVisitFunctionCaller(AbstractFunctionExpression expr) {
- return true;
- }
-
- @Override
- public void visitNonFunctionCaller(GroovyExpression expr) {
-
- }
-
- @Override
- public void visitNullCaller() {
-
- }
-
- private static final Set<TraversalStepType> TRANSFORMATION_STEP_TYPES = new HashSet<>(Arrays.asList(
- TraversalStepType.MAP_TO_ELEMENT,
- TraversalStepType.MAP_TO_VALUE,
- TraversalStepType.FLAT_MAP_TO_ELEMENTS,
- TraversalStepType.FLAT_MAP_TO_VALUES,
- TraversalStepType.BARRIER,
- TraversalStepType.NONE));
-
-
- @Override
- public boolean postVisitFunctionCaller(AbstractFunctionExpression functionCall) {
-
- if (functionCall instanceof FunctionCallExpression) {
- FunctionCallExpression expr = (FunctionCallExpression)functionCall;
- if (expr.getType() == TraversalStepType.SIDE_EFFECT && expr.getFunctionName().equals("as")) {
- //We found an alias. This is currently the last expression we've seen
- //in our traversal back up the expression tree, so at this point a final
- //alias is not needed.
- LiteralExpression aliasNameExpr = (LiteralExpression)expr.getArguments().get(0);
- foundAliases.add(aliasNameExpr);
- finalAliasNeeded=false;
- }
- }
-
- if(TRANSFORMATION_STEP_TYPES.contains(functionCall.getType())) {
- //This step changes the value of the traverser. Now, a final alias
- //needs to be added.
- if(!foundAliases.isEmpty()) {
- finalAliasNeeded = true;
- }
- }
-
- return true;
- }
-
- public List<LiteralExpression> getAliases() {
- return foundAliases;
- }
-
- public boolean isFinalAliasNeeded() {
-
- return finalAliasNeeded;
- }
-}
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/CallHierarchyVisitor.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/CallHierarchyVisitor.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/CallHierarchyVisitor.java
deleted file mode 100644
index 6089353..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/CallHierarchyVisitor.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-
-/**
- * Call back interface for visiting the call hierarchy of a function call.
- */
-public interface CallHierarchyVisitor {
-
- /**
- * Visits a function expression before the visit to its caller.
- *
- * @param expr
- *
- * @return false to terminate the recursion
- */
- boolean preVisitFunctionCaller(AbstractFunctionExpression expr);
-
- /**
- * Called when a caller that is not an instance of
- * AbstractFunctionExpression is found. This indicates that the deepest
- * point in the call hierarchy has been reached.
- *
- *
- */
- void visitNonFunctionCaller(GroovyExpression expr);
-
- /**
- * Called when a null caller is found (this happens for static/user-defined
- * functions). This indicates that the deepest point in the call hierarchy
- * has been reached.
- *
- */
- void visitNullCaller();
-
- /**
- * Visits a function expression after the visit to its caller.
- *
- * @param expr
- *
- * @return false to terminate the recursion
- */
- boolean postVisitFunctionCaller(AbstractFunctionExpression functionCall);
-}
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandAndsOptimization.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandAndsOptimization.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandAndsOptimization.java
deleted file mode 100644
index d8ecd07..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandAndsOptimization.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.atlas.gremlin.GremlinExpressionFactory;
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.FunctionCallExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Optimizer that pulls has expressions out of an 'and' expression.
- * <p>
- * For example:
- * <pre class=code>
- * g.V().and(has('x'),has('y') </pre>
- * <p>
- * is optimized to:
- * <pre class=code>
- * g.V().has('x').has('y') </pre>
- * <p>
- * There are certain cases where it is not safe to move an expression out
- * of the 'and'. For example, in the expression
- * <pre class=code>
- * g.V().and(has('x').out('y'),has('z')) </pre>
- * <p>
- * has('x').out('y') cannot be moved out of the 'and', since it changes the value of the traverser.
- * <p>
- * At this time, the ExpandAndsOptimizer is not able to handle this scenario, so we don't extract
- * that expression. In this case, the result is:
- * <pre class=code>
- * g.V().has('z').and(has('x').out('y')) </pre>
- * <p>
- * The optimizer will call ExpandAndsOptimization recursively on the children, so
- * there is no need to recursively update the children here.
- *
- */
-public class ExpandAndsOptimization implements GremlinOptimization {
-
- private static final Logger logger_ = LoggerFactory.getLogger(ExpandAndsOptimization.class);
-
-
- private final GremlinExpressionFactory factory;
-
- public ExpandAndsOptimization(GremlinExpressionFactory factory) {
- this.factory = factory;
- }
-
- @Override
- public boolean appliesTo(GroovyExpression expr, OptimizationContext contxt) {
- return expr instanceof FunctionCallExpression && ((FunctionCallExpression)expr).getFunctionName().equals("and");
- }
-
- /**
- * Expands the given and expression. There is no need to recursively
- * expand the children here. This method is called recursively by
- * GremlinQueryOptimier on the children.
- *
- */
- @Override
- public GroovyExpression apply(GroovyExpression expr, OptimizationContext context) {
-
- FunctionCallExpression exprAsFunction = (FunctionCallExpression)expr;
- GroovyExpression result = exprAsFunction.getCaller();
-
- List<GroovyExpression> nonExtractableArguments = new ArrayList<>();
- for(GroovyExpression argument : exprAsFunction.getArguments()) {
-
- if (GremlinQueryOptimizer.isExtractable(argument)) {
- //Set the caller of the deepest expression in the call hierarchy
- //of the argument to point to the current result.
- //For example, if result is "g.V()" and the updatedArgument is "has('x').has('y')",
- //updatedArgument would be a tree like this:
- //
- // has('y')
- // /
- // / caller
- // |/_
- // has('x')
- // /
- // / caller
- // |/_
- // (null)
- //
- //We would set the caller of has('x') to be g.V(), so result would become g.V().has('x').has('y').
- //
- // Note: This operation is currently done by making a copy of the argument tree. That should
- // be changed.
- result = GremlinQueryOptimizer.copyWithNewLeafNode(
- (AbstractFunctionExpression) argument, result);
- } else {
- logger_.warn("Found non-extractable argument '{}' in the 'and' expression '{}'",argument.toString(), expr.toString());
- nonExtractableArguments.add(argument);
- }
- }
-
- if (!nonExtractableArguments.isEmpty()) {
- //add a final 'and' call with the arguments that could not be extracted
- result = factory.generateLogicalExpression(result, "and", nonExtractableArguments);
- }
- return result;
- }
-
- @Override
- public boolean isApplyRecursively() {
- return true;
- }
-}
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandOrsOptimization.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandOrsOptimization.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandOrsOptimization.java
deleted file mode 100644
index a48a007..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpandOrsOptimization.java
+++ /dev/null
@@ -1,588 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-import org.apache.atlas.gremlin.GremlinExpressionFactory;
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.ClosureExpression;
-import org.apache.atlas.groovy.FunctionCallExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-import org.apache.atlas.groovy.LiteralExpression;
-import org.apache.atlas.groovy.StatementListExpression;
-import org.apache.atlas.groovy.TraversalStepType;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.google.common.collect.Lists;
-
-
-
-/**
- * Optimization that removes 'or' expressions from a graph traversal when possible
- * and replaces them with separate calls that are combined using a logical union operation.
- * Unfortunately, Titan does not use indices when executing the child graph traversals associated
- * with an 'or' call. In order to make the index be used, we split queries with
- * or expressions into multiple queries. These queries are executed individually,
- * using indices, and then the results are combined back together. Here is a
- * simple example to illustrate this:
- *
- * <h4>Original Query</h4>
- *
- * <pre>
- * g.V().or(has('name','Fred'),has('age','17'))
- * </pre>
- *
- *<h4>Optimized Query</h4>
- *
- * <pre>
- * def r = [] as Set;
- * g.V().has('name','Fred').fill(r);
- * g.V().has('age','17').fill(r);
- * r;
- * </pre>
- *
- * Here, we introduce an intermediate variable "r" which is declared as a Set. The Set is performing
- * the union for us. If there are vertices that happen to both have "Fred" as the name and "17" as the age,
- * the Set will prevent the second query execution from adding a duplicate vertex to the result. Recall that
- * in Groovy scripts, the last expression is the one that will be returned back to the caller. We refer to
- * that expression is the "result expression". For this example, the result expression is simply "r", which
- * contains the vertices that matched the query.
- * <p/>
- * If the query does any kind of transformation of the vertices to produce the query result, that needs
- * to be done in the result expression. To understand why that is, let's take a look at another example:
- *
- * <h4>Original Query</h4>
- *
- * <pre>
- * g.V().or(has('name','Fred'),has('age','17')).as('person').select('person').by('gender')
- * </pre>
- *
- * <h4>Incorrect Optimized Query</h4>
- *
- * <pre>
- * def r = [] as Set;
- * g.V().has('name','Fred').as('person').select('person').by('gender').fill(r)
- * g.V().has('age','17').as('person').select('person').by('gender').fill(r)
- * r;
- * </pre>
- *
- * The problem with this query is that now 'r' contains Strings (the gender of the person). Suppose
- * that there is one person named Fred and there are 3 people whose age is 17 (let's say Fred's age is 16).
- * The original query would have produced 4 rows, one corresponding to each of those people. The new
- * query would produce at most 2 rows - one for 'male' and one for 'female'. This is happening because
- * we are now performing the union on the Strings, not on the vertices. To fix this, we need to split
- * the original query and put the end portion into the result expression:
- *
- * <h4>Correct Optimized Query</h4>
- *
- * <pre>
- * def r = [] as Set;
- * g.V().has('name','Fred').fill(r)
- * g.V().has('age','17').fill(r)
- * __.inject(r as Object[]).as('person').select('person').by('gender')
- * </pre>
- *
- * The logic for doing this splitting is described in more detail in
- * {@link #moveTransformationsToResultExpression(GroovyExpression, OptimizationContext)}.
- * <p/>
- * There is one more problematic case that this optimizer is able to handle. Let's look at the following example:
- *
- * <h4>Original Query</h4>
- *
- * <pre>
- * g.V().or(has('type','Person'),has('superType','Person')).as('x').has('qualifiedName','Fred').as('y').select('x','y').by('name').by('name')
- * </pre>
- *
- * Queries of this form appear often when translating DSL queries.
- *
- * If we were to optimize this query using the logic described above, we would get something like this:
- *
- * <h4>Incorrect Optimized Query</h4>
- *
- * <pre>
- * def r = [] as Set;
- * g.V().has('type','Person').fill(r);
- * g.V().has('superType','Person').fill(r);
- * __.inject(r as Object[]).as('x').has('qualifiedName','Fred').as('y').select('x','y');
- * </pre>
- *
- * While not strictly incorrect, this query will not perform well since the index on qualifiedName will
- * not be used. In order for that index to be used, the 'has' expression needs to be part of the original
- * query. However, if we do that alone, the query will be broken, since the select
- * will now refer to an undefined label:
- *
- * <h4>Incorrect Optimized Query</h4>
- *
- * <pre>
- * def r = [] as Set;
- * g.V().has('type','Person').as('x').has('qualifiedName','Fred').fill(r);
- * g.V().has('superType','Person').as('x').has('qualifiedName','Fred').fill(r);
- * __.inject(r as Object[]).as('y').select('x','y')
- * </pre>
- *
- * To fix this, we need to save the values of the aliased vertices in the original
- * query, and create labels in the result expression that refer to them. We do this
- * as follows:
- *
- * <h4>Correct Optimized Query</h4>
- *
- * <pre>
- * def r = [] as Set;
- * g.V().has('type','Person').as('x').has('qualifiedName','Fred').as('y').select('x','y').fill(r);
- * g.V().has('superType','Person').as('x').has('qualifiedName','Fred').select('x','y').fill(r);
- * __.inject(r as Object[]).as('__tmp').map({((Map)it.get()).get('x')}).as('x').select('__tmp').map({((Map)it.get()).get('x')}).as('y').select('x','y').by('name').by('name')
- * </pre>
- *
- * This is not pretty, but is the best solution we've found so far for supporting expressions that contain aliases in this optimization.
- * What ends up happening is that r gets populated with alias->Vertex maps. In the result expression, we make 'x' point
- * to a step where the value in the traverser is the vertex for 'x', and we do the same thing for y. The <code>select('_tmp')</code> step in the middle restores the value of
- * the traverser back to the map.
- * <p/>
- * The one known issue with the alias rearrangement is that it breaks loop expressions. As a result, expressions containing loops are currently excluded
- * from this optimization.
- *
- * ExpandOrsOptimization expands the entire expression tree recursively, so it is not invoked
- * recursively by GremlinQueryOptimizer.
- *
- */
-public class ExpandOrsOptimization implements GremlinOptimization {
-
- private static final Logger logger_ = LoggerFactory.getLogger(ExpandOrsOptimization.class);
-
- private final GremlinExpressionFactory factory;
-
- public ExpandOrsOptimization(GremlinExpressionFactory factory) {
- this.factory = factory;
- }
-
- @Override
- public boolean appliesTo(GroovyExpression expr, OptimizationContext contxt) {
-
- ExpressionFinder finder = new ExpressionFinder(IsOr.INSTANCE);
- GremlinQueryOptimizer.visitCallHierarchy(expr, finder);
- return finder.isExpressionFound();
- }
-
- @Override
- public GroovyExpression apply(GroovyExpression expr, OptimizationContext context) {
-
- setupRangeOptimization(expr, context);
- GroovyExpression traveralExpression = moveTransformationsToResultExpression(expr, context);
-
- FunctionGenerator functionGenerator = new FunctionGenerator(factory, context);
- GremlinQueryOptimizer.visitCallHierarchy(traveralExpression, functionGenerator);
- traveralExpression = functionGenerator.getNewRootExpression();
- List<GroovyExpression> bodyExpressions = expandOrs(traveralExpression, context);
-
-
- //Adds a statement to define the result variable 'v' in the
- //groovy script. The variable is declared as a Set. The type
- //of the objects in the Set depend on the number of aliases in the Groovy
- // expression:
- // - 0 or 1 alias : Vertex
- // - multiple aliases: Map<String,Vertex>
- StatementListExpression result = new StatementListExpression();
- context.prependStatement(context.getDefineResultVariableStmt());
-
-
- for (GroovyExpression bodyExpression : bodyExpressions) {
- result.addStatement(bodyExpression);
- }
- result.addStatement(context.getResultExpression());
- return result;
- }
-
- private void setupRangeOptimization(GroovyExpression expr, OptimizationContext context) {
-
- // Find any range expressions in the expression tree.
- RangeFinder rangeFinder = new RangeFinder(factory);
- GremlinQueryOptimizer.visitCallHierarchy(expr, rangeFinder);
- List<AbstractFunctionExpression> rangeExpressions = rangeFinder.getRangeExpressions();
- if (rangeExpressions.size() == 1) {
- OrderFinder orderFinder = new OrderFinder(factory);
- GremlinQueryOptimizer.visitCallHierarchy(expr, orderFinder);
- if (!orderFinder.hasOrderExpression()) {
- // If there is one range expression and no order expression in the unoptimized gremlin,
- // save the range parameters to use for adding a range expression to
- // each expanded "or" expression result, such that it will only contain the specified range of vertices.
- // For now, apply this optimization only if the range start index is zero.
- AbstractFunctionExpression rangeExpression = rangeExpressions.get(0);
- int[] rangeParameters = factory.getRangeParameters(rangeExpression);
- if (rangeParameters[0] == 0) {
- context.setRangeExpression(rangeExpression);
- }
- }
- }
- }
-
- private GroovyExpression moveTransformationsToResultExpression(GroovyExpression expr, OptimizationContext context) {
- GroovyExpression traveralExpression = expr;
-
- // Determine the 'split point'. This is the expression that will become
- // the deepest function call in the result expression. If a split
- // point is found, its caller is changed. The new caller is
- // set to the graph traversal expression in the result expression.
- // The original caller becomes the new traversal expression that
- // will be carried through the rest of the 'or' expansion processing.
- //
- // Example: g.V().has('x').as('x').select('x')
- // Here, select('x') is the split expression
- // so :
- // 1) the result expression in OptimizationContext becomes [base result expression].select('x')
- // 2) we return g.V().has('x').as('x')
-
- SplitPointFinder finder = new SplitPointFinder(factory);
- GremlinQueryOptimizer.visitCallHierarchy(traveralExpression, finder);
- AbstractFunctionExpression splitPoint = finder.getSplitPoint();
-
-
- List<LiteralExpression> aliases = new ArrayList<>();
-
- //If we're not splitting the query, there is no need to save/restore
- //the aliases.
- if(splitPoint != null) {
-
- traveralExpression = splitPoint.getCaller();
-
- AliasFinder aliasFinder = new AliasFinder();
- GremlinQueryOptimizer.visitCallHierarchy(traveralExpression, aliasFinder);
- aliases.addAll(aliasFinder.getAliases());
- if(aliasFinder.isFinalAliasNeeded()) {
- //The last alias in the expression does not capture the final vertex in the traverser,
- //so we need to create an alias to record that.
- traveralExpression = factory.generateAliasExpression(traveralExpression, context.getFinalAliasName());
- aliases.add(new LiteralExpression(context.getFinalAliasName()));
- }
-
- GroovyExpression resultExpr = getBaseResultExpression(context, aliases);
- splitPoint.setCaller(resultExpr);
- expr = removeMapFromPathsIfNeeded(expr, aliases);
- context.setResultExpression(expr);
- }
-
- //Add expression(s) to the end of the traversal expression to add the vertices
- //that were found into the intermediate variable ('r')
- traveralExpression = addCallToUpdateResultVariable(traveralExpression, aliases, context);
- return traveralExpression;
- }
-
- private GroovyExpression removeMapFromPathsIfNeeded(GroovyExpression expr, List<LiteralExpression> aliases) {
- if(aliases.size() > 0 && factory.isSelectGeneratesMap(aliases.size())) {
- RepeatExpressionFinder repeatExprFinder = new RepeatExpressionFinder(factory);
- GremlinQueryOptimizer.visitCallHierarchy(expr, repeatExprFinder);
- boolean hasRepeat = repeatExprFinder.isRepeatExpressionFound();
-
- PathExpressionFinder pathExprFinder = new PathExpressionFinder();
- GremlinQueryOptimizer.visitCallHierarchy(expr, pathExprFinder);
- boolean hasPath = pathExprFinder.isPathExpressionFound();
- if(! hasRepeat && hasPath) {
- //the path will now start with the map that we added. That is an artifact
- //of the optimization process and must be removed.
- if(expr.getType() != TraversalStepType.END && expr.getType() != TraversalStepType.NONE) {
- //we're still in the pipeline, need to execute the query before we can
- //modify the result
- expr = factory.generateToListExpression(expr);
- }
- expr = factory.removeExtraMapFromPathInResult(expr);
- }
-
- }
- return expr;
- }
-
- /**
- * This method adds steps to the end of the initial traversal to add the vertices
- * that were found into an intermediate variable (defined as a Set). If there is one alias,
- * this set will contain the vertices associated with that Alias. If there are multiple
- * aliases, the values in the set will be alias->vertex maps that have the vertex
- * associated with the alias for each result.
-
- * @param expr
- * @param aliasNames
- * @param context
- * @return
- */
- private GroovyExpression addCallToUpdateResultVariable(GroovyExpression expr,List<LiteralExpression> aliasNames, OptimizationContext context) {
-
- GroovyExpression result = expr;
- // If there is one range expression in the unoptimized gremlin,
- // add a range expression here so that the intermediate variable will only contain
- // the specified range of vertices.
- AbstractFunctionExpression rangeExpression = context.getRangeExpression();
- if (rangeExpression != null) {
- int[] rangeParameters = factory.getRangeParameters(rangeExpression);
- result = factory.generateRangeExpression(result, rangeParameters[0], rangeParameters[1]);
- }
- if( ! aliasNames.isEmpty()) {
- result = factory.generateSelectExpression(result, aliasNames, Collections.<GroovyExpression>emptyList());
- }
- return factory.generateFillExpression(result, context.getResultVariable());
- }
-
- /**
- * Recursively traverses the given expression, expanding or expressions
- * wherever they are found.
- *
- * @param expr
- * @param context
- * @return expressions that should be unioned together to get the query result
- */
- private List<GroovyExpression> expandOrs(GroovyExpression expr, OptimizationContext context) {
-
- if (GremlinQueryOptimizer.isOrExpression(expr)) {
- return expandOrFunction(expr, context);
- }
- return processOtherExpression(expr, context);
- }
-
- /**
- * This method takes an 'or' expression and expands it into multiple expressions.
- *
- * For example:
- *
- * g.V().or(has('x'),has('y')
- *
- * is expanded to:
- *
- * g.V().has('x')
- * g.V().has('y')
- *
- * There are certain cases where it is not safe to move an expression out
- * of the 'or'. For example, in the expression
- *
- * g.V().or(has('x').out('y'),has('z'))
- *
- * has('x').out('y') cannot be moved out of the 'or', since it changes the value of the traverser.
- *
- * At this time, the ExpandOrsOptimizer is not able to handle this scenario, so we don't remove
- * that expression. In cases like this, a final expression is created that ors together
- * all of the expressions that could not be extracted. In this case that would be:
- *
- * g.V().has('z')
- * g.V().or(has('y').out('z'))
- *
- * This processing is done recursively.
- *
- *
- * @param expr
- * @param context
- * @return the expressions that should be unioned together to get the query result
- */
- private List<GroovyExpression> expandOrFunction(GroovyExpression expr, OptimizationContext context) {
- FunctionCallExpression functionCall = (FunctionCallExpression) expr;
- GroovyExpression caller = functionCall.getCaller();
- List<GroovyExpression> updatedCallers = null;
- if (caller != null) {
- updatedCallers = expandOrs(caller, context);
- } else {
- updatedCallers = Collections.singletonList(null);
- }
- UpdatedExpressions newArguments = getUpdatedChildren(functionCall.getArguments(), context);
- List<GroovyExpression> allUpdatedArguments = new ArrayList<>();
- for (List<GroovyExpression> exprs : newArguments.getUpdatedChildren()) {
- allUpdatedArguments.addAll(exprs);
- }
- List<AbstractFunctionExpression> extractableArguments = new ArrayList<>();
- List<GroovyExpression> nonExtractableArguments = new ArrayList<>();
- for (GroovyExpression argument : allUpdatedArguments) {
-
- if (GremlinQueryOptimizer.isExtractable(argument)) {
- extractableArguments.add((AbstractFunctionExpression) argument);
- } else {
- logger_.warn("Found non-extractable argument '{}; in the 'or' expression '{}'",argument.toString(), expr.toString());
- nonExtractableArguments.add(argument);
- }
- }
-
- List<GroovyExpression> result = new ArrayList<>();
- for (GroovyExpression updatedCaller : updatedCallers) {
-
- for (AbstractFunctionExpression arg : extractableArguments) {
- GroovyExpression updated = GremlinQueryOptimizer.copyWithNewLeafNode(arg, updatedCaller);
- result.add(updated);
- }
- if (!nonExtractableArguments.isEmpty()) {
- result.add(factory.generateLogicalExpression(updatedCaller, "or", nonExtractableArguments));
- }
-
- }
- return result;
- }
-
- private UpdatedExpressions getUpdatedChildren(List<GroovyExpression> children, OptimizationContext context) {
- List<List<GroovyExpression>> updatedChildren = new ArrayList<>();
- boolean changed = false;
- for (GroovyExpression child : children) {
- List<GroovyExpression> childChoices = expandOrs(child, context);
- if (childChoices.size() != 1 || childChoices.iterator().next() != child) {
- changed = true;
- }
- updatedChildren.add(childChoices);
- }
- return new UpdatedExpressions(changed, updatedChildren);
- }
-
- private UpdatedExpressions getUpdatedChildren(GroovyExpression expr, OptimizationContext context) {
- return getUpdatedChildren(expr.getChildren(), context);
- }
-
- /**
- * This is called when we encounter an expression that is not an "or", for example an "and" expressio. For these
- * expressions, we process the children and create copies with the cartesian product of the updated
- * arguments.
- *
- * Example:
- *
- * g.V().and(or(has('x),has('y'), or(has('a'),has('b')))
- *
- * Here, we have an "and" expression with two children:
- *
- * 1) or(has('x),has('y')
- * 2) or(has('a'),has('b'))
- *
- * We first process these children. They each yield 2 expressions:
- *
- * 1 -> [ has('x'), has('y') ]
- * 2 -> [ has('a'), has('b') ]
- *
- * The cartesian product of these gives this:
- *
- * [ has('x'), has('a') ]
- * [ has('x'), has('b') ]
- * [ has('y'), has('a') ]
- * [ has('y'), has('b') ]
- *
- * So the overall result is:
- *
- * g.V().and(has('x'), has('a'))
- * g.V().and(has('x'), has('b'))
- * g.V().and(has('y'), has('a'))
- * g.V().and(has('y'), has('b'))
- *
- *
- * @param source
- * @param context
- * @return expressions that should be unioned together to get the query result
- */
- private List<GroovyExpression> processOtherExpression(GroovyExpression source, OptimizationContext context) {
- UpdatedExpressions updatedChildren = getUpdatedChildren(source, context);
- if (!updatedChildren.hasChanges()) {
- return Collections.singletonList(source);
- }
- List<GroovyExpression> result = new ArrayList<GroovyExpression>();
-
- //The updated children list we get back has the possible values for each child
- //in the expression. We compute a cartesian product to get all possible
- //combinations of child values.
- List<List<GroovyExpression>> updateChildLists = Lists.cartesianProduct(updatedChildren.getUpdatedChildren());
-
- for (List<GroovyExpression> updatedChildList : updateChildLists) {
- result.add(source.copy(updatedChildList));
- }
- return result;
- }
-
- @Override
- public boolean isApplyRecursively() {
- return false;
- }
-
- /**
- *
- * This method creates a base result expression that recreates the state of the
- * graph traverser at start of the result expression to what it would have been
- * if we had been executing one Gremlin query (instead of many and doing a union).
- *
- * To do this, we start with an anonymous graph traversal that will iterate
- * through the values in the intermediate Set that was created. We then need
- * to set things up so that the aliases that were in the original gremlin query
- * refer to steps with the correct traverser value.
- *
- * The way we do this depends on the number of aliases. If there are 0 or 1 alias,
- * the intermediate variable already contains Vertices, so we just create the alias.
- *
- * If there are multiple aliases, the intermediate variable contains a String->Vertex
- * map. We first create a temporary alias that refers to that map. For each alias,
- * we use a MapStep to map the map to the Vertex for that alias. We then add back
- * the alias, making it refer to the MapStep. Between the alias restorations, we restore the
- * traverser object back to the map.
- *
- * @param context
- * @param aliases
- * @return
- */
- private GroovyExpression getBaseResultExpression(OptimizationContext context,
- List<LiteralExpression> aliases) {
-
- //Start with an anonymous traversal that gets its objects from the intermediate result variable.
- GroovyExpression parent = factory.generateSeededTraversalExpresssion(aliases.size() > 1, context.getResultVariable());
-
- if(aliases.isEmpty()) {
- return parent;
- }
-
- //The expression we will return.
- GroovyExpression result = parent;
-
- //We use a temporary alias to save/restore the original value of the traverser
- //at the start of the query. We do this so we can set the value of the traverser
- //back to being the map after we retrieve each alias. If there is only one
- //alias, the save/restore is not needed, so there is no need to create this alias.
- if(aliases.size() > 1) {
-
- result = factory.generateAliasExpression(result, context.getTempAliasName());
- }
-
- Iterator<LiteralExpression> it = aliases.iterator();
- while(it.hasNext()) {
- LiteralExpression curAlias = it.next();
- //A map is only generated by Gremlin when there is more than one alias. When there is only one
- //alias, the intermediate variable will directly contain the vertices.`
- if(factory.isSelectGeneratesMap(aliases.size())) {
- //Since there is more than one alias, the current traverser object is an alias->vertex
- //map. We use a MapStep to map that map to the Vertex for the current alias. This sets
- //the current traverser object to that Vertex. We do this by defining the closure we
- //pass to the MapStep call [map].get(aliasName) where [map] is the expression
- //that refers to the map.
-
- GroovyExpression rowMapExpr = factory.getCurrentTraverserObject(factory.getClosureArgumentValue());
- GroovyExpression getExpr = factory.generateGetSelectedValueExpression(curAlias, rowMapExpr);
- result = factory.generateMapExpression(result, new ClosureExpression(getExpr));
- }
-
- //Create alias that points to the previous step. The traverser value at that step
- //is the Vertex associated with this alias.
- result = factory.generateAliasExpression(result, curAlias.getValue().toString());
- if(it.hasNext()) {
- //Restore the current value of the traverser back to the current alias->vertex map
- result = factory.generateBackReferenceExpression(result, false, context.getTempAliasName());
- }
- }
- return result;
- }
-
-
-
-
-}
-
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpressionFinder.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpressionFinder.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpressionFinder.java
deleted file mode 100644
index 2721049..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/ExpressionFinder.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import com.google.common.base.Function;
-
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-
-/**
- * Call hierarchy visitor that checks if an expression
- * matching the specified criteria is present
- * in the call hierarch.
- */
-public class ExpressionFinder implements CallHierarchyVisitor {
-
- private final Function<GroovyExpression, Boolean> predicate;
- private boolean expressionFound = false;
-
- public ExpressionFinder(Function<GroovyExpression, Boolean> predicate) {
- this.predicate = predicate;
- }
- @Override
- public boolean preVisitFunctionCaller(AbstractFunctionExpression expr) {
- if (predicate.apply(expr)) {
- expressionFound = true;
- return false;
- }
- return true;
- }
-
- @Override
- public void visitNonFunctionCaller(GroovyExpression expr) {
- if (predicate.apply(expr)) {
- expressionFound = true;
- }
- }
-
- @Override
- public void visitNullCaller() {
- //nothing to do
- }
-
- @Override
- public boolean postVisitFunctionCaller(AbstractFunctionExpression functionCall) {
- //nothing to do
- return true;
- }
-
- public boolean isExpressionFound() {
- return expressionFound;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/FunctionGenerator.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/FunctionGenerator.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/FunctionGenerator.java
deleted file mode 100644
index 1a93d0f..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/FunctionGenerator.java
+++ /dev/null
@@ -1,326 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import java.util.List;
-
-import org.apache.atlas.gremlin.GremlinExpressionFactory;
-import org.apache.atlas.groovy.AbstractFunctionExpression;
-import org.apache.atlas.groovy.ClosureExpression;
-import org.apache.atlas.groovy.ClosureExpression.VariableDeclaration;
-import org.apache.atlas.groovy.FunctionCallExpression;
-import org.apache.atlas.groovy.GroovyExpression;
-import org.apache.atlas.groovy.IdentifierExpression;
-
-/**
- * Extracts common expressions from an or-containing expression
- * into functions. These expressions would otherwise be duplicated
- * as part of expanding the "or". Doing this shortens the overall length
- * of the Gremlin script so we can maximize query performance.
- *
- */
-public class FunctionGenerator implements CallHierarchyVisitor {
-
- //Function length constants.
- //These assume we won't reach more than 9 function definition. Even if we do, this is still
- //a reasonable approximation.
- private static final int INITIAL_FUNCTION_DEF_LENGTH = "def f1={};".length();
- private final int functionDefLength;
- private static final int FUNCTION_CALL_OVERHEAD = "f1()".length();
-
- /**
- * The expression that should be the first (deepest) expression
- * in the body of the next generated function. As we go up the
- * expression tree in the post visit, this is updated based on the
- * expressions we see. During the post visits, if it is null,
- * the body expression is set to the expression we're visiting.
- * As we go up the tree, it is nulled out if we create a function
- * or encounter an or expression. This guarantees that the
- * next function body will not contain any or expressions
- * and that it will not have expressions that are already
- * part of some other function.
- */
- private GroovyExpression nextFunctionBodyStart;
-
- /**
- * The number of times expressions will be duplicated.
- */
- private int scaleFactor = 1;
-
- private final OptimizationContext context;
-
- /**
- * The current depth in the expression tree.
- */
- private int depth = 0;
-
- /**
- * The name of the last function that was generated. If set,
- * we can safely update this function instead of creating a new one.
- */
- private String currentFunctionName;
-
- /**
- * The updated expression we will pass back to the caller.
- */
- private GroovyExpression newRootExpression;
-
- private final GremlinExpressionFactory factory;
-
- public FunctionGenerator(GremlinExpressionFactory factory, OptimizationContext context) {
- this.context = context;
- this.factory = factory;
- functionDefLength = ("def f1={" + factory.getTraversalExpressionClass() + " x->};").length();
- }
-
- @Override
- public boolean preVisitFunctionCaller(AbstractFunctionExpression expr) {
- depth++;
- if (IsOr.INSTANCE.apply(expr)) {
- FunctionCallExpression functionCall = (FunctionCallExpression) expr;
- scaleFactor *= functionCall.getArguments().size();
- }
- if (newRootExpression == null) {
- newRootExpression = expr;
- }
-
- return true;
- }
-
- @Override
- public void visitNonFunctionCaller(GroovyExpression expr) {
- if (nextFunctionBodyStart == null) {
- nextFunctionBodyStart = expr;
- }
-
- }
-
- @Override
- public void visitNullCaller() {
- //nothing to do
- }
-
- @Override
- public boolean postVisitFunctionCaller(AbstractFunctionExpression expr) {
- boolean isRootExpr = depth == 1;
- visitParentExpression(expr);
-
- //The root expression has no parent. To simplify the logic, we create
- //a dummy expression so it does have a parent, then call visitParentExpression again
- //to examine the root expression.
- if (isRootExpr) {
- FunctionCallExpression dummyParent = new FunctionCallExpression(expr, "dummy");
- visitParentExpression(dummyParent);
- newRootExpression = dummyParent.getCaller();
- }
-
- depth--;
- return true;
- }
-
- /**
- * Checks to see if the *caller* of this expression should become part
- * of a function. If so, either a new function is created, or the
- * expression becomes part of the last function we created.
- *
- * @param parentExpr
- */
- private void visitParentExpression(AbstractFunctionExpression parentExpr) {
-
- if (nextFunctionBodyStart == null) {
- nextFunctionBodyStart = parentExpr;
- }
-
- if (currentFunctionName != null) {
- updateCurrentFunction(parentExpr);
- } else {
- createFunctionIfNeeded(parentExpr);
- }
-
- if (GremlinQueryOptimizer.isOrExpression(parentExpr)) {
- //reset
- currentFunctionName = null;
- //don't include 'or' in generated functions
- nextFunctionBodyStart = null;
- }
-
- }
-
- /**
- * Creates a function whose body goes from the child of parentExpr
- * up to (and including) the functionBodyEndExpr.
- * @param parentExpr
- */
- private void createFunctionIfNeeded(AbstractFunctionExpression parentExpr) {
- GroovyExpression potentialFunctionBody = parentExpr.getCaller();
-
- if (creatingFunctionShortensGremlin(potentialFunctionBody)) {
- GroovyExpression functionCall = null;
-
- if (nextFunctionBodyStart instanceof AbstractFunctionExpression) {
- //The function body start is a a function call. In this
- //case, we generate a function that takes one argument, which
- //is a graph traversal. We have an expression tree that
- //looks kind of like the following:
- //
- // parentExpr
- // /
- // / caller
- // |/_
- // potentialFunctionBody
- // /
- // / caller
- // |/_
- // ...
- // /
- // / caller
- // |/_
- // nextFunctionBodyStart
- // /
- // / caller
- // |/_
- // oldCaller
- //
- //
- // Note that potentialFunctionBody and nextFunctionBodyStart
- // could be the same expression. Let's say that the next
- // function name is f1
- //
- // We reshuffle these expressions to the following:
- //
- // parentExpr
- // /
- // / caller
- // |/_
- // f1(oldCaller)
- //
- //
- // potentialFunctionBody <- body of new function "f1(GraphTraversal x)"
- // /
- // / caller
- // |/_
- // ...
- // /
- // / caller
- // |/_
- // nextFunctionBodyStart
- // /
- // / caller
- // |/_
- // x
- //
- // As an example, suppose parentExpr is g.V().or(x,y).has(a).has(b).has(c)
- // where has(a) is nextFunctionBodyStart.
- //
- // We generate a function f1 = { GraphTraversal x -> x.has(a).has(b) }
- // parentExpr would become : f1(g.V().or(x,y)).has(c)
-
- AbstractFunctionExpression nextFunctionBodyStartFunction=
- (AbstractFunctionExpression) nextFunctionBodyStart;
- String variableName = "x";
- IdentifierExpression var = new IdentifierExpression(variableName);
- GroovyExpression oldCaller = nextFunctionBodyStartFunction.getCaller();
- nextFunctionBodyStartFunction.setCaller(var);
-
- currentFunctionName = context.addFunctionDefinition(new VariableDeclaration(factory.getTraversalExpressionClass(), "x"),
- potentialFunctionBody);
- functionCall = new FunctionCallExpression(potentialFunctionBody.getType(),
- currentFunctionName, oldCaller);
-
- } else {
- //The function body start is a not a function call. In this
- //case, we generate a function that takes no arguments.
-
- // As an example, suppose parentExpr is g.V().has(a).has(b).has(c)
- // where g is nextFunctionBodyStart.
- //
- // We generate a function f1 = { g.V().has(a).has(b) }
- // parentExpr would become : f1().has(c)
-
- currentFunctionName = context.addFunctionDefinition(null, potentialFunctionBody);
- functionCall = new FunctionCallExpression(potentialFunctionBody.getType(), currentFunctionName);
- }
-
- //functionBodyEnd is now part of a function definition, don't propagate it
- nextFunctionBodyStart = null;
- parentExpr.setCaller(functionCall);
- }
- }
-
- /**
- * Adds the caller of parentExpr to the current body of the last
- * function that was created.
- *
- * @param parentExpr
- */
- private void updateCurrentFunction(AbstractFunctionExpression parentExpr) {
- GroovyExpression expr = parentExpr.getCaller();
- if (expr instanceof AbstractFunctionExpression) {
- AbstractFunctionExpression exprAsFunction = (AbstractFunctionExpression) expr;
- GroovyExpression exprCaller = exprAsFunction.getCaller();
- parentExpr.setCaller(exprCaller);
- updateCurrentFunctionDefintion(exprAsFunction);
- }
- }
-
- private void updateCurrentFunctionDefintion(AbstractFunctionExpression exprToAdd) {
- ClosureExpression functionBodyClosure = context.getUserDefinedFunctionBody(currentFunctionName);
- if (functionBodyClosure == null) {
- throw new IllegalStateException("User-defined function " + currentFunctionName + " not found!");
- }
- List<GroovyExpression> exprs = functionBodyClosure.getStatements();
- GroovyExpression currentFunctionBody = exprs.get(exprs.size() - 1);
- //Update the expression so it is called by the current return
- //value of the function.
- exprToAdd.setCaller(currentFunctionBody);
- functionBodyClosure.replaceStatement(exprs.size() - 1, exprToAdd);
- }
-
- //Determines if extracting this expression into a function will shorten
- //the overall length of the Groovy script.
- private boolean creatingFunctionShortensGremlin(GroovyExpression headExpr) {
- int tailLength = getTailLength();
- int length = headExpr.toString().length() - tailLength;
-
- int overhead = 0;
- if (nextFunctionBodyStart instanceof AbstractFunctionExpression) {
- overhead = functionDefLength;
- } else {
- overhead = INITIAL_FUNCTION_DEF_LENGTH;
- }
- overhead += FUNCTION_CALL_OVERHEAD * scaleFactor;
- //length * scaleFactor = space taken by having the expression be inlined [scaleFactor] times
- //overhead + length = space taken by the function definition and its calls
- return length * scaleFactor > overhead + length;
- }
-
- private int getTailLength() {
- if (nextFunctionBodyStart == null) {
- return 0;
- }
- if (!(nextFunctionBodyStart instanceof AbstractFunctionExpression)) {
- return 0;
- }
- AbstractFunctionExpression bodyEndAsFunction = (AbstractFunctionExpression) nextFunctionBodyStart;
- return bodyEndAsFunction.getCaller().toString().length();
- }
-
- public GroovyExpression getNewRootExpression() {
- return newRootExpression;
- }
-}
http://git-wip-us.apache.org/repos/asf/atlas/blob/435fe3fb/repository/src/main/java/org/apache/atlas/gremlin/optimizer/GremlinOptimization.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/GremlinOptimization.java b/repository/src/main/java/org/apache/atlas/gremlin/optimizer/GremlinOptimization.java
deleted file mode 100644
index bfa45af..0000000
--- a/repository/src/main/java/org/apache/atlas/gremlin/optimizer/GremlinOptimization.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.atlas.gremlin.optimizer;
-
-import org.apache.atlas.groovy.GroovyExpression;
-
-/**
- * An optimization that can be applied to a gremlin query.
- */
-public interface GremlinOptimization {
-
- /**
- * Whether or not this optimization should be applied to the given expression
- * @param expr
- * @param contxt
- * @return
- */
- boolean appliesTo(GroovyExpression expr, OptimizationContext contxt);
- /**
- * Whether or not GremlinQueryOptimizer should call this optimization recursively
- * on the updated children.
- */
- boolean isApplyRecursively();
-
- /**
- * Applies the optimization.
- *
- * @param expr
- * @param context
- * @return the optimized expression
- */
- GroovyExpression apply(GroovyExpression expr, OptimizationContext context);
-}