queryjumblefuncs.c File Reference

#include "postgres.h"
#include "access/transam.h"
#include "catalog/pg_proc.h"
#include "common/hashfn.h"
#include "common/int.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "nodes/queryjumble.h"
#include "utils/lsyscache.h"
#include "parser/scanner.h"
#include "parser/scansup.h"
#include "queryjumblefuncs.funcs.c"
#include "queryjumblefuncs.switch.c"

Include dependency graph for queryjumblefuncs.c:

Go to the source code of this file.

Macros
#define	JUMBLE_SIZE   1024 /* query serialization buffer size */
#define	JUMBLE_NODE(item)    _jumbleNode(jstate, (Node *) expr->item)
#define	JUMBLE_ELEMENTS(list, node)    _jumbleElements(jstate, (List *) expr->list, node)
#define	JUMBLE_LOCATION(location)    RecordConstLocation(jstate, false, expr->location, -1)
#define	JUMBLE_FIELD(item)
#define	JUMBLE_STRING(str)
#define	JUMBLE_CUSTOM(nodetype, item)    _jumble##nodetype##_##item(jstate, expr, expr->item)

Functions
static JumbleState *	InitJumble (void)
static int64	DoJumble (JumbleState *jstate, Node *node)
static void	AppendJumble (JumbleState *jstate, const unsigned char *value, Size size)
static void	FlushPendingNulls (JumbleState *jstate)
static void	RecordConstLocation (JumbleState *jstate, bool extern_param, int location, int len)
static void	_jumbleNode (JumbleState *jstate, Node *node)
static void	_jumbleList (JumbleState *jstate, Node *node)
static void	_jumbleElements (JumbleState *jstate, List *elements, Node *node)
static void	_jumbleParam (JumbleState *jstate, Node *node)
static void	_jumbleA_Const (JumbleState *jstate, Node *node)
static void	_jumbleVariableSetStmt (JumbleState *jstate, Node *node)
static void	_jumbleRangeTblEntry_eref (JumbleState *jstate, RangeTblEntry *rte, Alias *expr)
const char *	CleanQuerytext (const char *query, int *location, int *len)
JumbleState *	JumbleQuery (Query *query)
void	EnableQueryId (void)
static pg_attribute_always_inline void	AppendJumbleInternal (JumbleState *jstate, const unsigned char *item, Size size)
static pg_attribute_always_inline void	AppendJumbleNull (JumbleState *jstate)
static pg_noinline void	AppendJumble8 (JumbleState *jstate, const unsigned char *value)
static pg_noinline void	AppendJumble16 (JumbleState *jstate, const unsigned char *value)
static pg_noinline void	AppendJumble32 (JumbleState *jstate, const unsigned char *value)
static pg_noinline void	AppendJumble64 (JumbleState *jstate, const unsigned char *value)
static bool	IsSquashableConstant (Node *element)
static bool	IsSquashableConstantList (List *elements)
static int	CompLocation (const void *a, const void *b)
LocationLen *	ComputeConstantLengths (const JumbleState *jstate, const char *query, int query_loc)

Variables
int	compute_query_id = COMPUTE_QUERY_ID_AUTO
bool	query_id_enabled = false

Macro Definition Documentation

JUMBLE_CUSTOM

#define JUMBLE_CUSTOM	(		nodetype,
			item
	)		_jumble##nodetype##_##item(jstate, expr, expr->item)

Definition at line 557 of file queryjumblefuncs.c.

{
    Node       *expr = node;
#ifdef USE_ASSERT_CHECKING
    Size        prev_jumble_len = jstate->total_jumble_len;
#endif
 
    if (expr == NULL)
    {
        AppendJumbleNull(jstate);
        return;
    }
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    /*
     * We always emit the node's NodeTag, then any additional fields that are
     * considered significant, and then we recurse to any child nodes.
     */
    JUMBLE_FIELD(type);
 
    switch (nodeTag(expr))
    {
#include "queryjumblefuncs.switch.c"
 
        case T_List:
        case T_IntList:
        case T_OidList:
        case T_XidList:
            _jumbleList(jstate, expr);
            break;
 
        default:
            /* Only a warning, since we can stumble along anyway */
            elog(WARNING, "unrecognized node type: %d",
                 (int) nodeTag(expr));
            break;
    }
 
    /* Ensure we added something to the jumble buffer */
    Assert(jstate->total_jumble_len > prev_jumble_len);
}
 
static void
_jumbleList(JumbleState *jstate, Node *node)
{
    List       *expr = (List *) node;
    ListCell   *l;
 
    switch (expr->type)
    {
        case T_List:
            foreach(l, expr)
                _jumbleNode(jstate, lfirst(l));
            break;
        case T_IntList:
            foreach(l, expr)
                AppendJumble32(jstate, (const unsigned char *) &lfirst_int(l));
            break;
        case T_OidList:
            foreach(l, expr)
                AppendJumble32(jstate, (const unsigned char *) &lfirst_oid(l));
            break;
        case T_XidList:
            foreach(l, expr)
                AppendJumble32(jstate, (const unsigned char *) &lfirst_xid(l));
            break;
        default:
            elog(ERROR, "unrecognized list node type: %d",
                 (int) expr->type);
            return;
    }
}
 
