mirror of https://github.com/postgres/postgres
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
6.6 KiB
219 lines
6.6 KiB
/*--------------------------------------------------------------------------
|
|
*
|
|
* test_predtest.c
|
|
* Test correctness of optimizer's predicate proof logic.
|
|
*
|
|
* Copyright (c) 2018-2019, PostgreSQL Global Development Group
|
|
*
|
|
* IDENTIFICATION
|
|
* src/test/modules/test_predtest/test_predtest.c
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "access/htup_details.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "executor/spi.h"
|
|
#include "funcapi.h"
|
|
#include "nodes/makefuncs.h"
|
|
#include "optimizer/clauses.h"
|
|
#include "optimizer/predtest.h"
|
|
#include "utils/builtins.h"
|
|
|
|
PG_MODULE_MAGIC;
|
|
|
|
/*
|
|
* test_predtest(query text) returns record
|
|
*/
|
|
PG_FUNCTION_INFO_V1(test_predtest);
|
|
|
|
Datum
|
|
test_predtest(PG_FUNCTION_ARGS)
|
|
{
|
|
text *txt = PG_GETARG_TEXT_PP(0);
|
|
char *query_string = text_to_cstring(txt);
|
|
SPIPlanPtr spiplan;
|
|
int spirc;
|
|
TupleDesc tupdesc;
|
|
bool s_i_holds,
|
|
w_i_holds,
|
|
s_r_holds,
|
|
w_r_holds;
|
|
CachedPlan *cplan;
|
|
PlannedStmt *stmt;
|
|
Plan *plan;
|
|
Expr *clause1;
|
|
Expr *clause2;
|
|
bool strong_implied_by,
|
|
weak_implied_by,
|
|
strong_refuted_by,
|
|
weak_refuted_by;
|
|
Datum values[8];
|
|
bool nulls[8];
|
|
int i;
|
|
|
|
/* We use SPI to parse, plan, and execute the test query */
|
|
if (SPI_connect() != SPI_OK_CONNECT)
|
|
elog(ERROR, "SPI_connect failed");
|
|
|
|
/*
|
|
* First, plan and execute the query, and inspect the results. To the
|
|
* extent that the query fully exercises the two expressions, this
|
|
* provides an experimental indication of whether implication or
|
|
* refutation holds.
|
|
*/
|
|
spiplan = SPI_prepare(query_string, 0, NULL);
|
|
if (spiplan == NULL)
|
|
elog(ERROR, "SPI_prepare failed for \"%s\"", query_string);
|
|
|
|
spirc = SPI_execute_plan(spiplan, NULL, NULL, true, 0);
|
|
if (spirc != SPI_OK_SELECT)
|
|
elog(ERROR, "failed to execute \"%s\"", query_string);
|
|
tupdesc = SPI_tuptable->tupdesc;
|
|
if (tupdesc->natts != 2 ||
|
|
TupleDescAttr(tupdesc, 0)->atttypid != BOOLOID ||
|
|
TupleDescAttr(tupdesc, 1)->atttypid != BOOLOID)
|
|
elog(ERROR, "query must yield two boolean columns");
|
|
|
|
s_i_holds = w_i_holds = s_r_holds = w_r_holds = true;
|
|
for (i = 0; i < SPI_processed; i++)
|
|
{
|
|
HeapTuple tup = SPI_tuptable->vals[i];
|
|
Datum dat;
|
|
bool isnull;
|
|
char c1,
|
|
c2;
|
|
|
|
/* Extract column values in a 3-way representation */
|
|
dat = SPI_getbinval(tup, tupdesc, 1, &isnull);
|
|
if (isnull)
|
|
c1 = 'n';
|
|
else if (DatumGetBool(dat))
|
|
c1 = 't';
|
|
else
|
|
c1 = 'f';
|
|
|
|
dat = SPI_getbinval(tup, tupdesc, 2, &isnull);
|
|
if (isnull)
|
|
c2 = 'n';
|
|
else if (DatumGetBool(dat))
|
|
c2 = 't';
|
|
else
|
|
c2 = 'f';
|
|
|
|
/* Check for violations of various proof conditions */
|
|
|
|
/* strong implication: truth of c2 implies truth of c1 */
|
|
if (c2 == 't' && c1 != 't')
|
|
s_i_holds = false;
|
|
/* weak implication: non-falsity of c2 implies non-falsity of c1 */
|
|
if (c2 != 'f' && c1 == 'f')
|
|
w_i_holds = false;
|
|
/* strong refutation: truth of c2 implies falsity of c1 */
|
|
if (c2 == 't' && c1 != 'f')
|
|
s_r_holds = false;
|
|
/* weak refutation: truth of c2 implies non-truth of c1 */
|
|
if (c2 == 't' && c1 == 't')
|
|
w_r_holds = false;
|
|
}
|
|
|
|
/*
|
|
* Now, dig the clause querytrees out of the plan, and see what predtest.c
|
|
* does with them.
|
|
*/
|
|
cplan = SPI_plan_get_cached_plan(spiplan);
|
|
|
|
if (list_length(cplan->stmt_list) != 1)
|
|
elog(ERROR, "failed to decipher query plan");
|
|
stmt = linitial_node(PlannedStmt, cplan->stmt_list);
|
|
if (stmt->commandType != CMD_SELECT)
|
|
elog(ERROR, "failed to decipher query plan");
|
|
plan = stmt->planTree;
|
|
Assert(list_length(plan->targetlist) >= 2);
|
|
clause1 = castNode(TargetEntry, linitial(plan->targetlist))->expr;
|
|
clause2 = castNode(TargetEntry, lsecond(plan->targetlist))->expr;
|
|
|
|
/*
|
|
* Because the clauses are in the SELECT list, preprocess_expression did
|
|
* not pass them through canonicalize_qual nor make_ands_implicit.
|
|
*
|
|
* We can't do canonicalize_qual here, since it's unclear whether the
|
|
* expressions ought to be treated as WHERE or CHECK clauses. Fortunately,
|
|
* useful test expressions wouldn't be affected by those transformations
|
|
* anyway. We should do make_ands_implicit, though.
|
|
*
|
|
* Another way in which this does not exactly duplicate the normal usage
|
|
* of the proof functions is that they are often given qual clauses
|
|
* containing RestrictInfo nodes. But since predtest.c just looks through
|
|
* those anyway, it seems OK to not worry about that point.
|
|
*/
|
|
clause1 = (Expr *) make_ands_implicit(clause1);
|
|
clause2 = (Expr *) make_ands_implicit(clause2);
|
|
|
|
strong_implied_by = predicate_implied_by((List *) clause1,
|
|
(List *) clause2,
|
|
false);
|
|
|
|
weak_implied_by = predicate_implied_by((List *) clause1,
|
|
(List *) clause2,
|
|
true);
|
|
|
|
strong_refuted_by = predicate_refuted_by((List *) clause1,
|
|
(List *) clause2,
|
|
false);
|
|
|
|
weak_refuted_by = predicate_refuted_by((List *) clause1,
|
|
(List *) clause2,
|
|
true);
|
|
|
|
/*
|
|
* Issue warning if any proof is demonstrably incorrect.
|
|
*/
|
|
if (strong_implied_by && !s_i_holds)
|
|
elog(WARNING, "strong_implied_by result is incorrect");
|
|
if (weak_implied_by && !w_i_holds)
|
|
elog(WARNING, "weak_implied_by result is incorrect");
|
|
if (strong_refuted_by && !s_r_holds)
|
|
elog(WARNING, "strong_refuted_by result is incorrect");
|
|
if (weak_refuted_by && !w_r_holds)
|
|
elog(WARNING, "weak_refuted_by result is incorrect");
|
|
|
|
/*
|
|
* Clean up and return a record of the results.
|
|
*/
|
|
if (SPI_finish() != SPI_OK_FINISH)
|
|
elog(ERROR, "SPI_finish failed");
|
|
|
|
tupdesc = CreateTemplateTupleDesc(8);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 1,
|
|
"strong_implied_by", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 2,
|
|
"weak_implied_by", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 3,
|
|
"strong_refuted_by", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 4,
|
|
"weak_refuted_by", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 5,
|
|
"s_i_holds", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 6,
|
|
"w_i_holds", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 7,
|
|
"s_r_holds", BOOLOID, -1, 0);
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 8,
|
|
"w_r_holds", BOOLOID, -1, 0);
|
|
tupdesc = BlessTupleDesc(tupdesc);
|
|
|
|
MemSet(nulls, 0, sizeof(nulls));
|
|
values[0] = BoolGetDatum(strong_implied_by);
|
|
values[1] = BoolGetDatum(weak_implied_by);
|
|
values[2] = BoolGetDatum(strong_refuted_by);
|
|
values[3] = BoolGetDatum(weak_refuted_by);
|
|
values[4] = BoolGetDatum(s_i_holds);
|
|
values[5] = BoolGetDatum(w_i_holds);
|
|
values[6] = BoolGetDatum(s_r_holds);
|
|
values[7] = BoolGetDatum(w_r_holds);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|