[SPARK-22333][SQL]timeFunctionCall(CURRENT_DATE, CURRENT_TIMESTAMP) has conflicts with columnReference

sql/catalyst/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBase.g4

@@ -564,8 +564,7 @@ valueExpression
     ;
 
 primaryExpression
-    : name=(CURRENT_DATE | CURRENT_TIMESTAMP)                                                  #timeFunctionCall
-    | CASE whenClause+ (ELSE elseExpression=expression)? END                                   #searchedCase
+    : CASE whenClause+ (ELSE elseExpression=expression)? END                                   #searchedCase
     | CASE value=expression whenClause+ (ELSE elseExpression=expression)? END                  #simpleCase
     | CAST '(' expression AS dataType ')'                                                      #cast
     | STRUCT '(' (argument+=namedExpression (',' argument+=namedExpression)*)? ')'             #struct
@@ -747,7 +746,7 @@ nonReserved
     | NULL | ORDER | OUTER | TABLE | TRUE | WITH | RLIKE
     | AND | CASE | CAST | DISTINCT | DIV | ELSE | END | FUNCTION | INTERVAL | MACRO | OR | STRATIFY | THEN
     | UNBOUNDED | WHEN
-    | DATABASE | SELECT | FROM | WHERE | HAVING | TO | TABLE | WITH | NOT | CURRENT_DATE | CURRENT_TIMESTAMP
+    | DATABASE | SELECT | FROM | WHERE | HAVING | TO | TABLE | WITH | NOT
     | DIRECTORY
     | BOTH | LEADING | TRAILING
     ;
@@ -983,8 +982,6 @@ OPTION: 'OPTION';
 ANTI: 'ANTI';
 LOCAL: 'LOCAL';
 INPATH: 'INPATH';
-CURRENT_DATE: 'CURRENT_DATE';
-CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP';
 
 STRING
     : '\'' ( ~('\''|'\\') | ('\\' .) )* '\''

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

@@ -783,6 +783,25 @@ class Analyzer(
       }
     }
 
+    /**
+     * Literal functions do not require the user to specify braces when calling them
+     * When an attributes is not resolvable, we try to resolve it as a literal function.
+     */
+    private def resolveAsLiteralFunctions(nameParts: Seq[String]): Option[NamedExpression] = {
+      if (nameParts.length != 1) {
+        return None
+      }
+      // support CURRENT_DATE and CURRENT_TIMESTAMP
+      val literalFunctions = Seq(CurrentDate(), CurrentTimestamp())
+      val name = nameParts.head
+      val func = literalFunctions.find(e => resolver(e.prettyName, name))
+      if (func.isDefined) {
+        Some(Alias(func.get, toPrettySQL(func.get))())
+      } else {
+        None
+      }
+    }
+
     def apply(plan: LogicalPlan): LogicalPlan = plan.resolveOperators {
       case p: LogicalPlan if !p.childrenResolved => p
 
@@ -844,7 +863,12 @@ class Analyzer(
         q.transformExpressionsUp  {
           case u @ UnresolvedAttribute(nameParts) =>
             // Leave unchanged if resolution fails. Hopefully will be resolved next round.
-            val result = withPosition(u) { q.resolveChildren(nameParts, resolver).getOrElse(u) }
+            val result =
+              withPosition(u) {
+                q.resolveChildren(nameParts, resolver).getOrElse {
+                  resolveAsLiteralFunctions(nameParts).getOrElse(u)
+                }
+              }
             logDebug(s"Resolving $u to $result")
             result
           case UnresolvedExtractValue(child, fieldExpr) if child.resolved =>

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala

@@ -1234,19 +1234,6 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging
     }
   }
 
-  /**
-   * Create a current timestamp/date expression. These are different from regular function because
-   * they do not require the user to specify braces when calling them.
-   */
-  override def visitTimeFunctionCall(ctx: TimeFunctionCallContext): Expression = withOrigin(ctx) {
-    ctx.name.getType match {
-      case SqlBaseParser.CURRENT_DATE =>
-        CurrentDate()
-      case SqlBaseParser.CURRENT_TIMESTAMP =>
-        CurrentTimestamp()
-    }
-  }
-
   /**
    * Create a function database (optional) and name pair.
    */

sql/core/src/test/resources/sql-tests/results/datetime.sql.out

@@ -5,7 +5,7 @@
 -- !query 0
 select current_date = current_date(), current_timestamp = current_timestamp()
 -- !query 0 schema
-struct<(current_date() = current_date()):boolean,(current_timestamp() = current_timestamp()):boolean>
+struct<(current_date() AS `current_date()` = current_date()):boolean,(current_timestamp() AS `current_timestamp()` = current_timestamp()):boolean>
 -- !query 0 output
 true	true
 

sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala

@@ -56,6 +56,24 @@ class DateFunctionsSuite extends QueryTest with SharedSQLContext {
     checkAnswer(sql("""SELECT CURRENT_TIMESTAMP() = NOW()"""), Row(true))
   }
 
+  test("SPARK-22333: timeFunctionCall has conflicts with columnReference ") {
+    val df = Seq((1, 2), (2, 3)).toDF("current_date", "current_timestamp")
+    df.createOrReplaceTempView("ttf")
+    withTempView("ttf") {
+      checkAnswer(sql("SELECT current_date, current_timestamp FROM ttf"),
+        Seq(Row(1, 2), Row(2, 3)))
+    }
+
+    val df1 = Seq((1, 2), (2, 3)).toDF("a", "b")
+    df1.createOrReplaceTempView("ttf1")
+    withTempView("ttf1") {
+      checkAnswer(
+        sql("SELECT current_date = current_date(), current_timestamp = current_timestamp(), " +
+          "a, b FROM ttf1"),
+        Seq(Row(true, true, 1, 2), Row(true, true, 2, 3)))
+    }
+  }
+
   val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US)
   val sdfDate = new SimpleDateFormat("yyyy-MM-dd", Locale.US)
   val d = new Date(sdf.parse("2015-04-08 13:10:15").getTime)