/*
 * We try to jumble lists of expressions as one individual item regardless
 * of how many elements are in the list. This is know as squashing, which
 * results in different queries jumbling to the same query_id, if the only
 * difference is the number of elements in the list.
 *
 * We allow constants and PARAM_EXTERN parameters to be squashed. To normalize
 * such queries, we use the start and end locations of the list of elements in
 * a list.
 */
static void
_jumbleElements(JumbleState *jstate, List *elements, Node *node)
{
    bool        normalize_list = false;
 
    if (IsSquashableConstantList(elements))
    {
        if (IsA(node, ArrayExpr))
        {
            ArrayExpr  *aexpr = (ArrayExpr *) node;
 
            if (aexpr->list_start > 0 && aexpr->list_end > 0)
            {
                RecordConstLocation(jstate,
                                    false,
                                    aexpr->list_start + 1,
                                    (aexpr->list_end - aexpr->list_start) - 1);
                normalize_list = true;
                jstate->has_squashed_lists = true;
            }
        }
    }
 
    if (!normalize_list)
    {
        _jumbleNode(jstate, (Node *) elements);
    }
}
 
/*
 * We store the highest param ID of extern params.  This can later be used
 * to start the numbering of the placeholder for squashed lists.
 */
static void
_jumbleParam(JumbleState *jstate, Node *node)
{
    Param      *expr = (Param *) node;
 
    JUMBLE_FIELD(paramkind);
    JUMBLE_FIELD(paramid);
    JUMBLE_FIELD(paramtype);
    /* paramtypmod and paramcollid are ignored */
 
    if (expr->paramkind == PARAM_EXTERN)
    {
        /*
         * At this point, only external parameter locations outside of
         * squashable lists will be recorded.
         */
        RecordConstLocation(jstate, true, expr->location, -1);
 
        /*
         * Update the highest Param id seen, in order to start normalization
         * correctly.
         *
         * Note: This value is reset at the end of jumbling if there exists a
         * squashable list. See the comment in the definition of JumbleState.
         */
        if (expr->paramid > jstate->highest_extern_param_id)
            jstate->highest_extern_param_id = expr->paramid;
    }
}
 
static void
_jumbleA_Const(JumbleState *jstate, Node *node)
{
    A_Const    *expr = (A_Const *) node;
 
    JUMBLE_FIELD(isnull);
    if (!expr->isnull)
    {
        JUMBLE_FIELD(val.node.type);
        switch (nodeTag(&expr->val))
        {
            case T_Integer:
                JUMBLE_FIELD(val.ival.ival);
                break;
            case T_Float:
                JUMBLE_STRING(val.fval.fval);
                break;
            case T_Boolean:
                JUMBLE_FIELD(val.boolval.boolval);
                break;
            case T_String:
                JUMBLE_STRING(val.sval.sval);
                break;
            case T_BitString:
                JUMBLE_STRING(val.bsval.bsval);
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(&expr->val));
                break;
        }
    }
}
 
static void
_jumbleVariableSetStmt(JumbleState *jstate, Node *node)
{
    VariableSetStmt *expr = (VariableSetStmt *) node;
 
    JUMBLE_FIELD(kind);
    JUMBLE_STRING(name);
 
    /*
     * Account for the list of arguments in query jumbling only if told by the
     * parser.
     */
    if (expr->jumble_args)
        JUMBLE_NODE(args);
    JUMBLE_FIELD(is_local);
    JUMBLE_LOCATION(location);
}
 
/*
 * Custom query jumble function for RangeTblEntry.eref.
 */
static void
_jumbleRangeTblEntry_eref(JumbleState *jstate,
                          RangeTblEntry *rte,
                          Alias *expr)
{
    JUMBLE_FIELD(type);
 
    /*
     * This includes only the table name, the list of column names is ignored.
     */
    JUMBLE_STRING(aliasname);
}
 
/*
 * CompLocation: comparator for qsorting LocationLen structs by location
 */
static int
CompLocation(const void *a, const void *b)
{
    int         l = ((const LocationLen *) a)->location;
    int         r = ((const LocationLen *) b)->location;
 
    return pg_cmp_s32(l, r);
}
 
/*
 * Given a valid SQL string and an array of constant-location records, return
 * the textual lengths of those constants in a newly allocated LocationLen
 * array, or NULL if there are no constants.
 *
 * The constants may use any allowed constant syntax, such as float literals,
 * bit-strings, single-quoted strings and dollar-quoted strings.  This is
 * accomplished by using the public API for the core scanner.
 *
 * It is the caller's job to ensure that the string is a valid SQL statement
 * with constants at the indicated locations.  Since in practice the string
 * has already been parsed, and the locations that the caller provides will
 * have originated from within the authoritative parser, this should not be
 * a problem.
 *
 * Multiple constants can have the same location.  We reset lengths of those
 * past the first to -1 so that they can later be ignored.
 *
 * If query_loc > 0, then "query" has been advanced by that much compared to
 * the original string start, as is the case with multi-statement strings, so
 * we need to translate the provided locations to compensate.  (This lets us
 * avoid re-scanning statements before the one of interest, so it's worth
 * doing.)
 *
 * N.B. There is an assumption that a '-' character at a Const location begins
 * a negative numeric constant.  This precludes there ever being another
 * reason for a constant to start with a '-'.
 *
 * It is the caller's responsibility to free the result, if necessary.
 */
