void
GetForeignRelSize(PlannerInfo *root,
                  RelOptInfo *baserel,
                  Oid foreigntableid);

获取外部表的关系大小估计值。这在扫描外部表的查询计划开始时调用。root 是规划器关于查询的全局信息；baserel 是规划器关于此表的信息；foreigntableid 是外部表的 pg_class OID。（foreigntableid 可以从规划器数据结构中获取，但它是显式传递的，以节省精力。）

此函数应将 baserel->rows 更新为表扫描返回的预期行数，在考虑限制条件执行的筛选之后。baserel->rows 的初始值只是一个恒定的默认估计值，如果可能的话，应该替换掉。如果该函数可以计算出平均结果行宽的更好估计值，它也可以选择更新 baserel->width。（初始值基于列数据类型和上次 ANALYZE 测量的列平均宽度值。）此外，如果该函数可以计算出外部表的总行数的更好估计值，它可以更新 baserel->tuples。（初始值来自 pg_class.reltuples，它表示上次 ANALYZE 看到的总行数；如果未在此外部表上执行 ANALYZE，则它将为 -1。）

有关其他信息，请参见第 57.4 节。

void
GetForeignPaths(PlannerInfo *root,
                RelOptInfo *baserel,
                Oid foreigntableid);

为扫描外部表创建可能的访问路径。这在查询规划期间调用。参数与已调用的 GetForeignRelSize 相同。

此函数必须为外部表的扫描生成至少一个访问路径（ForeignPath 节点），并且必须调用 add_path 将每个这样的路径添加到 baserel->pathlist。建议使用 create_foreignscan_path 构建 ForeignPath 节点。该函数可以生成多个访问路径，例如，具有有效 pathkeys 的路径，以表示预排序的结果。每个访问路径都必须包含成本估计，并且可以包含标识预期特定扫描方法所需的任何 FDW 私有信息。

有关其他信息，请参见第 57.4 节。

ForeignScan *
GetForeignPlan(PlannerInfo *root,
               RelOptInfo *baserel,
               Oid foreigntableid,
               ForeignPath *best_path,
               List *tlist,
               List *scan_clauses,
               Plan *outer_plan);

从选定的外部访问路径创建 ForeignScan 计划节点。这在查询计划结束时调用。参数与 GetForeignRelSize 的参数相同，外加选定的 ForeignPath（先前由 GetForeignPaths、GetForeignJoinPaths 或 GetForeignUpperPaths 生成）、计划节点将发出的目标列表、计划节点将强制执行的限制子句以及 ForeignScan 的外部子计划，该子计划用于 RecheckForeignScan 执行的重新检查。（如果路径用于连接而不是基本关系，则 foreigntableid 为 InvalidOid。）

此函数必须创建并返回一个 ForeignScan 计划节点；建议使用 make_foreignscan 构建 ForeignScan 节点。

有关其他信息，请参见第 57.4 节。

void
BeginForeignScan(ForeignScanState *node,
                 int eflags);

开始执行外部扫描。这在执行程序启动期间调用。它应该在扫描开始之前执行所需的任何初始化，但不会开始执行实际扫描（这应该在第一次调用 IterateForeignScan 时完成）。ForeignScanState 节点已经创建，但其 fdw_state 字段仍为 NULL。有关要扫描的表的信息可以通过 ForeignScanState 节点访问（特别是，从基础 ForeignScan 计划节点访问，其中包含 GetForeignPlan 提供的任何 FDW 私有信息）。eflags 包含描述此计划节点的执行程序操作模式的标志位。

请注意，当 (eflags & EXEC_FLAG_EXPLAIN_ONLY) 为 true 时，此函数不应执行任何外部可见的操作；它只应执行使节点状态对于 ExplainForeignScan 和 EndForeignScan 有效所需的最低限度操作。

TupleTableSlot *
IterateForeignScan(ForeignScanState *node);

从外部源获取一行，将其返回到元组表槽中（该节点的 ScanTupleSlot 应为此目的使用）。如果没有更多行可用，则返回 NULL。元组表槽基础结构允许返回物理或虚拟元组；在大多数情况下，从性能的角度来看，后一种选择更可取。请注意，这是在短暂的内存上下文中调用的，该内存上下文将在调用之间重置。如果在 BeginForeignScan 中需要更长时间的存储，请创建一个内存上下文，或使用该节点的 EState 的 es_query_cxt。

如果提供了 fdw_scan_tlist 目标列表，则返回的行必须与该列表匹配，否则它们必须与正在扫描的外部表的行类型匹配。如果您选择优化掉不需要的列的获取，则应在这些列位置插入 null 值，或者生成一个省略了这些列的 fdw_scan_tlist 列表。

请注意，PostgreSQL 的执行程序并不关心返回的行是否违反了在外部表上定义的任何约束，但规划器确实关心，并且如果外部表中存在不满足声明的约束的可见行，则可能不正确地优化查询。如果当用户声明约束应为真时违反了约束，则可能需要引发错误（就像您在数据类型不匹配的情况下需要做的那样）。

void
ReScanForeignScan(ForeignScanState *node);

从头开始重新启动扫描。请注意，扫描所依赖的任何参数的值可能已更改，因此新的扫描不一定会返回完全相同的行。

void
EndForeignScan(ForeignScanState *node);

结束扫描并释放资源。释放 palloc'd 内存通常不重要，但是例如，应该清理打开的文件和与远程服务器的连接。

