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)
LocationLen *	ComputeConstantLengths (const JumbleState *jstate, const char *query, int query_loc)
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 81 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  )

extern

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().

ComputeConstantLengths()

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

extern

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().

EnableQueryId()

void EnableQueryId ( void  )

extern

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().

IsQueryIdEnabled()

static bool IsQueryIdEnabled ( void  )

inlinestatic

Definition at line 107 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 ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), JumbleQuery(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), and PerformCursorOpen().

JumbleQuery()

JumbleState * JumbleQuery ( Query *  query )

extern

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().

Variable Documentation

compute_query_id

PGDLLIMPORT int compute_query_id

extern

Definition at line 54 of file queryjumblefuncs.c.

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

query_id_enabled

PGDLLIMPORT bool query_id_enabled

extern

Definition at line 63 of file queryjumblefuncs.c.

Referenced by EnableQueryId(), and IsQueryIdEnabled().