network_selfuncs.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/htup_details.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_statistic.h"
#include "utils/fmgrprotos.h"
#include "utils/inet.h"
#include "utils/lsyscache.h"
#include "utils/selfuncs.h"

Include dependency graph for network_selfuncs.c:

Go to the source code of this file.

Macros
#define	DEFAULT_OVERLAP_SEL   0.01
#define	DEFAULT_INCLUSION_SEL   0.005
#define	DEFAULT_SEL(operator)
#define	MAX_CONSIDERED_ELEMS   1024

Functions
static Selectivity	networkjoinsel_inner (Oid operator, int opr_codenum, VariableStatData *vardata1, VariableStatData *vardata2)
static Selectivity	networkjoinsel_semi (Oid operator, int opr_codenum, VariableStatData *vardata1, VariableStatData *vardata2)
static Selectivity	mcv_population (float4 *mcv_numbers, int mcv_nvalues)
static Selectivity	inet_hist_value_sel (const Datum *values, int nvalues, Datum constvalue, int opr_codenum)
static Selectivity	inet_mcv_join_sel (Datum *mcv1_values, float4 *mcv1_numbers, int mcv1_nvalues, Datum *mcv2_values, float4 *mcv2_numbers, int mcv2_nvalues, Oid operator)
static Selectivity	inet_mcv_hist_sel (const Datum *mcv_values, float4 *mcv_numbers, int mcv_nvalues, const Datum *hist_values, int hist_nvalues, int opr_codenum)
static Selectivity	inet_hist_inclusion_join_sel (const Datum *hist1_values, int hist1_nvalues, const Datum *hist2_values, int hist2_nvalues, int opr_codenum)
static Selectivity	inet_semi_join_sel (Datum lhs_value, bool mcv_exists, Datum *mcv_values, int mcv_nvalues, bool hist_exists, Datum *hist_values, int hist_nvalues, double hist_weight, FmgrInfo *proc, int opr_codenum)
static int	inet_opr_codenum (Oid operator)
static int	inet_inclusion_cmp (inet *left, inet *right, int opr_codenum)
static int	inet_masklen_inclusion_cmp (inet *left, inet *right, int opr_codenum)
static int	inet_hist_match_divider (inet *boundary, inet *query, int opr_codenum)
Datum	networksel (PG_FUNCTION_ARGS)
Datum	networkjoinsel (PG_FUNCTION_ARGS)

Macro Definition Documentation

DEFAULT_INCLUSION_SEL

#define DEFAULT_INCLUSION_SEL   0.005

Definition at line 36 of file network_selfuncs.c.

DEFAULT_OVERLAP_SEL

#define DEFAULT_OVERLAP_SEL   0.01

Definition at line 33 of file network_selfuncs.c.

DEFAULT_SEL

#define DEFAULT_SEL

(

operator

)

Value:

    ((operator) == OID_INET_OVERLAP_OP ? \
     DEFAULT_OVERLAP_SEL : DEFAULT_INCLUSION_SEL)

Definition at line 39 of file network_selfuncs.c.

                         : DEFAULT_INCLUSION_SEL)

MAX_CONSIDERED_ELEMS

#define MAX_CONSIDERED_ELEMS   1024

Definition at line 44 of file network_selfuncs.c.

Function Documentation

inet_hist_inclusion_join_sel()

static Selectivity inet_hist_inclusion_join_sel ( const Datum *  hist1_values, int  hist1_nvalues, const Datum *  hist2_values, int  hist2_nvalues, int  opr_codenum  )

static

Definition at line 757 of file network_selfuncs.c.

{
    double      match = 0.0;
    int         i,
                k,
                n;
 
    if (hist2_nvalues <= 2)
        return 0.0;             /* no interior histogram elements */
 
    /* if there are too many histogram elements, decimate to limit runtime */
    k = (hist2_nvalues - 3) / MAX_CONSIDERED_ELEMS + 1;
 
    n = 0;
    for (i = 1; i < hist2_nvalues - 1; i += k)
    {
        match += inet_hist_value_sel(hist1_values, hist1_nvalues,
                                     hist2_values[i], opr_codenum);
        n++;
    }
 
    return match / n;
}