如果 FDW 支持远程执行外部连接（而不是通过获取两个表的数据并在本地执行连接），则它应提供此回调函数

void
GetForeignJoinPaths(PlannerInfo *root,
                    RelOptInfo *joinrel,
                    RelOptInfo *outerrel,
                    RelOptInfo *innerrel,
                    JoinType jointype,
                    JoinPathExtraData *extra);

为属于同一外部服务器的两个（或多个）外部表之间的连接创建可能的访问路径。这个可选函数在查询规划期间被调用。与 GetForeignPaths 一样，此函数应为提供的 joinrel 生成 ForeignPath 路径（使用 create_foreign_join_path 来构建它们），并调用 add_path 将这些路径添加到连接所考虑的路径集中。但是，与 GetForeignPaths 不同，此函数不必成功创建至少一个路径，因为总是可能存在涉及本地连接的路径。

请注意，对于相同的连接关系，此函数将被重复调用，使用不同的内部和外部关系组合；FDW 有责任最大程度地减少重复的工作。

另请注意，要应用于连接的连接子句集，作为 extra->restrictlist 传递，会根据内部和外部关系的组合而变化。为 joinrel 生成的 ForeignPath 路径必须包含它使用的连接子句集，如果规划器选择它作为 joinrel 的最佳路径，规划器将使用这些子句将 ForeignPath 路径转换为计划。

如果为连接选择了 ForeignPath 路径，它将表示整个连接过程；为组件表和辅助连接生成的路径将不会被使用。对连接路径的后续处理与扫描单个外部表的路径的处理方式大致相同。一个不同之处在于，生成的 ForeignScan 计划节点的 scanrelid 应设置为零，因为它不代表单个关系；相反，ForeignScan 节点的 fs_relids 字段表示已连接的关系集。（后一个字段由核心规划器代码自动设置，无需由 FDW 填充。）另一个不同之处在于，因为无法从系统目录中找到远程连接的列列表，FDW 必须使用 TargetEntry 节点的适当列表填充 fdw_scan_tlist，表示它在运行时返回的元组中将提供的列集。

有关其他信息，请参见第 57.4 节。

如果 FDW 支持执行远程扫描后/连接后处理（例如远程聚合），则应提供此回调函数

void
GetForeignUpperPaths(PlannerInfo *root,
                     UpperRelationKind stage,
                     RelOptInfo *input_rel,
                     RelOptInfo *output_rel,
                     void *extra);

为上层关系处理创建可能的访问路径，这是规划器对所有扫描后/连接后查询处理（例如聚合、窗口函数、排序和表更新）的术语。这个可选函数在查询规划期间被调用。目前，仅当查询中涉及的所有基本关系都属于同一个 FDW 时才会调用它。此函数应为 FDW 知道如何远程执行的任何扫描后/连接后处理生成 ForeignPath 路径（使用 create_foreign_upper_path 来构建它们），并调用 add_path 将这些路径添加到指定的上层关系。与 GetForeignJoinPaths 一样，此函数不必成功创建任何路径，因为总是可能存在涉及本地处理的路径。

stage 参数标识当前正在考虑的扫描后/连接后步骤。output_rel 是应接收表示此步骤计算的路径的上层关系，input_rel 是表示此步骤输入的输入关系。extra 参数提供其他详细信息，目前，仅为 UPPERREL_PARTIAL_GROUP_AGG 或 UPPERREL_GROUP_AGG 设置，在这种情况下，它指向一个 GroupPathExtraData 结构；或者为 UPPERREL_FINAL 设置，在这种情况下，它指向一个 FinalPathExtraData 结构。（请注意，添加到 output_rel 的 ForeignPath 路径通常不会直接依赖于 input_rel 的路径，因为它们的处理预计将在外部完成。但是，检查先前为上一步处理生成的路径可能有助于避免冗余规划工作。）

有关其他信息，请参见第 57.4 节。

如果 FDW 支持可写的外部表，则应根据 FDW 的需求和功能提供以下部分或全部回调函数

void
AddForeignUpdateTargets(PlannerInfo *root,
                        Index rtindex,
                        RangeTblEntry *target_rte,
                        Relation target_relation);

UPDATE 和 DELETE 操作是针对先前由表扫描函数获取的行执行的。FDW 可能需要额外的信息（例如行 ID 或主键列的值）来确保它可以识别要更新或删除的确切行。为了支持这一点，此函数可以向在 UPDATE 或 DELETE 期间从外部表检索的列列表中添加额外的隐藏或“垃圾”目标列。

为此，请构造一个表示您需要的额外值的 Var，并将其连同垃圾列的名称一起传递给 add_row_identity_var。（如果需要多个列，可以多次执行此操作。）您必须为您需要的每个不同的 Var 选择一个不同的垃圾列名称，但 varno 字段除外，相同的 Var 应共享一个列名称。核心系统对表的 tableoid 列使用垃圾列名称 tableoid，对 ctid 使用 ctid 或 ctidN，对标记为 vartype = RECORD 的整行 Var 使用 wholerow，对 vartype 等于表的声明行类型的整行 Var 使用 wholerowN。在可以的情况下重复使用这些名称（规划器将组合对相同垃圾列的重复请求）。如果您除了这些之外还需要其他类型的垃圾列，最好选择以您的扩展名作为前缀的名称，以避免与其他 FDW 冲突。