LocationLen *
ComputeConstantLengths(const JumbleState *jstate, const char *query,
                       int query_loc)
{
    LocationLen *locs;
    core_yyscan_t yyscanner;
    core_yy_extra_type yyextra;
    core_YYSTYPE yylval;
    YYLTYPE     yylloc;
 
    if (jstate->clocations_count == 0)
        return NULL;
 
    /* Copy constant locations to avoid modifying jstate */
    locs = palloc_array(LocationLen, jstate->clocations_count);
    memcpy(locs, jstate->clocations, jstate->clocations_count * sizeof(LocationLen));
 
    /*
     * Sort the records by location so that we can process them in order while
     * scanning the query text.
     */
    if (jstate->clocations_count > 1)
        qsort(locs, jstate->clocations_count,
              sizeof(LocationLen), CompLocation);
 
    /* initialize the flex scanner --- should match raw_parser() */
    yyscanner = scanner_init(query,
                             &yyextra,
                             &ScanKeywords,
                             ScanKeywordTokens);
 
    /* Search for each constant, in sequence */
    for (int i = 0; i < jstate->clocations_count; i++)
    {
        int         loc;
        int         tok;
 
        /* Ignore constants after the first one in the same location */
        if (i > 0 && locs[i].location == locs[i - 1].location)
        {
            locs[i].length = -1;
            continue;
        }
 
        if (locs[i].squashed)
            continue;           /* squashable list, ignore */
 
        /*
         * Adjust the constant's location using the provided starting location
         * of the current statement.  This allows us to avoid scanning a
         * multi-statement string from the beginning.
         */
        loc = locs[i].location - query_loc;
        Assert(loc >= 0);
 
        /*
         * We have a valid location for a constant that's not a dupe. Lex
         * tokens until we find the desired constant.
         */
        for (;;)
        {
            tok = core_yylex(&yylval, &yylloc, yyscanner);
 
            /* We should not hit end-of-string, but if we do, behave sanely */
            if (tok == 0)
                break;          /* out of inner for-loop */
 
            /*
             * We should find the token position exactly, but if we somehow
             * run past it, work with that.
             */
            if (yylloc >= loc)
            {
                if (query[loc] == '-')
                {
                    /*
                     * It's a negative value - this is the one and only case
                     * where we replace more than a single token.
                     *
                     * Do not compensate for the special-case adjustment of
                     * location to that of the leading '-' operator in the
                     * event of a negative constant (see doNegate() in
                     * gram.y).  It is also useful for our purposes to start
                     * from the minus symbol.  In this way, queries like
                     * "select * from foo where bar = 1" and "select * from
                     * foo where bar = -2" can be treated similarly.
                     */
                    tok = core_yylex(&yylval, &yylloc, yyscanner);
                    if (tok == 0)
                        break;  /* out of inner for-loop */
                }
 
                /*
                 * We now rely on the assumption that flex has placed a zero
                 * byte after the text of the current token in scanbuf.
                 */
                locs[i].length = strlen(yyextra.scanbuf + loc);
                break;          /* out of inner for-loop */
            }
        }
 
        /* If we hit end-of-string, give up, leaving remaining lengths -1 */
        if (tok == 0)
            break;
    }
 
    scanner_finish(yyscanner);
 
    return locs;
}

JUMBLE_ELEMENTS

#define JUMBLE_ELEMENTS	(		list,
			node
	)		_jumbleElements(jstate, (List *) expr->list, node)

Definition at line 532 of file queryjumblefuncs.c.

JUMBLE_FIELD

#define JUMBLE_FIELD

(

item

)

Value:

do { \
	if (sizeof(expr->item) == 8) \
		AppendJumble64(jstate, (const unsigned char *) &(expr->item)); \
    else if (sizeof(expr->item) == 4) \
		AppendJumble32(jstate, (const unsigned char *) &(expr->item)); \
    else if (sizeof(expr->item) == 2) \
		AppendJumble16(jstate, (const unsigned char *) &(expr->item)); \
    else if (sizeof(expr->item) == 1) \
		AppendJumble8(jstate, (const unsigned char *) &(expr->item)); \
	else \
		AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item)); \
} while (0)

Definition at line 536 of file queryjumblefuncs.c.

   { \
	if (sizeof(expr->item) == 8) \
		AppendJumble64(jstate, (const unsigned char *) &(expr->item)); \
    else if (sizeof(expr->item) == 4) \
		AppendJumble32(jstate, (const unsigned char *) &(expr->item)); \
    else if (sizeof(expr->item) == 2) \
		AppendJumble16(jstate, (const unsigned char *) &(expr->item)); \
    else if (sizeof(expr->item) == 1) \
		AppendJumble8(jstate, (const unsigned char *) &(expr->item)); \
	else \
		AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item)); \
} while (0)

JUMBLE_LOCATION

#define JUMBLE_LOCATION

(

location

)