References fb(), i, inet_hist_value_sel(), and MAX_CONSIDERED_ELEMS.

Referenced by networkjoinsel_inner().

inet_hist_match_divider()

static int inet_hist_match_divider ( inet *  boundary, inet *  query, int  opr_codenum  )

static

Definition at line 957 of file network_selfuncs.c.

{
    if (ip_family(boundary) == ip_family(query) &&
        inet_masklen_inclusion_cmp(boundary, query, opr_codenum) == 0)
    {
        int         min_bits,
                    decisive_bits;
 
        min_bits = Min(ip_bits(boundary), ip_bits(query));
 
        /*
         * Set decisive_bits to the masklen of the one that should contain the
         * other according to the operator.
         */
        if (opr_codenum < 0)
            decisive_bits = ip_bits(boundary);
        else if (opr_codenum > 0)
            decisive_bits = ip_bits(query);
        else
            decisive_bits = min_bits;
 
        /*
         * Now return the number of non-common decisive bits.  (This will be
         * zero if the boundary and query in fact match, else positive.)
         */
        if (min_bits > 0)
            return decisive_bits - bitncommon(ip_addr(boundary),
                                              ip_addr(query),
                                              min_bits);
        return decisive_bits;
    }
 
    return -1;
}

References bitncommon(), fb(), inet_masklen_inclusion_cmp(), ip_addr, ip_bits, ip_family, and Min.

Referenced by inet_hist_value_sel().

inet_hist_value_sel()

static Selectivity inet_hist_value_sel ( const Datum *  values, int  nvalues, Datum  constvalue, int  opr_codenum  )

static

Definition at line 619 of file network_selfuncs.c.

{
    Selectivity match = 0.0;
    inet       *query,
               *left,
               *right;
    int         i,
                k,
                n;
    int         left_order,
                right_order,
                left_divider,
                right_divider;
 
    /* guard against zero-divide below */
    if (nvalues <= 1)
        return 0.0;
 
    /* if there are too many histogram elements, decimate to limit runtime */
    k = (nvalues - 2) / MAX_CONSIDERED_ELEMS + 1;
 
    query = DatumGetInetPP(constvalue);
 
    /* "left" is the left boundary value of the current bucket ... */
    left = DatumGetInetPP(values[0]);
    left_order = inet_inclusion_cmp(left, query, opr_codenum);
 
    n = 0;
    for (i = k; i < nvalues; i += k)
    {
        /* ... and "right" is the right boundary value */
        right = DatumGetInetPP(values[i]);
        right_order = inet_inclusion_cmp(right, query, opr_codenum);
 
        if (left_order == 0 && right_order == 0)
        {
            /* The whole bucket matches, since both endpoints do. */
            match += 1.0;
        }
        else if ((left_order <= 0 && right_order >= 0) ||
                 (left_order >= 0 && right_order <= 0))
        {
            /* Partial bucket match. */
            left_divider = inet_hist_match_divider(left, query, opr_codenum);
            right_divider = inet_hist_match_divider(right, query, opr_codenum);
 
            if (left_divider >= 0 || right_divider >= 0)
                match += 1.0 / pow(2.0, Max(left_divider, right_divider));
        }
 
        /* Shift the variables. */
        left = right;
        left_order = right_order;
 
        /* Count the number of buckets considered. */
        n++;
    }
 
    return match / n;
}

References DatumGetInetPP(), fb(), i, inet_hist_match_divider(), inet_inclusion_cmp(), Max, MAX_CONSIDERED_ELEMS, and values.

Referenced by inet_hist_inclusion_join_sel(), inet_mcv_hist_sel(), inet_semi_join_sel(), and networksel().

inet_inclusion_cmp()

static int inet_inclusion_cmp ( inet *  left, inet *  right, int  opr_codenum  )

static

Definition at line 897 of file network_selfuncs.c.

{
    if (ip_family(left) == ip_family(right))
    {
        int         order;
 
        order = bitncmp(ip_addr(left), ip_addr(right),
                        Min(ip_bits(left), ip_bits(right)));
        if (order != 0)
            return order;
 
        return inet_masklen_inclusion_cmp(left, right, opr_codenum);
    }
 
    return ip_family(left) - ip_family(right);
}