如果 AddForeignUpdateTargets 指针设置为 NULL，则不会添加额外的目标表达式。（这将使实现 DELETE 操作变得不可能，但如果 FDW 依赖于不变的主键来识别行，则 UPDATE 可能仍然可行。）

List *
PlanForeignModify(PlannerInfo *root,
                  ModifyTable *plan,
                  Index resultRelation,
                  int subplan_index);

执行对外表上的插入、更新或删除所需的任何其他规划操作。此函数生成将附加到执行更新操作的 ModifyTable 计划节点的 FDW 私有信息。此私有信息必须具有 List 的形式，并且将在执行阶段传递给 BeginForeignModify。

root 是规划器关于查询的全局信息。plan 是 ModifyTable 计划节点，除了 fdwPrivLists 字段之外，它是完整的。resultRelation 通过其范围表索引标识目标外部表。subplan_index 标识 ModifyTable 计划节点的哪个目标，从零开始计数；如果您想索引到 plan 节点的每个目标关系的子结构中，请使用此选项。

有关其他信息，请参见第 57.4 节。

如果 PlanForeignModify 指针设置为 NULL，则不会执行其他计划时操作，并且传递给 BeginForeignModify 的 fdw_private 列表将为 NIL。

void
BeginForeignModify(ModifyTableState *mtstate,
                   ResultRelInfo *rinfo,
                   List *fdw_private,
                   int subplan_index,
                   int eflags);

开始执行外部表修改操作。此例程在执行程序启动期间被调用。它应在实际表修改之前执行任何所需的初始化。随后，将为要插入、更新或删除的元组调用 ExecForeignInsert/ExecForeignBatchInsert、ExecForeignUpdate 或 ExecForeignDelete。

mtstate 是正在执行的 ModifyTable 计划节点的整体状态；有关计划和执行状态的全局数据可通过此结构获得。rinfo 是描述目标外部表的 ResultRelInfo 结构。（ResultRelInfo 的 ri_FdwState 字段可供 FDW 存储此操作所需的任何私有状态。）fdw_private 包含由 PlanForeignModify 生成的私有数据（如果有）。subplan_index 标识 ModifyTable 计划节点的哪个目标。eflags 包含描述此计划节点的执行程序操作模式的标志位。

请注意，当 (eflags & EXEC_FLAG_EXPLAIN_ONLY) 为 true 时，此函数不应执行任何外部可见的操作；它应该仅执行使节点状态对 ExplainForeignModify 和 EndForeignModify 有效所需的最小操作。

如果 BeginForeignModify 指针设置为 NULL，则在执行程序启动期间不会采取任何操作。

TupleTableSlot *
ExecForeignInsert(EState *estate,
                  ResultRelInfo *rinfo,
                  TupleTableSlot *slot,
                  TupleTableSlot *planSlot);

将一个元组插入到外部表中。estate 是查询的全局执行状态。rinfo 是描述目标外部表的 ResultRelInfo 结构体。slot 包含要插入的元组；它将匹配外部表的行类型定义。planSlot 包含由 ModifyTable 计划节点的子计划生成的元组；它与 slot 的不同之处在于可能包含额外的“垃圾”列。（planSlot 通常对 INSERT 情况不太重要，但为了完整性而提供。）

返回值是一个包含实际插入数据的槽（这可能与提供的数据不同，例如由于触发器操作的结果），如果实际上没有插入任何行，则返回 NULL（同样，通常是由于触发器的结果）。传入的 slot 可以重复用于此目的。

仅当 INSERT 语句具有 RETURNING 子句或涉及具有 WITH CHECK OPTION 的视图时；或者如果外部表具有 AFTER ROW 触发器时，才会使用返回的槽中的数据。触发器需要所有列，但 FDW 可以选择根据 RETURNING 子句或 WITH CHECK OPTION 约束的内容优化掉返回部分或全部列。无论如何，必须返回一些槽来指示成功，否则查询报告的行数将是错误的。

如果 ExecForeignInsert 指针设置为 NULL，则尝试插入到外部表的操作将失败并显示错误消息。

请注意，当将路由元组插入到外部表分区或在外部表上执行 COPY FROM 时，也会调用此函数，在这种情况下，它的调用方式与 INSERT 情况不同。请参阅下面描述的回调函数，这些函数允许 FDW 支持此操作。

TupleTableSlot **
ExecForeignBatchInsert(EState *estate,
                       ResultRelInfo *rinfo,
                       TupleTableSlot **slots,
                       TupleTableSlot **planSlots,
                       int *numSlots);

将多个元组批量插入到外部表中。参数与 ExecForeignInsert 相同，除了 slots 和 planSlots 包含多个元组，并且 *numSlots 指定这些数组中的元组数。

返回值是一个包含实际插入数据的槽数组（这可能与提供的数据不同，例如由于触发器操作的结果）。传入的 slots 可以重复用于此目的。成功插入的元组数在 *numSlots 中返回。

仅当 INSERT 语句涉及具有 WITH CHECK OPTION 的视图时；或者如果外部表具有 AFTER ROW 触发器时，才会使用返回的槽中的数据。触发器需要所有列，但 FDW 可以选择根据 WITH CHECK OPTION 约束的内容优化掉返回部分或全部列。

