simplified toStrings, fix issues exposed with fieldValidator in play

typesystem/src/main/scala/org/apache/hadoop/metadata/query/Expressions.scala

@@ -249,6 +249,7 @@ object Expressions {
       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(", ")
 

typesystem/src/main/scala/org/apache/hadoop/metadata/query/GremlinQuery.scala

@@ -53,7 +53,10 @@ trait SelectExpressionHandling {
     }
 
     def apply(e: Expression) = e match {
-      case SelectExpression(_: AliasExpression, _) => e
+      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")

typesystem/src/main/scala/org/apache/hadoop/metadata/query/Resolver.scala

@@ -85,18 +85,20 @@ object FieldValidator extends PartialFunction[Expression, Expression] {
 
   def isDefinedAt(x: Expression) = true
 
+  def isSrc(e : Expression) = e.isInstanceOf[ClassExpression] || e.isInstanceOf[TraitExpression]
+
   def validateQualifiedField(srcDataType : IDataType[_]) : PartialFunction[Expression, Expression] = {
-    case FieldExpression(fNm, fInfo, Some(child)) if child.children == Nil && child.dataType == srcDataType =>
+    case FieldExpression(fNm, fInfo, Some(child)) if (child.children == Nil && child.dataType == srcDataType) =>
       FieldExpression(fNm, fInfo, None)
-    case fe@FieldExpression(fNm, fInfo, Some(child)) if child.children == Nil =>
+    case fe@FieldExpression(fNm, fInfo, Some(child)) if isSrc(child) =>
       throw new ExpressionException(fe, s"srcType of field doesn't match input type")
     case hasFieldUnaryExpression(fNm, child) if child.dataType == srcDataType =>
       hasFieldLeafExpression(fNm)
-    case hF@hasFieldUnaryExpression(fNm, child) =>
+    case hF@hasFieldUnaryExpression(fNm, child) if isSrc(child) =>
       throw new ExpressionException(hF, s"srcType of field doesn't match input type")
     case isTraitUnaryExpression(fNm, child) if child.dataType == srcDataType =>
       isTraitLeafExpression(fNm)
-    case iT@isTraitUnaryExpression(fNm, child) =>
+    case iT@isTraitUnaryExpression(fNm, child) if isSrc(child) =>
       throw new ExpressionException(iT, s"srcType of field doesn't match input type")
   }
 

typesystem/src/main/scala/org/apache/hadoop/metadata/query/TypeUtils.scala

@@ -79,6 +79,13 @@ object TypeUtils {
   import scala.language.existentials
   case class FieldInfo(dataType : IDataType[_], attrInfo : AttributeInfo, reverseDataType : IDataType[_] = null) {
     def isReverse = reverseDataType != null
+    override  def toString : String = {
+      if ( reverseDataType == null ) {
+        s"""FieldInfo("${dataType.getName}", "${attrInfo.name}")"""
+      } else {
+        s"""FieldInfo("${dataType.getName}", "${attrInfo.name}", "${reverseDataType.getName}")"""
+      }
+    }
   }
 
   /**

typesystem/src/test/scala/org/apache/hadoop/metadata/query/ExpressionTest.scala

@@ -109,7 +109,7 @@ class ExpressionTest extends BaseTest {
 
   @Test def testBackReference: Unit = {
     val e = QueryProcessor.validate(
-      _class("DB").as("db").field("Table").where(id("db").field("name").`=`(string("Reporting"))))
+      _class("DB").as("db1").field("Table").where(id("db1").field("name").`=`(string("Reporting"))))
     println(e)
   }
 
@@ -127,8 +127,8 @@ class ExpressionTest extends BaseTest {
 
   @Test def testJoinAndSelect1: Unit = {
     val e = QueryProcessor.validate(
-      _class("DB").as("db").field("Table").as("tab").where((id("db").field("createTime") + int(1) > int(0))
-        .and(id("db").field("name").`=`(string("Reporting")))).select(id("db").field("name").as("dbName"),
+      _class("DB").as("db1").field("Table").as("tab").where((id("db1").field("createTime") + int(1) > int(0))
+        .and(id("db1").field("name").`=`(string("Reporting")))).select(id("db1").field("name").as("dbName"),
           id("tab").field("name").as("tabName"))
     )
     println(e)
@@ -136,31 +136,31 @@ class ExpressionTest extends BaseTest {
 
   @Test def testJoinAndSelect2: Unit = {
     val e = QueryProcessor.validate(
-      _class("DB").as("db").field("Table").as("tab").where((id("db").field("createTime") + int(1) > int(0))
-        .or(id("db").field("name").`=`(string("Reporting"))))
-        .select(id("db").field("name").as("dbName"), id("tab").field("name").as("tabName"))
+      _class("DB").as("db1").field("Table").as("tab").where((id("db1").field("createTime") + int(1) > int(0))
+        .or(id("db1").field("name").`=`(string("Reporting"))))
+        .select(id("db1").field("name").as("dbName"), id("tab").field("name").as("tabName"))
     )
     println(e)
   }
 
   @Test def testJoinAndSelect3: Unit = {
     val e = QueryProcessor.validate(
-      _class("DB").as("db").field("Table").as("tab").where((id("db").field("createTime") + int(1) > int(0))
-        .and(id("db").field("name").`=`(string("Reporting")))
-        .or(id("db").hasField("owner")))
-        .select(id("db").field("name").as("dbName"), id("tab").field("name").as("tabName"))
+      _class("DB").as("db1").field("Table").as("tab").where((id("db1").field("createTime") + int(1) > int(0))
+        .and(id("db1").field("name").`=`(string("Reporting")))
+        .or(id("db1").hasField("owner")))
+        .select(id("db1").field("name").as("dbName"), id("tab").field("name").as("tabName"))
     )
     println(e)
   }
 
   @Test def testJoinAndSelect4: Unit = {
     val e = QueryProcessor.validate(
-      _class("DB") as "db" join "Table" as "tab" where (
-        id("db").field("createTime") + int(1) > int(0) and
-        ( id("db") `.` "name" `=` string("Reporting") ) or
-        ( id("db") hasField "owner" )
+      _class("DB") as "db1" join "Table" as "tab" where (
+        id("db1").field("createTime") + int(1) > int(0) and
+        ( id("db1") `.` "name" `=` string("Reporting") ) or
+        ( id("db1") hasField "owner" )
       ) select (
-        id("db") `.` "name" as "dbName", id("tab") `.` "name" as "tabName"
+        id("db1") `.` "name" as "dbName", id("tab") `.` "name" as "tabName"
       )
     )
     println(e)