Address comments and fix bug.

Author: viirya

sql/core/src/main/scala/org/apache/spark/sql/execution/SparkQl.scala

@@ -50,39 +50,42 @@ private[sql] class SparkQl(conf: ParserConf = SimpleParserConf()) extends Cataly
         RefreshTable(tableIdent)
 
       case Token("TOK_CREATETABLEUSING", createTableArgs) =>
-        val clauses = getClauses(
-            Seq("TEMPORARY", "TOK_IFNOTEXISTS", "TOK_TABNAME", "TOK_TABCOLLIST",
-              "TOK_TABLEPROVIDER", "TOK_TABLEOPTIONS", "TOK_QUERY"), createTableArgs)
-
-        val temp = clauses(0)
-        val allowExisting = clauses(1)
-        val Some(tabName) = clauses(2)
-        val tableCols = clauses(3)
-        val Some(tableProvider) = clauses(4)
-        val tableOpts = clauses(5)
-        val tableAs = clauses(6)
+        val Seq(
+          temp,
+          allowExisting,
+          Some(tabName),
+          tableCols,
+          Some(Token("TOK_TABLEPROVIDER", providerNameParts)),
+          tableOpts,
+          tableAs) = getClauses(Seq(
+          "TEMPORARY",
+          "TOK_IFNOTEXISTS",
+          "TOK_TABNAME", "TOK_TABCOLLIST",
+          "TOK_TABLEPROVIDER",
+          "TOK_TABLEOPTIONS",
+          "TOK_QUERY"), createTableArgs)
 
         val tableIdent: TableIdentifier = tabName match {
           case Token("TOK_TABNAME", Token(dbName, _) :: Token(tableName, _) :: Nil) =>
-            new TableIdentifier(tableName, Some(dbName))
+            new TableIdentifier(cleanIdentifier(tableName), Some(cleanIdentifier(dbName)))
           case Token("TOK_TABNAME", Token(tableName, _) :: Nil) =>
-            TableIdentifier(tableName)
+            TableIdentifier(cleanIdentifier(tableName))
         }
 
         val columns = tableCols.map {
           case Token("TOK_TABCOLLIST", fields) => StructType(fields.map(nodeToStructField))
         }
 
-        val provider = tableProvider match {
-          case Token("TOK_TABLEPROVIDER", Token(provider, _) :: Nil) => provider
-        }
+        val provider = providerNameParts.map {
+          case Token(name, _) => name
+        }.mkString(".")
 
         val options = tableOpts.map { opts =>
           opts match {
             case Token("TOK_TABLEOPTIONS", options) =>
               options.map {
                 case Token("TOK_TABLEOPTION", Token(key, _) :: Token(value, _) :: Nil) =>
-                  (key, value.replaceAll("^\'|^\"|\"$|\'$", ""))
+                  (key, unquoteString(value))
               }.asInstanceOf[Seq[(String, String)]].toMap
           }
         }.getOrElse(Map.empty[String, String])
@@ -148,7 +151,7 @@ private[sql] class SparkQl(conf: ParserConf = SimpleParserConf()) extends Cataly
                 case tableName :: Nil =>
                   // It is describing a table with the format like "describe table".
                   datasources.DescribeCommand(
-                    UnresolvedRelation(TableIdentifier(tableName.text), None),
+                    UnresolvedRelation(TableIdentifier(cleanIdentifier(tableName.text)), None),
                     isExtended = extended.isDefined)
                 case _ =>
                   nodeToDescribeFallback(node)