Github user jiangxb1987 commented on a diff in the pull request:

    https://github.com/apache/spark/pull/16233#discussion_r95510361
  
    --- Diff: 
sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveMetastoreCatalog.scala ---
    @@ -125,11 +132,16 @@ private[hive] class 
HiveMetastoreCatalog(sparkSession: SparkSession) extends Log
           // Otherwise, wrap the table with a Subquery using the table name.
           alias.map(a => SubqueryAlias(a, qualifiedTable, 
None)).getOrElse(qualifiedTable)
         } else if (table.tableType == CatalogTableType.VIEW) {
    +      val tableIdentifier = table.identifier
           val viewText = table.viewText.getOrElse(sys.error("Invalid view 
without text."))
    -      SubqueryAlias(
    -        alias.getOrElse(table.identifier.table),
    -        sparkSession.sessionState.sqlParser.parsePlan(viewText),
    -        Option(table.identifier))
    +      // The relation is a view, so we wrap the relation by:
    +      // 1. Add a [[View]] operator over the relation to keep track of the 
view desc;
    +      // 2. Wrap the logical plan in a [[SubqueryAlias]] which tracks the 
name of the view.
    +      val child = View(
    +        desc = table,
    +        output = table.schema.toAttributes,
    +        child = sparkSession.sessionState.sqlParser.parsePlan(viewText))
    --- End diff --
    
    The resolution of a View operator takes place by two stages:
    For the first stage, we look up the relation and generate a View node by:
    1. Parse the `viewText` to generate a child logical plan, which is 
unresolved;
    2. Generate the output attribute from the `CatalogTable.schema`, which is 
resolved;
    This stage focus on planning of the view.
    
    For the second stage, we resolve the child logical plan of the View node, 
the logic is in `ResolveRelations.resolveRelation()`.
    In this stage, we resolve the child logical plan, which was parsed from the 
`viewText`(the sql query string that creates the view).
    
    At last, in `AliasViewChild` rule, we alias the resolved child plan to the 
view node. In this way, we successfully resolve a view.
    
    In the future, we could cache the `viewText` and its corresponding logical 
plan. In case a view is referenced for multiple times, we only have to parse 
and resolve the query for once, and for later references we can read directly 
from the cache.


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

---------------------------------------------------------------------
To unsubscribe, e-mail: reviews-unsubscr...@spark.apache.org
For additional commands, e-mail: reviews-h...@spark.apache.org

Reply via email to