/* Acquire the sample rows */
  rows = (HeapTuple *) palloc(targrows * sizeof(HeapTuple));
  if (inh) numrows = acquire_inherited_sample_rows(onerel, elevel, rows, targrows, &totalrows, &totaldeadrows);
  else numrows = (*acquirefunc) (onerel, elevel, rows, targrows, &totalrows, &totaldeadrows);

static int acquire_inherited_sample_rows(Relation onerel, int elevel, HeapTuple *rows, int targrows, double *totalrows, double *totaldeadrows){
  Relation   *rels; ListCell   *lc;  
  double     *relblocks,totalblocks; int      numrows, nrels, i;  
  bool    has_child; AcquireSampleRowsFunc *acquirefuncs;  
  List     *tableOIDs = find_all_inheritors(RelationGetRelid(onerel), AccessShareLock, NULL); /* Find all members of inheritance set.  We only need AccessShareLock on the children. */ // 查找继承集的所有成员。我们只需要在子表身上使用AccessShareLock。
  /* Check that there's at least one descendant, else fail.  This could happen despite analyze_rel's relhassubclass check, if table once had a child but no longer does.  In that case, we can clear the relhassubclass field so as not to make the same mistake again later. (This is safe because we hold ShareUpdateExclusiveLock.) */ // 检查至少有一个后代，否则失败。尽管analyze_rel进行了relhassubclass检查，但如果表曾经有一个子类，但不再有子类，这可能会发生。在这种情况下，我们可以清除relhassubclass字段，以便以后不再犯同样的错误。（这是安全的，因为我们持有ShareUpdateExclusiveLock。）
  if (list_length(tableOIDs) < 2){ // 如果指定表没有子表
    SetRelationHasSubclass(RelationGetRelid(onerel), false); // 设置pg_class系统表对应记录的relhassubclass列为false
    ereport(elevel,(errmsg("skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no child tables",get_namespace_name(RelationGetNamespace(onerel)),RelationGetRelationName(onerel))));
    return 0;
  }

  /* Identify acquirefuncs to use, and count blocks in all the relations. The result could overflow BlockNumber, so we use double arithmetic. */ // 标识要使用的AcquireFunc，并对所有关系中的块进行计数。结果可能会使BlockNumber溢出，因此我们使用双算术。
  rels = (Relation *) palloc(list_length(tableOIDs) * sizeof(Relation));
  acquirefuncs = (AcquireSampleRowsFunc *)palloc(list_length(tableOIDs) * sizeof(AcquireSampleRowsFunc));
  relblocks = (double *) palloc(list_length(tableOIDs) * sizeof(double));
  totalblocks = 0; nrels = 0; has_child = false;

  foreach(lc, tableOIDs){
    Oid      childOID = lfirst_oid(lc);  // 取出表的Oid
    Relation childrel = table_open(childOID, NoLock); /* We already got the needed lock */ // 获取表对应的Relation结构体    
    if (RELATION_IS_OTHER_TEMP(childrel)){ /* Ignore if temp table of another backend */
      table_close(childrel, AccessShareLock); continue;
    }
    
    AcquireSampleRowsFunc acquirefunc = NULL;
    BlockNumber relpages = 0;      
    if (childrel->rd_rel->relkind == RELKIND_RELATION || childrel->rd_rel->relkind == RELKIND_MATVIEW) { /* Check table type (MATVIEW can't happen, but might as well allow) */      
      acquirefunc = acquire_sample_rows; /* Regular table, so use the regular row acquisition function */
      relpages = RelationGetNumberOfBlocks(childrel);
    }else if (childrel->rd_rel->relkind == RELKIND_FOREIGN_TABLE){ /* For a foreign table, call the FDW's hook function to see whether it supports analysis. */      
      FdwRoutine *fdwroutine = GetFdwRoutineForRelation(childrel, false);
      bool    ok = false;
      if (fdwroutine->AnalyzeForeignTable != NULL) ok = fdwroutine->AnalyzeForeignTable(childrel, &acquirefunc, &relpages);
      if (!ok){/* ignore, but release the lock on it */
        table_close(childrel, AccessShareLock); continue;
      }
    }else {/* ignore, but release the lock on it.  don't try to unlock the passed-in relation */
      if (childrel != onerel) table_close(childrel, AccessShareLock);
      else table_close(childrel, NoLock);
      continue;
    }    
    has_child = true; /* OK, we'll process this child */
    rels[nrels] = childrel;  
    acquirefuncs[nrels] = acquirefunc;
    relblocks[nrels] = (double) relpages;
    totalblocks += (double) relpages;
    nrels++;
  }
  
  if (!has_child){ /* If we don't have at least one child table to consider, fail.  If the relation is a partitioned table, it's not counted as a child table. */
    ereport(elevel,(errmsg("skipping analyze of \"%s.%s\" inheritance tree --- this inheritance tree contains no analyzable child tables",get_namespace_name(RelationGetNamespace(onerel)),RelationGetRelationName(onerel)))); return 0;
  }

  /* Now sample rows from each relation, proportionally to its fraction of the total block count.  (This might be less than desirable if the child rels have radically different free-space percentages, but it's not clear that it's worth working harder.) */ // 现在从每个表中按其占总块计数的比例采样行。（如果子REL具有完全不同的自由空间百分比，这可能不太理想，但不清楚是否值得更加努力。）
  numrows = 0;*totalrows = 0;*totaldeadrows = 0;
  for (i = 0; i < nrels; i++){
    Relation  childrel = rels[i];
    AcquireSampleRowsFunc acquirefunc = acquirefuncs[i];
    double    childblocks = relblocks[i];    
    if (childblocks > 0){
      int      childtargrows = (int) rint(targrows * childblocks / totalblocks);      
      childtargrows = Min(childtargrows, targrows - numrows); /* Make sure we don't overrun due to roundoff error */
      if (childtargrows > 0){
        int      childrows;double    trows,tdrows;      
        childrows = (*acquirefunc) (childrel, elevel, rows + numrows, childtargrows, &trows, &tdrows); /* Fetch a random sample of the child's rows */
        /* We may need to convert from child's rowtype to parent's */
        if (childrows > 0 && !equalTupleDescs(RelationGetDescr(childrel), RelationGetDescr(onerel))) {
          TupleConversionMap *map = convert_tuples_by_name(RelationGetDescr(childrel), RelationGetDescr(onerel));
          if (map != NULL){
            for (int j = 0; j < childrows; j++) {
              HeapTuple  newtup = execute_attr_map_tuple(rows[numrows + j], map);
              heap_freetuple(rows[numrows + j]);
              rows[numrows + j] = newtup;
            }
            free_conversion_map(map);
          }
        }      
        numrows += childrows; *totalrows += trows; *totaldeadrows += tdrows; /* And add to counts */              
      }
    }    
    table_close(childrel, NoLock); /* Note: we cannot release the child-table locks, since we may have pointers to their TOAST tables in the sampled rows. */
  }
  return numrows;
}