create table t1 (id int, c2 text);
alter table t1  add constraint pk_t1_id primary key (id);


CREATE OR REPLACE FUNCTION generate_data()
RETURNS int AS $$
DECLARE
  i INT;
  start INT;
    row_count INT := 20000;
  val INT;
BEGIN
  SELECT COUNT(*) INTO start FROM t1;
    FOR i IN SELECT generate_series(1, row_count) LOOP
        INSERT INTO t1 VALUES (start + i, left(pg_catalog.random()::text, 7));
    END LOOP;


  -- set null value
  val := abs(right(pg_catalog.random(), 2)::int - right(pg_catalog.random(), 2)::int);
  i := 1;
  FOR i IN SELECT generate_series(1, val) LOOP
    start := start * (right(pg_catalog.random(), 1)::int);
    UPDATE t1 SET c2 = NULL WHERE id = start;
  END LOOP;


  RETURN row_count;
END;
$$ LANGUAGE plpgsql;


select  generate_data();
analyze t1;

select * from pg_statistic where starelid = 't1'::regclass and staattnum = 2;

select Oid, relname, relpages, reltuples from pg_class where relname = 't1';

-- 非高频值
select * from t1 where c2 = '.734463';

/* default selectivity estimate for equalities such as "A = b" */
#define DEFAULT_EQ_SEL 0.005


/* default selectivity estimate for inequalities such as "A < b" */
#define DEFAULT_INEQ_SEL 0.3333333333333333


/* default selectivity estimate for range inequalities "A > b AND A < c" */
#define DEFAULT_RANGE_INEQ_SEL 0.005


/* default selectivity estimate for pattern-match operators such as LIKE */
#define DEFAULT_MATCH_SEL 0.005


/* default number of distinct values in a table */
#define DEFAULT_NUM_DISTINCT 200


/* default number of rows */
#define DEFAULT_NUM_ROWS 10


/* default number of distinct values and biase for the special expression */
#define DEFAULT_SPECIAL_EXPR_DISTINCT 10
#define DEFAULT_SPECIAL_EXPR_BIASE (pow(u_sess->pgxc_cxt.NumDataNodes, (double)1  2)  u_sess->pgxc_cxt.NumDataNodes)


/* default selectivity estimate for boolean、null、nan、infinite test nodes */
#define DEFAULT_UNK_SEL 0.005
#define DEFAULT_NOT_UNK_SEL (1.0 - DEFAULT_UNK_SEL)


/* default selectivity estimate for neq anti join */
#define MIN_NEQ_ANTI_SEL 0.05
#define MAX_NEQ_SEMI_SEL (1.0 - MIN_NEQ_ANTI_SEL)

/*
 * If expression is not variable = something or something = variable, then
 * punt and return a default estimate.
 */
if (!get_restriction_variable(root, args, varRelid, &vardata, &other, &varonleft)) {
    *
     * For Var=Var cases, return non-null frac instead of DEFAULT_EQ_SEL.
     * This is to avoid selectivity underestimate.
     */
    if (is_var_eq_var_expr(args)) {
        Node* left = (Node*)linitial(args);
        selec = nulltestsel(root, IS_NOT_NULL, left, varRelid, JOIN_INNER, NULL);
        PG_RETURN_FLOAT8((float8)selec);
    }
    PG_RETURN_FLOAT8(DEFAULT_EQ_SEL);
}

/*
 * If we matched the var to a unique index or DISTINCT clause, assume
 * there is exactly one match regardless of anything else.  (This is
 * slightly bogus, since the index or clause's equality operator might be
 * different from ours, but it's much more likely to be right than
 * ignoring the information.)
 */
if (vardata->isunique && vardata->rel && vardata->rel->tuples >= 1.0)
    return 1.0 / vardata->rel->tuples;

        *
         * Is the constant "=" to any of the column's most common values?
         * (Although the given operator may not really be "=", we will assume
         * that seeing whether it returns TRUE is an appropriate test.  If you
         * don't like this, maybe you shouldn't be using eqsel for your
         * operator...)
         */
        if (get_attstatsslot(vardata->statsTuple,
                vardata->atttype,
                vardata->atttypmod,
                STATISTIC_KIND_MCV,
                InvalidOid,
                NULL,
                &values,
                &nvalues,
                &numbers,
                &nnumbers)) {
            FmgrInfo eqproc;


            fmgr_info(opfuncoid, &eqproc);


            for (i = 0; i < nvalues; i++) {
                /* be careful to apply operator right way 'round */
                if (varonleft)
                    match = DatumGetBool(FunctionCall2Coll(&eqproc, DEFAULT_COLLATION_OID, values[i], constval));
                else
                    match = DatumGetBool(FunctionCall2Coll(&eqproc, DEFAULT_COLLATION_OID, constval, values[i]));
                if (match)
                    break;
            }
        } else {
            /* no most-common-value info available */
            values = NULL;
            numbers = NULL;
            i = nvalues = nnumbers = 0;
        }


        if (match) {
            selec = numbers[i];

        /*
         * Comparison is against a constant that is neither NULL nor any
         * of the common values.  Its selectivity cannot be more than
         * this:
         */
        double sumcommon = 0.0;
        double otherdistinct;
        double extrapolationselec = 0.0;


        for (i = 0; i < nnumbers; i++)
            sumcommon += numbers[i];
        selec = 1.0 - sumcommon - stats->stanullfrac;

otherdistinct = get_variable_numdistinct(vardata, &isdefault, false, 1.0, NULL, STATS_TYPE_GLOBAL) - nnumbers;

static double var_eq_const_selectivity(VariableStatData *vardata, double selec, double otherdistinct, Datum constval)
{
    if (u_sess->attr.attr_sql.var_eq_const_selectivity == true && IsIntType(vardata->atttype)) {
        double hist_selec = var_eq_const_histogram(vardata, selec, otherdistinct, constval);


        ......
    }
    return selec;
}

if (otherdistinct > 1)
    selec /= otherdistinct;

if (nnumbers > 0 && selec > numbers[nnumbers - 1])
                selec = numbers[nnumbers - 1];