standard_ProcessUtility
 | -- ExecVacuum(pstate, stmt, isTopLevel)
       | -- 参数处理
       | -- vacuum(vacstmt->rels, &params, NULL, isTopLevel)
             | -- pgstat_vacuum_stat # 向PgStat进程发送关于dead objects的信息
             | -- foreach(cur, relations)
               | -- analyze_rel(vrel->oid, vrel->relation, params, vrel->va_cols, in_outer_xact, vac_strategy)
                     | -- 确定采样函数acquirefunc
                     | -- do_analyze_rel
                           | -- update_attstats # 更新pg_statistic
                           | -- vac_update_relstats # 更新pg_class
                           | -- pgstat_report_analyze # 向PgStat进程发送统计信息

    * Emit the completed stats rows into pg_statistic, replacing any previous statistics for the target columns.  (If there are stats in pg_statistic for columns we didn't process, we leave them alone.) */  将完成的统计数据行发送到pg_statistic，替换目标列的任何以前的统计数据。（如果pg_statistic中有我们没有处理的列的统计信息，我们就不处理它们。）
    update_attstats(RelationGetRelid(onerel), inh, attr_cnt, vacattrstats); 
    for (ind = 0; ind < nindexes; ind++){
      AnlIndexData *thisdata = &indexdata[ind];
      update_attstats(RelationGetRelid(Irel[ind]), false, thisdata->attr_cnt, thisdata->vacattrstats);
    }
    * Build extended statistics (if there are any). For now we only build extended statistics on individual relations, not for relations representing inheritance trees. */  构建扩展统计数据（如果有）。目前，我们只对单个关系构建扩展统计数据，而不是表示继承树的关系
    if (!inh) BuildRelationExtStatistics(onerel, totalrows, numrows, rows,  attr_cnt, vacattrstats);
  }