RecordConstLocation(jstate, false, expr->location, -1)

Definition at line 534 of file queryjumblefuncs.c.

JUMBLE_NODE

#define JUMBLE_NODE

(

item

)

_jumbleNode(jstate, (Node *) expr->item)

Definition at line 530 of file queryjumblefuncs.c.

JUMBLE_SIZE

#define JUMBLE_SIZE   1024 /* query serialization buffer size */

Definition at line 51 of file queryjumblefuncs.c.

JUMBLE_STRING

#define JUMBLE_STRING

(

str

)

Value:

do { \
	if (expr->str) \
		AppendJumble(jstate, (const unsigned char *) (expr->str), strlen(expr->str) + 1); \
	else \
		AppendJumbleNull(jstate); \
} while(0)

Definition at line 549 of file queryjumblefuncs.c.

   { \
	if (expr->str) \
		AppendJumble(jstate, (const unsigned char *) (expr->str), strlen(expr->str) + 1); \
	else \
		AppendJumbleNull(jstate); \
} while(0)

Function Documentation

_jumbleA_Const()

static void _jumbleA_Const ( JumbleState *  jstate, Node *  node  )

static

Definition at line 712 of file queryjumblefuncs.c.

{
    A_Const    *expr = (A_Const *) node;
 
    JUMBLE_FIELD(isnull);
    if (!expr->isnull)
    {
        JUMBLE_FIELD(val.node.type);
        switch (nodeTag(&expr->val))
        {
            case T_Integer:
                JUMBLE_FIELD(val.ival.ival);
                break;
            case T_Float:
                JUMBLE_STRING(val.fval.fval);
                break;
            case T_Boolean:
                JUMBLE_FIELD(val.boolval.boolval);
                break;
            case T_String:
                JUMBLE_STRING(val.sval.sval);
                break;
            case T_BitString:
                JUMBLE_STRING(val.bsval.bsval);
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(&expr->val));
                break;
        }
    }
}

References elog, ERROR, fb(), A_Const::isnull, JUMBLE_FIELD, JUMBLE_STRING, nodeTag, A_Const::val, and val.

_jumbleElements()

static void _jumbleElements ( JumbleState *  jstate, List *  elements, Node *  node  )

static

Definition at line 649 of file queryjumblefuncs.c.

{
    bool        normalize_list = false;
 
    if (IsSquashableConstantList(elements))
    {
        if (IsA(node, ArrayExpr))
        {
            ArrayExpr  *aexpr = (ArrayExpr *) node;
 
            if (aexpr->list_start > 0 && aexpr->list_end > 0)
            {
                RecordConstLocation(jstate,
                                    false,
                                    aexpr->list_start + 1,
                                    (aexpr->list_end - aexpr->list_start) - 1);
                normalize_list = true;
                jstate->has_squashed_lists = true;
            }
        }
    }
 
    if (!normalize_list)
    {
        _jumbleNode(jstate, (Node *) elements);
    }
}

References _jumbleNode(), fb(), IsA, IsSquashableConstantList(), and RecordConstLocation().

_jumbleList()

static void _jumbleList ( JumbleState *  jstate, Node *  node  )

static

Definition at line 608 of file queryjumblefuncs.c.

{
    List       *expr = (List *) node;
    ListCell   *l;
 
    switch (expr->type)
    {
        case T_List:
            foreach(l, expr)
                _jumbleNode(jstate, lfirst(l));
            break;
        case T_IntList:
            foreach(l, expr)
                AppendJumble32(jstate, (const unsigned char *) &lfirst_int(l));
            break;
        case T_OidList:
            foreach(l, expr)
                AppendJumble32(jstate, (const unsigned char *) &lfirst_oid(l));
            break;
        case T_XidList:
            foreach(l, expr)
                AppendJumble32(jstate, (const unsigned char *) &lfirst_xid(l));
            break;
        default:
            elog(ERROR, "unrecognized list node type: %d",
                 (int) expr->type);
            return;
    }
}

References _jumbleNode(), AppendJumble32(), elog, ERROR, fb(), lfirst, lfirst_int, lfirst_oid, lfirst_xid, and List::type.

Referenced by _jumbleNode().

_jumbleNode()

static void _jumbleNode ( JumbleState *  jstate, Node *  node  )

static

Definition at line 563 of file queryjumblefuncs.c.

{
    Node       *expr = node;
#ifdef USE_ASSERT_CHECKING
    Size        prev_jumble_len = jstate->total_jumble_len;
#endif
 
    if (expr == NULL)
    {
        AppendJumbleNull(jstate);
        return;
    }
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    /*
     * We always emit the node's NodeTag, then any additional fields that are
     * considered significant, and then we recurse to any child nodes.
     */
    JUMBLE_FIELD(type);
 
    switch (nodeTag(expr))
    {
#include "queryjumblefuncs.switch.c"
 
        case T_List:
        case T_IntList:
        case T_OidList:
        case T_XidList:
            _jumbleList(jstate, expr);
            break;
 
        default:
            /* Only a warning, since we can stumble along anyway */
            elog(WARNING, "unrecognized node type: %d",
                 (int) nodeTag(expr));
            break;
    }
 
    /* Ensure we added something to the jumble buffer */
    Assert(jstate->total_jumble_len > prev_jumble_len);
}

