queryjumblefuncs.c File Reference

#include "postgres.h"
#include "common/hashfn.h"
#include "miscadmin.h"
#include "nodes/queryjumble.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_LOCATION(location)    RecordConstLocation(jstate, expr->location)
#define	JUMBLE_FIELD(item)    AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item))
#define	JUMBLE_FIELD_SINGLE(item)    AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))
#define	JUMBLE_STRING(str)

Functions
static void	AppendJumble (JumbleState *jstate, const unsigned char *item, Size size)
static void	RecordConstLocation (JumbleState *jstate, int location)
static void	_jumbleNode (JumbleState *jstate, Node *node)
static void	_jumbleA_Const (JumbleState *jstate, Node *node)
static void	_jumbleList (JumbleState *jstate, Node *node)
static void	_jumbleRangeTblEntry (JumbleState *jstate, Node *node)
const char *	CleanQuerytext (const char *query, int *location, int *len)
JumbleState *	JumbleQuery (Query *query, const char *querytext)
void	EnableQueryId (void)

Variables
int	compute_query_id = COMPUTE_QUERY_ID_AUTO
bool	query_id_enabled = false

Macro Definition Documentation

JUMBLE_FIELD

#define JUMBLE_FIELD

(

item

)

AppendJumble(jstate, (const unsigned char *) &(expr->item), sizeof(expr->item))

Definition at line 218 of file queryjumblefuncs.c.

JUMBLE_FIELD_SINGLE

#define JUMBLE_FIELD_SINGLE

(

item

)

AppendJumble(jstate, (const unsigned char *) &(item), sizeof(item))

Definition at line 220 of file queryjumblefuncs.c.

JUMBLE_LOCATION

#define JUMBLE_LOCATION

(

location

)

RecordConstLocation(jstate, expr->location)

Definition at line 216 of file queryjumblefuncs.c.

JUMBLE_NODE

#define JUMBLE_NODE

(

item

)

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

Definition at line 214 of file queryjumblefuncs.c.

JUMBLE_SIZE

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

Definition at line 40 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); \
} while(0)

Definition at line 222 of file queryjumblefuncs.c.

Function Documentation

_jumbleA_Const()

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

static

Definition at line 318 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, A_Const::isnull, JUMBLE_FIELD, JUMBLE_STRING, nodeTag, A_Const::val, and val.

_jumbleList()

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

static

Definition at line 287 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)
                JUMBLE_FIELD_SINGLE(lfirst_int(l));
            break;
        case T_OidList:
            foreach(l, expr)
                JUMBLE_FIELD_SINGLE(lfirst_oid(l));
            break;
        case T_XidList:
            foreach(l, expr)
                JUMBLE_FIELD_SINGLE(lfirst_xid(l));
            break;
        default:
            elog(ERROR, "unrecognized list node type: %d",
                 (int) expr->type);
            return;
    }
}

References _jumbleNode(), elog(), ERROR, JUMBLE_FIELD_SINGLE, 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 231 of file queryjumblefuncs.c.

{
    Node       *expr = node;
 
    if (expr == NULL)
        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;
    }
 
    /* Special cases to handle outside the automated code */
    switch (nodeTag(expr))
    {
        case T_Param:
            {
                Param      *p = (Param *) node;
 
                /*
                 * Update the highest Param id seen, in order to start
                 * normalization correctly.
                 */
                if (p->paramkind == PARAM_EXTERN &&
                    p->paramid > jstate->highest_extern_param_id)
                    jstate->highest_extern_param_id = p->paramid;
            }
            break;
        default:
            break;
    }
}

References _jumbleList(), check_stack_depth(), elog(), JumbleState::highest_extern_param_id, JUMBLE_FIELD, nodeTag, PARAM_EXTERN, Param::paramid, Param::paramkind, generate_unaccent_rules::type, and WARNING.

Referenced by _jumbleList(), and JumbleQuery().

_jumbleRangeTblEntry()

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

static

Definition at line 352 of file queryjumblefuncs.c.