static void update_attstats(Oid relid, bool inh, int natts, VacAttrStats **vacattrstats) {
  int      attno;
  if (natts <= 0) return;          /* nothing to do */ // 没有需要更新的列
  Relation sd = table_open(StatisticRelationId, RowExclusiveLock);
  for (attno = 0; attno < natts; attno++) {
      int      i,k,n;
    VacAttrStats *stats = vacattrstats[attno];
    HeapTuple  stup,oldtup;
        
    Datum    values[Natts_pg_statistic];  //   pg_statistic系统表对应列的值
    if (!stats->stats_valid) continue; /* Ignore attr if we weren't able to collect stats */ // 非法的，直接放弃
    bool    nulls[Natts_pg_statistic], replaces[Natts_pg_statistic];
    for (i = 0; i < Natts_pg_statistic; ++i){ /* Construct a new pg_statistic tuple */ // 构建pg_statistic系统表的所有列，用nulls[i]表示该列没有数据，用replaces[i]表示该列要更新数据
      nulls[i] = false; replaces[i] = true;
    }
    values[Anum_pg_statistic_starelid - 1] = ObjectIdGetDatum(relid);
    values[Anum_pg_statistic_staattnum - 1] = Int16GetDatum(stats->attr->attnum);
    values[Anum_pg_statistic_stainherit - 1] = BoolGetDatum(inh);
    values[Anum_pg_statistic_stanullfrac - 1] = Float4GetDatum(stats->stanullfrac);
    values[Anum_pg_statistic_stawidth - 1] = Int32GetDatum(stats->stawidth);
    values[Anum_pg_statistic_stadistinct - 1] = Float4GetDatum(stats->stadistinct);
    
    i = Anum_pg_statistic_stakind1 - 1;
    for (k = 0; k < STATISTIC_NUM_SLOTS; k++){ // STATISTIC_NUM_SLOTS为5，也就是stakind1...5
      values[i++] = Int16GetDatum(stats->stakind[k]); /* stakindN */
    }
    i = Anum_pg_statistic_staop1 - 1;
    for (k = 0; k < STATISTIC_NUM_SLOTS; k++){
      values[i++] = ObjectIdGetDatum(stats->staop[k]);  /* staopN */
    }
    i = Anum_pg_statistic_stacoll1 - 1;
    for (k = 0; k < STATISTIC_NUM_SLOTS; k++){
      values[i++] = ObjectIdGetDatum(stats->stacoll[k]);  /* stacollN */
    }
    i = Anum_pg_statistic_stanumbers1 - 1;
    for (k = 0; k < STATISTIC_NUM_SLOTS; k++){
      int      nnum = stats->numnumbers[k];
      if (nnum > 0){
        Datum     *numdatums = (Datum *) palloc(nnum * sizeof(Datum));
        ArrayType  *arry;
        for (n = 0; n < nnum; n++) numdatums[n] = Float4GetDatum(stats->stanumbers[k][n]);
        /* XXX knows more than it should about type float4: */
        arry = construct_array(numdatums, nnum, FLOAT4OID, sizeof(float4), true, TYPALIGN_INT);
        values[i++] = PointerGetDatum(arry);  /* stanumbersN */
      }else{ nulls[i] = true; values[i++] = (Datum) 0; }
    }
    i = Anum_pg_statistic_stavalues1 - 1;
    for (k = 0; k < STATISTIC_NUM_SLOTS; k++){
      if (stats->numvalues[k] > 0){
        ArrayType  *arry = construct_array(stats->stavalues[k], stats->numvalues[k], stats->statypid[k], stats->statyplen[k], stats->statypbyval[k], stats->statypalign[k]);
        values[i++] = PointerGetDatum(arry);  /* stavaluesN */
      }else{
        nulls[i] = true;
        values[i++] = (Datum) 0;
      }
    }


    /* Is there already a pg_statistic tuple for this attribute? */
    oldtup = SearchSysCache3(STATRELATTINH, ObjectIdGetDatum(relid), Int16GetDatum(stats->attr->attnum), BoolGetDatum(inh));
    if (HeapTupleIsValid(oldtup)){/* Yes, replace it */
      stup = heap_modify_tuple(oldtup, RelationGetDescr(sd), values, nulls, replaces);
      ReleaseSysCache(oldtup);CatalogTupleUpdate(sd, &stup->t_self, stup);
    }else{/* No, insert new tuple */
      stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);CatalogTupleInsert(sd, stup);
    }
    heap_freetuple(stup);
  }
  table_close(sd, RowExclusiveLock);
}

  /* Update pages/tuples stats in pg_class ... but not if we're doing inherited stats. */ // 更新pg_class中的页面/元组统计
  if (!inh) {
    BlockNumber relallvisible;
    visibilitymap_count(onerel, &relallvisible, NULL);
    vac_update_relstats(onerel,relpages,totalrows,relallvisible,hasindex,InvalidTransactionId,InvalidMultiXactId,in_outer_xact);
  }
  /* Same for indexes. Vacuum always scans all indexes, so if we're part of VACUUM ANALYZE, don't overwrite the accurate count already inserted by VACUUM. */
  if (!inh && !(params->options & VACOPT_VACUUM)){
    for (ind = 0; ind < nindexes; ind++){
      AnlIndexData *thisdata = &indexdata[ind];
      double    totalindexrows;
      totalindexrows = ceil(thisdata->tupleFract * totalrows);
      vac_update_relstats(Irel[ind],RelationGetNumberOfBlocks(Irel[ind]),totalindexrows,0,false,InvalidTransactionId,InvalidMultiXactId,in_outer_xact);
    }
  }

