static Node *transformAExprOp(ParseState *pstate, A_Expr *a){
	Node	   *lexpr = a->lexpr; Node	   *rexpr = a->rexpr; // 操作符左右表达式
	Node	   *result;

	/* Special-case "foo = NULL" and "NULL = foo" for compatibility with standards-broken products (like Microsoft's).  Turn these into IS NULL exprs. (If either side is a CaseTestExpr, then the expression was generated internally from a CASE-WHEN expression, and transform_null_equals does not apply.) */
	if (Transform_null_equals && list_length(a->name) == 1 && strcmp(strVal(linitial(a->name)), "=") == 0 &&(exprIsNullConstant(lexpr) || exprIsNullConstant(rexpr)) && (!IsA(lexpr, CaseTestExpr) && !IsA(rexpr, CaseTestExpr))) {
		NullTest   *n = makeNode(NullTest); n->nulltesttype = IS_NULL; n->location = a->location;
		if (exprIsNullConstant(lexpr)) n->arg = (Expr *) rexpr;
		else n->arg = (Expr *) lexpr;
		result = transformExprRecurse(pstate, (Node *) n);
	}
	else if (lexpr && IsA(lexpr, RowExpr) && rexpr && IsA(rexpr, SubLink) && ((SubLink *) rexpr)->subLinkType == EXPR_SUBLINK) { /* Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the grammar did this, but now that a row construct is allowed anywhere in expressions, it's easier to do it here. */
		SubLink    *s = (SubLink *) rexpr;
		s->subLinkType = ROWCOMPARE_SUBLINK; s->testexpr = lexpr; s->operName = a->name; s->location = a->location;
		result = transformExprRecurse(pstate, (Node *) s);
	}
	else if (lexpr && IsA(lexpr, RowExpr) && rexpr && IsA(rexpr, RowExpr)){ /* ROW() op ROW() is handled specially */
		lexpr = transformExprRecurse(pstate, lexpr);
		rexpr = transformExprRecurse(pstate, rexpr);
		result = make_row_comparison_op(pstate, a->name,castNode(RowExpr, lexpr)->args, castNode(RowExpr, rexpr)->args, a->location);
	}
	else { /* Ordinary scalar operator */
		Node	   *last_srf = pstate->p_last_srf;
		lexpr = transformExprRecurse(pstate, lexpr); rexpr = transformExprRecurse(pstate, rexpr);
		result = (Node *) make_op(pstate, a->name, lexpr, rexpr, last_srf, a->location);
	}
	return result;
}

transformAExprOp函数将对AEXPR_OP、AEXPR_LIKE、AEXPR_ILIKE和AEXPR_SIMILAR类型的A_Expr表达式进行转换，分为四种类型。

• “foo = NULL” and “NULL = foo” 转为IS NULL表达式
• "row op subselect"转为ROWCOMPARE sublink表达式
• ROW() op ROW()调用make_row_comparison_op进行处理
• scalar operator调用make_op进行处理

scalar operator

make_op函数用于转换运算符表达式，确保类型兼容性。首先获取左表达式、右表达式类型，加上操作符名，调用oper函数获取pg_operator中匹配运算符表达式的operator记录；强制实现多态参数和返回类型的一致性，可能会调整返回类型或declard_arg_types（make_fn_arguments将其用作强制转换目标）；为形参设置必要的强转函数；

/* make_op() Operator expression construction.
 * Transform operator expression ensuring type compatibility. This is where some type conversion happens.
 * last_srf should be a copy of pstate->p_last_srf from just before we started transforming the operator's arguments; this is used for nested-SRF detection.  If the caller will throw an error anyway for a set-returning expression, it's okay to cheat and just pass pstate->p_last_srf. */
