diff --git a/src/backend/executor/Makefile b/src/backend/executor/Makefile index 0152e31f0c..ea053209a1 100644 --- a/src/backend/executor/Makefile +++ b/src/backend/executor/Makefile @@ -27,9 +27,8 @@ OBJS = execAmi.o execCurrent.o execExpr.o execExprInterp.o \ nodeSamplescan.o nodeSeqscan.o nodeSetOp.o nodeSort.o nodeUnique.o \ nodeValuesscan.o \ nodeCtescan.o nodeNamedtuplestorescan.o nodeWorktablescan.o \ - nodeGroup.o nodeSubplan.o nodeSubqueryscan.o nodeTidscan.o \ - nodeTidrangescan.o \ - nodeForeignscan.o nodeWindowAgg.o tstoreReceiver.o tqueue.o spi.o \ - nodeTableFuncscan.o + nodeGroup.o nodeSubplan.o nodeSubqueryscan.o nodeTidrangescan.o \ + nodeTidscan.o nodeForeignscan.o nodeWindowAgg.o tstoreReceiver.o \ + tqueue.o spi.o nodeTableFuncscan.o include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/executor/execAmi.c b/src/backend/executor/execAmi.c index d64771a097..58e4d8555a 100644 --- a/src/backend/executor/execAmi.c +++ b/src/backend/executor/execAmi.c @@ -536,10 +536,6 @@ ExecSupportsBackwardScan(Plan *node) /* Simplify life for tablesample methods by disallowing this */ return false; - case T_TidRangeScan: - /* Keep TidRangeScan as simple as possible. */ - return false; - case T_Gather: return false; diff --git a/src/backend/executor/nodeTidrangescan.c b/src/backend/executor/nodeTidrangescan.c index c4706e3677..8a72f52074 100644 --- a/src/backend/executor/nodeTidrangescan.c +++ b/src/backend/executor/nodeTidrangescan.c @@ -12,14 +12,6 @@ * *------------------------------------------------------------------------- */ -/* - * INTERFACE ROUTINES - * - * ExecTidRangeScan scans a relation using a range of tids - * ExecInitTidRangeScan creates and initializes state info. - * ExecReScanTidRangeScan rescans the tid relation. - * ExecEndTidRangeScan releases all storage. - */ #include "postgres.h" #include "access/relscan.h" @@ -45,7 +37,7 @@ typedef enum TIDEXPR_LOWER_BOUND } TidExprType; -/* one element in TidExpr's opexprs */ +/* Upper or lower range bound for scan */ typedef struct TidOpExpr { TidExprType exprtype; /* type of op */ @@ -93,7 +85,7 @@ MakeTidOpExpr(OpExpr *expr, TidRangeScanState *tidstate) tidopexpr->exprtype = invert ? TIDEXPR_UPPER_BOUND : TIDEXPR_LOWER_BOUND; break; default: - elog(ERROR, "could not identify CTID expression"); + elog(ERROR, "could not identify CTID operator"); } tidopexpr->exprstate = exprstate; @@ -115,8 +107,12 @@ TidExprListCreate(TidRangeScanState *tidrangestate) foreach(l, node->tidrangequals) { OpExpr *opexpr = lfirst(l); - TidOpExpr *tidopexpr = MakeTidOpExpr(opexpr, tidrangestate); + TidOpExpr *tidopexpr; + if (!IsA(opexpr, OpExpr)) + elog(ERROR, "could not identify CTID expression"); + + tidopexpr = MakeTidOpExpr(opexpr, tidrangestate); tidexprs = lappend(tidexprs, tidopexpr); } @@ -124,8 +120,10 @@ TidExprListCreate(TidRangeScanState *tidrangestate) } /* - * Set a lower bound tid, taking into account the inclusivity of the bound. - * Return true if the bound is valid. + * Set 'lowerBound' based on 'tid'. If 'inclusive' is false then the + * lowerBound is incremented to the next tid value so that it becomes + * inclusive. If there is no valid next tid value then we return false, + * otherwise we return true. */ static bool SetTidLowerBound(ItemPointer tid, bool inclusive, ItemPointer lowerBound) @@ -144,11 +142,12 @@ SetTidLowerBound(ItemPointer tid, bool inclusive, ItemPointer lowerBound) /* * If the lower bound was already at or above the maximum block - * number, then there is no valid range. + * number, then there is no valid value for it be set to. */ if (block >= MaxBlockNumber) return false; + /* Set the lowerBound to the first offset in the next block */ ItemPointerSet(lowerBound, block + 1, 1); } else @@ -161,8 +160,10 @@ SetTidLowerBound(ItemPointer tid, bool inclusive, ItemPointer lowerBound) } /* - * Set an upper bound tid, taking into account the inclusivity of the bound. - * Return true if the bound is valid. + * Set 'upperBound' based on 'tid'. If 'inclusive' is false then the + * upperBound is decremented to the previous tid value so that it becomes + * inclusive. If there is no valid previous tid value then we return false, + * otherwise we return true. */ static bool SetTidUpperBound(ItemPointer tid, bool inclusive, ItemPointer upperBound) @@ -189,7 +190,7 @@ SetTidUpperBound(ItemPointer tid, bool inclusive, ItemPointer upperBound) /* * If the upper bound was already in block 0, then there is no - * valid range. + * valid value for it to be set to. */ if (block == 0) return false; @@ -206,8 +207,9 @@ SetTidUpperBound(ItemPointer tid, bool inclusive, ItemPointer upperBound) /* ---------------------------------------------------------------- * TidRangeEval * - * Compute the range of TIDs to scan, by evaluating the - * expressions for them. + * Compute and set node's block and offset range to scan by evaluating + * the trss_tidexprs. If we detect an invalid range that cannot yield + * any rows, the range is left unset. * ---------------------------------------------------------------- */ static void @@ -227,7 +229,6 @@ TidRangeEval(TidRangeScanState *node) */ nblocks = RelationGetNumberOfBlocks(node->ss.ss_currentRelation); - /* The biggest range on an empty table is empty; just skip it. */ if (nblocks == 0) return; @@ -256,6 +257,10 @@ TidRangeEval(TidRangeScanState *node) { ItemPointerData lb; + /* + * If the lower bound is beyond the maximum value for ctid, then + * just bail without setting the range. No rows can match. + */ if (!SetTidLowerBound(itemptr, tidopexpr->inclusive, &lb)) return; @@ -267,6 +272,10 @@ TidRangeEval(TidRangeScanState *node) { ItemPointerData ub; + /* + * If the upper bound is below the minimum value for ctid, then + * just bail without setting the range. No rows can match. + */ if (!SetTidUpperBound(itemptr, tidopexpr->inclusive, &ub)) return; @@ -275,7 +284,7 @@ TidRangeEval(TidRangeScanState *node) } } - /* If the resulting range is not empty, use it. */ + /* If the resulting range is not empty, set it. */ if (ItemPointerCompare(&lowerBound, &upperBound) <= 0) { node->trss_startBlock = ItemPointerGetBlockNumberNoCheck(&lowerBound); @@ -290,7 +299,7 @@ TidRangeEval(TidRangeScanState *node) * * Fetch the next tuple when scanning a range of TIDs. * - * Since the heap access method may return tuples that are in the scan + * Since the table access method may return tuples that are in the scan * limit, but not within the required TID range, this function will * check for such tuples and skip over them. * ---------------------------------------------------------------- @@ -399,7 +408,7 @@ TidRangeNext(TidRangeScanState *node) foundTuple = NextInTidRange(node, scandesc, slot); /* - * If we've exhuasted all the tuples in the range, reset the inScan flag. + * If we've exhausted all the tuples in the range, reset the inScan flag. * This will cause the heap to be rescanned for any subsequent fetches, * which is important for some cursor operations: for instance, FETCH LAST * fetches all the tuples in order and then fetches one tuple in reverse. @@ -460,8 +469,7 @@ ExecReScanTidRangeScan(TidRangeScanState *node) TableScanDesc scan = node->ss.ss_currentScanDesc; if (scan != NULL) - table_rescan(scan, /* scan desc */ - NULL); /* new scan keys */ + table_rescan(scan, NULL); /* mark scan as not in progress, and tid range list as not computed yet */ node->trss_inScan = false; @@ -482,6 +490,9 @@ ExecEndTidRangeScan(TidRangeScanState *node) { TableScanDesc scan = node->ss.ss_currentScanDesc; + if (scan != NULL) + table_endscan(scan); + /* * Free the exprcontext */ @@ -493,10 +504,6 @@ ExecEndTidRangeScan(TidRangeScanState *node) if (node->ss.ps.ps_ResultTupleSlot) ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); ExecClearTuple(node->ss.ss_ScanTupleSlot); - - /* close heap scan */ - if (scan != NULL) - table_endscan(scan); } /* ---------------------------------------------------------------- @@ -532,7 +539,7 @@ ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags) ExecAssignExprContext(estate, &tidrangestate->ss.ps); /* - * mark scan as not in progress, and tid range list as not computed yet + * mark scan as not in progress, and tid range as not computed yet */ tidrangestate->trss_inScan = false; tidrangestate->trss_startBlock = InvalidBlockNumber; @@ -543,7 +550,7 @@ ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags) currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags); tidrangestate->ss.ss_currentRelation = currentRelation; - tidrangestate->ss.ss_currentScanDesc = NULL; /* no heap scan here */ + tidrangestate->ss.ss_currentScanDesc = NULL; /* no table scan here */ /* * get the scan type from the relation descriptor. diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index a67111ee6b..616fe75749 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -1273,8 +1273,8 @@ cost_tidscan(Path *path, PlannerInfo *root, /* * cost_tidrangescan - * Determines and returns the cost of scanning a relation using a range of - * TIDs. + * Determines and sets the costs of scanning a relation using a range of + * TIDs for 'path' * * 'baserel' is the relation to be scanned * 'tidrangequals' is the list of TID-checkable range quals @@ -1282,7 +1282,8 @@ cost_tidscan(Path *path, PlannerInfo *root, */ void cost_tidrangescan(Path *path, PlannerInfo *root, - RelOptInfo *baserel, List *tidrangequals, ParamPathInfo *param_info) + RelOptInfo *baserel, List *tidrangequals, + ParamPathInfo *param_info) { Selectivity selectivity; double pages; @@ -1292,7 +1293,6 @@ cost_tidrangescan(Path *path, PlannerInfo *root, Cost cpu_per_tuple; QualCost tid_qual_cost; double ntuples; - double nrandompages; double nseqpages; double spc_random_page_cost; double spc_seq_page_cost; @@ -1325,7 +1325,6 @@ cost_tidrangescan(Path *path, PlannerInfo *root, */ ntuples = selectivity * baserel->tuples; nseqpages = pages - 1.0; - nrandompages = 1.0; if (!enable_tidscan) startup_cost += disable_cost; @@ -1341,8 +1340,8 @@ cost_tidrangescan(Path *path, PlannerInfo *root, &spc_random_page_cost, &spc_seq_page_cost); - /* disk costs */ - run_cost += spc_random_page_cost * nrandompages + spc_seq_page_cost * nseqpages; + /* disk costs; 1 random page and the remainder as seq pages */ + run_cost += spc_random_page_cost + spc_seq_page_cost * nseqpages; /* Add scanning CPU costs */ get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost); diff --git a/src/backend/optimizer/path/tidpath.c b/src/backend/optimizer/path/tidpath.c index 3f8533c8d8..2e8535fa14 100644 --- a/src/backend/optimizer/path/tidpath.c +++ b/src/backend/optimizer/path/tidpath.c @@ -73,7 +73,7 @@ IsCTIDVar(Var *var, RelOptInfo *rel) * and nothing on the other side of the clause does. */ static bool -IsTidBinaryClause(RestrictInfo *rinfo, RelOptInfo *rel) +IsBinaryTidClause(RestrictInfo *rinfo, RelOptInfo *rel) { OpExpr *node; Node *arg1, @@ -86,7 +86,7 @@ IsTidBinaryClause(RestrictInfo *rinfo, RelOptInfo *rel) return false; node = (OpExpr *) rinfo->clause; - /* Operator must take two arguments */ + /* OpExpr must have two arguments */ if (list_length(node->args) != 2) return false; arg1 = linitial(node->args); @@ -129,9 +129,13 @@ IsTidBinaryClause(RestrictInfo *rinfo, RelOptInfo *rel) static bool IsTidEqualClause(RestrictInfo *rinfo, RelOptInfo *rel) { - if (!IsTidBinaryClause(rinfo, rel)) + if (!IsBinaryTidClause(rinfo, rel)) return false; - return ((OpExpr *) rinfo->clause)->opno == TIDEqualOperator; + + if (((OpExpr *) rinfo->clause)->opno == TIDEqualOperator) + return true; + + return false; } /* @@ -147,13 +151,15 @@ IsTidRangeClause(RestrictInfo *rinfo, RelOptInfo *rel) { Oid opno; - if (!IsTidBinaryClause(rinfo, rel)) + if (!IsBinaryTidClause(rinfo, rel)) return false; opno = ((OpExpr *) rinfo->clause)->opno; - return opno == TIDLessOperator || - opno == TIDLessEqOperator || - opno == TIDGreaterOperator || - opno == TIDGreaterEqOperator; + + if (opno == TIDLessOperator || opno == TIDLessEqOperator || + opno == TIDGreaterOperator || opno == TIDGreaterEqOperator) + return true; + + return false; } /* @@ -262,7 +268,7 @@ TidQualFromRestrictInfo(RestrictInfo *rinfo, RelOptInfo *rel) * * Returns a List of CTID qual RestrictInfos for the specified rel (with * implicit OR semantics across the list), or NIL if there are no usable - * conditions. + * equality conditions. * * This function is just concerned with handling AND/OR recursion. */ @@ -346,7 +352,7 @@ TidQualFromRestrictInfoList(List *rlist, RelOptInfo *rel) * * Returns a List of CTID range qual RestrictInfos for the specified rel * (with implicit AND semantics across the list), or NIL if there are no - * usable conditions. + * usable range conditions. */ static List * TidRangeQualFromRestrictInfoList(List *rlist, RelOptInfo *rel) @@ -362,9 +368,7 @@ TidRangeQualFromRestrictInfoList(List *rlist, RelOptInfo *rel) RestrictInfo *rinfo = lfirst_node(RestrictInfo, l); if (IsTidRangeClause(rinfo, rel)) - { rlst = lappend(rlst, rinfo); - } } return rlst; @@ -478,7 +482,8 @@ create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel) * If there are range quals in the baserestrict list, generate a * TidRangePath. */ - tidrangequals = TidRangeQualFromRestrictInfoList(rel->baserestrictinfo, rel); + tidrangequals = TidRangeQualFromRestrictInfoList(rel->baserestrictinfo, + rel); if (tidrangequals) { diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index 018da82719..104be4082d 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -127,8 +127,10 @@ static Plan *create_bitmap_subplan(PlannerInfo *root, Path *bitmapqual, static void bitmap_subplan_mark_shared(Plan *plan); static TidScan *create_tidscan_plan(PlannerInfo *root, TidPath *best_path, List *tlist, List *scan_clauses); -static TidRangeScan *create_tidrangescan_plan(PlannerInfo *root, TidRangePath *best_path, - List *tlist, List *scan_clauses); +static TidRangeScan *create_tidrangescan_plan(PlannerInfo *root, + TidRangePath *best_path, + List *tlist, + List *scan_clauses); static SubqueryScan *create_subqueryscan_plan(PlannerInfo *root, SubqueryScanPath *best_path, List *tlist, List *scan_clauses); @@ -3386,7 +3388,7 @@ create_tidrangescan_plan(PlannerInfo *root, TidRangePath *best_path, /* * The qpqual list must contain all restrictions not enforced by the - * tidrangequals list. tidquals has AND semantics, so we can simply + * tidrangequals list. tidrangequals has AND semantics, so we can simply * remove any qual that appears in it. */ { @@ -3401,8 +3403,6 @@ create_tidrangescan_plan(PlannerInfo *root, TidRangePath *best_path, continue; /* we may drop pseudoconstants here */ if (list_member_ptr(tidrangequals, rinfo)) continue; /* simple duplicate */ - if (is_redundant_derived_clause(rinfo, tidrangequals)) - continue; /* derived from same EquivalenceClass */ qpqual = lappend(qpqual, rinfo); } scan_clauses = qpqual; diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index c06a053ca9..5c7a3a04d0 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -1178,8 +1178,8 @@ create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, * the pathnode. */ TidRangePath * -create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel, List *tidrangequals, - Relids required_outer) +create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel, + List *tidrangequals, Relids required_outer) { TidRangePath *pathnode = makeNode(TidRangePath); diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c index 162a369655..77e4ba6726 100644 --- a/src/backend/optimizer/util/plancat.c +++ b/src/backend/optimizer/util/plancat.c @@ -445,7 +445,8 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent, get_relation_foreign_keys(root, rel, relation, inhparent); /* Collect info about functions implemented by the rel's table AM. */ - rel->has_scan_setlimits = relation->rd_tableam && relation->rd_tableam->scan_bitmap_next_block != NULL; + rel->has_scan_setlimits = relation->rd_tableam && + relation->rd_tableam->scan_setlimits != NULL; /* * Collect info about relation's partitioning scheme, if any. Only diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h index 109741b52e..fa47119213 100644 --- a/src/include/access/tableam.h +++ b/src/include/access/tableam.h @@ -859,7 +859,6 @@ static inline void table_scan_setlimits(TableScanDesc scan, BlockNumber startBlk, BlockNumber numBlks) { - Assert(scan->rs_rd->rd_tableam->scan_setlimits != NULL); scan->rs_rd->rd_tableam->scan_setlimits(scan, startBlk, numBlks); } diff --git a/src/include/executor/nodeTidrangescan.h b/src/include/executor/nodeTidrangescan.h index cff87907fa..f0bbcc6a04 100644 --- a/src/include/executor/nodeTidrangescan.h +++ b/src/include/executor/nodeTidrangescan.h @@ -16,7 +16,8 @@ #include "nodes/execnodes.h" -extern TidRangeScanState *ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags); +extern TidRangeScanState *ExecInitTidRangeScan(TidRangeScan *node, + EState *estate, int eflags); extern void ExecEndTidRangeScan(TidRangeScanState *node); extern void ExecReScanTidRangeScan(TidRangeScanState *node); diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index fdf37b0bc9..6a1328481d 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1580,7 +1580,8 @@ typedef struct TidScanState * trss_tidexprs list of TidOpExpr structs (see nodeTidrangescan.c) * trss_startBlock first block to scan * trss_endBlock last block to scan (inclusive) - * trss_startOffset first offset in first block to scan + * trss_startOffset first offset in first block to scan or InvalidBlockNumber + * when the range is not set * trss_endOffset last offset in last block to scan (inclusive) * trss_inScan is a scan currently in progress? * ---------------- diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h index 9d90a996df..c352a7c1a7 100644 --- a/src/include/optimizer/cost.h +++ b/src/include/optimizer/cost.h @@ -83,7 +83,8 @@ extern void cost_bitmap_tree_node(Path *path, Cost *cost, Selectivity *selec); extern void cost_tidscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, List *tidquals, ParamPathInfo *param_info); extern void cost_tidrangescan(Path *path, PlannerInfo *root, - RelOptInfo *baserel, List *tidquals, ParamPathInfo *param_info); + RelOptInfo *baserel, List *tidquals, + ParamPathInfo *param_info); extern void cost_subqueryscan(SubqueryScanPath *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info); extern void cost_functionscan(Path *path, PlannerInfo *root, diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h index 23b6bc4d3d..dff8fdd126 100644 --- a/src/include/optimizer/pathnode.h +++ b/src/include/optimizer/pathnode.h @@ -63,8 +63,10 @@ extern BitmapOrPath *create_bitmap_or_path(PlannerInfo *root, List *bitmapquals); extern TidPath *create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, Relids required_outer); -extern TidRangePath *create_tidrangescan_path(PlannerInfo *root, RelOptInfo *rel, - List *tidrangequals, Relids required_outer); +extern TidRangePath *create_tidrangescan_path(PlannerInfo *root, + RelOptInfo *rel, + List *tidrangequals, + Relids required_outer); extern AppendPath *create_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *partial_subpaths, List *pathkeys, Relids required_outer, diff --git a/src/test/regress/expected/tidrangescan.out b/src/test/regress/expected/tidrangescan.out index 6a1d08686c..fc11894c8e 100644 --- a/src/test/regress/expected/tidrangescan.out +++ b/src/test/regress/expected/tidrangescan.out @@ -1,7 +1,13 @@ -- tests for tidrangescans +SET enable_seqscan TO off; CREATE TABLE tidrangescan(id integer, data text); -INSERT INTO tidrangescan SELECT i,repeat('x', 100) FROM generate_series(1,1000) AS s(i); -DELETE FROM tidrangescan WHERE substring(ctid::text from ',(\d+)\)')::integer > 10 OR substring(ctid::text from '\((\d+),')::integer >= 10;; +-- insert enough tuples to fill at least two pages +INSERT INTO tidrangescan SELECT i,repeat('x', 100) FROM generate_series(1,200) AS s(i); +-- remove all tuples after the 10th tuple on each page. Trying to ensure +-- we get the same layout with all CPU architectures and smaller than standard +-- page sizes. +DELETE FROM tidrangescan +WHERE substring(ctid::text from ',(\d+)\)')::integer > 10 OR substring(ctid::text from '\((\d+),')::integer > 2; VACUUM tidrangescan; -- range scans with upper bound EXPLAIN (COSTS OFF) @@ -70,49 +76,49 @@ SELECT ctid FROM tidrangescan WHERE ctid < '(0,0)'; -- range scans with lower bound EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE ctid > '(9,8)'; +SELECT ctid FROM tidrangescan WHERE ctid > '(2,8)'; QUERY PLAN ----------------------------------- Tid Range Scan on tidrangescan - TID Cond: (ctid > '(9,8)'::tid) + TID Cond: (ctid > '(2,8)'::tid) (2 rows) -SELECT ctid FROM tidrangescan WHERE ctid > '(9,8)'; +SELECT ctid FROM tidrangescan WHERE ctid > '(2,8)'; ctid -------- - (9,9) - (9,10) + (2,9) + (2,10) (2 rows) EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE '(9,8)' < ctid; +SELECT ctid FROM tidrangescan WHERE '(2,8)' < ctid; QUERY PLAN ----------------------------------- Tid Range Scan on tidrangescan - TID Cond: ('(9,8)'::tid < ctid) + TID Cond: ('(2,8)'::tid < ctid) (2 rows) -SELECT ctid FROM tidrangescan WHERE '(9,8)' < ctid; +SELECT ctid FROM tidrangescan WHERE '(2,8)' < ctid; ctid -------- - (9,9) - (9,10) + (2,9) + (2,10) (2 rows) EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE ctid >= '(9,8)'; +SELECT ctid FROM tidrangescan WHERE ctid >= '(2,8)'; QUERY PLAN ------------------------------------ Tid Range Scan on tidrangescan - TID Cond: (ctid >= '(9,8)'::tid) + TID Cond: (ctid >= '(2,8)'::tid) (2 rows) -SELECT ctid FROM tidrangescan WHERE ctid >= '(9,8)'; +SELECT ctid FROM tidrangescan WHERE ctid >= '(2,8)'; ctid -------- - (9,8) - (9,9) - (9,10) + (2,8) + (2,9) + (2,10) (3 rows) EXPLAIN (COSTS OFF) @@ -130,35 +136,35 @@ SELECT ctid FROM tidrangescan WHERE ctid >= '(100,0)'; -- range scans with both bounds EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE ctid > '(4,4)' AND '(4,7)' >= ctid; +SELECT ctid FROM tidrangescan WHERE ctid > '(1,4)' AND '(1,7)' >= ctid; QUERY PLAN ---------------------------------------------------------------- Tid Range Scan on tidrangescan - TID Cond: ((ctid > '(4,4)'::tid) AND ('(4,7)'::tid >= ctid)) + TID Cond: ((ctid > '(1,4)'::tid) AND ('(1,7)'::tid >= ctid)) (2 rows) -SELECT ctid FROM tidrangescan WHERE ctid > '(4,4)' AND '(4,7)' >= ctid; +SELECT ctid FROM tidrangescan WHERE ctid > '(1,4)' AND '(1,7)' >= ctid; ctid ------- - (4,5) - (4,6) - (4,7) + (1,5) + (1,6) + (1,7) (3 rows) EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE '(4,7)' >= ctid AND ctid > '(4,4)'; +SELECT ctid FROM tidrangescan WHERE '(1,7)' >= ctid AND ctid > '(1,4)'; QUERY PLAN ---------------------------------------------------------------- Tid Range Scan on tidrangescan - TID Cond: (('(4,7)'::tid >= ctid) AND (ctid > '(4,4)'::tid)) + TID Cond: (('(1,7)'::tid >= ctid) AND (ctid > '(1,4)'::tid)) (2 rows) -SELECT ctid FROM tidrangescan WHERE '(4,7)' >= ctid AND ctid > '(4,4)'; +SELECT ctid FROM tidrangescan WHERE '(1,7)' >= ctid AND ctid > '(1,4)'; ctid ------- - (4,5) - (4,6) - (4,7) + (1,5) + (1,6) + (1,7) (3 rows) -- extreme offsets @@ -236,3 +242,4 @@ FETCH LAST c; COMMIT; DROP TABLE tidrangescan; DROP TABLE tidrangescan_empty; +RESET enable_seqscan; diff --git a/src/test/regress/sql/tidrangescan.sql b/src/test/regress/sql/tidrangescan.sql index 1baf584937..d60439d56c 100644 --- a/src/test/regress/sql/tidrangescan.sql +++ b/src/test/regress/sql/tidrangescan.sql @@ -1,9 +1,16 @@ -- tests for tidrangescans +SET enable_seqscan TO off; CREATE TABLE tidrangescan(id integer, data text); -INSERT INTO tidrangescan SELECT i,repeat('x', 100) FROM generate_series(1,1000) AS s(i); -DELETE FROM tidrangescan WHERE substring(ctid::text from ',(\d+)\)')::integer > 10 OR substring(ctid::text from '\((\d+),')::integer >= 10;; +-- insert enough tuples to fill at least two pages +INSERT INTO tidrangescan SELECT i,repeat('x', 100) FROM generate_series(1,200) AS s(i); + +-- remove all tuples after the 10th tuple on each page. Trying to ensure +-- we get the same layout with all CPU architectures and smaller than standard +-- page sizes. +DELETE FROM tidrangescan +WHERE substring(ctid::text from ',(\d+)\)')::integer > 10 OR substring(ctid::text from '\((\d+),')::integer > 2; VACUUM tidrangescan; -- range scans with upper bound @@ -21,16 +28,16 @@ SELECT ctid FROM tidrangescan WHERE ctid < '(0,0)'; -- range scans with lower bound EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE ctid > '(9,8)'; -SELECT ctid FROM tidrangescan WHERE ctid > '(9,8)'; +SELECT ctid FROM tidrangescan WHERE ctid > '(2,8)'; +SELECT ctid FROM tidrangescan WHERE ctid > '(2,8)'; EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE '(9,8)' < ctid; -SELECT ctid FROM tidrangescan WHERE '(9,8)' < ctid; +SELECT ctid FROM tidrangescan WHERE '(2,8)' < ctid; +SELECT ctid FROM tidrangescan WHERE '(2,8)' < ctid; EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE ctid >= '(9,8)'; -SELECT ctid FROM tidrangescan WHERE ctid >= '(9,8)'; +SELECT ctid FROM tidrangescan WHERE ctid >= '(2,8)'; +SELECT ctid FROM tidrangescan WHERE ctid >= '(2,8)'; EXPLAIN (COSTS OFF) SELECT ctid FROM tidrangescan WHERE ctid >= '(100,0)'; @@ -38,12 +45,12 @@ SELECT ctid FROM tidrangescan WHERE ctid >= '(100,0)'; -- range scans with both bounds EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE ctid > '(4,4)' AND '(4,7)' >= ctid; -SELECT ctid FROM tidrangescan WHERE ctid > '(4,4)' AND '(4,7)' >= ctid; +SELECT ctid FROM tidrangescan WHERE ctid > '(1,4)' AND '(1,7)' >= ctid; +SELECT ctid FROM tidrangescan WHERE ctid > '(1,4)' AND '(1,7)' >= ctid; EXPLAIN (COSTS OFF) -SELECT ctid FROM tidrangescan WHERE '(4,7)' >= ctid AND ctid > '(4,4)'; -SELECT ctid FROM tidrangescan WHERE '(4,7)' >= ctid AND ctid > '(4,4)'; +SELECT ctid FROM tidrangescan WHERE '(1,7)' >= ctid AND ctid > '(1,4)'; +SELECT ctid FROM tidrangescan WHERE '(1,7)' >= ctid AND ctid > '(1,4)'; -- extreme offsets SELECT ctid FROM tidrangescan where ctid > '(0,65535)' AND ctid < '(1,0)' LIMIT 1; @@ -72,3 +79,5 @@ COMMIT; DROP TABLE tidrangescan; DROP TABLE tidrangescan_empty; + +RESET enable_seqscan;