{
    RangeTblEntry *expr = (RangeTblEntry *) node;
 
    JUMBLE_FIELD(rtekind);
    switch (expr->rtekind)
    {
        case RTE_RELATION:
            JUMBLE_FIELD(relid);
            JUMBLE_NODE(tablesample);
            JUMBLE_FIELD(inh);
            break;
        case RTE_SUBQUERY:
            JUMBLE_NODE(subquery);
            break;
        case RTE_JOIN:
            JUMBLE_FIELD(jointype);
            break;
        case RTE_FUNCTION:
            JUMBLE_NODE(functions);
            break;
        case RTE_TABLEFUNC:
            JUMBLE_NODE(tablefunc);
            break;
        case RTE_VALUES:
            JUMBLE_NODE(values_lists);
            break;
        case RTE_CTE:
 
            /*
             * Depending on the CTE name here isn't ideal, but it's the only
             * info we have to identify the referenced WITH item.
             */
            JUMBLE_STRING(ctename);
            JUMBLE_FIELD(ctelevelsup);
            break;
        case RTE_NAMEDTUPLESTORE:
            JUMBLE_STRING(enrname);
            break;
        case RTE_RESULT:
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d", (int) expr->rtekind);
            break;
    }
}

References elog(), ERROR, functions, JUMBLE_FIELD, JUMBLE_NODE, JUMBLE_STRING, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, and RangeTblEntry::rtekind.

AppendJumble()

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

static

Definition at line 156 of file queryjumblefuncs.c.

{
    unsigned char *jumble = jstate->jumble;
    Size        jumble_len = jstate->jumble_len;
 
    /*
     * 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.
     */
    while (size > 0)
    {
        Size        part_size;
 
        if (jumble_len >= JUMBLE_SIZE)
        {
            uint64      start_hash;
 
            start_hash = DatumGetUInt64(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;
    }
    jstate->jumble_len = jumble_len;
}

References DatumGetUInt64(), hash_any_extended(), JumbleState::jumble, JumbleState::jumble_len, JUMBLE_SIZE, and Min.

CleanQuerytext()

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

Definition at line 61 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.
     */
    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(), len, and scanner_isspace().

Referenced by pgss_store().

EnableQueryId()

void EnableQueryId

(

void

)

Definition at line 145 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().

JumbleQuery()

JumbleState* JumbleQuery	(	Query *	query,
		const char *	querytext
	)

Definition at line 100 of file queryjumblefuncs.c.

{
    JumbleState *jstate = NULL;
 
    Assert(IsQueryIdEnabled());
 
    jstate = (JumbleState *) palloc(sizeof(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;
 
    /* Compute query ID and mark the Query node with it */
    _jumbleNode(jstate, (Node *) query);
    query->queryId = DatumGetUInt64(hash_any_extended(jstate->jumble,
                                                      jstate->jumble_len,
                                                      0));
 
    /*
     * 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 == UINT64CONST(0))
    {
        if (query->utilityStmt)
            query->queryId = UINT64CONST(2);
        else
            query->queryId = UINT64CONST(1);
    }
 
    return jstate;
}

References _jumbleNode(), Assert(), JumbleState::clocations, JumbleState::clocations_buf_size, JumbleState::clocations_count, DatumGetUInt64(), hash_any_extended(), JumbleState::highest_extern_param_id, IsQueryIdEnabled(), JumbleState::jumble, JumbleState::jumble_len, JUMBLE_SIZE, palloc(), and Query::utilityStmt.

Referenced by ExplainQuery(), parse_analyze_fixedparams(), parse_analyze_varparams(), and parse_analyze_withcb().

RecordConstLocation()

static void RecordConstLocation ( JumbleState *  jstate, int  location  )

static

Definition at line 193 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;
        /* initialize lengths to -1 to simplify third-party module usage */
        jstate->clocations[jstate->clocations_count].length = -1;
        jstate->clocations_count++;
    }
}

References JumbleState::clocations, JumbleState::clocations_buf_size, JumbleState::clocations_count, LocationLen::length, LocationLen::location, and repalloc().

Variable Documentation

compute_query_id

int compute_query_id = COMPUTE_QUERY_ID_AUTO

Definition at line 43 of file queryjumblefuncs.c.

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

query_id_enabled

bool query_id_enabled = false

Definition at line 46 of file queryjumblefuncs.c.

Referenced by EnableQueryId(), and IsQueryIdEnabled().