如果 ExecForeignBatchInsert 或 GetForeignModifyBatchSize 指针设置为 NULL，则尝试插入到外部表的操作将使用 ExecForeignInsert。如果 INSERT 具有 RETURNING 子句，则不使用此函数。

请注意，当将路由元组插入到外部表分区或在外部表上执行 COPY FROM 时，也会调用此函数，在这种情况下，它的调用方式与 INSERT 情况不同。请参阅下面描述的回调函数，这些函数允许 FDW 支持此操作。

int
GetForeignModifyBatchSize(ResultRelInfo *rinfo);

报告单个 ExecForeignBatchInsert 调用可以处理的指定外部表的最大元组数。执行器最多将给定数量的元组传递给 ExecForeignBatchInsert。rinfo 是描述目标外部表的 ResultRelInfo 结构体。FDW 应该为用户提供外部服务器和/或外部表选项来设置此值，或者提供一些硬编码的值。

如果 ExecForeignBatchInsert 或 GetForeignModifyBatchSize 指针设置为 NULL，则尝试插入到外部表的操作将使用 ExecForeignInsert。

TupleTableSlot *
ExecForeignUpdate(EState *estate,
                  ResultRelInfo *rinfo,
                  TupleTableSlot *slot,
                  TupleTableSlot *planSlot);

更新外部表中的一个元组。estate 是查询的全局执行状态。rinfo 是描述目标外部表的 ResultRelInfo 结构体。slot 包含元组的新数据；它将匹配外部表的行类型定义。planSlot 包含由 ModifyTable 计划节点的子计划生成的元组。与 slot 不同，此元组仅包含查询更改的列的新值，因此不要依赖外部表的属性编号来索引到 planSlot 中。此外，planSlot 通常包含额外的“垃圾”列。特别是，AddForeignUpdateTargets 请求的任何垃圾列都将从此槽中获得。

返回值是一个包含实际更新行的槽（这可能与提供的数据不同，例如由于触发器操作的结果），如果实际上没有更新任何行，则返回 NULL（同样，通常是由于触发器的结果）。传入的 slot 可以重复用于此目的。

仅当 UPDATE 语句具有 RETURNING 子句或涉及具有 WITH CHECK OPTION 的视图时；或者如果外部表具有 AFTER ROW 触发器时，才会使用返回的槽中的数据。触发器需要所有列，但 FDW 可以选择根据 RETURNING 子句或 WITH CHECK OPTION 约束的内容优化掉返回部分或全部列。无论如何，必须返回一些槽来指示成功，否则查询报告的行数将是错误的。

如果 ExecForeignUpdate 指针设置为 NULL，则尝试更新外部表的操作将失败并显示错误消息。

TupleTableSlot *
ExecForeignDelete(EState *estate,
                  ResultRelInfo *rinfo,
                  TupleTableSlot *slot,
                  TupleTableSlot *planSlot);

从外部表中删除一个元组。estate 是查询的全局执行状态。rinfo 是描述目标外部表的 ResultRelInfo 结构体。slot 在调用时没有包含任何有用的信息，但可以用于保存返回的元组。planSlot 包含由 ModifyTable 计划节点的子计划生成的元组；特别是，它将携带 AddForeignUpdateTargets 请求的任何垃圾列。必须使用垃圾列来标识要删除的元组。

返回值是一个包含已删除行的槽，如果未删除任何行，则返回 NULL（通常是由于触发器的结果）。传入的 slot 可用于保存要返回的元组。

仅当 DELETE 查询具有 RETURNING 子句或外部表具有 AFTER ROW 触发器时，才会使用返回的槽中的数据。触发器需要所有列，但 FDW 可以选择根据 RETURNING 子句的内容优化掉返回部分或全部列。无论如何，必须返回一些槽来指示成功，否则查询报告的行数将是错误的。

如果 ExecForeignDelete 指针设置为 NULL，则尝试从外部表中删除的操作将失败并显示错误消息。

void
EndForeignModify(EState *estate,
                 ResultRelInfo *rinfo);

结束表更新并释放资源。通常释放 palloc'd 内存并不重要，但例如应该清理打开的文件和与远程服务器的连接。

如果 EndForeignModify 指针设置为 NULL，则在执行器关闭期间不采取任何操作。

通过 INSERT 或 COPY FROM 插入到分区表中的元组将被路由到分区。如果 FDW 支持可路由的外部表分区，它还应提供以下回调函数。当在外部表上执行 COPY FROM 时，也会调用这些函数。

void
BeginForeignInsert(ModifyTableState *mtstate,
                   ResultRelInfo *rinfo);

开始对外部表执行插入操作。在将第一个元组插入到外部表之前，无论它是选择用于元组路由的分区还是 COPY FROM 命令中指定的目标，都会调用此例程。它应执行实际插入之前所需的任何初始化。随后，将为要插入到外部表中的元组调用 ExecForeignInsert 或 ExecForeignBatchInsert。

mtstate 是正在执行的 ModifyTable 计划节点的整体状态；有关计划和执行状态的全局数据可通过此结构获得。rinfo 是描述目标外部表的 ResultRelInfo 结构体。（ResultRelInfo 的 ri_FdwState 字段可供 FDW 存储此操作所需的任何私有状态。）

当 COPY FROM 命令调用此函数时，不提供 mtstate 中的计划相关全局数据，并且随后为每个插入的元组调用的 ExecForeignInsert 的 planSlot 参数为 NULL，无论外部表是选择用于元组路由的分区还是命令中指定的目标。