Expr *make_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, Node *last_srf, int location){
	Oid			ltypeId, rtypeId; Oid			rettype; // 左表达式、右表达式、返回值类型
	Operator	tup; Form_pg_operator opform;
	Oid			actual_arg_types[2]; Oid			declared_arg_types[2]; int			nargs; List	   *args;	
	OpExpr	   *result;

	/* Select the operator */
	if (ltree == NULL){/* prefix operator */ // 查找一元左operator(unary left operator)
		rtypeId = exprType(rtree); ltypeId = InvalidOid; tup = left_oper(pstate, opname, rtypeId, false, location);
	}else{/* otherwise, binary operator */   // 查找二元operator
		ltypeId = exprType(ltree); rtypeId = exprType(rtree); tup = oper(pstate, opname, ltypeId, rtypeId, false, location);
	}
	opform = (Form_pg_operator) GETSTRUCT(tup);
	
	/* Do typecasting and build the expression tree */
	if (ltree == NULL){ /* prefix operator */
		args = list_make1(rtree); actual_arg_types[0] = rtypeId; declared_arg_types[0] = opform->oprright; nargs = 1;
	}else{/* otherwise, binary operator */
		args = list_make2(ltree, rtree); actual_arg_types[0] = ltypeId; actual_arg_types[1] = rtypeId;
		declared_arg_types[0] = opform->oprleft; declared_arg_types[1] = opform->oprright; nargs = 2;
	}

	/* enforce consistency with polymorphic argument and return types, possibly adjusting return type or declared_arg_types (which will be used as the cast destination by make_fn_arguments) */
	rettype = enforce_generic_type_consistency(actual_arg_types, declared_arg_types, nargs, opform->oprresult, false);
	/* perform the necessary typecasting of arguments */
	make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
	
	result = makeNode(OpExpr); /* and build the expression node */
	result->opno = oprid(tup); result->opfuncid = opform->oprcode; result->opresulttype = rettype;
	result->opretset = get_func_retset(opform->oprcode);
	/* opcollid and inputcollid will be set by parse_collate.c */
	result->args = args; result->location = location;	
	if (result->opretset) { /* if it returns a set, check that's OK */
		check_srf_call_placement(pstate, last_srf, location);		
		pstate->p_last_srf = (Node *) result; /* ... and remember it for error checks at higher levels */
	}
	ReleaseSysCache(tup);

	return (Expr *) result;
}

ROW() op ROW()

c_expr中指明了表达式为Row表达式的规则，而Explicit row production的规则如下所示，语法中有ROW关键字或括号：

row:		ROW '(' expr_list ')'					{ $$ = $3; }
			| ROW '(' ')'							{ $$ = NIL; }
			| '(' expr_list ',' a_expr ')'			{ $$ = lappend($2, $4); }
		;
explicit_row:	ROW '(' expr_list ')'				{ $$ = $3; }
			| ROW '(' ')'							{ $$ = NIL; }
		;
implicit_row:	'(' expr_list ',' a_expr ')'		{ $$ = lappend($2, $4); }
		;

expr_list:	a_expr { $$ = list_make1($1); }
			| expr_list ',' a_expr { $$ = lappend($1, $3); }

