typedef struct Expr {
    NodeTag type;              /*表达式节点类型*/
} Expr;
struct ExprState {
    NodeTag type;
    Expr* expr;                 /*关联的表达式节点*/
    ExprStateEvalFunc evalfunc;   /*表达式运算的函数指针*/
    VectorExprFun vecExprFun;
    exprFakeCodeGenSig exprCodeGen; /*运行LLVM汇编函数的指针*/
    ScalarVector tmpVector;
    Oid resultType;
};

if (node == NULL) {  /* 判断输入是否为空 */
  gstrace_exit(GS_TRC_ID_ExecInitExpr);
  return NULL;}
switch (nodeTag(node)) {  /* 根据节点类型初始化节点内容 */
        case T_Var:
        case T_Const:
case T_Param:
        ……
        case T_CaseTestExpr:
        case T_Aggref:
        ……
case T_CurrentOfExpr:
case T_TargetEntry: 
case T_List:
        case T_Rownum:
default:…… }
return state;   /* 返回表达式节点树 */

输入:
expression：需要计算的表达式状态树。
econtext：评估上下文信息。
输出:
return value：Datum类型的返回值。
*isNull：如果结果为NULL，则设置为TRUE（实际返回值无意义）；如果结果非空，则设置为FALSE。
*isDone：设置为set-result状态的指标。

fcinfo = &fcache->fcinfo_data;                           /* 声明fcinfo */
InitFunctionCallInfoArgs(*fcinfo, list_length(fcache->args), 1); /*初始化fcinfo */ 
econtext->is_cursor = false;
    foreach (arg, fcache->args) {                          /* 遍历获取参数值 */
        ExprState* argstate = (ExprState*)lfirst(arg);
        fcinfo->argTypes[i] = argstate->resultType;
        fcinfo->arg[i] = ExecEvalExpr(argstate, econtext, &fcinfo->argnull[i], NULL);
if (fcache->func.fn_strict)                   /* 判断参数是否存在空值 */
…… 
result = FunctionCallInvoke(fcinfo);           /* 计算表达式结果 */
return result;

init_fcache<false>(func->funcid,func->inputcollid,fcache, econtext->ecxt_per_query_memory, true);                 /* 初始化fcache */
if (fcache->func.fn_retset) {                           /* 判断返回结果类型 */
    ……
return ExecMakeFunctionResult<true, true, true>(fcache, econtext, isNull, isDone);
} else if (expression_returns_set((Node*)func->args)) {
……
return ExecMakeFunctionResult<true, true, false>(fcache, econtext, isNull, isDone);
} else {
……
return ExecMakeFunctionResultNoSets<true, true>(fcache, econtext, isNull, isDone);
}

foreach (l, qual) {        /* 遍历qual中的子表达式并计算 */
expr_value = ExecEvalExpr(clause, econtext, &isNull, NULL);
if (isNull) {  /* 判断计算结果 */
if (resultForNull == false) {
result = false; 
break;
}
        } else {
            if (!DatumGetBool(expr_value)) {
                  result = false;
 ……
 return result;   /* 返回结果是否满足表达式 */

foreach (clause, clauses) {              /* 遍历子表达式 */
        ExprState* clausestate = (ExprState*)lfirst(clause);
        Datum clause_value;
        clause_value = ExecEvalExpr(clausestate, econtext, isNull, NULL);  /* 执行表达式 */
        /* 如果得到不空且ture的结果，直接返回结果 */
if (*isNull) 
/* 记录存在空值 */
            AnyNull = true; 
        else if (DatumGetBool(clause_value))
/* 一次结果为true就返回 */
            return clause_value;  /* 返回执行结果 */
    }
*isNull = AnyNull;
return BoolGetDatum(false);

typedef struct GenericExprState {
    ExprState xprstate;
    ExprState* arg; /*子节点的状态*/
} GenericExprState;
typedef struct TargetEntry {
    Expr xpr;
    Expr* expr;            /*要计算的表达式*/
    AttrNumber resno;      /*属性号*/
    char* resname;         /*列的名称*/
    Index ressortgroupref;    /*如果被sort/group子句引用，则为非零*/
    Oid resorigtbl;           /*列的源表的OID */
    AttrNumber resorigcol;    /*源表中的列号*/
    bool resjunk;            /*设置为true可从最终目标列表中删除该属性*/
} TargetEntry;

typedef struct ProjectionInfo {
    NodeTag type;
    List* pi_targetlist;            /*目标列表*/
    ExprContext* pi_exprContext;  /*内存上下文*/
    TupleTableSlot* pi_slot;       /*投影结果*/
    ExprDoneCond* pi_itemIsDone; /*ExecProject的工作区数组*/
    bool pi_directMap;
    int pi_numSimpleVars;    /*在原始tlist（查询目标列表）中找到的简单变量数*/
    int* pi_varSlotOffsets;    /*指示变量来自哪个slot（槽位）的数组*/
    int* pi_varNumbers;     /*包含变量的输入属性数的数组*/
    int* pi_varOutputCols;   /*包含变量的输出属性数的数组*/
    int pi_lastInnerVar;      /*内部参数*/
    int pi_lastOuterVar;     /*外部参数*/
    int pi_lastScanVar;      /*扫描参数*/
    List* pi_acessedVarNumbers;
    List* pi_sysAttrList;
    List* pi_lateAceessVarNumbers;
    List* pi_maxOrmin;    /*列表优化，指示获取此列的最大值还是最小值*/
    List* pi_PackTCopyVars;            /*记录需要移动的列*/
    List* pi_PackLateAccessVarNumbers;  /*记录cstore（列存储）扫描中移动的内容的列*/
    bool pi_const;
    VectorBatch* pi_batch;
    vectarget_func jitted_vectarget;      /* LLVM函数指针*/
    VectorBatch* pi_setFuncBatch;
} ProjectionInfo;

prm = &(econtext->ecxt_param_exec_vals[thisParamId]); /* 获取econtext中参数 */
if (prm->execPlan != NULL) {                    /* 判断是否需要生成参数 */
  /* 参数还未计算执行此函数*/
  ExecSetParamPlan((SubPlanState*)prm->execPlan, econtext);
  /*参数计算完计划重置为空*/
  Assert(prm->execPlan == NULL);
  prm->isConst = true;
  prm->valueType = expression->paramtype;
}
*isNull = prm->isnull;
prm->isChanged = true;
return prm->value;

if (paramInfo && thisParamId > 0 && thisParamId <= paramInfo->numParams) {/* 判断参数 */
ParamExternData* prm = ¶mInfo->params[thisParamId - 1];
  if (!OidIsValid(prm->ptype) && paramInfo->paramFetch != NULL)   /* 获取动态参数 */ 
    (*paramInfo->paramFetch)(paramInfo, thisParamId);
    if (OidIsValid(prm->ptype)) {                               /*检查参数并返回 */ 
if (prm->ptype != expression->paramtype)
ereport(……);
       *isNull = prm->isnull;
       if (econtext->is_cursor && prm->ptype == REFCURSOROID) {
         CopyCursorInfoData(&econtext->cursor_data, &prm->cursor_data);
         econtext->dno = thisParamId - 1;
       }
       return prm->value;
   }
}
  ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("no value found for parameter %d", thisParamId)));
  return (Datum)0;