References _jumbleList(), AppendJumbleNull(), Assert, check_stack_depth(), elog, fb(), JUMBLE_FIELD, nodeTag, type, and WARNING.

Referenced by _jumbleElements(), _jumbleList(), and DoJumble().

_jumbleParam()

static void _jumbleParam ( JumbleState *  jstate, Node *  node  )

static

Definition at line 682 of file queryjumblefuncs.c.

{
    Param      *expr = (Param *) node;
 
    JUMBLE_FIELD(paramkind);
    JUMBLE_FIELD(paramid);
    JUMBLE_FIELD(paramtype);
    /* paramtypmod and paramcollid are ignored */
 
    if (expr->paramkind == PARAM_EXTERN)
    {
        /*
         * At this point, only external parameter locations outside of
         * squashable lists will be recorded.
         */
        RecordConstLocation(jstate, true, expr->location, -1);
 
        /*
         * Update the highest Param id seen, in order to start normalization
         * correctly.
         *
         * Note: This value is reset at the end of jumbling if there exists a
         * squashable list. See the comment in the definition of JumbleState.
         */
        if (expr->paramid > jstate->highest_extern_param_id)
            jstate->highest_extern_param_id = expr->paramid;
    }
}

References fb(), JUMBLE_FIELD, Param::location, PARAM_EXTERN, Param::paramid, Param::paramkind, and RecordConstLocation().

_jumbleRangeTblEntry_eref()

static void _jumbleRangeTblEntry_eref ( JumbleState *  jstate, RangeTblEntry *  rte, Alias *  expr  )

static

Definition at line 767 of file queryjumblefuncs.c.

{
    JUMBLE_FIELD(type);
 
    /*
     * This includes only the table name, the list of column names is ignored.
     */
    JUMBLE_STRING(aliasname);
}

References JUMBLE_FIELD, JUMBLE_STRING, and type.

_jumbleVariableSetStmt()

static void _jumbleVariableSetStmt ( JumbleState *  jstate, Node *  node  )

static

Definition at line 746 of file queryjumblefuncs.c.

{
    VariableSetStmt *expr = (VariableSetStmt *) node;
 
    JUMBLE_FIELD(kind);
    JUMBLE_STRING(name);
 
    /*
     * Account for the list of arguments in query jumbling only if told by the
     * parser.
     */
    if (expr->jumble_args)
        JUMBLE_NODE(args);
    JUMBLE_FIELD(is_local);
    JUMBLE_LOCATION(location);
}

References VariableSetStmt::jumble_args, JUMBLE_FIELD, JUMBLE_LOCATION, JUMBLE_NODE, JUMBLE_STRING, and name.

AppendJumble()

static pg_noinline void AppendJumble ( JumbleState *  jstate, const unsigned char *  value, Size  size  )

static

Definition at line 299 of file queryjumblefuncs.c.

{
    if (jstate->pending_nulls > 0)
        FlushPendingNulls(jstate);
 
    AppendJumbleInternal(jstate, value, size);
}

References AppendJumbleInternal(), fb(), FlushPendingNulls(), and value.

AppendJumble16()

static pg_noinline void AppendJumble16 ( JumbleState *  jstate, const unsigned char *  value  )

static

Definition at line 336 of file queryjumblefuncs.c.

{
    if (jstate->pending_nulls > 0)
        FlushPendingNulls(jstate);
 
    AppendJumbleInternal(jstate, value, 2);
}

References AppendJumbleInternal(), fb(), FlushPendingNulls(), and value.

AppendJumble32()

static pg_noinline void AppendJumble32 ( JumbleState *  jstate, const unsigned char *  value  )

static

Definition at line 350 of file queryjumblefuncs.c.

{
    if (jstate->pending_nulls > 0)
        FlushPendingNulls(jstate);
 
    AppendJumbleInternal(jstate, value, 4);
}

References AppendJumbleInternal(), fb(), FlushPendingNulls(), and value.

Referenced by _jumbleList().

AppendJumble64()

static pg_noinline void AppendJumble64 ( JumbleState *  jstate, const unsigned char *  value  )

static

Definition at line 364 of file queryjumblefuncs.c.

{
    if (jstate->pending_nulls > 0)
        FlushPendingNulls(jstate);
 
    AppendJumbleInternal(jstate, value, 8);
}

References AppendJumbleInternal(), fb(), FlushPendingNulls(), and value.

AppendJumble8()

static pg_noinline void AppendJumble8 ( JumbleState *  jstate, const unsigned char *  value  )

static

Definition at line 322 of file queryjumblefuncs.c.

{
    if (jstate->pending_nulls > 0)
        FlushPendingNulls(jstate);
 
    AppendJumbleInternal(jstate, value, 1);
}

References AppendJumbleInternal(), fb(), FlushPendingNulls(), and value.

AppendJumbleInternal()

static pg_attribute_always_inline void AppendJumbleInternal ( JumbleState *  jstate, const unsigned char *  item, Size  size  )

static

Definition at line 236 of file queryjumblefuncs.c.