References bitncmp(), fb(), inet_masklen_inclusion_cmp(), ip_addr, ip_bits, ip_family, and Min.

Referenced by inet_hist_value_sel().

inet_masklen_inclusion_cmp()

static int inet_masklen_inclusion_cmp ( inet *  left, inet *  right, int  opr_codenum  )

static

Definition at line 923 of file network_selfuncs.c.

{
    int         order;
 
    order = (int) ip_bits(left) - (int) ip_bits(right);
 
    /*
     * Return 0 if the operator would accept this combination of masklens.
     * Note that opr_codenum zero (overlaps) will accept all cases.
     */
    if ((order > 0 && opr_codenum >= 0) ||
        (order == 0 && opr_codenum >= -1 && opr_codenum <= 1) ||
        (order < 0 && opr_codenum <= 0))
        return 0;
 
    /*
     * Otherwise, return a negative value for sup/supeq (notionally, the RHS
     * needs to have a larger masklen than it has, which would make it sort
     * later), or a positive value for sub/subeq (vice versa).
     */
    return opr_codenum;
}

References fb(), and ip_bits.

Referenced by inet_hist_match_divider(), and inet_inclusion_cmp().

inet_mcv_hist_sel()

static Selectivity inet_mcv_hist_sel ( const Datum *  mcv_values, float4 *  mcv_numbers, int  mcv_nvalues, const Datum *  hist_values, int  hist_nvalues, int  opr_codenum  )

static

Definition at line 720 of file network_selfuncs.c.

{
    Selectivity selec = 0.0;
    int         i;
 
    /*
     * We'll call inet_hist_value_selec with the histogram on the left, so we
     * must commute the operator.
     */
    opr_codenum = -opr_codenum;
 
    for (i = 0; i < mcv_nvalues; i++)
    {
        selec += mcv_numbers[i] *
            inet_hist_value_sel(hist_values, hist_nvalues, mcv_values[i],
                                opr_codenum);
    }
    return selec;
}

References fb(), i, and inet_hist_value_sel().

Referenced by networkjoinsel_inner().

inet_mcv_join_sel()

static Selectivity inet_mcv_join_sel ( Datum *  mcv1_values, float4 *  mcv1_numbers, int  mcv1_nvalues, Datum *  mcv2_values, float4 *  mcv2_numbers, int  mcv2_nvalues, Oid  operator  )

static

Definition at line 688 of file network_selfuncs.c.

{
    Selectivity selec = 0.0;
    FmgrInfo    proc;
    int         i,
                j;
 
    fmgr_info(get_opcode(operator), &proc);
 
    for (i = 0; i < mcv1_nvalues; i++)
    {
        for (j = 0; j < mcv2_nvalues; j++)
            if (DatumGetBool(FunctionCall2(&proc,
                                           mcv1_values[i],
                                           mcv2_values[j])))
                selec += mcv1_numbers[i] * mcv2_numbers[j];
    }
    return selec;
}

References DatumGetBool(), fb(), fmgr_info(), FunctionCall2, get_opcode(), i, and j.

Referenced by networkjoinsel_inner().

inet_opr_codenum()

static int inet_opr_codenum ( Oid  operator )

static

Definition at line 854 of file network_selfuncs.c.

{
    switch (operator)
    {
        case OID_INET_SUP_OP:
            return -2;
        case OID_INET_SUPEQ_OP:
            return -1;
        case OID_INET_OVERLAP_OP:
            return 0;
        case OID_INET_SUBEQ_OP:
            return 1;
        case OID_INET_SUB_OP:
            return 2;
        default:
            elog(ERROR, "unrecognized operator %u for inet selectivity",
                 operator);
    }
    return 0;                   /* unreached, but keep compiler quiet */
}

References elog, ERROR, and fb().

Referenced by networkjoinsel(), and networksel().

inet_semi_join_sel()