对于ROW() op ROW()调用make_row_comparison_op(pstate, a->name, castNode(RowExpr, lexpr)->args, castNode(RowExpr, rexpr)->args, a->location)进行转换处理.该函数输入是已转换表达式的列表。与coerce_type一样，如果不需要特殊的未知Param处理，pstate可能为NULL。输出可以是单个OpExpr、OpExpr的AND或OR组合或RowCompareExpr。在所有情况下，都保证返回布尔值。AND、OR和RowCompareExpr的情况进一步暗示了运算符的行为（即，它们的行为为=、<>或<<=>=）。The inputs are lists of already-transformed expressions. As with coerce_type, pstate may be NULL if no special unknown-Param processing is wanted. The output may be a single OpExpr, an AND or OR combination of OpExprs, or a RowCompareExpr. In all cases it is guaranteed to return boolean. The AND, OR, and RowCompareExpr cases further imply things about the behavior of the operators (ie, they behave as =, <>, or < <= > >=). 首先取出左右RowExpr表达式args中的子表达式，通过make_op函数为其创建OpExpr结构。如果row()的长度为1，则只返回单个运算符OpExpr。否则需要为每对运算符OpExpr，寻找包含运算符的btree操作族；对于=和<>创建BoolExpr(AND_EXPR、OR_EXPR）；对于其他运算符，查找到其对于的opfamily，创建RowCompareExpr，并关联OpExpr的中的左右表达式。

static Node *make_row_comparison_op(ParseState *pstate, List *opname, List *largs, List *rargs, int location) {
	RowCompareExpr *rcexpr; RowCompareType rctype;
	ListCell   *l, *r;
	/* Identify all the pairwise operators, using make_op so that behavior is the same as in the simple scalar case. */
	List	   *opexprs = NIL; // 使用make_op识别所有成对运算符，使其行为与简单标量情况相同。
	forboth(l, largs, r, rargs){
		Node	   *larg = (Node *) lfirst(l); Node	   *rarg = (Node *) lfirst(r);
		OpExpr	   *cmp = castNode(OpExpr, make_op(pstate, opname, larg, rarg, pstate->p_last_srf, location));
		opexprs = lappend(opexprs, cmp);
	}
    int nopers = list_length(largs);
	/* If rows are length 1, just return the single operator.  In this case we don't insist on identifying btree semantics for the operator (but we still require it to return boolean). */ //如果行的长度为1，则只返回单个运算符。在这种情况下，我们并不坚持为运算符识别btree语义（但我们仍然要求它返回布尔值）。
	if (nopers == 1)return (Node *) linitial(opexprs);

	/* Now we must determine which row comparison semantics (= <> < <= > >=) apply to this set of operators.  We look for btree opfamilies containing the operators, and see which interpretations (strategy numbers) exist for each operator. */ // 现在，我们必须确定哪一行比较语义（= <> < <= > >=）应用于这组运算符。我们寻找包含运算符的btree操作族，并查看每个运算符存在哪些解释（策略编号）。
	List	  **opinfo_lists = (List **) palloc(nopers * sizeof(List *));
	Bitmapset  *strats = NULL;
	int i = 0;
	foreach(l, opexprs){ // 从OpExpr列表中取出row左右对应位置的子表达式创建而成的OpExpr
		Oid			opno = ((OpExpr *) lfirst(l))->opno;
		opinfo_lists[i] = get_op_btree_interpretation(opno); // 寻找包含运算符的btree操作族

		/* convert strategy numbers into a Bitmapset to make the intersection calculation easy. */
		Bitmapset  *this_strats = NULL;  ListCell   *j;
		foreach(j, opinfo_lists[i]){
			OpBtreeInterpretation *opinfo = lfirst(j);
			this_strats = bms_add_member(this_strats, opinfo->strategy);
		}
		if (i == 0) strats = this_strats;
		else strats = bms_int_members(strats, this_strats);
		i++;
	}

	/* If there are multiple common interpretations, we may use any one of them ... this coding arbitrarily picks the lowest btree strategy number. */ // 如果有多种常见的解释，我们可以使用其中的任何一种。。。这种编码任意地选择最低的btree策略编号。
	i = bms_first_member(strats); rctype = (RowCompareType) i;

	/* For = and <> cases, we just combine the pairwise operators with AND or OR respectively. */
	if (rctype == ROWCOMPARE_EQ) return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
	if (rctype == ROWCOMPARE_NE) return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);

	/* Otherwise we need to choose exactly which opfamily to associate with each operator. */
	List	   *opfamilies = NIL;
	for (i = 0; i < nopers; i++){
		Oid			opfamily = InvalidOid;
		ListCell   *j;
		foreach(j, opinfo_lists[i]){
			OpBtreeInterpretation *opinfo = lfirst(j);
			if (opinfo->strategy == rctype){
				opfamily = opinfo->opfamily_id;
				break;
			}
		}
		if (OidIsValid(opfamily)) opfamilies = lappend_oid(opfamilies, opfamily);
		else					/* should not happen */
			ereport(ERROR,(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),errmsg("could not determine interpretation of row comparison operator %s",strVal(llast(opname))), errdetail("There are multiple equally-plausible candidates."), parser_errposition(pstate, location)));
	}

	/* Now deconstruct the OpExprs and create a RowCompareExpr. Note: can't just reuse the passed largs/rargs lists, because of possibility that make_op inserted coercion operations. */
	List	   *opnos = NIL; largs = NIL; rargs = NIL;
	foreach(l, opexprs){
		OpExpr	   *cmp = (OpExpr *) lfirst(l);
		opnos = lappend_oid(opnos, cmp->opno);
		largs = lappend(largs, linitial(cmp->args)); rargs = lappend(rargs, lsecond(cmp->args));
	}

	rcexpr = makeNode(RowCompareExpr);
	rcexpr->rctype = rctype; rcexpr->opnos = opnos; rcexpr->opfamilies = opfamilies;
	rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */
	rcexpr->largs = largs; rcexpr->rargs = rargs;

	return (Node *) rcexpr;
}