You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by ve...@apache.org on 2015/06/17 01:05:02 UTC
[28/58] [abbrv] incubator-atlas git commit: Refactor packages and
scripts to Atlas (cherry picked from commit 414beba)
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/30711973/repository/src/main/scala/org/apache/hadoop/metadata/query/Expressions.scala
----------------------------------------------------------------------
diff --git a/repository/src/main/scala/org/apache/hadoop/metadata/query/Expressions.scala b/repository/src/main/scala/org/apache/hadoop/metadata/query/Expressions.scala
deleted file mode 100755
index aec424c..0000000
--- a/repository/src/main/scala/org/apache/hadoop/metadata/query/Expressions.scala
+++ /dev/null
@@ -1,739 +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.hadoop.metadata.query
-
-import org.apache.hadoop.metadata.MetadataException
-import org.apache.hadoop.metadata.typesystem.types.DataTypes.{ArrayType, PrimitiveType, TypeCategory}
-import org.apache.hadoop.metadata.typesystem.types._
-
-object Expressions {
-
- import TypeUtils._
-
- class ExpressionException(val e: Expression, message: String, cause: Throwable, enableSuppression: Boolean,
- writableStackTrace: Boolean)
- extends MetadataException(message, cause, enableSuppression, writableStackTrace) {
-
- def this(e: Expression, message: String) {
- this(e, message, null, false, false)
- }
-
- def this(e: Expression, message: String, cause: Throwable) {
- this(e, message, cause, false, false)
- }
-
- def this(e: Expression, cause: Throwable) {
- this(e, null, cause, false, false)
- }
-
- override def getMessage: String = {
- val eString = e.toString
- s"${super.getMessage}, expression:${if (eString contains "\n") "\n" else " "}$e"
- }
-
- }
-
- class UnresolvedException(expr: Expression, function: String) extends
- ExpressionException(expr, s"Unresolved $function")
-
- def attachExpression[A](e: Expression, msg: String = "")(f: => A): A = {
- try f catch {
- case eex: ExpressionException => throw eex
- case ex: Exception => throw new ExpressionException(e, msg, ex)
- }
- }
-
- trait Expression {
- self: Product =>
-
- def children: Seq[Expression]
-
- /**
- * Returns `true` if the schema for this expression and all its children have been resolved.
- * The default logic is that an Expression is resolve if all its children are resolved.
- */
- lazy val resolved: Boolean = childrenResolved
-
- /**
- * Returns the output [[IDataType[_]] of this expression. Expressions that are unresolved will
- * throw if this method is invoked.
- */
- def dataType: IDataType[_]
-
- /**
- * Returns true if all the children have been resolved.
- */
- def childrenResolved = !children.exists(!_.resolved)
-
-
- /**
- * the aliases that are present in this Expression Tree
- */
- def namedExpressions: Map[String, Expression] = Map()
-
- def fastEquals(other: Expression): Boolean = {
- this.eq(other) || this == other
- }
-
- def makeCopy(newArgs: Array[AnyRef]): this.type = attachExpression(this, "makeCopy") {
- try {
- val defaultCtor = getClass.getConstructors.find(_.getParameterTypes.size != 0).head
- defaultCtor.newInstance(newArgs: _*).asInstanceOf[this.type]
- } catch {
- case e: java.lang.IllegalArgumentException =>
- throw new ExpressionException(
- this, s"Failed to copy node. Reason: ${e.getMessage}.")
- }
- }
-
- def transformChildrenDown(rule: PartialFunction[Expression, Expression]): this.type = {
- var changed = false
- val newArgs = productIterator.map {
- case arg: Expression if children contains arg =>
- val newChild = arg.asInstanceOf[Expression].transformDown(rule)
- if (!(newChild fastEquals arg)) {
- changed = true
- newChild
- } else {
- arg
- }
- case Some(arg: Expression) if children contains arg =>
- val newChild = arg.asInstanceOf[Expression].transformDown(rule)
- if (!(newChild fastEquals arg)) {
- changed = true
- Some(newChild)
- } else {
- Some(arg)
- }
- case m: Map[_, _] => m
- case args: Traversable[_] => args.map {
- case arg: Expression if children contains arg =>
- val newChild = arg.asInstanceOf[Expression].transformDown(rule)
- if (!(newChild fastEquals arg)) {
- changed = true
- newChild
- } else {
- arg
- }
- case other => other
- }
- case nonChild: AnyRef => nonChild
- case null => null
- }.toArray
- if (changed) makeCopy(newArgs) else this
- }
-
- def transformDown(rule: PartialFunction[Expression, Expression]): Expression = {
- val afterRule = rule.applyOrElse(this, identity[Expression])
- // Check if unchanged and then possibly return old copy to avoid gc churn.
- if (this fastEquals afterRule) {
- transformChildrenDown(rule)
- } else {
- afterRule.transformChildrenDown(rule)
- }
- }
-
- def traverseChildren(traverseFunc: (Expression, PartialFunction[Expression, Unit]) => Unit)
- (rule: PartialFunction[Expression, Unit]): Unit = {
- productIterator.foreach {
- case arg: Expression if children contains arg =>
- traverseFunc(arg.asInstanceOf[Expression], rule)
- case Some(arg: Expression) if children contains arg =>
- traverseFunc(arg.asInstanceOf[Expression], rule)
- case m: Map[_, _] => m
- case args: Traversable[_] => args.map {
- case arg: Expression if children contains arg =>
- traverseFunc(arg.asInstanceOf[Expression], rule)
- case other => other
- }
- case nonChild: AnyRef => nonChild
- case null => null
- }
- }
-
- def traverseChildrenDown = traverseChildren(_traverseDown) _
-
- private def _traverseDown(e: Expression, rule: PartialFunction[Expression, Unit]): Unit = {
- if (rule.isDefinedAt(e)) {
- rule.apply(e)
- }
- e.traverseChildrenDown(rule)
- }
-
- def traverseDown(rule: PartialFunction[Expression, Unit]): Unit = {
- _traverseDown(this, rule)
- }
-
- def traverseChildrenUp = traverseChildren(_traverseUp) _
-
- private def _traverseUp(e: Expression, rule: PartialFunction[Expression, Unit]): Unit = {
- e.traverseChildrenUp(rule)
- if (rule.isDefinedAt(e)) {
- rule.apply(e)
- }
- }
-
- def traverseUp(rule: PartialFunction[Expression, Unit]): Unit = {
- _traverseUp(this, rule)
- }
-
- def transformUp(rule: PartialFunction[Expression, Expression]): Expression = {
- val afterRuleOnChildren = transformChildrenUp(rule);
- if (this fastEquals afterRuleOnChildren) {
- rule.applyOrElse(this, identity[Expression])
- } else {
- rule.applyOrElse(afterRuleOnChildren, identity[Expression])
- }
- }
-
- def transformChildrenUp(rule: PartialFunction[Expression, Expression]): this.type = {
- var changed = false
- val newArgs = productIterator.map {
- case arg: Expression if children contains arg =>
- val newChild = arg.asInstanceOf[Expression].transformUp(rule)
- if (!(newChild fastEquals arg)) {
- changed = true
- newChild
- } else {
- arg
- }
- case Some(arg: Expression) if children contains arg =>
- val newChild = arg.asInstanceOf[Expression].transformUp(rule)
- if (!(newChild fastEquals arg)) {
- changed = true
- Some(newChild)
- } else {
- Some(arg)
- }
- case m: Map[_, _] => m
- case args: Traversable[_] => args.map {
- case arg: Expression if children contains arg =>
- val newChild = arg.asInstanceOf[Expression].transformUp(rule)
- if (!(newChild fastEquals arg)) {
- changed = true
- newChild
- } else {
- arg
- }
- case other => other
- }
- case nonChild: AnyRef => nonChild
- case null => null
- }.toArray
- if (changed) makeCopy(newArgs) else this
- }
-
- /*
- * treeString methods
- */
- def nodeName = getClass.getSimpleName
-
- def argString: String = productIterator.flatMap {
- case e: Expression if children contains e => Nil
- case e: Expression if e.toString contains "\n" => s"(${e.simpleString})" :: Nil
- case seq: Seq[_] => seq.mkString("[", ",", "]") :: Nil
- case set: Set[_] => set.mkString("{", ",", "}") :: Nil
- case f: IDataType[_] => f.getName :: Nil
- case other => other :: Nil
- }.mkString(", ")
-
- /** String representation of this node without any children */
- def simpleString = s"$nodeName $argString"
-
- protected def generateTreeString(depth: Int, builder: StringBuilder): StringBuilder = {
- builder.append(" " * depth)
- builder.append(simpleString)
- builder.append("\n")
- children.foreach(_.generateTreeString(depth + 1, builder))
- builder
- }
-
- def treeString = generateTreeString(0, new StringBuilder).toString
-
- /*
- * Fluent API methods
- */
- def field(fieldName: String) = new UnresolvedFieldExpression(this, fieldName)
-
- def join(fieldName: String) = field(fieldName)
-
- def `.`(fieldName: String) = field(fieldName)
-
- def as(alias: String) = new AliasExpression(this, alias)
-
- def arith(op: String)(rightExpr: Expression) = new ArithmeticExpression(op, this, rightExpr)
-
- def + = arith("+") _
-
- def - = arith("-") _
-
- def * = arith("*") _
-
- def / = arith("/") _
-
- def % = arith("%") _
-
- def isTrait(name: String) = new isTraitUnaryExpression(name, this)
-
- def hasField(name: String) = new hasFieldUnaryExpression(name, this)
-
- def compareOp(op: String)(rightExpr: Expression) = new ComparisonExpression(op, this, rightExpr)
-
- def `=` = compareOp("=") _
-
- def `!=` = compareOp("!=") _
-
- def `>` = compareOp(">") _
-
- def `>=` = compareOp(">=") _
-
- def `<` = compareOp("<") _
-
- def `<=` = compareOp("=") _
-
- def logicalOp(op: String)(rightExpr: Expression) = new LogicalExpression(op, List(this, rightExpr))
-
- def and = logicalOp("and") _
-
- def or = logicalOp("or") _
-
- def where(condExpr: Expression) = new FilterExpression(this, condExpr)
-
- def select(selectList: Expression*) = new SelectExpression(this, selectList.toList)
-
- def loop(loopingExpr: Expression) = new LoopExpression(this, loopingExpr, None)
-
- def loop(loopingExpr: Expression, times: Literal[Integer]) =
- new LoopExpression(this, loopingExpr, Some(times))
-
- def traitInstance() = new TraitInstanceExpression(this)
- def instance() = new InstanceExpression(this)
-
- def path() = new PathExpression(this)
- }
-
- trait BinaryNode {
- self: Expression =>
- def left: Expression
-
- def right: Expression
-
- def children = Seq(left, right)
-
- override def namedExpressions = left.namedExpressions ++ right.namedExpressions
- }
-
- trait LeafNode {
- def children = Nil
- }
-
- trait UnaryNode {
- self: Expression =>
- def child: Expression
-
- override def namedExpressions = child.namedExpressions
-
- def children = child :: Nil
- }
-
- abstract class BinaryExpression extends Expression with BinaryNode {
- self: Product =>
- def symbol: String
-
- override def toString = s"($left $symbol $right)"
- }
-
- case class ClassExpression(clsName: String) extends Expression with LeafNode {
- val dataType = typSystem.getDataType(classOf[ClassType], clsName)
-
- override def toString = clsName
- }
-
- def _class(name: String): Expression = new ClassExpression(name)
-
- case class TraitExpression(traitName: String) extends Expression with LeafNode {
- val dataType = typSystem.getDataType(classOf[TraitType], traitName)
-
- override def toString = traitName
- }
-
- def _trait(name: String) = new TraitExpression(name)
-
- case class IdExpression(name: String) extends Expression with LeafNode {
- override def toString = name
-
- override lazy val resolved = false
-
- override def dataType = throw new UnresolvedException(this, "id")
- }
-
- def id(name: String) = new IdExpression(name)
-
- case class UnresolvedFieldExpression(child: Expression, fieldName: String) extends Expression
- with UnaryNode {
- override def toString = s"${child}.$fieldName"
-
- override lazy val resolved = false
-
- override def dataType = throw new UnresolvedException(this, "field")
- }
-
- case class FieldExpression(fieldName: String, fieldInfo: FieldInfo, child: Option[Expression])
- extends Expression {
-
- def elemType(t: IDataType[_]): IDataType[_] = {
- if (t.getTypeCategory == TypeCategory.ARRAY) {
- val aT = t.asInstanceOf[ArrayType]
- if (aT.getElemType.getTypeCategory == TypeCategory.CLASS ||
- aT.getElemType.getTypeCategory == TypeCategory.STRUCT) {
- return aT.getElemType
- }
- }
- t
- }
-
- val children = if (child.isDefined) List(child.get) else Nil
- import scala.language.existentials
- lazy val dataType = {
- val t = {
- if (fieldInfo.traitName != null ) {
- typSystem.getDataType(classOf[TraitType], fieldInfo.traitName)
- } else if (!fieldInfo.isReverse) {
- fieldInfo.attrInfo.dataType()
- } else {
- fieldInfo.reverseDataType
- }
- }
- elemType(t)
- }
- override lazy val resolved: Boolean = true
-
- override def namedExpressions = if (child.isDefined) child.get.namedExpressions else Map()
-
- override def toString = {
- if (child.isDefined) {
- val sep = if (dataType.isInstanceOf[ClassType]) " " else "."
- s"${child.get}${sep}$fieldName"
- } else {
- fieldName
- }
- }
- }
-
- case class AliasExpression(child: Expression, alias: String) extends Expression with UnaryNode {
- override def namedExpressions = child.namedExpressions + (alias -> child)
-
- override def toString = s"$child as $alias"
-
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved child")
- }
- child.dataType
- }
- }
-
- case class BackReference(alias: String, reference: Expression, child: Option[Expression]) extends Expression {
- val children = if (child.isDefined) List(child.get) else Nil
- val dataType = reference.dataType
-
- override def namedExpressions = if (child.isDefined) child.get.namedExpressions else Map()
-
- override def toString = if (child.isDefined) s"${child.get} $alias" else alias
- }
-
- case class Literal[T](dataType: PrimitiveType[T], rawValue: Any) extends Expression with LeafNode {
- val value = if (rawValue == null) dataType.nullValue() else dataType.convert(rawValue, Multiplicity.REQUIRED)
-
- override def toString = value match {
- case s: String => s""""$s""""
- case x => x.toString
- }
- }
-
- def literal[T](typ: PrimitiveType[T], rawValue: Any) = new Literal[T](typ, rawValue)
-
- def boolean(rawValue: Any) = literal(DataTypes.BOOLEAN_TYPE, rawValue)
-
- def byte(rawValue: Any) = literal(DataTypes.BYTE_TYPE, rawValue)
-
- def short(rawValue: Any) = literal(DataTypes.SHORT_TYPE, rawValue)
-
- def int(rawValue: Any) = literal(DataTypes.INT_TYPE, rawValue)
-
- def long(rawValue: Any) = literal(DataTypes.LONG_TYPE, rawValue)
-
- def float(rawValue: Any) = literal(DataTypes.FLOAT_TYPE, rawValue)
-
- def double(rawValue: Any) = literal(DataTypes.DOUBLE_TYPE, rawValue)
-
- def bigint(rawValue: Any) = literal(DataTypes.BIGINTEGER_TYPE, rawValue)
-
- def bigdecimal(rawValue: Any) = literal(DataTypes.BIGDECIMAL_TYPE, rawValue)
-
- def string(rawValue: Any) = literal(DataTypes.STRING_TYPE, rawValue)
-
- case class ArithmeticExpression(symbol: String,
- left: Expression,
- right: Expression)
- extends BinaryExpression {
-
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved children")
- }
- TypeUtils.combinedType(left.dataType, right.dataType)
- }
- }
-
- case class isTraitLeafExpression(traitName: String, classExpression: Option[Expression] = None)
- extends Expression with LeafNode {
- // validate TraitName
- try {
- typSystem.getDataType(classOf[TraitType], traitName)
- } catch {
- case me: MetadataException => throw new ExpressionException(this, "not a TraitType", me)
- }
-
- override lazy val resolved = classExpression.isDefined
- lazy val dataType = {
-
- if (!resolved) {
- throw new UnresolvedException(this,
- s"cannot resolve isTrait application")
- }
-
- if (!classExpression.get.dataType.isInstanceOf[ClassType]) {
- throw new ExpressionException(this,
- s"Cannot apply isTrait on ${classExpression.get.dataType.getName}, it is not a ClassType")
- }
- DataTypes.BOOLEAN_TYPE
- }
-
- override def toString = s"${classExpression.getOrElse("")} is $traitName"
- }
-
- def isTrait(name: String) = new isTraitLeafExpression(name)
-
- case class isTraitUnaryExpression(traitName: String, child: Expression)
- extends Expression with UnaryNode {
- // validate TraitName
- typSystem.getDataType(classOf[TraitType], traitName)
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved child")
- }
- if (!child.dataType.isInstanceOf[ClassType]) {
- throw new ExpressionException(this,
- s"Cannot apply isTrait on ${child.dataType.getName}, it is not a ClassType")
- }
- DataTypes.BOOLEAN_TYPE
- }
-
- override def toString = s"$child is $traitName"
- }
-
- case class hasFieldLeafExpression(fieldName: String, classExpression: Option[Expression] = None)
- extends Expression with LeafNode {
-
- override lazy val resolved = classExpression.isDefined
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"Cannot apply hasField on ${classExpression.get.dataType.getName}, it is not a ClassType")
- }
- if (classExpression.isDefined && !TypeUtils.fieldMapping(classExpression.get.dataType).isDefined) {
- throw new ExpressionException(this, s"Cannot apply hasField on ${classExpression.get.dataType.getName}")
- }
- DataTypes.BOOLEAN_TYPE
- }
-
- override def toString = s"${classExpression.getOrElse("")} has $fieldName"
- }
-
- def hasField(name: String) = new hasFieldLeafExpression(name)
-
- case class hasFieldUnaryExpression(fieldName: String, child: Expression)
- extends Expression with UnaryNode {
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved child")
- }
- if (!TypeUtils.fieldMapping(child.dataType).isDefined) {
- throw new MetadataException(s"Cannot apply hasField on ${child.dataType.getName}")
- }
- DataTypes.BOOLEAN_TYPE
- }
-
- override def toString = s"$child has $fieldName"
- }
-
- case class ComparisonExpression(symbol: String,
- left: Expression,
- right: Expression)
- extends BinaryExpression {
-
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved children")
- }
- if (left.dataType != DataTypes.STRING_TYPE || right.dataType != DataTypes.STRING_TYPE) {
- TypeUtils.combinedType(left.dataType, right.dataType)
- }
- DataTypes.BOOLEAN_TYPE
- }
- }
-
- case class LogicalExpression(symbol: String, children: List[Expression])
- extends Expression {
- assert(children.size > 0)
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved children")
- }
- children.foreach { childExpr =>
- if (childExpr.dataType != DataTypes.BOOLEAN_TYPE) {
- throw new MetadataException(
- s"Cannot apply logical operator '$symbol' on input of type '${childExpr.dataType}")
- }
- }
- DataTypes.BOOLEAN_TYPE
- }
-
- override def toString = children.mkString("", s" $symbol ", "")
- }
-
- case class FilterExpression(val child: Expression, val condExpr: Expression) extends Expression {
- val children = List(child, condExpr)
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved children")
- }
- if (condExpr.dataType != DataTypes.BOOLEAN_TYPE) {
- throw new ExpressionException(this, s"Filter condition '$condExpr' is not a boolean expression")
- }
- child.dataType
- }
-
- override def namedExpressions = child.namedExpressions ++ condExpr.namedExpressions
-
- override def toString = s"$child where $condExpr"
- }
-
- val GEN_COL_ALIAS_PREFIX = "_col"
-
- case class SelectExpression(child: Expression, selectList: List[Expression]) extends Expression {
-
- val children = List(child) ::: selectList
- lazy val selectListWithAlias = selectList.zipWithIndex map {
- case (s: AliasExpression, _) => s
- case (x, i) => new AliasExpression(x, s"${GEN_COL_ALIAS_PREFIX}_$i")
- }
-
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved children")
- }
- TypeUtils.createStructType(selectListWithAlias)
- }
-
- override def namedExpressions = child.namedExpressions ++ (selectList.flatMap(_.namedExpressions))
-
- override def toString = s"""$child select ${selectListWithAlias.mkString("", ", ", "")}"""
- }
-
- case class LoopExpression(val input: Expression, val loopingExpression: Expression,
- val times: Option[Literal[Integer]]) extends Expression {
- val children = List(input, loopingExpression)
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved children")
- }
- if (input.dataType.getTypeCategory != TypeCategory.CLASS) {
- throw new ExpressionException(this, s"Loop Expression applied to type : '${input.dataType.getName}';" +
- " loop can only be applied to Class Expressions")
- }
- if (input.dataType != loopingExpression.dataType) {
- throw new ExpressionException(this,
- s"Invalid Loop Expression; input and loopExpression dataTypes don't match: " +
- s"(${input.dataType.getName},${loopingExpression.dataType.getName}})")
- }
- input.dataType
- }
-
- override def namedExpressions = input.namedExpressions
-
- override def toString = {
- if (times.isDefined) s"$input loop ($loopingExpression) times ${times.get.value}"
- else s"$input loop ($loopingExpression)"
- }
- }
-
- case class TraitInstanceExpression(child: Expression)
- extends Expression with UnaryNode {
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved child")
- }
- if (!child.dataType.isInstanceOf[TraitType]) {
- throw new ExpressionException(this,
- s"Cannot apply instance on ${child.dataType.getName}, it is not a TraitType")
- }
- typSystem.getIdType.getStructType
- }
-
- override def toString = s"$child traitInstance"
- }
-
- case class InstanceExpression(child: Expression)
- extends Expression with UnaryNode {
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved child")
- }
- typSystem.getIdType.getStructType
- }
-
- override def toString = s"$child instance"
- }
-
- case class PathExpression(child: Expression)
- extends Expression with UnaryNode {
- lazy val dataType = {
- if (!resolved) {
- throw new UnresolvedException(this,
- s"datatype. Can not resolve due to unresolved child")
- }
- TypeUtils.ResultWithPathStruct.createType(this, child.dataType)
- }
-
- override def toString = s"$child withPath"
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/30711973/repository/src/main/scala/org/apache/hadoop/metadata/query/GraphPersistenceStrategies.scala
----------------------------------------------------------------------
diff --git a/repository/src/main/scala/org/apache/hadoop/metadata/query/GraphPersistenceStrategies.scala b/repository/src/main/scala/org/apache/hadoop/metadata/query/GraphPersistenceStrategies.scala
deleted file mode 100755
index 5684365..0000000
--- a/repository/src/main/scala/org/apache/hadoop/metadata/query/GraphPersistenceStrategies.scala
+++ /dev/null
@@ -1,327 +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.hadoop.metadata.query
-
-import com.thinkaurelius.titan.core.TitanVertex
-import com.tinkerpop.blueprints.Direction
-import org.apache.hadoop.metadata.query.Expressions.{ComparisonExpression, ExpressionException}
-import org.apache.hadoop.metadata.query.TypeUtils.FieldInfo
-import org.apache.hadoop.metadata.typesystem.persistence.Id
-import org.apache.hadoop.metadata.typesystem.types.DataTypes._
-import org.apache.hadoop.metadata.typesystem.types._
-import org.apache.hadoop.metadata.typesystem.{ITypedInstance, ITypedReferenceableInstance}
-
-import scala.collection.JavaConversions._
-
-/**
- * Represents the Bridge between the QueryProcessor and the Graph Persistence scheme used.
- * Some of the behaviors captured are:
- * - how is type and id information stored in the Vertex that represents an [[ITypedReferenceableInstance]]
- * - how are edges representing trait and attribute relationships labelled.
- * - how are attribute names mapped to Property Keys in Vertices.
- *
- * This is a work in progress.
- */
-trait GraphPersistenceStrategies {
- /**
- * Name of attribute used to store typeName in vertex
- */
- def typeAttributeName: String
-
- /**
- * Name of attribute used to store super type names in vertex.
- */
- def superTypeAttributeName: String
-
- /**
- * Name of attribute used to store guid in vertex
- */
- def idAttributeName : String
-
- /**
- * Given a dataType and a reference attribute, how is edge labeled
- */
- def edgeLabel(iDataType: IDataType[_], aInfo: AttributeInfo): String
-
- def traitLabel(cls: IDataType[_], traitName: String): String
-
- def instanceToTraitEdgeDirection : String = "out"
- def traitToInstanceEdgeDirection = instanceToTraitEdgeDirection match {
- case "out" => "in"
- case "in" => "out"
- case x => x
- }
-
- /**
- * The propertyKey used to store the attribute in a Graph Vertex.
- * @param dataType
- * @param aInfo
- * @return
- */
- def fieldNameInVertex(dataType: IDataType[_], aInfo: AttributeInfo): String
-
- /**
- * from a vertex for an [[ITypedReferenceableInstance]] get the traits that it has.
- * @param v
- * @return
- */
- def traitNames(v: TitanVertex): java.util.List[String]
-
- def edgeLabel(fInfo: FieldInfo): String = fInfo match {
- case FieldInfo(dataType, aInfo, null, null) => edgeLabel(dataType, aInfo)
- case FieldInfo(dataType, aInfo, reverseDataType, null) => edgeLabel(reverseDataType, aInfo)
- case FieldInfo(dataType, null, null, traitName) => traitLabel(dataType, traitName)
- }
-
- def fieldPrefixInSelect: String
-
- /**
- * extract the Id from a Vertex.
- * @param dataTypeNm the dataType of the instance that the given vertex represents
- * @param v
- * @return
- */
- def getIdFromVertex(dataTypeNm: String, v: TitanVertex): Id
-
- def constructInstance[U](dataType: IDataType[U], v: java.lang.Object): U
-
- def gremlinCompOp(op: ComparisonExpression) = op.symbol match {
- case "=" => "T.eq"
- case "!=" => "T.neq"
- case ">" => "T.gt"
- case ">=" => "T.gte"
- case "<" => "T.lt"
- case "<=" => "T.lte"
- case _ => throw new ExpressionException(op, "Comparison operator not supported in Gremlin")
- }
-
- def loopObjectExpression(dataType: IDataType[_]) = {
- _typeTestExpression(dataType.getName, "it.object")
- }
-
- def addGraphVertexPrefix(preStatements : Traversable[String]) = !collectTypeInstancesIntoVar
-
- /**
- * Controls behavior of how instances of a Type are discovered.
- * - query is generated in a way that indexes are exercised using a local set variable across multiple lookups
- * - query is generated using an 'or' expression.
- *
- * '''This is a very bad idea: controlling query execution behavior via query generation.''' But our current
- * knowledge of seems to indicate we have no choice. See
- * [[https://groups.google.com/forum/#!topic/gremlin-users/n1oV86yr4yU discussion in Gremlin group]].
- * Also this seems a fragile solution, dependend on the memory requirements of the Set variable.
- * For now enabling via the '''collectTypeInstancesIntoVar''' behavior setting. Reverting back would require
- * setting this to false.
- *
- * Long term have to get to the bottom of Gremlin:
- * - there doesn't seem to be way to see the physical query plan. Maybe we should directly interface with Titan.
- * - At least from querying perspective a columnar db maybe a better route. Daniel Abadi did some good work
- * on showing how to use a columnar store as a Graph Db.
- *
- *
- * @return
- */
- def collectTypeInstancesIntoVar = true
-
- def typeTestExpression(typeName : String, intSeq : IntSequence) : Seq[String] = {
- if (collectTypeInstancesIntoVar)
- typeTestExpressionMultiStep(typeName, intSeq)
- else
- typeTestExpressionUsingFilter(typeName)
- }
-
- private def typeTestExpressionUsingFilter(typeName : String) : Seq[String] = {
- Seq(s"""filter${_typeTestExpression(typeName, "it")}""")
- }
-
- private def _typeTestExpression(typeName: String, itRef: String): String = {
- s"""{(${itRef}.'${typeAttributeName}' == '${typeName}') |
- |(${itRef}.'${superTypeAttributeName}' ?
- |${itRef}.'${superTypeAttributeName}'.contains('${typeName}') : false)}""".
- stripMargin.replace(System.getProperty("line.separator"), "")
- }
-
- private def typeTestExpressionMultiStep(typeName : String, intSeq : IntSequence) : Seq[String] = {
-
- val varName = s"_var_${intSeq.next}"
- Seq(
- newSetVar(varName),
- fillVarWithTypeInstances(typeName, varName),
- fillVarWithSubTypeInstances(typeName, varName),
- s"$varName._()"
- )
- }
-
- private def newSetVar(varName : String) = s"$varName = [] as Set"
-
- private def fillVarWithTypeInstances(typeName : String, fillVar : String) = {
- s"""g.V().has("${typeAttributeName}", "${typeName}").fill($fillVar)"""
- }
-
- private def fillVarWithSubTypeInstances(typeName : String, fillVar : String) = {
- s"""g.V().has("${superTypeAttributeName}", "${typeName}").fill($fillVar)"""
- }
-}
-
-object GraphPersistenceStrategy1 extends GraphPersistenceStrategies {
- val typeAttributeName = "typeName"
- val superTypeAttributeName = "superTypeNames"
- val idAttributeName = "guid"
-
- def edgeLabel(dataType: IDataType[_], aInfo: AttributeInfo) = s"${dataType.getName}.${aInfo.name}"
-
- val fieldPrefixInSelect = "it"
-
- def traitLabel(cls: IDataType[_], traitName: String) = s"${cls.getName}.$traitName"
-
- def fieldNameInVertex(dataType: IDataType[_], aInfo: AttributeInfo) = aInfo.name
-
- def getIdFromVertex(dataTypeNm: String, v: TitanVertex): Id =
- new Id(v.getId.toString, 0, dataTypeNm)
-
- def traitNames(v: TitanVertex): java.util.List[String] = {
- val s = v.getProperty[String]("traitNames")
- if (s != null) {
- Seq[String](s.split(","): _*)
- } else {
- Seq()
- }
- }
-
- def constructInstance[U](dataType: IDataType[U], v: AnyRef): U = {
- dataType.getTypeCategory match {
- case DataTypes.TypeCategory.PRIMITIVE => dataType.convert(v, Multiplicity.OPTIONAL)
- case DataTypes.TypeCategory.STRUCT
- if dataType.getName == TypeSystem.getInstance().getIdType.getName => {
- val sType = dataType.asInstanceOf[StructType]
- val sInstance = sType.createInstance()
- val tV = v.asInstanceOf[TitanVertex]
- sInstance.set(TypeSystem.getInstance().getIdType.typeNameAttrName,
- tV.getProperty[java.lang.String](typeAttributeName))
- sInstance.set(TypeSystem.getInstance().getIdType.idAttrName,
- tV.getProperty[java.lang.String](idAttributeName))
- dataType.convert(sInstance, Multiplicity.OPTIONAL)
- }
- case DataTypes.TypeCategory.STRUCT => {
- val sType = dataType.asInstanceOf[StructType]
- val sInstance = sType.createInstance()
- loadStructInstance(sType, sInstance, v.asInstanceOf[TitanVertex])
- dataType.convert(sInstance, Multiplicity.OPTIONAL)
- }
- case DataTypes.TypeCategory.TRAIT => {
- val tType = dataType.asInstanceOf[TraitType]
- val tInstance = tType.createInstance()
- /*
- * this is not right, we should load the Instance associated with this trait.
- * for now just loading the trait struct.
- */
- loadStructInstance(tType, tInstance, v.asInstanceOf[TitanVertex])
- dataType.convert(tInstance, Multiplicity.OPTIONAL)
- }
- case DataTypes.TypeCategory.CLASS => {
- val cType = dataType.asInstanceOf[ClassType]
- val cInstance = constructClassInstance(dataType.asInstanceOf[ClassType], v.asInstanceOf[TitanVertex])
- dataType.convert(cInstance, Multiplicity.OPTIONAL)
- }
- case DataTypes.TypeCategory.ENUM => dataType.convert(v, Multiplicity.OPTIONAL)
- case x => throw new UnsupportedOperationException(s"load for ${dataType} not supported")
- }
- }
-
- def loadStructInstance(dataType: IConstructableType[_, _ <: ITypedInstance],
- typInstance: ITypedInstance, v: TitanVertex): Unit = {
- import scala.collection.JavaConversions._
- dataType.fieldMapping().fields.foreach { t =>
- val fName = t._1
- val aInfo = t._2
- loadAttribute(dataType, aInfo, typInstance, v)
- }
- }
-
- def constructClassInstance(dataType: ClassType, v: TitanVertex): ITypedReferenceableInstance = {
- val id = getIdFromVertex(dataType.name, v)
- val tNms = traitNames(v)
- val cInstance = dataType.createInstance(id, tNms: _*)
- // load traits
- tNms.foreach { tNm =>
- val tLabel = traitLabel(dataType, tNm)
- val edges = v.getEdges(Direction.OUT, tLabel)
- val tVertex = edges.iterator().next().getVertex(Direction.IN).asInstanceOf[TitanVertex]
- val tType = TypeSystem.getInstance().getDataType[TraitType](classOf[TraitType], tNm)
- val tInstance = cInstance.getTrait(tNm).asInstanceOf[ITypedInstance]
- loadStructInstance(tType, tInstance, tVertex)
- }
- loadStructInstance(dataType, cInstance, v)
- cInstance
- }
-
- def loadAttribute(dataType: IDataType[_], aInfo: AttributeInfo, i: ITypedInstance, v: TitanVertex): Unit = {
- aInfo.dataType.getTypeCategory match {
- case DataTypes.TypeCategory.PRIMITIVE => loadPrimitiveAttribute(dataType, aInfo, i, v)
- case DataTypes.TypeCategory.ENUM => loadEnumAttribute(dataType, aInfo, i, v)
- case DataTypes.TypeCategory.ARRAY =>
- throw new UnsupportedOperationException(s"load for ${aInfo.dataType()} not supported")
- case DataTypes.TypeCategory.MAP =>
- throw new UnsupportedOperationException(s"load for ${aInfo.dataType()} not supported")
- case DataTypes.TypeCategory.STRUCT => loadStructAttribute(dataType, aInfo, i, v)
- case DataTypes.TypeCategory.TRAIT =>
- throw new UnsupportedOperationException(s"load for ${aInfo.dataType()} not supported")
- case DataTypes.TypeCategory.CLASS => loadStructAttribute(dataType, aInfo, i, v)
- }
- }
-
- private def loadEnumAttribute(dataType: IDataType[_], aInfo: AttributeInfo, i: ITypedInstance, v: TitanVertex)
- : Unit = {
- val fName = fieldNameInVertex(dataType, aInfo)
- i.setInt(aInfo.name, v.getProperty[java.lang.Integer](fName))
- }
-
- private def loadPrimitiveAttribute(dataType: IDataType[_], aInfo: AttributeInfo,
- i: ITypedInstance, v: TitanVertex): Unit = {
- val fName = fieldNameInVertex(dataType, aInfo)
- aInfo.dataType() match {
- case x: BooleanType => i.setBoolean(aInfo.name, v.getProperty[java.lang.Boolean](fName))
- case x: ByteType => i.setByte(aInfo.name, v.getProperty[java.lang.Byte](fName))
- case x: ShortType => i.setShort(aInfo.name, v.getProperty[java.lang.Short](fName))
- case x: IntType => i.setInt(aInfo.name, v.getProperty[java.lang.Integer](fName))
- case x: LongType => i.setLong(aInfo.name, v.getProperty[java.lang.Long](fName))
- case x: FloatType => i.setFloat(aInfo.name, v.getProperty[java.lang.Float](fName))
- case x: DoubleType => i.setDouble(aInfo.name, v.getProperty[java.lang.Double](fName))
- case x: StringType => i.setString(aInfo.name, v.getProperty[java.lang.String](fName))
- case _ => throw new UnsupportedOperationException(s"load for ${aInfo.dataType()} not supported")
- }
- }
-
- private def loadStructAttribute(dataType: IDataType[_], aInfo: AttributeInfo,
- i: ITypedInstance, v: TitanVertex): Unit = {
- val eLabel = edgeLabel(FieldInfo(dataType, aInfo, null))
- val edges = v.getEdges(Direction.OUT, eLabel)
- val sVertex = edges.iterator().next().getVertex(Direction.IN).asInstanceOf[TitanVertex]
- if (aInfo.dataType().getTypeCategory == DataTypes.TypeCategory.STRUCT) {
- val sType = aInfo.dataType().asInstanceOf[StructType]
- val sInstance = sType.createInstance()
- loadStructInstance(sType, sInstance, sVertex)
- i.set(aInfo.name, sInstance)
- } else {
- val cInstance = constructClassInstance(aInfo.dataType().asInstanceOf[ClassType], sVertex)
- i.set(aInfo.name, cInstance)
- }
- }
-}
-
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/30711973/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinEvaluator.scala
----------------------------------------------------------------------
diff --git a/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinEvaluator.scala b/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinEvaluator.scala
deleted file mode 100755
index 6a77bc3..0000000
--- a/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinEvaluator.scala
+++ /dev/null
@@ -1,139 +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.hadoop.metadata.query
-
-import javax.script.{Bindings, ScriptEngine, ScriptEngineManager}
-
-import com.thinkaurelius.titan.core.TitanGraph
-import com.tinkerpop.pipes.util.structures.Row
-import org.apache.hadoop.metadata.query.TypeUtils.ResultWithPathStruct
-import org.apache.hadoop.metadata.typesystem.json._
-import org.apache.hadoop.metadata.typesystem.types._
-import org.json4s._
-import org.json4s.native.Serialization._
-
-import scala.language.existentials
-
-case class GremlinQueryResult(query: String,
- resultDataType: IDataType[_],
- rows: List[_]) {
- def toJson = JsonHelper.toJson(this)
-}
-
-class GremlinEvaluator(qry: GremlinQuery, persistenceStrategy: GraphPersistenceStrategies, g: TitanGraph) {
-
- val manager: ScriptEngineManager = new ScriptEngineManager
- val engine: ScriptEngine = manager.getEngineByName("gremlin-groovy")
- val bindings: Bindings = engine.createBindings
- bindings.put("g", g)
-
- /**
- *
- * @param gResultObj is the object returned from gremlin. This must be a List
- * @param qryResultObj is the object constructed for the output w/o the Path.
- * @return a ResultWithPathStruct
- */
- def addPathStruct(gResultObj : AnyRef, qryResultObj : Any) : Any = {
- if ( !qry.isPathExpresion) {
- qryResultObj
- } else {
- import scala.collection.JavaConversions._
- import scala.collection.JavaConverters._
- val iPaths = gResultObj.asInstanceOf[java.util.List[AnyRef]].init
-
- val oPaths = iPaths.map { p =>
- persistenceStrategy.constructInstance(TypeSystem.getInstance().getIdType.getStructType, p)
- }.toList.asJava
- val sType = qry.expr.dataType.asInstanceOf[StructType]
- val sInstance = sType.createInstance()
- sInstance.set(ResultWithPathStruct.pathAttrName, oPaths)
- sInstance.set(ResultWithPathStruct.resultAttrName, qryResultObj)
- sInstance
- }
- }
-
- def instanceObject(v : AnyRef) : AnyRef = {
- if ( qry.isPathExpresion ) {
- import scala.collection.JavaConversions._
- v.asInstanceOf[java.util.List[AnyRef]].last
- } else {
- v
- }
- }
-
- def evaluate(): GremlinQueryResult = {
- import scala.collection.JavaConversions._
- val rType = qry.expr.dataType
- val oType = if (qry.isPathExpresion) qry.expr.children(0).dataType else rType
- val rawRes = engine.eval(qry.queryStr, bindings)
-
- if (!qry.hasSelectList) {
- val rows = rawRes.asInstanceOf[java.util.List[AnyRef]].map { v =>
- val iV = instanceObject(v)
- val o = persistenceStrategy.constructInstance(oType, iV)
- addPathStruct(v, o)
- }
- GremlinQueryResult(qry.expr.toString, rType, rows.toList)
- } else {
- val sType = oType.asInstanceOf[StructType]
- val rows = rawRes.asInstanceOf[java.util.List[AnyRef]].map { r =>
- val rV = instanceObject(r).asInstanceOf[Row[java.util.List[AnyRef]]]
- val sInstance = sType.createInstance()
- val selExpr =
- (if (qry.isPathExpresion) qry.expr.children(0) else qry.expr).
- asInstanceOf[Expressions.SelectExpression]
- selExpr.selectListWithAlias.foreach { aE =>
- val cName = aE.alias
- val (src, idx) = qry.resultMaping(cName)
- val v = rV.getColumn(src).get(idx)
- sInstance.set(cName, persistenceStrategy.constructInstance(aE.dataType, v))
- }
- addPathStruct(r, sInstance)
- }
- GremlinQueryResult(qry.expr.toString, rType, rows.toList)
- }
-
- }
-}
-
-object JsonHelper {
-
- class GremlinQueryResultSerializer()
- extends Serializer[GremlinQueryResult] {
- def deserialize(implicit format: Formats) = {
- throw new UnsupportedOperationException("Deserialization of GremlinQueryResult not supported")
- }
-
- def serialize(implicit f: Formats) = {
- case GremlinQueryResult(query, rT, rows) =>
- JObject(JField("query", JString(query)),
- JField("dataType", TypesSerialization.toJsonValue(rT)(f)),
- JField("rows", Extraction.decompose(rows)(f))
- )
- }
- }
-
- implicit val formats = org.json4s.native.Serialization.formats(NoTypeHints) + new TypedStructSerializer +
- new TypedReferenceableInstanceSerializer + new BigDecimalSerializer + new BigIntegerSerializer +
- new GremlinQueryResultSerializer
-
- def toJson(r: GremlinQueryResult): String = {
- writePretty(r)
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/30711973/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinQuery.scala
----------------------------------------------------------------------
diff --git a/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinQuery.scala b/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinQuery.scala
deleted file mode 100755
index 1395f6d..0000000
--- a/repository/src/main/scala/org/apache/hadoop/metadata/query/GremlinQuery.scala
+++ /dev/null
@@ -1,349 +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.hadoop.metadata.query
-
-import org.apache.hadoop.metadata.query.Expressions._
-import org.apache.hadoop.metadata.typesystem.types.DataTypes.TypeCategory
-import org.apache.hadoop.metadata.typesystem.types.TypeSystem
-
-import scala.collection.mutable
-import scala.collection.mutable.ArrayBuffer
-
-trait IntSequence {
- def next: Int
-}
-
-case class GremlinQuery(expr: Expression, queryStr: String, resultMaping: Map[String, (String, Int)]) {
-
- def hasSelectList = resultMaping != null
-
- def isPathExpresion = expr.isInstanceOf[PathExpression]
-}
-
-trait SelectExpressionHandling {
-
- /**
- * To aide in gremlinQuery generation add an alias to the input of SelectExpressions
- */
- class AddAliasToSelectInput extends PartialFunction[Expression, Expression] {
-
- private var idx = 0
-
- def isDefinedAt(e: Expression) = true
-
- class DecorateFieldWithAlias(aliasE: AliasExpression)
- extends PartialFunction[Expression, Expression] {
- def isDefinedAt(e: Expression) = true
-
- def apply(e: Expression) = e match {
- case fe@FieldExpression(fieldName, fInfo, None) =>
- FieldExpression(fieldName, fInfo, Some(BackReference(aliasE.alias, aliasE.child, None)))
- case _ => e
- }
- }
-
- def apply(e: Expression) = e match {
- case SelectExpression(aliasE@AliasExpression(_, _), selList) => {
- idx = idx + 1
- SelectExpression(aliasE, selList.map(_.transformUp(new DecorateFieldWithAlias(aliasE))))
- }
- case SelectExpression(child, selList) => {
- idx = idx + 1
- val aliasE = AliasExpression(child, s"_src$idx")
- SelectExpression(aliasE, selList.map(_.transformUp(new DecorateFieldWithAlias(aliasE))))
- }
- case _ => e
- }
- }
-
- def getSelectExpressionSrc(e: Expression): List[String] = {
- val l = ArrayBuffer[String]()
- e.traverseUp {
- case BackReference(alias, _, _) => l += alias
- }
- l.toSet.toList
- }
-
- def validateSelectExprHaveOneSrc: PartialFunction[Expression, Unit] = {
- case SelectExpression(_, selList) => {
- selList.foreach { se =>
- val srcs = getSelectExpressionSrc(se)
- if (srcs.size > 1) {
- throw new GremlinTranslationException(se, "Only one src allowed in a Select Expression")
- }
- }
- }
- }
-
- def groupSelectExpressionsBySrc(sel: SelectExpression): mutable.LinkedHashMap[String, List[Expression]] = {
- val m = mutable.LinkedHashMap[String, List[Expression]]()
- sel.selectListWithAlias.foreach { se =>
- val l = getSelectExpressionSrc(se.child)
- if (!m.contains(l(0))) {
- m(l(0)) = List()
- }
- m(l(0)) = m(l(0)) :+ se.child
- }
- m
- }
-
- /**
- * For each Output Column in the SelectExpression compute the ArrayList(Src) this maps to and the position within
- * this list.
- * @param sel
- * @return
- */
- def buildResultMapping(sel: SelectExpression): Map[String, (String, Int)] = {
- val srcToExprs = groupSelectExpressionsBySrc(sel)
- val m = new mutable.HashMap[String, (String, Int)]
- sel.selectListWithAlias.foreach { se =>
- val src = getSelectExpressionSrc(se.child)(0)
- val srcExprs = srcToExprs(src)
- var idx = srcExprs.indexOf(se.child)
- m(se.alias) = (src, idx)
- }
- m.toMap
- }
-
-}
-
-class GremlinTranslationException(expr: Expression, reason: String) extends
-ExpressionException(expr, s"Unsupported Gremlin translation: $reason")
-
-class GremlinTranslator(expr: Expression,
- gPersistenceBehavior: GraphPersistenceStrategies)
- extends SelectExpressionHandling {
-
- val preStatements = ArrayBuffer[String]()
- val postStatements = ArrayBuffer[String]()
-
- val wrapAndRule: PartialFunction[Expression, Expression] = {
- case f: FilterExpression if !f.condExpr.isInstanceOf[LogicalExpression] =>
- FilterExpression(f.child, new LogicalExpression("and", List(f.condExpr)))
- }
-
- val validateComparisonForm: PartialFunction[Expression, Unit] = {
- case c@ComparisonExpression(_, left, right) =>
- if (!left.isInstanceOf[FieldExpression]) {
- throw new GremlinTranslationException(c, s"lhs of comparison is not a field")
- }
- if (!right.isInstanceOf[Literal[_]]) {
- throw new GremlinTranslationException(c,
- s"rhs of comparison is not a literal")
- }
- ()
- }
-
- val counter = new IntSequence {
- var i: Int = -1;
-
- def next: Int = {
- i += 1; i
- }
- }
-
- def addAliasToLoopInput(c: IntSequence = counter): PartialFunction[Expression, Expression] = {
- case l@LoopExpression(aliasE@AliasExpression(_, _), _, _) => l
- case l@LoopExpression(inputExpr, loopExpr, t) => {
- val aliasE = AliasExpression(inputExpr, s"_loop${c.next}")
- LoopExpression(aliasE, loopExpr, t)
- }
- }
-
- def instanceClauseToTop(topE : Expression) : PartialFunction[Expression, Expression] = {
- case le : LogicalExpression if (le fastEquals topE) => {
- le.instance()
- }
- case ce : ComparisonExpression if (ce fastEquals topE) => {
- ce.instance()
- }
- case he : hasFieldUnaryExpression if (he fastEquals topE) => {
- he.instance()
- }
- }
-
- def traitClauseWithInstanceForTop(topE : Expression) : PartialFunction[Expression, Expression] = {
- case te : TraitExpression if (te fastEquals topE) => {
- val theTrait = te.as("theTrait")
- val theInstance = theTrait.traitInstance().as("theInstance")
- val outE =
- theInstance.select(id("theTrait").as("traitDetails"),
- id("theInstance").as("instanceInfo"))
- QueryProcessor.validate(outE)
- }
- }
-
- def typeTestExpression(typeName : String) : String = {
- val stats = gPersistenceBehavior.typeTestExpression(typeName, counter)
- preStatements ++= stats.init
- stats.last
- }
-
- private def genQuery(expr: Expression, inSelect: Boolean): String = expr match {
- case ClassExpression(clsName) =>
- typeTestExpression(clsName)
- case TraitExpression(clsName) =>
- typeTestExpression(clsName)
- case fe@FieldExpression(fieldName, fInfo, child) if fe.dataType.getTypeCategory == TypeCategory.PRIMITIVE => {
- val fN = "\"" + gPersistenceBehavior.fieldNameInVertex(fInfo.dataType, fInfo.attrInfo) + "\""
- child match {
- case Some(e) => s"${genQuery(e, inSelect)}.$fN"
- case None => s"$fN"
- }
- }
- case fe@FieldExpression(fieldName, fInfo, child)
- if fe.dataType.getTypeCategory == TypeCategory.CLASS || fe.dataType.getTypeCategory == TypeCategory.STRUCT => {
- val direction = if (fInfo.isReverse) "in" else "out"
- val edgeLbl = gPersistenceBehavior.edgeLabel(fInfo)
- val step = s"""$direction("$edgeLbl")"""
- child match {
- case Some(e) => s"${genQuery(e, inSelect)}.$step"
- case None => step
- }
- }
- case fe@FieldExpression(fieldName, fInfo, child)
- if fInfo.traitName != null => {
- val direction = gPersistenceBehavior.instanceToTraitEdgeDirection
- val edgeLbl = gPersistenceBehavior.edgeLabel(fInfo)
- val step = s"""$direction("$edgeLbl")"""
- child match {
- case Some(e) => s"${genQuery(e, inSelect)}.$step"
- case None => step
- }
- }
- case c@ComparisonExpression(symb, f@FieldExpression(fieldName, fInfo, ch), l) => {
- val fieldGremlinExpr = s"${gPersistenceBehavior.fieldNameInVertex(fInfo.dataType, fInfo.attrInfo)}"
- ch match {
- case Some(child) => {
- s"""${genQuery(child, inSelect)}.has("$fieldGremlinExpr", ${gPersistenceBehavior.gremlinCompOp(c)}, $l)"""
- }
- case None => s"""has("$fieldGremlinExpr", ${gPersistenceBehavior.gremlinCompOp(c)}, $l)"""
- }
- }
- case fil@FilterExpression(child, condExpr) => {
- s"${genQuery(child, inSelect)}.${genQuery(condExpr, inSelect)}"
- }
- case l@LogicalExpression(symb, children) => {
- s"""$symb${children.map("_()." + genQuery(_, inSelect)).mkString("(", ",", ")")}"""
- }
- case sel@SelectExpression(child, selList) => {
- val m = groupSelectExpressionsBySrc(sel)
- var srcNamesList: List[String] = List()
- var srcExprsList: List[List[String]] = List()
- val it = m.iterator
- while (it.hasNext) {
- val (src, selExprs) = it.next
- srcNamesList = srcNamesList :+ s""""$src""""
- srcExprsList = srcExprsList :+ selExprs.map { selExpr =>
- genQuery(selExpr, true)
- }
- }
- val srcNamesString = srcNamesList.mkString("[", ",", "]")
- val srcExprsStringList = srcExprsList.map {
- _.mkString("[", ",", "]")
- }
- val srcExprsString = srcExprsStringList.foldLeft("")(_ + "{" + _ + "}")
- s"${genQuery(child, inSelect)}.select($srcNamesString)$srcExprsString"
- }
- case loop@LoopExpression(input, loopExpr, t) => {
- val inputQry = genQuery(input, inSelect)
- val loopingPathGExpr = genQuery(loopExpr, inSelect)
- val loopGExpr = s"""loop("${input.asInstanceOf[AliasExpression].alias}")"""
- val untilCriteria = if (t.isDefined) s"{it.loops < ${t.get.value}}" else "{true}"
- val loopObjectGExpr = gPersistenceBehavior.loopObjectExpression(input.dataType)
- s"""${inputQry}.${loopingPathGExpr}.${loopGExpr}${untilCriteria}${loopObjectGExpr}"""
- }
- case BackReference(alias, _, _) =>
- if (inSelect) gPersistenceBehavior.fieldPrefixInSelect else s"""back("$alias")"""
- case AliasExpression(child, alias) => s"""${genQuery(child, inSelect)}.as("$alias")"""
- case isTraitLeafExpression(traitName, Some(clsExp)) =>
- s"""out("${gPersistenceBehavior.traitLabel(clsExp.dataType, traitName)}")"""
- case isTraitUnaryExpression(traitName, child) =>
- s"""out("${gPersistenceBehavior.traitLabel(child.dataType, traitName)}")"""
- case hasFieldLeafExpression(fieldName, Some(clsExp)) =>
- s"""has("$fieldName")"""
- case hasFieldUnaryExpression(fieldName, child) =>
- s"""${genQuery(child, inSelect)}.has("$fieldName")"""
- case ArithmeticExpression(symb, left, right) => s"${genQuery(left, inSelect)} $symb ${genQuery(right, inSelect)}"
- case l: Literal[_] => l.toString
- case in@TraitInstanceExpression(child) => {
- val direction = gPersistenceBehavior.traitToInstanceEdgeDirection
- s"${genQuery(child, inSelect)}.$direction()"
- }
- case in@InstanceExpression(child) => {
- s"${genQuery(child, inSelect)}"
- }
- case pe@PathExpression(child) => {
- s"${genQuery(child, inSelect)}.path"
- }
- case x => throw new GremlinTranslationException(x, "expression not yet supported")
- }
-
- def genFullQuery(expr: Expression): String = {
- var q = genQuery(expr, false)
-
- if(gPersistenceBehavior.addGraphVertexPrefix(preStatements)) {
- q = s"g.V.$q"
- }
-
- q = s"$q.toList()"
-
- q = (preStatements ++ Seq(q) ++ postStatements).mkString("", ";", "")
- /*
- * the L:{} represents a groovy code block; the label is needed
- * to distinguish it from a groovy closure.
- */
- s"L:{$q}"
- }
-
- def translate(): GremlinQuery = {
- var e1 = expr.transformUp(wrapAndRule)
-
- e1.traverseUp(validateComparisonForm)
-
- e1 = e1.transformUp(new AddAliasToSelectInput)
- e1.traverseUp(validateSelectExprHaveOneSrc)
- e1 = e1.transformUp(addAliasToLoopInput())
- e1 = e1.transformUp(instanceClauseToTop(e1))
- e1 = e1.transformUp(traitClauseWithInstanceForTop(e1))
-
- e1 match {
- case e1: SelectExpression => {
- val rMap = buildResultMapping(e1)
- GremlinQuery(e1, genFullQuery(e1), rMap)
- }
- case pe@PathExpression(se@SelectExpression(child, selectList)) => {
- val rMap = buildResultMapping(se)
- GremlinQuery(e1, genFullQuery(e1), rMap)
- }
- case e1 => GremlinQuery(e1, genFullQuery(e1), null)
- }
-
- }
-
- /*
- * Translation Issues:
- * 1. back references in filters. For e.g. testBackreference: 'DB as db Table where (db.name = "Reporting")'
- * this is translated to:
- * g.V.has("typeName","DB").as("db").in("Table.db").and(_().back("db").has("name", T.eq, "Reporting")).map().toList()
- * But the '_().back("db") within the and is ignored, the has condition is applied on the current element.
- * The solution is to to do predicate pushdown and apply the filter immediately on top of the referred Expression.
- */
-
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/30711973/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryParser.scala
----------------------------------------------------------------------
diff --git a/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryParser.scala b/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryParser.scala
deleted file mode 100755
index 66628c0..0000000
--- a/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryParser.scala
+++ /dev/null
@@ -1,398 +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.hadoop.metadata.query
-
-import org.apache.hadoop.metadata.query.Expressions._
-
-import scala.util.parsing.combinator.lexical.StdLexical
-import scala.util.parsing.combinator.syntactical.StandardTokenParsers
-import scala.util.parsing.combinator.{ImplicitConversions, PackratParsers}
-import scala.util.parsing.input.CharArrayReader._
-
-trait QueryKeywords {
- this: StandardTokenParsers =>
-
- import scala.language.implicitConversions
-
- protected case class Keyword(str: String)
-
- protected implicit def asParser(k: Keyword): Parser[String] = k.str
-
- protected val LPAREN = Keyword("(")
- protected val RPAREN = Keyword(")")
- protected val EQ = Keyword("=")
- protected val LT = Keyword("<")
- protected val GT = Keyword(">")
- protected val NEQ = Keyword("!=")
- protected val LTE = Keyword("<=")
- protected val GTE = Keyword(">=")
- protected val COMMA = Keyword(",")
- protected val AND = Keyword("and")
- protected val OR = Keyword("or")
- protected val PLUS = Keyword("+")
- protected val MINUS = Keyword("-")
- protected val STAR = Keyword("*")
- protected val DIV = Keyword("/")
- protected val DOT = Keyword(".")
-
- protected val SELECT = Keyword("select")
- protected val FROM = Keyword("from")
- protected val WHERE = Keyword("where")
- protected val GROUPBY = Keyword("groupby")
- protected val LOOP = Keyword("loop")
- protected val ISA = Keyword("isa")
- protected val IS = Keyword("is")
- protected val HAS = Keyword("has")
- protected val AS = Keyword("as")
- protected val TIMES = Keyword("times")
- protected val WITHPATH = Keyword("withPath")
-}
-
-trait ExpressionUtils {
-
- def loop(input: Expression, l: (Expression, Option[Literal[Integer]], Option[String])) = l match {
- case (c, None, None) => input.loop(c)
- case (c, t, None) => input.loop(c, t.get)
- case (c, None, Some(a)) => input.loop(c).as(a)
- case (c, t, Some(a)) => input.loop(c, t.get).as(a)
- }
-
- def select(input: Expression, s: List[(Expression, Option[String])]) = {
- val selList = s.map { t =>
- t._2 match {
- case None => t._1
- case _ => t._1.as(t._2.get)
- }
- }
- input.select(selList: _*)
- }
-
- def leftmostId(e: Expression) = {
- var le: IdExpression = null
- e.traverseUp { case i: IdExpression if le == null => le = i}
- le
- }
-
- def notIdExpression = new PartialFunction[Expression, Expression] {
- def isDefinedAt(x: Expression): Boolean = !x.isInstanceOf[IdExpression]
-
- def apply(e: Expression) = e
- }
-
- def replaceIdWithField(id: IdExpression, fe: UnresolvedFieldExpression): PartialFunction[Expression, Expression] = {
- case e: IdExpression if e == id => fe
- }
-
- def merge(snglQuery1: Expression, sngQuery2: Expression): Expression = {
- val leftSrcId = leftmostId(sngQuery2)
- sngQuery2.transformUp(replaceIdWithField(leftSrcId, snglQuery1.field(leftSrcId.name)))
- }
-}
-
-class QueryParser extends StandardTokenParsers with QueryKeywords with ExpressionUtils with PackratParsers {
-
- import scala.language.higherKinds
-
- private val reservedWordsDelims: Seq[String] = this.
- getClass.getMethods.filter(_.getReturnType == classOf[Keyword]).map(_.invoke(this).asInstanceOf[Keyword].str)
-
- private val (queryreservedWords: Seq[String], querydelims: Seq[String]) =
- reservedWordsDelims.partition(s => s.charAt(0).isLetter)
-
- override val lexical = new QueryLexer(queryreservedWords, querydelims)
-
- def apply(input: String): Either[NoSuccess, Expression] = {
- phrase(queryWithPath)(new lexical.Scanner(input)) match {
- case Success(r, x) => Right(r)
- case f@Failure(m, x) => Left(f)
- case e@Error(m, x) => Left(e)
- }
- }
-
- def queryWithPath = query ~ opt(WITHPATH) ^^ {
- case q ~ None => q
- case q ~ p => q.path()
- }
-
- def query: Parser[Expression] = rep1sep(singleQuery, opt(COMMA)) ^^ { l => l match {
- case h :: Nil => h
- case h :: t => t.foldLeft(h)(merge(_, _))
- }
- }
-
- def singleQuery = singleQrySrc ~ opt(loopExpression) ~ opt(selectClause) ^^ {
- case s ~ None ~ None => s
- case s ~ l ~ None => loop(s, l.get)
- case s ~ l ~ sel if l.isDefined => select(loop(s, l.get), sel.get)
- case s ~ None ~ sel => select(s, sel.get)
- }
-
- /**
- * A SingleQuerySrc can have the following forms:
- * 1. FROM id [WHERE] [expr] -> from optionally followed by a filter
- * 2. WHERE expr -> where clause, FROM is assumed to be the leftmost Id in the where clause
- * 3. expr (that is not an IdExpression) -> where clause, FROM is assumed to be the leftmost Id in the expr
- * 4. Id [WHERE] [expr] -> from optionally followed by a filter
- *
- * @return
- */
- def singleQrySrc: Parser[Expression] = FROM ~ fromSrc ~ opt(WHERE) ~ opt(expr ^? notIdExpression) ^^ {
- case f ~ i ~ w ~ None => i
- case f ~ i ~ w ~ c => i.where(c.get)
- } |
- WHERE ~ (expr ^? notIdExpression) ^^ { case w ~ e => {
- val lId = leftmostId(e)
- if (lId == null) {
- failure("cannot infer Input from the where clause")
- }
- lId.where(e)
- }
- } |
- expr ^? notIdExpression ^^ { case e => {
- val lId = leftmostId(e)
- if (lId == null) {
- failure("cannot infer Input from the where clause")
- }
- lId.where(e)
- }
- } |
- fromSrc ~ opt(WHERE) ~ opt(expr ^? notIdExpression) ^^ {
- case i ~ w ~ None => i
- case i ~ w ~ c => i.where(c.get)
- }
-
- def fromSrc = identifier ~ AS ~ alias ^^ { case s ~ a ~ al => s.as(al)} |
- identifier
-
-
- def loopExpression: Parser[(Expression, Option[Literal[Integer]], Option[String])] =
- LOOP ~ (LPAREN ~> query <~ RPAREN) ~ opt(intConstant <~ TIMES) ~ opt(AS ~> alias) ^^ {
- case l ~ e ~ None ~ a => (e, None, a)
- case l ~ e ~ Some(i) ~ a => (e, Some(int(i)), a)
- }
-
- def selectClause: Parser[List[(Expression, Option[String])]] = SELECT ~ rep1sep(selectExpression, COMMA) ^^ {
- case s ~ cs => cs
- }
-
- def selectExpression: Parser[(Expression, Option[String])] = expr ~ opt(AS ~> alias) ^^ {
- case e ~ a => (e, a)
- }
-
- def expr: Parser[Expression] = compE ~ opt(rep(exprRight)) ^^ {
- case l ~ None => l
- case l ~ Some(r) => r.foldLeft(l) { (l, r) => l.logicalOp(r._1)(r._2)}
- }
-
- def exprRight = (AND | OR) ~ compE ^^ { case op ~ c => (op, c)}
-
- def compE =
- arithE ~ (LT | LTE | EQ | NEQ | GT | GTE) ~ arithE ^^ { case l ~ op ~ r => l.compareOp(op)(r)} |
- arithE ~ (ISA | IS) ~ ident ^^ { case l ~ i ~ t => l.isTrait(t)} |
- arithE ~ HAS ~ ident ^^ { case l ~ i ~ f => l.hasField(f)} |
- arithE
-
- def arithE = multiE ~ opt(rep(arithERight)) ^^ {
- case l ~ None => l
- case l ~ Some(r) => r.foldLeft(l) { (l, r) => l.arith(r._1)(r._2)}
- }
-
- def arithERight = (PLUS | MINUS) ~ multiE ^^ { case op ~ r => (op, r)}
-
- def multiE = atomE ~ opt(rep(multiERight)) ^^ {
- case l ~ None => l
- case l ~ Some(r) => r.foldLeft(l) { (l, r) => l.arith(r._1)(r._2)}
- }
-
- def multiERight = (STAR | DIV) ~ atomE ^^ { case op ~ r => (op, r)}
-
-
- def atomE = literal | identifier | LPAREN ~> expr <~ RPAREN
-
- def identifier = rep1sep(ident, DOT) ^^ { l => l match {
- case h :: Nil => id(h)
- case h :: t => {
- t.foldLeft(id(h).asInstanceOf[Expression])(_.field(_))
- }
- }
- }
-
- def alias = ident | stringLit
-
- def literal = booleanConstant ^^ {
- boolean(_)
- } |
- intConstant ^^ {
- int(_)
- } |
- longConstant ^^ {
- long(_)
- } |
- floatConstant ^^ {
- float(_)
- } |
- doubleConstant ^^ {
- double(_)
- } |
- stringLit ^^ {
- string(_)
- }
-
- def booleanConstant: Parser[String] =
- elem("int", _.isInstanceOf[lexical.BooleanLiteral]) ^^ (_.chars)
-
- def intConstant: Parser[String] =
- elem("int", _.isInstanceOf[lexical.IntLiteral]) ^^ (_.chars)
-
- def longConstant: Parser[String] =
- elem("int", _.isInstanceOf[lexical.LongLiteral]) ^^ (_.chars)
-
- def floatConstant: Parser[String] =
- elem("int", _.isInstanceOf[lexical.FloatLiteral]) ^^ (_.chars)
-
- def doubleConstant: Parser[String] =
- elem("int", _.isInstanceOf[lexical.DoubleLiteral]) ^^ (_.chars)
-
-}
-
-class QueryLexer(val keywords: Seq[String], val delims: Seq[String]) extends StdLexical with ImplicitConversions {
-
- case class BooleanLiteral(chars: String) extends Token {
- override def toString = chars
- }
-
- case class IntLiteral(chars: String) extends Token {
- override def toString = chars
- }
-
- case class LongLiteral(chars: String) extends Token {
- override def toString = chars
- }
-
- case class FloatLiteral(chars: String) extends Token {
- override def toString = chars
- }
-
- case class DoubleLiteral(chars: String) extends Token {
- override def toString = chars
- }
-
- reserved ++= keywords.flatMap(w => allCaseVersions(w))
-
- delimiters ++= delims
-
- override lazy val token: Parser[Token] =
- (
- (trueP | falseP)
- | longConstant ^^ LongLiteral
- | intConstant ^^ IntLiteral
- | floatConstant ^^ FloatLiteral
- | dubConstant ^^ DoubleLiteral
- | identifier ^^ processIdent
- | string ^^ StringLit
- | EofCh ^^^ EOF
- | '\'' ~> failure("unclosed string literal")
- | '"' ~> failure("unclosed string literal")
- | delim
- | '.' ^^^ new Keyword(".")
- | failure("illegal character")
- )
-
- override def identChar = letter | elem('_')
-
- def identifier = identChar ~ (identChar | digit).* ^^ { case first ~ rest => (first :: rest).mkString} |
- '`' ~> chrExcept('`', '\n', EofCh).* <~ '`' ^^ {
- _ mkString ""
- }
-
- override def whitespace: Parser[Any] =
- (whitespaceChar
- | '/' ~ '*' ~ comment
- | '/' ~ '/' ~ chrExcept(EofCh, '\n').*
- | '#' ~ chrExcept(EofCh, '\n').*
- | '/' ~ '*' ~ failure("unclosed comment")
- ).*
-
- protected override def comment: Parser[Any] = (
- commentChar.* ~ '*' ~ '/'
- )
-
- protected def commentChar = chrExcept(EofCh, '*') | '*' ~ not('/')
-
- def string = '\"' ~> chrExcept('\"', '\n', EofCh).* <~ '\"' ^^ {
- _ mkString ""
- } |
- '\'' ~> chrExcept('\'', '\n', EofCh).* <~ '\'' ^^ {
- _ mkString ""
- }
-
- def zero: Parser[String] = '0' ^^^ "0"
-
- def nonzero = elem("nonzero digit", d => d.isDigit && d != '0')
-
- def sign = elem("sign character", d => d == '-' || d == '+')
-
- def exponent = elem("exponent character", d => d == 'e' || d == 'E')
-
-
- def intConstant = opt(sign) ~> zero | intList
-
- def intList = opt(sign) ~ nonzero ~ rep(digit) ^^ { case s ~ x ~ y => (optString("", s) :: x :: y) mkString ""}
-
- def fracPart: Parser[String] = '.' ~> rep(digit) ^^ { r =>
- "." + (r mkString "")
- }
-
- def expPart = exponent ~ opt(sign) ~ rep1(digit) ^^ { case e ~ s ~ d =>
- e.toString + optString("", s) + d.mkString("")
- }
-
- def dubConstant = opt(sign) ~ digit.+ ~ fracPart ~ opt(expPart) ^^ {
- case s ~ i ~ f ~ e => {
- optString("", s) + (i mkString "") + f + optString("", e)
- }
- }
-
- def floatConstant = opt(sign) ~ digit.* ~ fracPart ~ 'f' ^^ { case s ~ i ~ fr ~ f =>
- optString("", s) + i + fr
- } | opt(sign) ~ digit.+ ~ opt(fracPart) ~ 'f' ^^ { case s ~ i ~ fr ~ f =>
- optString("", s) + i + optString("", fr)
- }
-
- def longConstant = intConstant ~ 'l' ^^ { case i ~ l => i}
-
- def trueP = 't' ~ 'r' ~ 'u' ~ 'e' ^^^ BooleanLiteral("true")
-
- def falseP = 'f' ~ 'a' ~ 'l' ~ 's' ~ 'e' ^^^ BooleanLiteral("false")
-
- private def optString[A](pre: String, a: Option[A]) = a match {
- case Some(x) => pre + x.toString
- case None => ""
- }
-
- /** Generate all variations of upper and lower case of a given string */
- def allCaseVersions(s: String, prefix: String = ""): Stream[String] = {
- if (s.isEmpty) {
- Stream(prefix)
- } else {
- allCaseVersions(s.tail, prefix + s.head.toLower) #:::
- allCaseVersions(s.tail, prefix + s.head.toUpper)
- }
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/30711973/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryProcessor.scala
----------------------------------------------------------------------
diff --git a/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryProcessor.scala b/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryProcessor.scala
deleted file mode 100755
index 538fe04..0000000
--- a/repository/src/main/scala/org/apache/hadoop/metadata/query/QueryProcessor.scala
+++ /dev/null
@@ -1,61 +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.hadoop.metadata.query
-
-import com.thinkaurelius.titan.core.TitanGraph
-import org.apache.hadoop.metadata.query.Expressions._
-import org.slf4j.{LoggerFactory, Logger}
-
-object QueryProcessor {
- val LOG : Logger = LoggerFactory.getLogger("org.apache.hadoop.metadata.query.QueryProcessor")
-
- def evaluate(e: Expression, g: TitanGraph, gP : GraphPersistenceStrategies = GraphPersistenceStrategy1):
- GremlinQueryResult = {
- val e1 = validate(e)
- val q = new GremlinTranslator(e1, gP).translate()
- LOG.debug("Query: " + e1)
- LOG.debug("Expression Tree:\n" + e1.treeString)
- LOG.debug("Gremlin Query: " + q.queryStr)
- new GremlinEvaluator(q, gP, g).evaluate()
- }
-
- def validate(e: Expression): Expression = {
- val e1 = e.transformUp(new Resolver())
-
- e1.traverseUp {
- case x: Expression if !x.resolved =>
- throw new ExpressionException(x, s"Failed to resolved expression $x")
- }
-
- /*
- * trigger computation of dataType of expression tree
- */
- e1.dataType
-
- /*
- * ensure fieldReferences match the input expression's dataType
- */
- val e2 = e1.transformUp(FieldValidator)
- val e3 = e2.transformUp(new Resolver())
-
- e3.dataType
-
- e3
- }
-}