static Selectivity inet_semi_join_sel ( Datum  lhs_value, bool  mcv_exists, Datum *  mcv_values, int  mcv_nvalues, bool  hist_exists, Datum *  hist_values, int  hist_nvalues, double  hist_weight, FmgrInfo *  proc, int  opr_codenum  )

static

Definition at line 808 of file network_selfuncs.c.

{
    if (mcv_exists)
    {
        int         i;
 
        for (i = 0; i < mcv_nvalues; i++)
        {
            if (DatumGetBool(FunctionCall2(proc,
                                           lhs_value,
                                           mcv_values[i])))
                return 1.0;
        }
    }
 
    if (hist_exists && hist_weight > 0)
    {
        Selectivity hist_selec;
 
        /* Commute operator, since we're passing lhs_value on the right */
        hist_selec = inet_hist_value_sel(hist_values, hist_nvalues,
                                         lhs_value, -opr_codenum);
 
        if (hist_selec > 0)
            return Min(1.0, hist_weight * hist_selec);
    }
 
    return 0.0;
}

References DatumGetBool(), fb(), FunctionCall2, i, inet_hist_value_sel(), and Min.

Referenced by networkjoinsel_semi().

mcv_population()

static Selectivity mcv_population ( float4 *  mcv_numbers, int  mcv_nvalues  )

static

Definition at line 554 of file network_selfuncs.c.

{
    Selectivity sumcommon = 0.0;
    int         i;
 
    for (i = 0; i < mcv_nvalues; i++)
    {
        sumcommon += mcv_numbers[i];
    }
 
    return sumcommon;
}

References fb(), and i.

Referenced by networkjoinsel_inner(), and networkjoinsel_semi().

networkjoinsel()

Datum networkjoinsel

(

PG_FUNCTION_ARGS

)

Definition at line 204 of file network_selfuncs.c.

{
    PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
    Oid         operator = PG_GETARG_OID(1);
    List       *args = (List *) PG_GETARG_POINTER(2);
#ifdef NOT_USED
    JoinType    jointype = (JoinType) PG_GETARG_INT16(3);
#endif
    SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) PG_GETARG_POINTER(4);
    double      selec;
    int         opr_codenum;
    VariableStatData vardata1;
    VariableStatData vardata2;
    bool        join_is_reversed;
 
    /*
     * Before all else, verify that the operator is one of the ones supported
     * by this function, which in turn proves that the input datatypes are
     * what we expect.  Otherwise, attaching this selectivity function to some
     * unexpected operator could cause trouble.
     */
    opr_codenum = inet_opr_codenum(operator);
 
    get_join_variables(root, args, sjinfo,
                       &vardata1, &vardata2, &join_is_reversed);
 
    switch (sjinfo->jointype)
    {
        case JOIN_INNER:
        case JOIN_LEFT:
        case JOIN_FULL:
 
            /*
             * Selectivity for left/full join is not exactly the same as inner
             * join, but we neglect the difference, as eqjoinsel does.
             */
            selec = networkjoinsel_inner(operator, opr_codenum,
                                         &vardata1, &vardata2);
            break;
        case JOIN_SEMI:
        case JOIN_ANTI:
            /* Here, it's important that we pass the outer var on the left. */
            if (!join_is_reversed)
                selec = networkjoinsel_semi(operator, opr_codenum,
                                            &vardata1, &vardata2);
            else
                selec = networkjoinsel_semi(get_commutator(operator),
                                            -opr_codenum,
                                            &vardata2, &vardata1);
            break;
        default:
            /* other values not expected here */
            elog(ERROR, "unrecognized join type: %d",
                 (int) sjinfo->jointype);
            selec = 0;          /* keep compiler quiet */
            break;
    }
 
    ReleaseVariableStats(vardata1);
    ReleaseVariableStats(vardata2);
 
    CLAMP_PROBABILITY(selec);
 
    PG_RETURN_FLOAT8((float8) selec);
}

References CLAMP_PROBABILITY, elog, ERROR, fb(), get_commutator(), get_join_variables(), inet_opr_codenum(), JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_SEMI, SpecialJoinInfo::jointype, networkjoinsel_inner(), networkjoinsel_semi(), PG_GETARG_INT16, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_FLOAT8, ReleaseVariableStats, and root.

