exec_simple_query
    pg_parse_query
        raw_parser
            base_yyparse
    pg_analyze_and_rewrite
        /* 语义分析 */
        parse_analyze
            // 根据分析树生成一个对应的查询树
        /* 查询重写 */
        pg_rewrite_query
            // 继续对这一查询树进行修改，返回查询树链表

typedef struct SelectStmt {
    NodeTag type;

    /*
     * These fields are used only in "leaf" SelectStmts.
     */
    List *distinctClause;   /* NULL, list of DISTINCT ON exprs, or
                             * lcons(NIL,NIL) for all (SELECT DISTINCT) */
    IntoClause *intoClause; /* target for SELECT INTO */
    List *targetList;       /* the target list (of ResTarget) */
    List *fromClause;       /* the FROM clause */
    Node *whereClause;      /* WHERE qualification */
    List *groupClause;      /* GROUP BY clauses */
    Node *havingClause;     /* HAVING conditional-expression */
    List *windowClause;     /* WINDOW window_name AS (...), ... */
    WithClause *withClause; /* WITH clause */

    /*
     * In a "leaf" node representing a VALUES list, the above fields are all
     * null, and instead this field is set.  Note that the elements of the
     * sublists are just expressions, without ResTarget decoration. Also note
     * that a list element can be DEFAULT (represented as a SetToDefault
     * node), regardless of the context of the VALUES list. It's up to parse
     * analysis to reject that where not valid.
     */
    List *valuesLists; /* untransformed list of expression lists */

    /*
     * These fields are used in both "leaf" SelectStmts and upper-level
     * SelectStmts.
     */
    List *sortClause;    /* sort clause (a list of SortBy's) */
    Node *limitOffset;   /* # of result tuples to skip */
    Node *limitCount;    /* # of result tuples to return */
    List *lockingClause; /* FOR UPDATE (list of LockingClause's) */
    HintState *hintState;

    /*
     * These fields are used only in upper-level SelectStmts.
     */
    SetOperation op;         /* type of set op */
    bool all;                /* ALL specified? */
    struct SelectStmt *larg; /* left child */
    struct SelectStmt *rarg; /* right child */

    /*
     * These fields are used by operator "(+)"
     */
    bool hasPlus;
    /* Eventually add fields for CORRESPONDING spec here */
} SelectStmt;

typedef struct ResTarget {
    NodeTag type;
    char *name;        /* column name or NULL */
    List *indirection; /* subscripts, field names, and '*', or NIL */
    Node *val;
             /* the value expression to compute or assign */
    int location;      /* token location, or -1 if unknown */
} ResTarget;

from_clause:
			FROM from_list							{ $$ = $2; }
			| /*EMPTY*/								{ $$ = NIL; }
		;

from_list:
			table_ref								{ $$ = list_make1($1); }
			| from_list ',' table_ref				{ $$ = lappend($1, $3); }
		;

table_ref:	relation_expr /* 关系表达式 */
				{
					$$ = (Node *) $1;
				}
			| relation_expr alias_clause /* 取别名的关系表达式 */
				{
					$1->alias = $2;
					$$ = (Node *) $1;
				}
			| func_table
				{
					RangeFunction *n = makeNode(RangeFunction);
					n->funccallnode = $1;
					n->coldeflist = NIL;
					$$ = (Node *) n;
				}

relation_expr:
			qualified_name
				{
					/* default inheritance */
					$$ = $1;
					$$->inhOpt = INH_DEFAULT;
					$$->alias = NULL;
				}
			| qualified_name '*'

qualified_name:
			ColId
				{
					$$ = makeRangeVar(NULL, $1, @1);
				}
			| ColId indirection

RangeVar* makeRangeVar(char* schemaname, char* relname, int location)
{
    RangeVar* r = makeNode(RangeVar);

    r->catalogname = NULL;
    r->schemaname = schemaname;
    r->relname = relname;
    r->partitionname = NULL;
    r->inhOpt = INH_DEFAULT;
    r->relpersistence = RELPERSISTENCE_PERMANENT;
    r->alias = NULL;
    r->location = location;
    r->ispartition = false;
    r->partitionKeyValuesList = NIL;
    r->isbucket = false;
    r->buckets = NIL;
    r->length = 0;
    return r;
}