如果 BeginForeignInsert 指针设置为 NULL，则不进行初始化操作。

请注意，如果 FDW 不支持可路由的外部表分区和/或在外部表上执行 COPY FROM，则此函数或随后调用的 ExecForeignInsert/ExecForeignBatchInsert 必须根据需要抛出错误。

void
EndForeignInsert(EState *estate,
                 ResultRelInfo *rinfo);

结束插入操作并释放资源。通常释放 palloc'd 内存并不重要，但例如应该清理打开的文件和与远程服务器的连接。

如果 EndForeignInsert 指针设置为 NULL，则不进行终止操作。

int
IsForeignRelUpdatable(Relation rel);

报告指定的外部表支持哪些更新操作。返回值应是一个规则事件编号的位掩码，指示外部表支持哪些操作，使用 CmdType 枚举；即，对于 UPDATE，(1 << CMD_UPDATE) = 4，对于 INSERT，(1 << CMD_INSERT) = 8，对于 DELETE，(1 << CMD_DELETE) = 16。

如果 IsForeignRelUpdatable 指针设置为 NULL，则如果 FDW 分别提供 ExecForeignInsert、ExecForeignUpdate 或 ExecForeignDelete，则假定外部表是可插入、可更新或可删除的。仅当 FDW 支持一些可更新的表和一些不可更新的表时，才需要此函数。（即便如此，也可以在执行例程中抛出错误，而不是在此函数中进行检查。但是，此函数用于确定 information_schema 视图中显示的可更新性。）

某些对外部表的插入、更新和删除操作可以通过实现一组替代接口进行优化。用于插入、更新和删除的普通接口会从远程服务器获取行，然后逐个修改这些行。在某些情况下，这种逐行处理的方式是必要的，但效率可能不高。如果外部服务器可以在不实际检索行的情况下确定应该修改哪些行，并且没有会影响操作的本地结构（行级本地触发器、存储生成的列或来自父视图的 WITH CHECK OPTION 约束），那么可以安排在远程服务器上执行整个操作。下面描述的接口使之成为可能。

bool
PlanDirectModify(PlannerInfo *root,
                 ModifyTable *plan,
                 Index resultRelation,
                 int subplan_index);

决定是否可以安全地在远程服务器上执行直接修改。如果可以，在执行所需的规划操作后返回 true。否则，返回 false。此可选函数在查询规划期间调用。如果此函数成功，则将在执行阶段调用 BeginDirectModify、IterateDirectModify 和 EndDirectModify。否则，将使用上述的表更新函数执行表修改。参数与 PlanForeignModify 的参数相同。

要在远程服务器上执行直接修改，此函数必须使用 ForeignScan 计划节点重写目标子计划，该节点在远程服务器上执行直接修改。ForeignScan 的 operation 和 resultRelation 字段必须正确设置。operation 必须设置为与语句类型对应的 CmdType 枚举（即，UPDATE 的 CMD_UPDATE，INSERT 的 CMD_INSERT 和 DELETE 的 CMD_DELETE），并且 resultRelation 参数必须复制到 resultRelation 字段。

有关其他信息，请参见第 57.4 节。

如果 PlanDirectModify 指针设置为 NULL，则不会尝试在远程服务器上执行直接修改。

void
BeginDirectModify(ForeignScanState *node,
                  int eflags);

准备在远程服务器上执行直接修改。这在执行器启动期间调用。它应该执行直接修改之前所需的任何初始化（应该在首次调用 IterateDirectModify 时完成）。ForeignScanState 节点已创建，但其 fdw_state 字段仍然为 NULL。可以通过 ForeignScanState 节点访问有关要修改的表的信息（特别是来自底层 ForeignScan 计划节点的信息，其中包含 PlanDirectModify 提供的任何 FDW 私有信息）。eflags 包含描述此计划节点的执行器操作模式的标志位。

请注意，当 (eflags & EXEC_FLAG_EXPLAIN_ONLY) 为 true 时，此函数不应执行任何外部可见的操作；它应该只执行使节点状态对 ExplainDirectModify 和 EndDirectModify 有效所需的最低限度操作。

如果 BeginDirectModify 指针设置为 NULL，则不会尝试在远程服务器上执行直接修改。

TupleTableSlot *
IterateDirectModify(ForeignScanState *node);

当 INSERT、UPDATE 或 DELETE 查询没有 RETURNING 子句时，只需在远程服务器上直接修改后返回 NULL。当查询具有该子句时，获取一个包含 RETURNING 计算所需数据的结果，并将其返回到元组表槽中（应为此目的使用节点的 ScanTupleSlot）。实际插入、更新或删除的数据必须存储在 node->resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple 中。如果没有更多行可用，则返回 NULL。请注意，此操作在一个短暂的内存上下文中调用，该内存上下文在调用之间重置。如果您需要更长时间的存储，请在 BeginDirectModify 中创建一个内存上下文，或使用节点的 EState 的 es_query_cxt。

返回的行必须与提供的 fdw_scan_tlist 目标列表匹配（如果提供了），否则它们必须与要更新的外部表的行类型匹配。如果您选择优化掉不需要用于 RETURNING 计算的列的获取，则应在这些列位置插入 null，或者生成一个省略这些列的 fdw_scan_tlist 列表。

