queryjumble.h File Reference

#include "nodes/parsenodes.h"

Include dependency graph for queryjumble.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	LocationLen
struct	JumbleState

Typedefs
typedef struct LocationLen	LocationLen
typedef struct JumbleState	JumbleState

Enumerations
enum	ComputeQueryIdType { COMPUTE_QUERY_ID_OFF , COMPUTE_QUERY_ID_ON , COMPUTE_QUERY_ID_AUTO , COMPUTE_QUERY_ID_REGRESS }

Functions
const char *	CleanQuerytext (const char *query, int *location, int *len)
JumbleState *	JumbleQuery (Query *query)
void	EnableQueryId (void)
static bool	IsQueryIdEnabled (void)

Variables
PGDLLIMPORT int	compute_query_id
PGDLLIMPORT bool	query_id_enabled

Typedef Documentation

JumbleState

typedef struct JumbleState JumbleState

LocationLen

typedef struct LocationLen LocationLen

Enumeration Type Documentation

ComputeQueryIdType

enum ComputeQueryIdType

Enumerator
COMPUTE_QUERY_ID_OFF
COMPUTE_QUERY_ID_ON
COMPUTE_QUERY_ID_AUTO
COMPUTE_QUERY_ID_REGRESS

Definition at line 54 of file queryjumble.h.

{
    COMPUTE_QUERY_ID_OFF,
    COMPUTE_QUERY_ID_ON,
    COMPUTE_QUERY_ID_AUTO,
    COMPUTE_QUERY_ID_REGRESS,
};

Function Documentation

CleanQuerytext()

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

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

IsQueryIdEnabled()

static bool IsQueryIdEnabled ( void  )

inlinestatic

Definition at line 77 of file queryjumble.h.

{
    if (compute_query_id == COMPUTE_QUERY_ID_OFF)
        return false;
    if (compute_query_id == COMPUTE_QUERY_ID_ON)
        return true;
    return query_id_enabled;
}

References compute_query_id, COMPUTE_QUERY_ID_OFF, COMPUTE_QUERY_ID_ON, and query_id_enabled.

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

JumbleQuery()

JumbleState* JumbleQuery

(

Query *

query

)

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

Variable Documentation

compute_query_id

PGDLLIMPORT int compute_query_id

extern

Definition at line 43 of file queryjumblefuncs.c.

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

query_id_enabled

PGDLLIMPORT bool query_id_enabled

extern

Definition at line 52 of file queryjumblefuncs.c.

Referenced by EnableQueryId(), and IsQueryIdEnabled().