{
    unsigned char *jumble = jstate->jumble;
    Size        jumble_len = jstate->jumble_len;
 
    /* Ensure the caller didn't mess up */
    Assert(size > 0);
 
    /*
     * Fast path for when there's enough space left in the buffer.  This is
     * worthwhile as means the memcpy can be inlined into very efficient code
     * when 'size' is a compile-time constant.
     */
    if (likely(size <= JUMBLE_SIZE - jumble_len))
    {
        memcpy(jumble + jumble_len, item, size);
        jstate->jumble_len += size;
 
#ifdef USE_ASSERT_CHECKING
        jstate->total_jumble_len += size;
#endif
 
        return;
    }
 
    /*
     * Whenever the jumble buffer is full, we hash the current contents and
     * reset the buffer to contain just that hash value, thus relying on the
     * hash to summarize everything so far.
     */
    do
    {
        Size        part_size;
 
        if (unlikely(jumble_len >= JUMBLE_SIZE))
        {
            int64       start_hash;
 
            start_hash = DatumGetInt64(hash_any_extended(jumble,
                                                         JUMBLE_SIZE, 0));
            memcpy(jumble, &start_hash, sizeof(start_hash));
            jumble_len = sizeof(start_hash);
        }
        part_size = Min(size, JUMBLE_SIZE - jumble_len);
        memcpy(jumble + jumble_len, item, part_size);
        jumble_len += part_size;
        item += part_size;
        size -= part_size;
 
#ifdef USE_ASSERT_CHECKING
        jstate->total_jumble_len += part_size;
#endif
    } while (size > 0);
 
    jstate->jumble_len = jumble_len;
}

References Assert, DatumGetInt64(), fb(), hash_any_extended(), JUMBLE_SIZE, likely, memcpy(), Min, and unlikely.

Referenced by AppendJumble(), AppendJumble16(), AppendJumble32(), AppendJumble64(), AppendJumble8(), and FlushPendingNulls().

AppendJumbleNull()

static pg_attribute_always_inline void AppendJumbleNull ( JumbleState *  jstate )

static

Definition at line 312 of file queryjumblefuncs.c.

{
    jstate->pending_nulls++;
}

References fb().

Referenced by _jumbleNode().

CleanQuerytext()

const char * CleanQuerytext	(	const char *	query,
		int *	location,
		int *	len
	)

Definition at line 88 of file queryjumblefuncs.c.

{
    int         query_location = *location;
    int         query_len = *len;
 
    /* First apply starting offset, unless it's -1 (unknown). */
    if (query_location >= 0)
    {
        Assert(query_location <= strlen(query));
        query += query_location;
        /* Length of 0 (or -1) means "rest of string" */
        if (query_len <= 0)
            query_len = strlen(query);
        else
            Assert(query_len <= strlen(query));
    }
    else
    {
        /* If query location is unknown, distrust query_len as well */
        query_location = 0;
        query_len = strlen(query);
    }
 
    /*
     * Discard leading and trailing whitespace, too.  Use scanner_isspace()
     * not libc's isspace(), because we want to match the lexer's behavior.
     *
     * Note: the parser now strips leading comments and whitespace from the
     * reported stmt_location, so this first loop will only iterate in the
     * unusual case that the location didn't propagate to here.  But the
     * statement length will extend to the end-of-string or terminating
     * semicolon, so the second loop often does something useful.
     */
    while (query_len > 0 && scanner_isspace(query[0]))
        query++, query_location++, query_len--;
    while (query_len > 0 && scanner_isspace(query[query_len - 1]))
        query_len--;
 
    *location = query_location;
    *len = query_len;
 
    return query;
}

References Assert, fb(), len, and scanner_isspace().

Referenced by pgss_store(), and script_error_callback().

CompLocation()

static int CompLocation ( const void *  a, const void *  b  )

static

Definition at line 783 of file queryjumblefuncs.c.

{
    int         l = ((const LocationLen *) a)->location;
    int         r = ((const LocationLen *) b)->location;
 
    return pg_cmp_s32(l, r);
}

References a, b, and pg_cmp_s32().

Referenced by ComputeConstantLengths().

ComputeConstantLengths()

LocationLen * ComputeConstantLengths	(	const JumbleState *	jstate,
		const char *	query,
		int	query_loc
	)

Definition at line 822 of file queryjumblefuncs.c.

