database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-30 11:03:19 +03:00
Code Activity

TABLESAMPLE, SQL Standard and extensible

Browse Source 
Add a TABLESAMPLE clause to SELECT statements that allows
user to specify random BERNOULLI sampling or block level
SYSTEM sampling. Implementation allows for extensible
sampling functions to be written, using a standard API.
Basic version follows SQLStandard exactly. Usable
concrete use cases for the sampling API follow in later
commits.

Petr Jelinek

Reviewed by Michael Paquier and Simon Riggs
This commit is contained in:
Simon Riggs
2015-05-15 14:37:10 -04:00
parent 11a83bbedd
commit f6d208d6e5
66 changed files with 2756 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/backend/nodes/copyfuncs.c
View File

@ -641,6 +641,22 @@ _copyCustomScan(const CustomScan *from)
return newnode;
}
/*
* _copySampleScan
*/
static SampleScan *
_copySampleScan(const SampleScan *from)
{
SampleScan *newnode = makeNode(SampleScan);
/*
* copy node superclass fields
*/
CopyScanFields((const Scan *) from, (Scan *) newnode);
return newnode;
}
/*
* CopyJoinFields
*
@ -2063,6 +2079,7 @@ _copyRangeTblEntry(const RangeTblEntry *from)
COPY_SCALAR_FIELD(rtekind);
COPY_SCALAR_FIELD(relid);
COPY_SCALAR_FIELD(relkind);
COPY_NODE_FIELD(tablesample);
COPY_NODE_FIELD(subquery);
COPY_SCALAR_FIELD(security_barrier);
COPY_SCALAR_FIELD(jointype);
@ -2224,6 +2241,40 @@ _copyCommonTableExpr(const CommonTableExpr *from)
return newnode;
}
static RangeTableSample *
_copyRangeTableSample(const RangeTableSample *from)
{
RangeTableSample *newnode = makeNode(RangeTableSample);
COPY_NODE_FIELD(relation);
COPY_STRING_FIELD(method);
COPY_NODE_FIELD(repeatable);
COPY_NODE_FIELD(args);
return newnode;
}
static TableSampleClause *
_copyTableSampleClause(const TableSampleClause *from)
{
TableSampleClause *newnode = makeNode(TableSampleClause);
COPY_SCALAR_FIELD(tsmid);
COPY_SCALAR_FIELD(tsmseqscan);
COPY_SCALAR_FIELD(tsmpagemode);
COPY_SCALAR_FIELD(tsminit);
COPY_SCALAR_FIELD(tsmnextblock);
COPY_SCALAR_FIELD(tsmnexttuple);
COPY_SCALAR_FIELD(tsmexaminetuple);
COPY_SCALAR_FIELD(tsmend);
COPY_SCALAR_FIELD(tsmreset);
COPY_SCALAR_FIELD(tsmcost);
COPY_NODE_FIELD(repeatable);
COPY_NODE_FIELD(args);
return newnode;
}
static A_Expr *
_copyAExpr(const A_Expr *from)
{
@ -4179,6 +4230,9 @@ copyObject(const void *from)
case T_CustomScan:
retval = _copyCustomScan(from);
break;
case T_SampleScan:
retval = _copySampleScan(from);
break;
case T_Join:
retval = _copyJoin(from);
break;
@ -4842,6 +4896,12 @@ copyObject(const void *from)
case T_CommonTableExpr:
retval = _copyCommonTableExpr(from);
break;
case T_RangeTableSample:
retval = _copyRangeTableSample(from);
break;
case T_TableSampleClause:
retval = _copyTableSampleClause(from);
break;
case T_FuncWithArgs:
retval = _copyFuncWithArgs(from);
break;

37
src/backend/nodes/equalfuncs.c
View File

@ -2359,6 +2359,7 @@ _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
COMPARE_SCALAR_FIELD(rtekind);
COMPARE_SCALAR_FIELD(relid);
COMPARE_SCALAR_FIELD(relkind);
COMPARE_NODE_FIELD(tablesample);
COMPARE_NODE_FIELD(subquery);
COMPARE_SCALAR_FIELD(security_barrier);
COMPARE_SCALAR_FIELD(jointype);
@ -2502,6 +2503,36 @@ _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
return true;
}
static bool
_equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b)
{
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(method);
COMPARE_NODE_FIELD(repeatable);
COMPARE_NODE_FIELD(args);
return true;
}
static bool
_equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b)
{
COMPARE_SCALAR_FIELD(tsmid);
COMPARE_SCALAR_FIELD(tsmseqscan);
COMPARE_SCALAR_FIELD(tsmpagemode);
COMPARE_SCALAR_FIELD(tsminit);
COMPARE_SCALAR_FIELD(tsmnextblock);
COMPARE_SCALAR_FIELD(tsmnexttuple);
COMPARE_SCALAR_FIELD(tsmexaminetuple);
COMPARE_SCALAR_FIELD(tsmend);
COMPARE_SCALAR_FIELD(tsmreset);
COMPARE_SCALAR_FIELD(tsmcost);
COMPARE_NODE_FIELD(repeatable);
COMPARE_NODE_FIELD(args);
return true;
}
static bool
_equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
{
@ -3236,6 +3267,12 @@ equal(const void *a, const void *b)
case T_CommonTableExpr:
retval = _equalCommonTableExpr(a, b);
break;
case T_RangeTableSample:
retval = _equalRangeTableSample(a, b);
break;
case T_TableSampleClause:
retval = _equalTableSampleClause(a, b);
break;
case T_FuncWithArgs:
retval = _equalFuncWithArgs(a, b);
break;

28
src/backend/nodes/nodeFuncs.c
View File

@ -2058,6 +2058,14 @@ range_table_walker(List *rtable,
switch (rte->rtekind)
{
case RTE_RELATION:
if (rte->tablesample)
{
if (walker(rte->tablesample->args, context))
return true;
if (walker(rte->tablesample->repeatable, context))
return true;
}
break;
case RTE_CTE:
/* nothing to do */
break;
@ -2813,6 +2821,14 @@ range_table_mutator(List *rtable,
switch (rte->rtekind)
{
case RTE_RELATION:
if (rte->tablesample)
{
MUTATE(rte->tablesample->args, rte->tablesample->args,
List *);
MUTATE(rte->tablesample->repeatable,
rte->tablesample->repeatable, Node *);
}
break;
case RTE_CTE:
/* we don't bother to copy eref, aliases, etc; OK? */
break;
@ -3309,6 +3325,18 @@ raw_expression_tree_walker(Node *node,
break;
case T_CommonTableExpr:
return walker(((CommonTableExpr *) node)->ctequery, context);
case T_RangeTableSample:
{
RangeTableSample *rts = (RangeTableSample *) node;
if (walker(rts->relation, context))
return true;
if (walker(rts->repeatable, context))
return true;
if (walker(rts->args, context))
return true;
}
break;
default:
elog(ERROR, "unrecognized node type: %d",
(int) nodeTag(node));

48
src/backend/nodes/outfuncs.c
View File

@ -591,6 +591,14 @@ _outCustomScan(StringInfo str, const CustomScan *node)
node->methods->TextOutCustomScan(str, node);
}
static void
_outSampleScan(StringInfo str, const SampleScan *node)
{
WRITE_NODE_TYPE("SAMPLESCAN");
_outScanInfo(str, (const Scan *) node);
}
static void
_outJoin(StringInfo str, const Join *node)
{
@ -2444,6 +2452,36 @@ _outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
WRITE_NODE_FIELD(ctecolcollations);
}
static void
_outRangeTableSample(StringInfo str, const RangeTableSample *node)
{
WRITE_NODE_TYPE("RANGETABLESAMPLE");
WRITE_NODE_FIELD(relation);
WRITE_STRING_FIELD(method);
WRITE_NODE_FIELD(repeatable);
WRITE_NODE_FIELD(args);
}
static void
_outTableSampleClause(StringInfo str, const TableSampleClause *node)
{
WRITE_NODE_TYPE("TABLESAMPLECLAUSE");
WRITE_OID_FIELD(tsmid);
WRITE_BOOL_FIELD(tsmseqscan);
WRITE_BOOL_FIELD(tsmpagemode);
WRITE_OID_FIELD(tsminit);
WRITE_OID_FIELD(tsmnextblock);
WRITE_OID_FIELD(tsmnexttuple);
WRITE_OID_FIELD(tsmexaminetuple);
WRITE_OID_FIELD(tsmend);
WRITE_OID_FIELD(tsmreset);
WRITE_OID_FIELD(tsmcost);
WRITE_NODE_FIELD(repeatable);
WRITE_NODE_FIELD(args);
}
static void
_outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
{
@ -2474,6 +2512,7 @@ _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
case RTE_RELATION:
WRITE_OID_FIELD(relid);
WRITE_CHAR_FIELD(relkind);
WRITE_NODE_FIELD(tablesample);
break;
case RTE_SUBQUERY:
WRITE_NODE_FIELD(subquery);
@ -2973,6 +3012,9 @@ _outNode(StringInfo str, const void *obj)
case T_CustomScan:
_outCustomScan(str, obj);
break;
case T_SampleScan:
_outSampleScan(str, obj);
break;
case T_Join:
_outJoin(str, obj);
break;
@ -3319,6 +3361,12 @@ _outNode(StringInfo str, const void *obj)
case T_CommonTableExpr:
_outCommonTableExpr(str, obj);
break;
case T_RangeTableSample:
_outRangeTableSample(str, obj);
break;
case T_TableSampleClause:
_outTableSampleClause(str, obj);
break;
case T_SetOperationStmt:
_outSetOperationStmt(str, obj);
break;

45
src/backend/nodes/readfuncs.c
View File

@ -351,6 +351,46 @@ _readCommonTableExpr(void)
READ_DONE();
}
/*
* _readRangeTableSample
*/
static RangeTableSample *
_readRangeTableSample(void)
{
READ_LOCALS(RangeTableSample);
READ_NODE_FIELD(relation);
READ_STRING_FIELD(method);
READ_NODE_FIELD(repeatable);
READ_NODE_FIELD(args);
READ_DONE();
}
/*
* _readTableSampleClause
*/
static TableSampleClause *
_readTableSampleClause(void)
{
READ_LOCALS(TableSampleClause);
READ_OID_FIELD(tsmid);
READ_BOOL_FIELD(tsmseqscan);
READ_BOOL_FIELD(tsmpagemode);
READ_OID_FIELD(tsminit);
READ_OID_FIELD(tsmnextblock);
READ_OID_FIELD(tsmnexttuple);
READ_OID_FIELD(tsmexaminetuple);
READ_OID_FIELD(tsmend);
READ_OID_FIELD(tsmreset);
READ_OID_FIELD(tsmcost);
READ_NODE_FIELD(repeatable);
READ_NODE_FIELD(args);
READ_DONE();
}
/*
* _readSetOperationStmt
*/
@ -1255,6 +1295,7 @@ _readRangeTblEntry(void)
case RTE_RELATION:
READ_OID_FIELD(relid);
READ_CHAR_FIELD(relkind);
READ_NODE_FIELD(tablesample);
break;
case RTE_SUBQUERY:
READ_NODE_FIELD(subquery);
@ -1351,6 +1392,10 @@ parseNodeString(void)
return_value = _readRowMarkClause();
else if (MATCH("COMMONTABLEEXPR", 15))
return_value = _readCommonTableExpr();
else if (MATCH("RANGETABLESAMPLE", 16))
return_value = _readRangeTableSample();
else if (MATCH("TABLESAMPLECLAUSE", 17))
return_value = _readTableSampleClause();
else if (MATCH("SETOPERATIONSTMT", 16))
return_value = _readSetOperationStmt();
else if (MATCH("ALIAS", 5))