address PR comments

Author: imback82

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/package.scala

@@ -153,11 +153,11 @@ package object expressions  {
     }
 
     /** Returns true if all qualifiers in `attrs` have 2 or less parts. */
-    @transient private val hasTwoOrLessPartQualifiers: Boolean =
+    @transient private val hasTwoOrLessQualifierParts: Boolean =
       attrs.forall(_.qualifier.length <= 2)
 
     /** Match attributes for the case where all qualifiers in `attrs` have 2 or less parts. */
-    private def matchWithTwoOrLessPartQualifiers(
+    private def matchWithTwoOrLessQualifierParts(
         nameParts: Seq[String],
         resolver: Resolver): (Seq[Attribute], Seq[String]) = {
       // Collect matching attributes given a name and a lookup.
@@ -221,7 +221,7 @@ package object expressions  {
     /**
      * Match attributes for the case where at least one qualifier in `attrs` has more than 2 parts.
      */
-    private def matchWithThreeOrMorePartQualifiers(
+    private def matchWithThreeOrMoreQualifierParts(
         nameParts: Seq[String],
         resolver: Resolver): (Seq[Attribute], Seq[String]) = {
       // Returns true if the `short` qualifier is a subset of the last elements of
@@ -277,10 +277,10 @@ package object expressions  {
 
     /** Perform attribute resolution given a name and a resolver. */
     def resolve(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression] = {
-      val (candidates, nestedFields) = if (hasTwoOrLessPartQualifiers) {
-        matchWithTwoOrLessPartQualifiers(nameParts, resolver)
+      val (candidates, nestedFields) = if (hasTwoOrLessQualifierParts) {
+        matchWithTwoOrLessQualifierParts(nameParts, resolver)
       } else {
-        matchWithThreeOrMorePartQualifiers(nameParts, resolver)
+        matchWithThreeOrMoreQualifierParts(nameParts, resolver)
       }
 
       def name = UnresolvedAttribute(nameParts).name

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/AttributeResolutionSuite.scala

@@ -38,13 +38,28 @@ class AttributeResolutionSuite extends SparkFunSuite {
       }
     }
 
-    // Non-matching cases.
+    // Non-matching cases
     Seq(Seq("ns1", "ns2", "t1"), Seq("ns2", "a")).foreach { nameParts =>
-      val resolved = attrs.resolve(nameParts, resolver)
-      assert(resolved.isEmpty)
+      assert(attrs.resolve(nameParts, resolver).isEmpty)
     }
   }
 
+  test("attribute resolution where table and attribute names are the same") {
+    val attrs = Seq(AttributeReference("t", IntegerType)(qualifier = Seq("ns1", "ns2", "t")))
+    // Matching cases
+    Seq(
+      Seq("t"), Seq("t", "t"), Seq("ns2", "t", "t"), Seq("ns1", "ns2", "t", "t")
+    ).foreach { nameParts =>
+      attrs.resolve(nameParts, resolver) match {
+        case Some(attr) => assert(attr.semanticEquals(attrs(0)))
+        case _ => fail()
+      }
+    }
+
+    // Non-matching case
+    assert(attrs.resolve(Seq("ns1", "ns2", "t"), resolver).isEmpty)
+  }
+
   test("attribute resolution ambiguity at the attribute name level") {
     val attrs = Seq(
       AttributeReference("a", IntegerType)(qualifier = Seq("ns1", "t1")),