networkjoinsel_inner()

static Selectivity networkjoinsel_inner ( Oid  operator, int  opr_codenum, VariableStatData *  vardata1, VariableStatData *  vardata2  )

static

Definition at line 283 of file network_selfuncs.c.

{
    Form_pg_statistic stats;
    double      nullfrac1 = 0.0,
                nullfrac2 = 0.0;
    Selectivity selec = 0.0,
                sumcommon1 = 0.0,
                sumcommon2 = 0.0;
    bool        mcv1_exists = false,
                mcv2_exists = false,
                hist1_exists = false,
                hist2_exists = false;
    int         mcv1_length = 0,
                mcv2_length = 0;
    AttStatsSlot mcv1_slot;
    AttStatsSlot mcv2_slot;
    AttStatsSlot hist1_slot;
    AttStatsSlot hist2_slot;
 
    if (HeapTupleIsValid(vardata1->statsTuple))
    {
        stats = (Form_pg_statistic) GETSTRUCT(vardata1->statsTuple);
        nullfrac1 = stats->stanullfrac;
 
        mcv1_exists = get_attstatsslot(&mcv1_slot, vardata1->statsTuple,
                                       STATISTIC_KIND_MCV, InvalidOid,
                                       ATTSTATSSLOT_VALUES | ATTSTATSSLOT_NUMBERS);
        hist1_exists = get_attstatsslot(&hist1_slot, vardata1->statsTuple,
                                        STATISTIC_KIND_HISTOGRAM, InvalidOid,
                                        ATTSTATSSLOT_VALUES);
        /* Arbitrarily limit number of MCVs considered */
        mcv1_length = Min(mcv1_slot.nvalues, MAX_CONSIDERED_ELEMS);
        if (mcv1_exists)
            sumcommon1 = mcv_population(mcv1_slot.numbers, mcv1_length);
    }
    else
    {
        memset(&mcv1_slot, 0, sizeof(mcv1_slot));
        memset(&hist1_slot, 0, sizeof(hist1_slot));
    }
 
    if (HeapTupleIsValid(vardata2->statsTuple))
    {
        stats = (Form_pg_statistic) GETSTRUCT(vardata2->statsTuple);
        nullfrac2 = stats->stanullfrac;
 
        mcv2_exists = get_attstatsslot(&mcv2_slot, vardata2->statsTuple,
                                       STATISTIC_KIND_MCV, InvalidOid,
                                       ATTSTATSSLOT_VALUES | ATTSTATSSLOT_NUMBERS);
        hist2_exists = get_attstatsslot(&hist2_slot, vardata2->statsTuple,
                                        STATISTIC_KIND_HISTOGRAM, InvalidOid,
                                        ATTSTATSSLOT_VALUES);
        /* Arbitrarily limit number of MCVs considered */
        mcv2_length = Min(mcv2_slot.nvalues, MAX_CONSIDERED_ELEMS);
        if (mcv2_exists)
            sumcommon2 = mcv_population(mcv2_slot.numbers, mcv2_length);
    }
    else
    {
        memset(&mcv2_slot, 0, sizeof(mcv2_slot));
        memset(&hist2_slot, 0, sizeof(hist2_slot));
    }
 
    /*
     * Calculate selectivity for MCV vs MCV matches.
     */
    if (mcv1_exists && mcv2_exists)
        selec += inet_mcv_join_sel(mcv1_slot.values, mcv1_slot.numbers,
                                   mcv1_length,
                                   mcv2_slot.values, mcv2_slot.numbers,
                                   mcv2_length,
                                   operator);
 
    /*
     * Add in selectivities for MCV vs histogram matches, scaling according to
     * the fractions of the populations represented by the histograms. Note
     * that the second case needs to commute the operator.
     */
    if (mcv1_exists && hist2_exists)
        selec += (1.0 - nullfrac2 - sumcommon2) *
            inet_mcv_hist_sel(mcv1_slot.values, mcv1_slot.numbers, mcv1_length,
                              hist2_slot.values, hist2_slot.nvalues,
                              opr_codenum);
    if (mcv2_exists && hist1_exists)
        selec += (1.0 - nullfrac1 - sumcommon1) *
            inet_mcv_hist_sel(mcv2_slot.values, mcv2_slot.numbers, mcv2_length,
                              hist1_slot.values, hist1_slot.nvalues,
                              -opr_codenum);
 
    /*
     * Add in selectivity for histogram vs histogram matches, again scaling
     * appropriately.
     */
    if (hist1_exists && hist2_exists)
        selec += (1.0 - nullfrac1 - sumcommon1) *
            (1.0 - nullfrac2 - sumcommon2) *
            inet_hist_inclusion_join_sel(hist1_slot.values, hist1_slot.nvalues,
                                         hist2_slot.values, hist2_slot.nvalues,
                                         opr_codenum);
 
    /*
     * If useful statistics are not available then use the default estimate.
     * We can apply null fractions if known, though.
     */
    if ((!mcv1_exists && !hist1_exists) || (!mcv2_exists && !hist2_exists))
        selec = (1.0 - nullfrac1) * (1.0 - nullfrac2) * DEFAULT_SEL(operator);
 
    /* Release stats. */
    free_attstatsslot(&mcv1_slot);
    free_attstatsslot(&mcv2_slot);
    free_attstatsslot(&hist1_slot);
    free_attstatsslot(&hist2_slot);
 
    return selec;
}

References ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, DEFAULT_SEL, fb(), free_attstatsslot(), get_attstatsslot(), GETSTRUCT(), HeapTupleIsValid, inet_hist_inclusion_join_sel(), inet_mcv_hist_sel(), inet_mcv_join_sel(), InvalidOid, MAX_CONSIDERED_ELEMS, mcv_population(), and Min.

Referenced by networkjoinsel().

networkjoinsel_semi()

static Selectivity networkjoinsel_semi ( Oid  operator, int  opr_codenum, VariableStatData *  vardata1, VariableStatData *  vardata2  )

static

Definition at line 407 of file network_selfuncs.c.

{
    Form_pg_statistic stats;
    Selectivity selec = 0.0,
                sumcommon1 = 0.0,
                sumcommon2 = 0.0;
    double      nullfrac1 = 0.0,
                nullfrac2 = 0.0,
                hist2_weight = 0.0;
    bool        mcv1_exists = false,
                mcv2_exists = false,
                hist1_exists = false,
                hist2_exists = false;
    FmgrInfo    proc;
    int         i,
                mcv1_length = 0,
                mcv2_length = 0;
    AttStatsSlot mcv1_slot;
    AttStatsSlot mcv2_slot;
    AttStatsSlot hist1_slot;
    AttStatsSlot hist2_slot;
 
    if (HeapTupleIsValid(vardata1->statsTuple))
    {
        stats = (Form_pg_statistic) GETSTRUCT(vardata1->statsTuple);
        nullfrac1 = stats->stanullfrac;
 
        mcv1_exists = get_attstatsslot(&mcv1_slot, vardata1->statsTuple,
                                       STATISTIC_KIND_MCV, InvalidOid,
                                       ATTSTATSSLOT_VALUES | ATTSTATSSLOT_NUMBERS);
        hist1_exists = get_attstatsslot(&hist1_slot, vardata1->statsTuple,
                                        STATISTIC_KIND_HISTOGRAM, InvalidOid,
                                        ATTSTATSSLOT_VALUES);
        /* Arbitrarily limit number of MCVs considered */
        mcv1_length = Min(mcv1_slot.nvalues, MAX_CONSIDERED_ELEMS);
        if (mcv1_exists)
            sumcommon1 = mcv_population(mcv1_slot.numbers, mcv1_length);
    }
    else
    {
        memset(&mcv1_slot, 0, sizeof(mcv1_slot));
        memset(&hist1_slot, 0, sizeof(hist1_slot));
    }
 
    if (HeapTupleIsValid(vardata2->statsTuple))
    {
        stats = (Form_pg_statistic) GETSTRUCT(vardata2->statsTuple);
        nullfrac2 = stats->stanullfrac;
 
        mcv2_exists = get_attstatsslot(&mcv2_slot, vardata2->statsTuple,
                                       STATISTIC_KIND_MCV, InvalidOid,
                                       ATTSTATSSLOT_VALUES | ATTSTATSSLOT_NUMBERS);
        hist2_exists = get_attstatsslot(&hist2_slot, vardata2->statsTuple,
                                        STATISTIC_KIND_HISTOGRAM, InvalidOid,
                                        ATTSTATSSLOT_VALUES);
        /* Arbitrarily limit number of MCVs considered */
        mcv2_length = Min(mcv2_slot.nvalues, MAX_CONSIDERED_ELEMS);
        if (mcv2_exists)
            sumcommon2 = mcv_population(mcv2_slot.numbers, mcv2_length);
    }
    else
    {
        memset(&mcv2_slot, 0, sizeof(mcv2_slot));
        memset(&hist2_slot, 0, sizeof(hist2_slot));
    }
 
    fmgr_info(get_opcode(operator), &proc);
 
    /* Estimate number of input rows represented by RHS histogram. */
    if (hist2_exists && vardata2->rel)
        hist2_weight = (1.0 - nullfrac2 - sumcommon2) * vardata2->rel->rows;
 
    /*
     * Consider each element of the LHS MCV list, matching it to whatever RHS
     * stats we have.  Scale according to the known frequency of the MCV.
     */
    if (mcv1_exists && (mcv2_exists || hist2_exists))
    {
        for (i = 0; i < mcv1_length; i++)
        {
            selec += mcv1_slot.numbers[i] *
                inet_semi_join_sel(mcv1_slot.values[i],
                                   mcv2_exists, mcv2_slot.values, mcv2_length,
                                   hist2_exists,
                                   hist2_slot.values, hist2_slot.nvalues,
                                   hist2_weight,
                                   &proc, opr_codenum);
        }
    }
 
    /*
     * Consider each element of the LHS histogram, except for the first and
     * last elements, which we exclude on the grounds that they're outliers
     * and thus not very representative.  Scale on the assumption that each
     * such histogram element represents an equal share of the LHS histogram
     * population (which is a bit bogus, because the members of its bucket may
     * not all act the same with respect to the join clause, but it's hard to
     * do better).
     *
     * If there are too many histogram elements, decimate to limit runtime.
     */
    if (hist1_exists && hist1_slot.nvalues > 2 && (mcv2_exists || hist2_exists))
    {
        double      hist_selec_sum = 0.0;
        int         k,
                    n;
 
        k = (hist1_slot.nvalues - 3) / MAX_CONSIDERED_ELEMS + 1;
 
        n = 0;
        for (i = 1; i < hist1_slot.nvalues - 1; i += k)
        {
            hist_selec_sum +=
                inet_semi_join_sel(hist1_slot.values[i],
                                   mcv2_exists, mcv2_slot.values, mcv2_length,
                                   hist2_exists,
                                   hist2_slot.values, hist2_slot.nvalues,
                                   hist2_weight,
                                   &proc, opr_codenum);
            n++;
        }
 
        selec += (1.0 - nullfrac1 - sumcommon1) * hist_selec_sum / n;
    }
 
    /*
     * If useful statistics are not available then use the default estimate.
     * We can apply null fractions if known, though.
     */
    if ((!mcv1_exists && !hist1_exists) || (!mcv2_exists && !hist2_exists))
        selec = (1.0 - nullfrac1) * (1.0 - nullfrac2) * DEFAULT_SEL(operator);
 
    /* Release stats. */
    free_attstatsslot(&mcv1_slot);
    free_attstatsslot(&mcv2_slot);
    free_attstatsslot(&hist1_slot);
    free_attstatsslot(&hist2_slot);
 
    return selec;
}

References ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, DEFAULT_SEL, fb(), fmgr_info(), free_attstatsslot(), get_attstatsslot(), get_opcode(), GETSTRUCT(), HeapTupleIsValid, i, inet_semi_join_sel(), InvalidOid, MAX_CONSIDERED_ELEMS, mcv_population(), and Min.

Referenced by networkjoinsel().

networksel()

Datum networksel

(

PG_FUNCTION_ARGS

)

Definition at line 79 of file network_selfuncs.c.

{
    PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
    Oid         operator = PG_GETARG_OID(1);
    List       *args = (List *) PG_GETARG_POINTER(2);
    int         varRelid = PG_GETARG_INT32(3);
    int         opr_codenum;
    VariableStatData vardata;
    Node       *other;
    bool        varonleft;
    Selectivity selec,
                mcv_selec,
                non_mcv_selec;
    Datum       constvalue;
    Form_pg_statistic stats;
    AttStatsSlot hslot;
    double      sumcommon,
                nullfrac;
    FmgrInfo    proc;
 
    /*
     * Before all else, verify that the operator is one of the ones supported
     * by this function, which in turn proves that the input datatypes are
     * what we expect.  Otherwise, attaching this selectivity function to some
     * unexpected operator could cause trouble.
     */
    opr_codenum = inet_opr_codenum(operator);
 
    /*
     * If expression is not (variable op something) or (something op
     * variable), then punt and return a default estimate.
     */
    if (!get_restriction_variable(root, args, varRelid,
                                  &vardata, &other, &varonleft))
        PG_RETURN_FLOAT8(DEFAULT_SEL(operator));
 
    /*
     * Can't do anything useful if the something is not a constant, either.
     */
    if (!IsA(other, Const))
    {
        ReleaseVariableStats(vardata);
        PG_RETURN_FLOAT8(DEFAULT_SEL(operator));
    }
 
    /* All of the operators handled here are strict. */
    if (((Const *) other)->constisnull)
    {
        ReleaseVariableStats(vardata);
        PG_RETURN_FLOAT8(0.0);
    }
    constvalue = ((Const *) other)->constvalue;
 
    /* Otherwise, we need stats in order to produce a non-default estimate. */
    if (!HeapTupleIsValid(vardata.statsTuple))
    {
        ReleaseVariableStats(vardata);
        PG_RETURN_FLOAT8(DEFAULT_SEL(operator));
    }
 
    stats = (Form_pg_statistic) GETSTRUCT(vardata.statsTuple);
    nullfrac = stats->stanullfrac;
 
    /*
     * If we have most-common-values info, add up the fractions of the MCV
     * entries that satisfy MCV OP CONST.  These fractions contribute directly
     * to the result selectivity.  Also add up the total fraction represented
     * by MCV entries.
     */
    fmgr_info(get_opcode(operator), &proc);
    mcv_selec = mcv_selectivity(&vardata, &proc, InvalidOid,
                                constvalue, varonleft,
                                &sumcommon);
 
    /*
     * If we have a histogram, use it to estimate the proportion of the
     * non-MCV population that satisfies the clause.  If we don't, apply the
     * default selectivity to that population.
     */
    if (get_attstatsslot(&hslot, vardata.statsTuple,
                         STATISTIC_KIND_HISTOGRAM, InvalidOid,
                         ATTSTATSSLOT_VALUES))
    {
        int         h_codenum;
 
        /* Commute if needed, so we can consider histogram to be on the left */
        h_codenum = varonleft ? opr_codenum : -opr_codenum;
        non_mcv_selec = inet_hist_value_sel(hslot.values, hslot.nvalues,
                                            constvalue, h_codenum);
 
        free_attstatsslot(&hslot);
    }
    else
        non_mcv_selec = DEFAULT_SEL(operator);
 
    /* Combine selectivities for MCV and non-MCV populations */
    selec = mcv_selec + (1.0 - nullfrac - sumcommon) * non_mcv_selec;
 
    /* Result should be in range, but make sure... */
    CLAMP_PROBABILITY(selec);
 
    ReleaseVariableStats(vardata);
 
    PG_RETURN_FLOAT8(selec);
}

References ATTSTATSSLOT_VALUES, CLAMP_PROBABILITY, DEFAULT_SEL, fb(), fmgr_info(), free_attstatsslot(), get_attstatsslot(), get_opcode(), get_restriction_variable(), GETSTRUCT(), HeapTupleIsValid, inet_hist_value_sel(), inet_opr_codenum(), InvalidOid, IsA, mcv_selectivity(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_FLOAT8, ReleaseVariableStats, and root.