typedef struct RangeVar {
    NodeTag type;
    char* catalogname;   /* the catalog (database) name, or NULL */
    char* schemaname;    /* the schema name, or NULL */
    char* relname;       /* the relation/sequence name */
    char* partitionname; /* partition name, if is a partition */
    InhOption inhOpt;    /* expand rel by inheritance? recursively act
                          * on children? */
    char relpersistence; /* see RELPERSISTENCE_* in pg_class.h */
    Alias* alias;        /* table alias & optional column aliases */
    int location;        /* token location, or -1 if unknown */
    bool ispartition;    /* for partition action */
    List* partitionKeyValuesList;
    bool isbucket;       /* is the RangeVar means a hash bucket id ? */
    List* buckets;       /* the corresponding bucketid list */
    int length;
#ifdef ENABLE_MOT
    Oid foreignOid;
#endif
} RangeVar;

typedef struct A_Expr {
    NodeTag type;
    A_Expr_Kind kind; /* see above */
    List *name;       /* possibly-qualified name of operator */
    Node *lexpr;      /* left argument, or NULL if none */
    Node *rexpr;      /* right argument, or NULL if none */
    int location;     /* token location, or -1 if unknown */
} A_Expr;

/* 用于记录语义分析的中间信息 */
struct ParseState {
    List* p_rtable;                      /* range table so far */
}

/* 用于存储查询树 */
typedef struct Query {
    CmdType commandType; /* select|insert|update|delete|merge|utility */
    List* rtable;       /* list of range table entries 查询中使用的表的列表 */
    int resultRelation; /* rtable index of target relation for
                         * INSERT/UPDATE/DELETE/MERGE; 0 for SELECT 
                         * 涉及数据修改的范围表的编号
                         */
    FromExpr* jointree; /* table join tree (FROM and WHERE clauses) */
    List* targetList; /* target list (of TargetEntry) */
} Query;

/*
 * parse_analyze
 *		Analyze a raw parse tree and transform it to Query form.
 *
 * Optionally, information about $n parameter types can be supplied.
 * References to $n indexes not defined by paramTypes[] are disallowed.
 *
 * The result is a Query node.	Optimizable statements require considerable
 * transformation, while utility-type statements are simply hung off
 * a dummy CMD_UTILITY Query node.
 */
Query* parse_analyze(
    Node* parseTree, const char* sourceText, Oid* paramTypes, int numParams, bool isFirstNode, bool isCreateView)
{
    ParseState* pstate = make_parsestate(NULL);
    // 将分析树`parseTree`转换成查询树`query`
    query = transformTopLevelStmt(pstate, parseTree, isFirstNode, isCreateView);
        // 以查询为例
        static Query* transformSelectStmt(ParseState* pstate, SelectStmt* stmt, bool isFirstNode, bool isCreateView)
}

typedef struct Node {
    NodeTag type;
} Node;

typedef enum NodeTag {
    /*
     * TAGS FOR STATEMENT NODES (mostly in parsenodes.h)
     */
    T_Query = 700,
    T_PlannedStmt,
    T_InsertStmt,
    T_DeleteStmt,
    T_UpdateStmt,
    T_MergeStmt,
    T_SelectStmt,
    ……
}

typedef struct RangeTblEntry {
    NodeTag type;

    RTEKind rtekind; /* see above */
}