void vac_update_relstats(Relation relation, BlockNumber num_pages, double num_tuples,
          BlockNumber num_all_visible_pages,
          bool hasindex, TransactionId frozenxid,MultiXactId minmulti,bool in_outer_xact){
  Oid      relid = RelationGetRelid(relation);
  Relation rd = table_open(RelationRelationId, RowExclusiveLock);  
  HeapTuple ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid)); /* Fetch a copy of the tuple to scribble on */
  if (!HeapTupleIsValid(ctup)) elog(ERROR, "pg_class entry for relid %u vanished during vacuuming", relid);
  Form_pg_class pgcform = (Form_pg_class) GETSTRUCT(ctup);


  /* Apply statistical updates, if any, to copied tuple */
  bool dirty = false;
  if (pgcform->relpages != (int32) num_pages){ pgcform->relpages = (int32) num_pages; dirty = true; }
  if (pgcform->reltuples != (float4) num_tuples){ pgcform->reltuples = (float4) num_tuples; dirty = true; }
  if (pgcform->relallvisible != (int32) num_all_visible_pages){ pgcform->relallvisible = (int32) num_all_visible_pages; dirty = true; }
  /* Apply DDL updates, but not inside an outer transaction (see above) */
  if (!in_outer_xact){/* If we didn't find any indexes, reset relhasindex. */
    if (pgcform->relhasindex && !hasindex){ pgcform->relhasindex = false; dirty = true; }    
    if (pgcform->relhasrules && relation->rd_rules == NULL){ /* We also clear relhasrules and relhastriggers if needed */    
      pgcform->relhasrules = false; dirty = true;
    }
    if (pgcform->relhastriggers && relation->trigdesc == NULL){ pgcform->relhastriggers = false;dirty = true; }
  }
  if (TransactionIdIsNormal(frozenxid) && pgcform->relfrozenxid != frozenxid && (TransactionIdPrecedes(pgcform->relfrozenxid, frozenxid) || TransactionIdPrecedes(ReadNextTransactionId(), pgcform->relfrozenxid))){ pgcform->relfrozenxid = frozenxid; dirty = true; }


  /* Similarly for relminmxid */
  if (MultiXactIdIsValid(minmulti) &&pgcform->relminmxid != minmulti &&(MultiXactIdPrecedes(pgcform->relminmxid, minmulti) || MultiXactIdPrecedes(ReadNextMultiXactId(), pgcform->relminmxid))) { pgcform->relminmxid = minmulti; dirty = true; }


  /* If anything changed, write out the tuple. */
  if (dirty) heap_inplace_update(rd, ctup);


  table_close(rd, RowExclusiveLock);
}

  /* Report ANALYZE to the stats collector, too.  However, if doing inherited stats we shouldn't report, because the stats collector only tracks per-table stats.  Reset the changes_since_analyze counter only if we analyzed all columns; otherwise, there is still work for auto-analyze to do. */ // 也向统计收集器报告分析。但是，如果执行继承的统计，我们不应该报告，因为统计收集器只跟踪每个表的统计。仅当我们分析了所有列时，重置changes_since_analyze计数器；否则，自动分析仍有工作要做
  if (!inh) pgstat_report_analyze(onerel, totalrows, totaldeadrows, (va_cols == NIL));


void pgstat_report_analyze(Relation rel,  PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter){
  PgStat_MsgAnalyze msg;
  if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts) return;


  /* Unlike VACUUM, ANALYZE might be running inside a transaction that has already inserted and/or deleted rows in the target table. ANALYZE will have counted such rows as live or dead respectively. Because we will report our counts of such rows at transaction end, we should subtract off these counts from what we send to the collector now, else they'll be double-counted after commit.  (This approach also ensures that the collector ends up with the right numbers if we abort instead of committing.) Waste no time on partitioned tables, though. */ // 与真空VACUUM, ANALYZE可能在已经在目标表中插入和/或删除行的事务中运行。ANALYZE将分别将这些行计数为“活”或“死”。因为我们将在事务结束时报告这些行的计数，所以我们应该从我们现在发送给收集器的数据中减去这些计数，否则在提交后它们将被重复计数。（如果我们中止而不是提交，这种方法还可以确保收集器最终得到正确的数字。）不过，不要浪费时间在分区表上。
  if (rel->pgstat_info != NULL && rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE) {
    for (PgStat_TableXactStatus *trans = rel->pgstat_info->trans; trans; trans = trans->upper){
      livetuples -= trans->tuples_inserted - trans->tuples_deleted;
      deadtuples -= trans->tuples_updated + trans->tuples_deleted;
    }
    /* count stuff inserted by already-aborted subxacts, too */
    deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
    /* Since ANALYZE's counts are estimates, we could have underflowed */
    livetuples = Max(livetuples, 0);
    deadtuples = Max(deadtuples, 0);
  }


  pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
  msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
  msg.m_tableoid = RelationGetRelid(rel);
  msg.m_autovacuum = IsAutoVacuumWorkerProcess();
  msg.m_resetcounter = resetcounter;
  msg.m_analyzetime = GetCurrentTimestamp();
  msg.m_live_tuples = livetuples;  // live元组
  msg.m_dead_tuples = deadtuples;  // dead元组
  pgstat_send(&msg, sizeof(msg));
}