无论查询是否具有该子句，查询报告的行数都必须由 FDW 本身递增。当查询没有该子句时，FDW 还必须在 EXPLAIN ANALYZE 的情况下递增 ForeignScanState 节点中的行数。

如果 IterateDirectModify 指针设置为 NULL，则不会尝试在远程服务器上执行直接修改。

void
EndDirectModify(ForeignScanState *node);

清理在远程服务器上进行直接修改后的操作。通常，释放 palloc 的内存并不重要，但例如，应清理打开的文件和与远程服务器的连接。

如果 EndDirectModify 指针设置为 NULL，则不会尝试在远程服务器上执行直接修改。

void
ExecForeignTruncate(List *rels,
                    DropBehavior behavior,
                    bool restart_seqs);

截断外部表。当在外部表上执行 TRUNCATE 时，将调用此函数。rels 是要截断的外部表的 Relation 数据结构的列表。

behavior 是 DROP_RESTRICT 或 DROP_CASCADE，分别表示在原始 TRUNCATE 命令中请求了 RESTRICT 或 CASCADE 选项。

如果 restart_seqs 为 true，则原始 TRUNCATE 命令请求了 RESTART IDENTITY 行为，否则请求了 CONTINUE IDENTITY 行为。

请注意，原始 TRUNCATE 命令中指定的 ONLY 选项不会传递给 ExecForeignTruncate。此行为类似于外部表上 SELECT、UPDATE 和 DELETE 的回调函数。

每个要截断的外部表的外服务器都会调用一次 ExecForeignTruncate。这意味着 rels 中包含的所有外部表必须属于同一服务器。

如果 ExecForeignTruncate 指针设置为 NULL，则尝试截断外部表将失败并显示错误消息。

如果 FDW 希望支持后期行锁定（如 第 57.5 节中所述），则它必须提供以下回调函数

RowMarkType
GetForeignRowMarkType(RangeTblEntry *rte,
                      LockClauseStrength strength);

报告要用于外部表的行标记选项。rte 是表的 RangeTblEntry 节点，strength 描述相关 FOR UPDATE/SHARE 子句请求的锁定强度（如果有）。结果必须是 RowMarkType 枚举类型的成员。

此函数在查询规划期间为出现在 UPDATE、DELETE 或 SELECT FOR UPDATE/SHARE 查询中且不是 UPDATE 或 DELETE 目标的所有外部表调用。

如果 GetForeignRowMarkType 指针设置为 NULL，则始终使用 ROW_MARK_COPY 选项。（这意味着永远不会调用 RefetchForeignRow，因此也不需要提供它。）

有关更多信息，请参见 第 57.5 节。

void
RefetchForeignRow(EState *estate,
                  ExecRowMark *erm,
                  Datum rowid,
                  TupleTableSlot *slot,
                  bool *updated);

根据需要锁定后，从外部表重新获取一个元组槽。estate 是查询的全局执行状态。erm 是 ExecRowMark 结构，描述目标外部表和要获取的行锁定类型（如果有）。rowid 标识要获取的元组。slot 在调用时没有任何有用的信息，但可用于保存返回的元组。updated 是一个输出参数。

此函数应将元组存储到提供的槽中，如果无法获取行锁，则清除该槽。要获取的行锁定类型由 erm->markType 定义，它是先前由 GetForeignRowMarkType 返回的值。（ROW_MARK_REFERENCE 表示仅重新获取元组而不获取任何锁，并且此例程永远不会看到 ROW_MARK_COPY。）

此外，如果获取的是元组的更新版本，而不是先前获取的相同版本，则应将 *updated 设置为 true。（如果 FDW 无法确定这一点，建议始终返回 true。）

请注意，默认情况下，无法获取行锁应导致引发错误；仅当 erm->waitPolicy 指定了 SKIP LOCKED 选项时，返回空槽才是合适的。

rowid 是先前为要重新获取的行读取的 ctid 值。尽管 rowid 值作为 Datum 传递，但当前它只能是 tid。选择函数 API 的目的是希望将来可以允许其他数据类型作为行 ID。

如果 RefetchForeignRow 指针设置为 NULL，则尝试重新获取行将失败并显示错误消息。

有关更多信息，请参见 第 57.5 节。

bool
RecheckForeignScan(ForeignScanState *node,
                   TupleTableSlot *slot);

重新检查先前返回的元组是否仍然与相关的扫描和连接限定符匹配，并可能提供元组的修改版本。对于不执行连接下推的外部数据包装器，通常更方便将其设置为 NULL，而是适当地设置 fdw_recheck_quals。但是，当下推外连接时，即使所有需要的属性都存在，也无法将与所有基本表相关的检查重新应用于结果元组，因为无法匹配某些限定符可能会导致某些属性变为 NULL，而不是没有返回元组。RecheckForeignScan 可以重新检查限定符，如果它们仍然满足则返回 true，否则返回 false，但它也可以将替换元组存储到提供的槽中。

为了实现连接下推，外部数据包装器通常会构建一个备用的本地连接计划，该计划仅用于重新检查；这将成为 ForeignScan 的外部子计划。当需要重新检查时，可以执行此子计划，并将结果元组存储在槽中。此计划不必高效，因为没有基本表会返回多于一行；例如，它可以将所有连接实现为嵌套循环。可以使用 GetExistingLocalJoinPath 函数在现有路径中搜索合适的本地连接路径，该路径可以用作备用的本地连接计划。GetExistingLocalJoinPath 会在指定连接关系的路径列表中搜索未参数化的路径。（如果找不到这样的路径，则返回 NULL，在这种情况下，外部数据包装器可以自行构建本地路径，或者可以选择不为该连接创建访问路径。）