void transformFromClause(ParseState* pstate, List* frmList, bool isFirstNode, bool isCreateView)
{
    foreach (fl, frmList) {
        Node* n = (Node*)lfirst(fl);
        RangeTblEntry* rte = NULL;
        int rtindex;
        List* relnamespace = NIL;

        // 根据`fromClause`的`Node`产生一个或多个`RangeTblEntry`结构， 加入到`ParseState::p_rtable`中
        n = transformFromClauseItem(
            pstate, n, &rte, &rtindex, NULL, NULL, &relnamespace, isFirstNode, isCreateView);
            Node* transformFromClauseItem(ParseState* pstate, Node* n, RangeTblEntry** top_rte, int* top_rti,
            RangeTblEntry**  right_rte, int* right_rti, List** relnamespace, bool isFirstNode, bool isCreateView, bool isMergeInto)
            {
                // 普通表
                if (IsA(n, RangeVar)) {
                    /* Plain relation reference, or perhaps a CTE reference */
                    RangeVar* rv = (RangeVar*)n;
                    RangeTblRef* rtr = NULL;
                    RangeTblEntry* rte = NULL;
            
                    /* if it is an unqualified name, it might be a CTE reference */
                    if (!rv->schemaname) {
                        CommonTableExpr* cte = NULL;
                        Index levelsup;
            
                        cte = scanNameSpaceForCTE(pstate, rv->relname, &levelsup);
                        if (cte != NULL) {
                            // 将其作为一个`RTE`加入到`ParseState::p_rtable`中
                            rte = transformCTEReference(pstate, rv, cte, levelsup);
                        }
                    }
            
                    /* if not found as a CTE, must be a table reference */
                    if (rte == NULL) {
                        rte = transformTableEntry(pstate, rv, isFirstNode, isCreateView);
                    }
            
                    rtr = transformItem(pstate, rte, top_rte, top_rti, relnamespace);
                    return (Node*)rtr;
                }
            }
        // 执行重名检查
        checkNameSpaceConflicts(pstate, pstate->p_relnamespace, relnamespace);

Query* parse_analyze(
    Node* parseTree, const char* sourceText, Oid* paramTypes, int numParams, bool isFirstNode, bool isCreateView)
{
    ParseState* pstate = make_parsestate(NULL);
    // 将分析树`parseTree`转换成查询树`query`
    query = transformTopLevelStmt(pstate, parseTree, isFirstNode, isCreateView);
        // 以查询为例
        static Query* transformSelectStmt(ParseState* pstate, SelectStmt* stmt, bool isFirstNode, bool isCreateView)
            /* process the FROM clause */
            transformFromClause(pstate, stmt->fromClause, isFirstNode, isCreateView); {
                foreach (fl, frmList) {
                    Node* n = (Node*)lfirst(fl);
                    RangeTblEntry* rte = NULL;
                    // 根据`fromClause`的`Node`产生一个或多个`RangeTblEntry`结构， 加入到`ParseState::p_rtable`中
                    n = transformFromClauseItem(pstate, n, &rte, &rtindex, NULL, NULL, &relnamespace, isFirstNode, isCreateView);
                }
            }
}

Query* parse_analyze(
    Node* parseTree, const char* sourceText, Oid* paramTypes, int numParams, bool isFirstNode, bool isCreateView)
{
    ParseState* pstate = make_parsestate(NULL);
    // 将分析树`parseTree`转换成查询树`query`
    query = transformTopLevelStmt(pstate, parseTree, isFirstNode, isCreateView);
        // 以查询为例
        static Query* transformSelectStmt(ParseState* pstate, SelectStmt* stmt, bool isFirstNode, bool isCreateView)
            Query* qry = makeNode(Query);
            /* transform targetlist */
            qry->targetList = transformTargetList(pstate, stmt->targetList);
                // * Turns a list of ResTarget's into a list of TargetEntry's.
                foreach (o_target, targetlist) {
                    // 多列元素`*`
                    p_target = list_concat(p_target, ExpandColumnRefStar(pstate, cref, true));
                    p_target = list_concat(p_target, ExpandIndirectionStar(pstate, ind, true));
                    // 单列
                    p_target = lappend(p_target, transformTargetEntry(pstate, res->val, NULL, res->name, false));
                }

}

    /* transform WHERE
     * Only "(+)" is valid when  it's in WhereClause of Select, set the flag to be trure
     * during transform Whereclause.
     */
    Node* qual = NULL;
    setIgnorePlusFlag(pstate, true);
    qual = transformWhereClause(pstate, stmt->whereClause, "WHERE");
    setIgnorePlusFlag(pstate, false);
    qry->jointree = makeFromExpr(pstate->p_joinlist, qual);