{
    LocationLen *locs;
    core_yyscan_t yyscanner;
    core_yy_extra_type yyextra;
    core_YYSTYPE yylval;
    YYLTYPE     yylloc;
 
    if (jstate->clocations_count == 0)
        return NULL;
 
    /* Copy constant locations to avoid modifying jstate */
    locs = palloc_array(LocationLen, jstate->clocations_count);
    memcpy(locs, jstate->clocations, jstate->clocations_count * sizeof(LocationLen));
 
    /*
     * Sort the records by location so that we can process them in order while
     * scanning the query text.
     */
    if (jstate->clocations_count > 1)
        qsort(locs, jstate->clocations_count,
              sizeof(LocationLen), CompLocation);
 
    /* initialize the flex scanner --- should match raw_parser() */
    yyscanner = scanner_init(query,
                             &yyextra,
                             &ScanKeywords,
                             ScanKeywordTokens);
 
    /* Search for each constant, in sequence */
    for (int i = 0; i < jstate->clocations_count; i++)
    {
        int         loc;
        int         tok;
 
        /* Ignore constants after the first one in the same location */
        if (i > 0 && locs[i].location == locs[i - 1].location)
        {
            locs[i].length = -1;
            continue;
        }
 
        if (locs[i].squashed)
            continue;           /* squashable list, ignore */
 
        /*
         * Adjust the constant's location using the provided starting location
         * of the current statement.  This allows us to avoid scanning a
         * multi-statement string from the beginning.
         */
        loc = locs[i].location - query_loc;
        Assert(loc >= 0);
 
        /*
         * We have a valid location for a constant that's not a dupe. Lex
         * tokens until we find the desired constant.
         */
        for (;;)
        {
            tok = core_yylex(&yylval, &yylloc, yyscanner);
 
            /* We should not hit end-of-string, but if we do, behave sanely */
            if (tok == 0)
                break;          /* out of inner for-loop */
 
            /*
             * We should find the token position exactly, but if we somehow
             * run past it, work with that.
             */
            if (yylloc >= loc)
            {
                if (query[loc] == '-')
                {
                    /*
                     * It's a negative value - this is the one and only case
                     * where we replace more than a single token.
                     *
                     * Do not compensate for the special-case adjustment of
                     * location to that of the leading '-' operator in the
                     * event of a negative constant (see doNegate() in
                     * gram.y).  It is also useful for our purposes to start
                     * from the minus symbol.  In this way, queries like
                     * "select * from foo where bar = 1" and "select * from
                     * foo where bar = -2" can be treated similarly.
                     */
                    tok = core_yylex(&yylval, &yylloc, yyscanner);
                    if (tok == 0)
                        break;  /* out of inner for-loop */
                }
 
                /*
                 * We now rely on the assumption that flex has placed a zero
                 * byte after the text of the current token in scanbuf.
                 */
                locs[i].length = strlen(yyextra.scanbuf + loc);
                break;          /* out of inner for-loop */
            }
        }
 
        /* If we hit end-of-string, give up, leaving remaining lengths -1 */
        if (tok == 0)
            break;
    }
 
    scanner_finish(yyscanner);
 
    return locs;
}

References Assert, CompLocation(), core_yylex(), fb(), i, memcpy(), palloc_array, qsort, ScanKeywords, ScanKeywordTokens, scanner_finish(), scanner_init(), yyextra, and yylloc.

Referenced by generate_normalized_query().

DoJumble()

static int64 DoJumble ( JumbleState *  jstate, Node *  node  )

static

Definition at line 211 of file queryjumblefuncs.c.

{
    /* Jumble the given node */
    _jumbleNode(jstate, node);
 
    /* Flush any pending NULLs before doing the final hash */
    if (jstate->pending_nulls > 0)
        FlushPendingNulls(jstate);
 
    /* Squashed list found, reset highest_extern_param_id */
    if (jstate->has_squashed_lists)
        jstate->highest_extern_param_id = 0;
 
    /* Process the jumble buffer and produce the hash value */
    return DatumGetInt64(hash_any_extended(jstate->jumble,
                                           jstate->jumble_len,
                                           0));
}

References _jumbleNode(), DatumGetInt64(), fb(), FlushPendingNulls(), and hash_any_extended().

Referenced by JumbleQuery().

EnableQueryId()

void EnableQueryId

(

void

)

Definition at line 171 of file queryjumblefuncs.c.

{
    if (compute_query_id != COMPUTE_QUERY_ID_OFF)
        query_id_enabled = true;
}

References compute_query_id, COMPUTE_QUERY_ID_OFF, and query_id_enabled.

Referenced by _PG_init().

FlushPendingNulls()

static pg_attribute_always_inline void FlushPendingNulls ( JumbleState *  jstate )

static

Definition at line 379 of file queryjumblefuncs.c.

{
    Assert(jstate->pending_nulls > 0);
 
    AppendJumbleInternal(jstate,
                         (const unsigned char *) &jstate->pending_nulls, 4);
    jstate->pending_nulls = 0;
}

References AppendJumbleInternal(), Assert, and fb().

Referenced by AppendJumble(), AppendJumble16(), AppendJumble32(), AppendJumble64(), AppendJumble8(), and DoJumble().

InitJumble()

static JumbleState * InitJumble ( void  )

static

Definition at line 182 of file queryjumblefuncs.c.

{
    JumbleState *jstate;
 
    jstate = palloc_object(JumbleState);
 
    /* Set up workspace for query jumbling */
    jstate->jumble = (unsigned char *) palloc(JUMBLE_SIZE);
    jstate->jumble_len = 0;
    jstate->clocations_buf_size = 32;
    jstate->clocations = (LocationLen *) palloc(jstate->clocations_buf_size *
                                                sizeof(LocationLen));
    jstate->clocations_count = 0;
    jstate->highest_extern_param_id = 0;
    jstate->pending_nulls = 0;
    jstate->has_squashed_lists = false;
#ifdef USE_ASSERT_CHECKING
    jstate->total_jumble_len = 0;
#endif
 
    return jstate;
}

