Re: On disable_cost

As a proof of concept, I hacked around a bit today to re-purpose one of the
bits of the Cost structure to mean "is_disabled" so that we can distinguish
'disabled' from 'non-disabled' paths without making the Cost structure any
bigger.  In fact, it's still a valid double.  The obvious choice would have
been to re-purpose the sign bit, but I've had occasion to exploit negative
costs before so for this POC I used the high-order bit of the fractional
bits of the double.  (see Wikipedia for double precision floating point for
the layout).

The idea is to set a special bit when disable_cost is added to a cost. 
Dedicating multiple bits instead of just 1 would be easily done, but as it
is we can accumulate many disable_costs without overflowing, so just
comparing the cost suffices.

The patch is not fully debugged and fails on a couple of tests in the serial
test suite.  It seems to fail on Cartesian products, and maybe in one other
non-CP case.  I wasn't able to debug it before the day came to an end.

In one place the core code subtracts off the disable_cost.  I left the
"disabled" bit set in this case, which might be wrong.

I don't see an option to attach the patch as an attachment, so here is the
patch inline (it is based on PG11).  The more interesting part is in a small
number of lines in costsize.c.  Other changes just add functions that assign
a disable_cost and set the bit, or that compare costs such that a
non-disabled cost always compares less than a disabled cost.

------------------

diff --git a/src/backend/optimizer/path/costsize.c
b/src/backend/optimizer/path/costsize.c
index 4e86458672..3718639330 100644
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -123,6 +123,8 @@ double        parallel_setup_cost =
DEFAULT_PARALLEL_SETUP_COST;
 int            effective_cache_size = DEFAULT_EFFECTIVE_CACHE_SIZE;
 
 Cost        disable_cost = 1.0e10;
+uint64      disabled_mask = 0x8000000000000;
+#define IS_DISABLED(cost) (((uint64) cost) & disabled_mask)
 
 int            max_parallel_workers_per_gather = 2;
 
@@ -205,6 +207,53 @@ clamp_row_est(double nrows)
     return nrows;
 }
 