void
ExplainForeignScan(ForeignScanState *node,
                   ExplainState *es);

为外部表扫描打印额外的 EXPLAIN 输出。此函数可以调用 ExplainPropertyText 和相关函数，将字段添加到 EXPLAIN 输出中。es 中的标志字段可用于确定要打印的内容，并且可以检查 ForeignScanState 节点的状态，以便在 EXPLAIN ANALYZE 情况下提供运行时统计信息。

如果 ExplainForeignScan 指针设置为 NULL，则在 EXPLAIN 期间不打印任何其他信息。

void
ExplainForeignModify(ModifyTableState *mtstate,
                     ResultRelInfo *rinfo,
                     List *fdw_private,
                     int subplan_index,
                     struct ExplainState *es);

为外部表更新打印额外的 EXPLAIN 输出。此函数可以调用 ExplainPropertyText 和相关函数，将字段添加到 EXPLAIN 输出中。es 中的标志字段可用于确定要打印的内容，并且可以检查 ModifyTableState 节点的状态，以便在 EXPLAIN ANALYZE 情况下提供运行时统计信息。前四个参数与 BeginForeignModify 的参数相同。

如果 ExplainForeignModify 指针设置为 NULL，则在 EXPLAIN 期间不打印任何其他信息。

void
ExplainDirectModify(ForeignScanState *node,
                    ExplainState *es);

为远程服务器上的直接修改打印额外的 EXPLAIN 输出。此函数可以调用 ExplainPropertyText 和相关函数，将字段添加到 EXPLAIN 输出中。es 中的标志字段可用于确定要打印的内容，并且可以检查 ForeignScanState 节点的状态，以便在 EXPLAIN ANALYZE 情况下提供运行时统计信息。

如果 ExplainDirectModify 指针设置为 NULL，则在 EXPLAIN 期间不打印任何其他信息。

bool
AnalyzeForeignTable(Relation relation,
                    AcquireSampleRowsFunc *func,
                    BlockNumber *totalpages);

当在外部表上执行 ANALYZE 时，会调用此函数。如果 FDW 可以收集此外部表的统计信息，则应返回 true，并提供一个指向函数的指针，该函数将从 func 中的表中收集样本行，以及 totalpages 中的表页面的估计大小。否则，返回 false。

如果 FDW 不支持收集任何表的统计信息，则可以将 AnalyzeForeignTable 指针设置为 NULL。

如果提供，则样本收集函数必须具有以下签名：

int
AcquireSampleRowsFunc(Relation relation,
                      int elevel,
                      HeapTuple *rows,
                      int targrows,
                      double *totalrows,
                      double *totaldeadrows);

应从表中收集最多 targrows 行的随机样本，并将其存储到调用方提供的 rows 数组中。必须返回收集的实际行数。此外，将表中活动行和死行的总数的估计值存储到输出参数 totalrows 和 totaldeadrows 中。（如果 FDW 没有任何死行的概念，则将 totaldeadrows 设置为零。）

List *
ImportForeignSchema(ImportForeignSchemaStmt *stmt, Oid serverOid);

获取外部表创建命令列表。当执行 IMPORT FOREIGN SCHEMA 时，会调用此函数，并传递该语句的解析树以及要使用的外部服务器的 OID。它应返回一个 C 字符串列表，每个字符串必须包含一个 CREATE FOREIGN TABLE 命令。这些字符串将由核心服务器解析和执行。

在 ImportForeignSchemaStmt 结构中，remote_schema 是要从中导入表的远程模式的名称。list_type 标识如何筛选表名：FDW_IMPORT_SCHEMA_ALL 表示应导入远程模式中的所有表（在这种情况下，table_list 为空），FDW_IMPORT_SCHEMA_LIMIT_TO 表示仅包含 table_list 中列出的表，而 FDW_IMPORT_SCHEMA_EXCEPT 表示排除 table_list 中列出的表。options 是用于导入过程的选项列表。这些选项的含义取决于 FDW。例如，FDW 可以使用选项来定义是否应导入列的 NOT NULL 属性。这些选项不必与 FDW 作为数据库对象选项支持的选项有任何关系。

FDW 可以忽略 ImportForeignSchemaStmt 的 local_schema 字段，因为核心服务器会自动将该名称插入到已解析的 CREATE FOREIGN TABLE 命令中。

FDW 也不必关心实现 list_type 和 table_list 指定的筛选，因为核心服务器会自动跳过根据这些选项排除的表的任何返回命令。但是，首先避免为排除的表创建命令的工作通常很有用。函数 IsImportableForeignTable() 对于测试给定的外部表名称是否会通过筛选器很有用。

如果 FDW 不支持导入表定义，则可以将 ImportForeignSchema 指针设置为 NULL。

一个 ForeignScan 节点可以选择支持并行执行。并行 ForeignScan 将在多个进程中执行，并且必须在所有协作进程中精确返回每一行一次。为此，进程可以通过固定大小的动态共享内存块进行协调。不能保证此共享内存在每个进程中映射到相同的地址，因此它不能包含指针。以下函数都是可选的，但是如果要支持并行执行，则大多数函数都是必需的。