References fb(), JUMBLE_SIZE, palloc(), and palloc_object.

Referenced by JumbleQuery().

IsSquashableConstant()

static bool IsSquashableConstant ( Node *  element )

static

Definition at line 439 of file queryjumblefuncs.c.

{
restart:
    switch (nodeTag(element))
    {
        case T_RelabelType:
            /* Unwrap RelabelType */
            element = (Node *) ((RelabelType *) element)->arg;
            goto restart;
 
        case T_CoerceViaIO:
            /* Unwrap CoerceViaIO */
            element = (Node *) ((CoerceViaIO *) element)->arg;
            goto restart;
 
        case T_Const:
            return true;
 
        case T_Param:
            return castNode(Param, element)->paramkind == PARAM_EXTERN;
 
        case T_FuncExpr:
            {
                FuncExpr   *func = (FuncExpr *) element;
                ListCell   *temp;
 
                if (func->funcformat != COERCE_IMPLICIT_CAST &&
                    func->funcformat != COERCE_EXPLICIT_CAST)
                    return false;
 
                if (func->funcid > FirstGenbkiObjectId)
                    return false;
 
                /*
                 * We can check function arguments recursively, being careful
                 * about recursing too deep.  At each recursion level it's
                 * enough to test the stack on the first element.  (Note that
                 * I wasn't able to hit this without bloating the stack
                 * artificially in this function: the parser errors out before
                 * stack size becomes a problem here.)
                 */
                foreach(temp, func->args)
                {
                    Node       *arg = lfirst(temp);
 
                    if (!IsA(arg, Const))
                    {
                        if (foreach_current_index(temp) == 0 &&
                            stack_is_too_deep())
                            return false;
                        else if (!IsSquashableConstant(arg))
                            return false;
                    }
                }
 
                return true;
            }
 
        default:
            return false;
    }
}

References arg, FuncExpr::args, castNode, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, element(), fb(), FirstGenbkiObjectId, foreach_current_index, FuncExpr::funcid, IsA, IsSquashableConstant(), lfirst, nodeTag, PARAM_EXTERN, and stack_is_too_deep().

Referenced by IsSquashableConstant(), and IsSquashableConstantList().

IsSquashableConstantList()

static bool IsSquashableConstantList ( List *  elements )

static

Definition at line 513 of file queryjumblefuncs.c.

{
    ListCell   *temp;
 
    /* If the list is too short, we don't try to squash it. */
    if (list_length(elements) < 2)
        return false;
 
    foreach(temp, elements)
    {
        if (!IsSquashableConstant(lfirst(temp)))
            return false;
    }
 
    return true;
}

References fb(), IsSquashableConstant(), lfirst, and list_length().

Referenced by _jumbleElements().

JumbleQuery()

JumbleState * JumbleQuery

(

Query *

query

)

Definition at line 139 of file queryjumblefuncs.c.

{
    JumbleState *jstate;
 
    Assert(IsQueryIdEnabled());
 
    jstate = InitJumble();
 
    query->queryId = DoJumble(jstate, (Node *) query);
 
    /*
     * If we are unlucky enough to get a hash of zero, use 1 instead for
     * normal statements and 2 for utility queries.
     */
    if (query->queryId == INT64CONST(0))
    {
        if (query->utilityStmt)
            query->queryId = INT64CONST(2);
        else
            query->queryId = INT64CONST(1);
    }
 
    return jstate;
}

References Assert, DoJumble(), fb(), InitJumble(), INT64CONST, IsQueryIdEnabled(), and Query::utilityStmt.

Referenced by ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), and PerformCursorOpen().

RecordConstLocation()

static void RecordConstLocation ( JumbleState *  jstate, bool  extern_param, int  location, int  len  )

static

Definition at line 400 of file queryjumblefuncs.c.

{
    /* -1 indicates unknown or undefined location */
    if (location >= 0)
    {
        /* enlarge array if needed */
        if (jstate->clocations_count >= jstate->clocations_buf_size)
        {
            jstate->clocations_buf_size *= 2;
            jstate->clocations = (LocationLen *)
                repalloc(jstate->clocations,
                         jstate->clocations_buf_size *
                         sizeof(LocationLen));
        }
        jstate->clocations[jstate->clocations_count].location = location;
 
        /*
         * Lengths are either positive integers (indicating a squashable
         * list), or -1.
         */
        Assert(len > -1 || len == -1);
        jstate->clocations[jstate->clocations_count].length = len;
        jstate->clocations[jstate->clocations_count].squashed = (len > -1);
        jstate->clocations[jstate->clocations_count].extern_param = extern_param;
        jstate->clocations_count++;
    }
}

References Assert, fb(), len, and repalloc().

Referenced by _jumbleElements(), and _jumbleParam().

Variable Documentation

compute_query_id

int compute_query_id = COMPUTE_QUERY_ID_AUTO

Definition at line 54 of file queryjumblefuncs.c.

Referenced by EnableQueryId(), ExplainPrintPlan(), and IsQueryIdEnabled().

query_id_enabled

bool query_id_enabled = false

Definition at line 63 of file queryjumblefuncs.c.

Referenced by EnableQueryId(), and IsQueryIdEnabled().