+Cost
+add_cost(Cost cost, Cost delta_cost)
+{
+    uint64 mask = (delta_cost == disable_cost) ? disabled_mask : 0;
+    Cost max_cost = disabled_mask - disable_cost;
+    
+    if (cost + delta_cost < max_cost)
+        return ((Cost) ((uint64)(cost + delta_cost) | mask));
+    else
+        return ((Cost) ((uint64)(max_cost) | mask));
+}
+
+bool
+is_lower_cost(Cost cost1, Cost cost2)
+{
+    if ((uint64)cost1 & disabled_mask && !((uint64)cost2 & disabled_mask))
+        return false;
+    
+    if (!((uint64)cost1 & disabled_mask) && (uint64)cost2 & disabled_mask)
+        return true;
+    
+    return (cost1 < cost2);
+}
+
+bool
+is_greater_cost(Cost cost1, Cost cost2)
+{
+    if ((uint64)cost1 & disabled_mask && !((uint64)cost2 & disabled_mask))
+        return true;
+    
+    if (!((uint64)cost1 & disabled_mask) && (uint64)cost2 & disabled_mask)
+        return false;
+    
+    return (cost1 > cost2);
+}
+
+bool
+is_geq_cost(Cost cost1, Cost cost2)
+{
+    if ((uint64)cost1 & disabled_mask && !((uint64)cost2 & disabled_mask))
+        return true;
+    
+    if (!((uint64)cost1 & disabled_mask) && (uint64)cost2 & disabled_mask)
+        return false;
+    
+    return (cost1 >= cost2);
+}
 
 /*
  * cost_seqscan
@@ -235,7 +284,7 @@ cost_seqscan(Path *path, PlannerInfo *root,
         path->rows = baserel->rows;
 
     if (!enable_seqscan)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /* fetch estimated page cost for tablespace containing table */
     get_tablespace_page_costs(baserel->reltablespace,
@@ -424,7 +473,7 @@ cost_gather_merge(GatherMergePath *path, PlannerInfo
*root,
         path->path.rows = rel->rows;
 
     if (!enable_gathermerge)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /*
      * Add one to the number of workers to account for the leader.  This might
@@ -538,7 +587,7 @@ cost_index(IndexPath *path, PlannerInfo *root, double
loop_count,
     }
 
     if (!enable_indexscan)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
     /* we don't need to check enable_indexonlyscan; indxpath.c does that */
 
     /*
@@ -976,7 +1025,7 @@ cost_bitmap_heap_scan(Path *path, PlannerInfo *root,
RelOptInfo *baserel,
         path->rows = baserel->rows;
 
     if (!enable_bitmapscan)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     pages_fetched = compute_bitmap_pages(root, baserel, bitmapqual,
                                          loop_count, &indexTotalCost,
@@ -1242,10 +1291,10 @@ cost_tidscan(Path *path, PlannerInfo *root,
     if (isCurrentOf)
     {
         Assert(baserel->baserestrictcost.startup >= disable_cost);
-        startup_cost -= disable_cost;
+        startup_cost -= disable_cost;  /* but do not un-set the disabled mark */
     }
     else if (!enable_tidscan)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /*
      * The TID qual expressions will be computed once, any other baserestrict
@@ -1676,7 +1725,7 @@ cost_sort(Path *path, PlannerInfo *root,
     long        sort_mem_bytes = sort_mem * 1024L;
 
     if (!enable_sort)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     path->rows = tuples;
 
@@ -2121,8 +2170,8 @@ cost_agg(Path *path, PlannerInfo *root,
         total_cost = input_total_cost;
         if (aggstrategy == AGG_MIXED && !enable_hashagg)
         {
-            startup_cost += disable_cost;
-            total_cost += disable_cost;
+            startup_cost = add_cost(startup_cost, disable_cost);
+            total_cost = add_cost(total_cost, disable_cost);
         }
         /* calcs phrased this way to match HASHED case, see note above */
         total_cost += aggcosts->transCost.startup;
@@ -2137,7 +2186,7 @@ cost_agg(Path *path, PlannerInfo *root,
         /* must be AGG_HASHED */
         startup_cost = input_total_cost;
         if (!enable_hashagg)
-            startup_cost += disable_cost;
+            startup_cost = add_cost(startup_cost, disable_cost);
         startup_cost += aggcosts->transCost.startup;
         startup_cost += aggcosts->transCost.per_tuple * input_tuples;
         startup_cost += (cpu_operator_cost * numGroupCols) * input_tuples;
@@ -2436,7 +2485,7 @@ final_cost_nestloop(PlannerInfo *root, NestPath *path,
      * disabled, which doesn't seem like the way to bet.
      */
     if (!enable_nestloop)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /* cost of inner-relation source data (we already dealt with outer rel) */
 
@@ -2882,7 +2931,7 @@ final_cost_mergejoin(PlannerInfo *root, MergePath
*path,
      * disabled, which doesn't seem like the way to bet.
      */
     if (!enable_mergejoin)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /*
      * Compute cost of the mergequals and qpquals (other restriction clauses)
@@ -3312,7 +3361,7 @@ final_cost_hashjoin(PlannerInfo *root, HashPath *path,
      * disabled, which doesn't seem like the way to bet.
      */
     if (!enable_hashjoin)
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /* mark the path with estimated # of batches */
     path->num_batches = numbatches;
@@ -3410,7 +3459,7 @@ final_cost_hashjoin(PlannerInfo *root, HashPath *path,
     if (relation_byte_size(clamp_row_est(inner_path_rows * innermcvfreq),
                            inner_path->pathtarget->width) >
         (work_mem * 1024L))
-        startup_cost += disable_cost;
+        startup_cost = add_cost(startup_cost, disable_cost);
 
     /*
      * Compute cost of the hashquals and qpquals (other restriction clauses)
@@ -3930,7 +3979,7 @@ cost_qual_eval_walker(Node *node,
cost_qual_eval_context *context)
     else if (IsA(node, CurrentOfExpr))
     {
         /* Report high cost to prevent selection of anything but TID scan */
-        context->total.startup += disable_cost;
+        context->total.startup = add_cost(context->total.startup, disable_cost);
     }
     else if (IsA(node, SubLink))
     {
diff --git a/src/backend/optimizer/util/pathnode.c
b/src/backend/optimizer/util/pathnode.c
index 4736d84a83..fd746a06bc 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -72,33 +72,33 @@ compare_path_costs(Path *path1, Path *path2,
CostSelector criterion)
 {
     if (criterion == STARTUP_COST)
     {
-        if (path1->startup_cost < path2->startup_cost)
+        if (is_lower_cost(path1->startup_cost, path2->startup_cost))
             return -1;
-        if (path1->startup_cost > path2->startup_cost)
+        if (is_greater_cost(path1->startup_cost, path2->startup_cost))
             return +1;
 
         /*
          * If paths have the same startup cost (not at all unlikely), order
          * them by total cost.
          */
-        if (path1->total_cost < path2->total_cost)
+        if (is_lower_cost(path1->total_cost, path2->total_cost))
             return -1;
-        if (path1->total_cost > path2->total_cost)
+        if (is_greater_cost(path1->total_cost, path2->total_cost))
             return +1;
     }
     else
     {
-        if (path1->total_cost < path2->total_cost)
+        if (is_lower_cost(path1->total_cost, path2->total_cost))
             return -1;
-        if (path1->total_cost > path2->total_cost)
+        if (is_greater_cost(path1->total_cost, path2->total_cost))
             return +1;
 
         /*
          * If paths have the same total cost, order them by startup cost.
          */
-        if (path1->startup_cost < path2->startup_cost)
+        if (is_lower_cost(path1->startup_cost, path2->startup_cost))
             return -1;
-        if (path1->startup_cost > path2->startup_cost)
+        if (is_greater_cost(path1->startup_cost, path2->startup_cost))
             return +1;
     }
     return 0;
@@ -126,9 +126,9 @@ compare_fractional_path_costs(Path *path1, Path *path2,
         fraction * (path1->total_cost - path1->startup_cost);
     cost2 = path2->startup_cost +
         fraction * (path2->total_cost - path2->startup_cost);
-    if (cost1 < cost2)
+    if (is_lower_cost(cost1, cost2))
         return -1;
-    if (cost1 > cost2)
+    if (is_greater_cost(cost1, cost2))
         return +1;
     return 0;
 }
@@ -172,11 +172,11 @@ compare_path_costs_fuzzily(Path *path1, Path *path2,
double fuzz_factor)
      * Check total cost first since it's more likely to be different; many
      * paths have zero startup cost.
      */
-    if (path1->total_cost > path2->total_cost * fuzz_factor)
+    if (is_greater_cost(path1->total_cost, path2->total_cost * fuzz_factor))
     {
         /* path1 fuzzily worse on total cost */
         if (CONSIDER_PATH_STARTUP_COST(path1) &&
-            path2->startup_cost > path1->startup_cost * fuzz_factor)
+            is_greater_cost(path2->startup_cost, path1->startup_cost * fuzz_factor))
         {
             /* ... but path2 fuzzily worse on startup, so DIFFERENT */
             return COSTS_DIFFERENT;
@@ -184,11 +184,11 @@ compare_path_costs_fuzzily(Path *path1, Path *path2,
double fuzz_factor)
         /* else path2 dominates */
         return COSTS_BETTER2;
     }
-    if (path2->total_cost > path1->total_cost * fuzz_factor)
+    if (is_greater_cost(path2->total_cost, path1->total_cost * fuzz_factor))
     {
         /* path2 fuzzily worse on total cost */
         if (CONSIDER_PATH_STARTUP_COST(path2) &&
-            path1->startup_cost > path2->startup_cost * fuzz_factor)
+            is_greater_cost(path1->startup_cost, path2->startup_cost * fuzz_factor))
         {
             /* ... but path1 fuzzily worse on startup, so DIFFERENT */
             return COSTS_DIFFERENT;
@@ -197,12 +197,12 @@ compare_path_costs_fuzzily(Path *path1, Path *path2,
double fuzz_factor)
         return COSTS_BETTER1;
     }
     /* fuzzily the same on total cost ... */
-    if (path1->startup_cost > path2->startup_cost * fuzz_factor)
+    if (is_greater_cost(path1->startup_cost, path2->startup_cost *
fuzz_factor))
     {
         /* ... but path1 fuzzily worse on startup, so path2 wins */
         return COSTS_BETTER2;
     }
-    if (path2->startup_cost > path1->startup_cost * fuzz_factor)
+    if (is_greater_cost(path2->startup_cost, path1->startup_cost *
fuzz_factor))
     {
         /* ... but path2 fuzzily worse on startup, so path1 wins */
         return COSTS_BETTER1;
@@ -605,7 +605,7 @@ add_path(RelOptInfo *parent_rel, Path *new_path)
         else
         {
             /* new belongs after this old path if it has cost >= old's */
-            if (new_path->total_cost >= old_path->total_cost)
+            if (is_geq_cost(new_path->total_cost, old_path->total_cost))
                 insert_after = p1;
             /* p1_prev advances */
             p1_prev = p1;
@@ -681,7 +681,7 @@ add_path_precheck(RelOptInfo *parent_rel,
          *
          * Cost comparisons here should match compare_path_costs_fuzzily.
          */
-        if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR)
+        if (is_greater_cost(total_cost, old_path->total_cost * STD_FUZZ_FACTOR))
         {
             /* new path can win on startup cost only if consider_startup */
             if (startup_cost > old_path->startup_cost * STD_FUZZ_FACTOR ||
@@ -796,14 +796,14 @@ add_partial_path(RelOptInfo *parent_rel, Path
*new_path)
         /* Unless pathkeys are incompable, keep just one of the two paths. */
         if (keyscmp != PATHKEYS_DIFFERENT)
         {
-            if (new_path->total_cost > old_path->total_cost * STD_FUZZ_FACTOR)
+            if (is_greater_cost(new_path->total_cost, old_path->total_cost *
STD_FUZZ_FACTOR))
             {
                 /* New path costs more; keep it only if pathkeys are better. */
                 if (keyscmp != PATHKEYS_BETTER1)
                     accept_new = false;
             }
-            else if (old_path->total_cost > new_path->total_cost
-                     * STD_FUZZ_FACTOR)
+            else if (is_greater_cost(old_path->total_cost, new_path->total_cost
+                                     * STD_FUZZ_FACTOR))
             {
                 /* Old path costs more; keep it only if pathkeys are better. */
                 if (keyscmp != PATHKEYS_BETTER2)
@@ -819,7 +819,7 @@ add_partial_path(RelOptInfo *parent_rel, Path *new_path)
                 /* Costs are about the same, old path has better pathkeys. */
                 accept_new = false;
             }
-            else if (old_path->total_cost > new_path->total_cost * 1.0000000001)
+            else if (is_greater_cost(old_path->total_cost, new_path->total_cost *
1.0000000001))
             {
                 /* Pathkeys are the same, and the old path costs more. */
                 remove_old = true;
@@ -847,7 +847,7 @@ add_partial_path(RelOptInfo *parent_rel, Path *new_path)
         else
         {
             /* new belongs after this old path if it has cost >= old's */
-            if (new_path->total_cost >= old_path->total_cost)
+            if (is_geq_cost(new_path->total_cost, old_path->total_cost))
                 insert_after = p1;
             /* p1_prev advances */
             p1_prev = p1;
@@ -913,10 +913,10 @@ add_partial_path_precheck(RelOptInfo *parent_rel, Cost
total_cost,
         keyscmp = compare_pathkeys(pathkeys, old_path->pathkeys);
         if (keyscmp != PATHKEYS_DIFFERENT)
         {
-            if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR &&
+            if (is_greater_cost(total_cost, old_path->total_cost * STD_FUZZ_FACTOR)
&&
                 keyscmp != PATHKEYS_BETTER1)
                 return false;
-            if (old_path->total_cost > total_cost * STD_FUZZ_FACTOR &&
+            if (is_greater_cost(old_path->total_cost, total_cost * STD_FUZZ_FACTOR)
&&
                 keyscmp != PATHKEYS_BETTER2)
                 return true;
         }
@@ -1697,7 +1697,7 @@ create_unique_path(PlannerInfo *root, RelOptInfo *rel,
Path *subpath,
 
     if (sjinfo->semi_can_btree && sjinfo->semi_can_hash)
     {
-        if (agg_path.total_cost < sort_path.total_cost)
+        if (is_lower_cost(agg_path.total_cost, sort_path.total_cost))
             pathnode->umethod = UNIQUE_PATH_HASH;
         else
             pathnode->umethod = UNIQUE_PATH_SORT;
diff --git a/src/backend/utils/cache/relcache.c
b/src/backend/utils/cache/relcache.c
index 78f3b99a76..c261a9d790 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -5076,8 +5076,8 @@ IsProjectionFunctionalIndex(Relation index)
          * when values differ because the expression is recalculated when
          * inserting a new index entry for the changed value.
          */
-        if ((index_expr_cost.startup + index_expr_cost.per_tuple) >
-            HEURISTIC_MAX_HOT_RECHECK_EXPR_COST)
+        if (is_greater_cost((index_expr_cost.startup +
index_expr_cost.per_tuple),
+                            HEURISTIC_MAX_HOT_RECHECK_EXPR_COST))
             is_projection = false;
 
         tuple = SearchSysCache1(RELOID,
ObjectIdGetDatum(RelationGetRelid(index)));
diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
index 9159f2bab1..c01d08eae5 100644
--- a/src/include/optimizer/cost.h
+++ b/src/include/optimizer/cost.h
@@ -251,6 +251,12 @@ extern PathTarget
*set_pathtarget_cost_width(PlannerInfo *root, PathTarget *targ
 extern double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel,
                      Path *bitmapqual, int loop_count, Cost *cost, double *tuple);
 
+extern Cost add_cost(Cost cost, Cost delta_cost);
+extern bool is_lower_cost(Cost cost1, Cost cost2);
+extern bool is_greater_cost(Cost cost1, Cost cost2);
+extern bool is_geq_cost(Cost cost1, Cost cost2);
+
+
 /*
  * prototypes for clausesel.c
  *      routines to compute clause selectivities





-----
Jim Finnerty, AWS, Amazon Aurora PostgreSQL
--
Sent from: https://www.postgresql-archive.org/PostgreSQL-hackers-f1928748.html