bool
IsForeignScanParallelSafe(PlannerInfo *root, RelOptInfo *rel,
                          RangeTblEntry *rte);

测试是否可以在并行工作进程中执行扫描。仅当规划器认为可能存在并行计划时，才会调用此函数，如果该扫描在并行工作进程中运行是安全的，则应返回 true。如果远程数据源具有事务语义，则通常不会出现这种情况，除非工作进程与数据的连接能够以某种方式与领导者共享相同的事务上下文。

如果未定义此函数，则假定该扫描必须在并行领导者中进行。请注意，返回 true 并不意味着扫描本身可以并行完成，而仅表示扫描可以在并行工作进程中执行。因此，即使不支持并行执行，定义此方法也很有用。

Size
EstimateDSMForeignScan(ForeignScanState *node, ParallelContext *pcxt);

估计并行操作所需的动态共享内存量。它可能高于实际使用的量，但不能低于它。返回值以字节为单位。此函数是可选的，如果不需要可以省略；但是如果省略，则还必须省略接下来的三个函数，因为不会为 FDW 的使用分配共享内存。

void
InitializeDSMForeignScan(ForeignScanState *node, ParallelContext *pcxt,
                         void *coordinate);

初始化并行操作所需的动态共享内存。coordinate 指向大小等于 EstimateDSMForeignScan 的返回值的共享内存区域。此函数是可选的，如果不需要可以省略。

void
ReInitializeDSMForeignScan(ForeignScanState *node, ParallelContext *pcxt,
                           void *coordinate);

当外部扫描计划节点即将重新扫描时，重新初始化并行操作所需的动态共享内存。此函数是可选的，如果不需要可以省略。推荐的做法是此函数仅重置共享状态，而 ReScanForeignScan 函数仅重置本地状态。目前，此函数将在 ReScanForeignScan 之前调用，但最好不要依赖这种顺序。

void
InitializeWorkerForeignScan(ForeignScanState *node, shm_toc *toc,
                            void *coordinate);

根据领导者在 InitializeDSMForeignScan 期间设置的共享状态，初始化并行工作进程的本地状态。此函数是可选的，如果不需要可以省略。

void
ShutdownForeignScan(ForeignScanState *node);

当预计节点不会执行完成时释放资源。并非在所有情况下都会调用此函数；有时，可能会在未先调用此函数的情况下调用 EndForeignScan。由于并行查询使用的 DSM 段在调用此回调后立即被销毁，因此希望在 DSM 段消失之前执行某些操作的外部数据包装器应实现此方法。

一个 ForeignScan 节点可以选择支持 src/backend/executor/README 中描述的异步执行。以下函数都是可选的，但是如果要支持异步执行，则所有函数都是必需的。

bool
IsForeignPathAsyncCapable(ForeignPath *path);

测试给定的 ForeignPath 路径是否可以异步扫描基础外部关系。仅当给定路径是 AppendPath 路径的直接子路径，并且规划器认为异步执行可以提高性能时，才会在查询规划结束时调用此函数，如果给定路径能够异步扫描外部关系，则应返回 true。

如果未定义此函数，则假定给定的路径使用 IterateForeignScan 扫描外部关系。（这意味着下面描述的回调函数永远不会被调用，因此也不需要提供。）

void
ForeignAsyncRequest(AsyncRequest *areq);

从 ForeignScan 节点异步生成一个元组。areq 是描述 ForeignScan 节点以及请求从中获取元组的父 Append 节点的 AsyncRequest 结构体。此函数应将元组存储到由 areq->result 指定的槽中，并将 areq->request_complete 设置为 true；或者，如果需要等待核心服务器之外的事件（例如网络 I/O），并且无法立即生成任何元组，则将该标志设置为 false，并将 areq->callback_pending 设置为 true，以便 ForeignScan 节点从下面描述的回调函数获取回调。如果不再有可用元组，则将槽设置为 NULL 或空槽，并将 areq->request_complete 标志设置为 true。建议使用 ExecAsyncRequestDone 或 ExecAsyncRequestPending 来设置 areq 中的输出参数。

void
ForeignAsyncConfigureWait(AsyncRequest *areq);

配置 ForeignScan 节点希望等待的文件描述符事件。只有当 ForeignScan 节点设置了 areq->callback_pending 标志时，才会调用此函数，并且应将该事件添加到由 areq 描述的父 Append 节点的 as_eventset 中。有关更多信息，请参阅 src/backend/executor/execAsync.c 中 ExecAsyncConfigureWait 的注释。当文件描述符事件发生时，将调用 ForeignAsyncNotify。

void
ForeignAsyncNotify(AsyncRequest *areq);

处理已发生的相关事件，然后从 ForeignScan 节点异步生成一个元组。此函数应以与 ForeignAsyncRequest 相同的方式设置 areq 中的输出参数。

List *
ReparameterizeForeignPathByChild(PlannerInfo *root, List *fdw_private,
                                 RelOptInfo *child_rel);

当转换由给定子关系 child_rel 的最顶层父级参数化的路径，以由该子关系参数化时，将调用此函数。该函数用于重新参数化保存在 ForeignPath 的给定 fdw_private 成员中的任何路径或转换任何表达式节点。回调可以根据需要使用 reparameterize_path_by_child、adjust_appendrel_attrs 或 adjust_appendrel_attrs_multilevel。