opt: rename "CostFlags" to "Penalties"

`memo.CostFlags` has been renamed to `memo.Penalities` which better
reflects its meaning.

Release note: None

Author: mgartner

pkg/sql/opt/memo/cost.go

@@ -11,8 +11,8 @@ import "math"
 // particular operator tree.
 // TODO: Need more details about what one "unit" of cost means.
 type Cost struct {
-	C     float64
-	Flags CostFlags
+	C float64
+	Penalties
 
 	// aux is auxiliary information within a cost that does not affect how the
 	// cost is compared to other costs with Less.
@@ -27,14 +27,14 @@ type Cost struct {
 // group members during testing, by setting their cost so high that any other
 // member will have a lower cost.
 var MaxCost = Cost{
-	C:     math.Inf(+1),
-	Flags: HugeCostPenalty | FullScanPenalty | UnboundedCardinality,
+	C:         math.Inf(+1),
+	Penalties: HugeCostPenalty | FullScanPenalty | UnboundedCardinality,
 }
 
 // Less returns true if this cost is lower than the given cost.
 func (c Cost) Less(other Cost) bool {
-	if c.Flags != other.Flags {
-		return c.Flags < other.Flags
+	if c.Penalties != other.Penalties {
+		return c.Penalties < other.Penalties
 	}
 	// Two plans with the same cost can have slightly different floating point
 	// results (e.g. same subcosts being added up in a different order). So we
@@ -52,7 +52,7 @@ func (c Cost) Less(other Cost) bool {
 // Add adds the other cost to this cost.
 func (c *Cost) Add(other Cost) {
 	c.C += other.C
-	c.Flags |= other.Flags
+	c.Penalties |= other.Penalties
 	if c.aux.fullScanCount > math.MaxUint8-other.aux.fullScanCount {
 		// Avoid overflow.
 		c.aux.fullScanCount = math.MaxUint8
@@ -75,20 +75,20 @@ func (c *Cost) IncrFullScanCount() {
 	c.aux.fullScanCount++
 }
 
-// CostFlags is an ordered bitmask where each bit indicates a cost penalty. The
+// Penalties is an ordered bitmask where each bit indicates a cost penalty. The
 // penalties are ordered by precedence, with the highest precedence penalty
-// using the highest-order bit. This allows CostFlags to be easily compared with
-// built-in comparison operators (>, <, =, etc.). For example, CostFlags with
-// HugeCostPenalty will always be greater than CostFlags without.
-type CostFlags uint8
+// using the highest-order bit. This allows Penalties to be easily compared with
+// built-in comparison operators (>, <, =, etc.). For example, Penalties with
+// HugeCostPenalty will always be greater than Penalties without.
+type Penalties uint8
 
 const (
 	// HugeCostPenalty is true if a plan should be avoided at all costs. This is
 	// used when the optimizer is forced to use a particular plan, and will
 	// error if it cannot be used. It takes precedence over other penalties,
 	// since it indicates that a plan is being forced with a hint, and will
 	// error if we cannot comply with the hint.
-	HugeCostPenalty CostFlags = 1 << (7 - iota)
+	HugeCostPenalty Penalties = 1 << (7 - iota)
 
 	// FullScanPenalty is true if the cost of a full table or index scan is
 	// penalized, indicating that a full scan should only be used if no other
@@ -101,5 +101,5 @@ const (
 	UnboundedCardinality
 
 	// NoPenalties represents no penalties.
-	NoPenalties CostFlags = 0
+	NoPenalties Penalties = 0
 )

pkg/sql/opt/memo/cost_test.go

@@ -26,17 +26,17 @@ func TestCostLess(t *testing.T) {
 		{Cost{C: 1}, Cost{C: 1.00000001}, true},
 		{Cost{C: 1000}, Cost{C: 1000.00000000001}, false},
 		{Cost{C: 1000}, Cost{C: 1000.00001}, true},
-		{Cost{C: 1.0, Flags: FullScanPenalty}, Cost{C: 1.0}, false},
-		{Cost{C: 1.0}, Cost{C: 1.0, Flags: HugeCostPenalty}, true},
-		{Cost{C: 1.0, Flags: FullScanPenalty | HugeCostPenalty}, Cost{C: 1.0}, false},
-		{Cost{C: 1.0, Flags: FullScanPenalty}, Cost{C: 1.0, Flags: HugeCostPenalty}, true},
+		{Cost{C: 1.0, Penalties: FullScanPenalty}, Cost{C: 1.0}, false},
+		{Cost{C: 1.0}, Cost{C: 1.0, Penalties: HugeCostPenalty}, true},
+		{Cost{C: 1.0, Penalties: FullScanPenalty | HugeCostPenalty}, Cost{C: 1.0}, false},
+		{Cost{C: 1.0, Penalties: FullScanPenalty}, Cost{C: 1.0, Penalties: HugeCostPenalty}, true},
 		{MaxCost, Cost{C: 1.0}, false},
 		{Cost{C: 0.0}, MaxCost, true},
 		{MaxCost, MaxCost, false},
-		{MaxCost, Cost{C: 1.0, Flags: FullScanPenalty}, false},
-		{Cost{C: 1.0, Flags: HugeCostPenalty}, MaxCost, true},
-		{Cost{C: 2.0}, Cost{C: 1.0, Flags: UnboundedCardinality}, true},
-		{Cost{C: 1.0, Flags: UnboundedCardinality}, Cost{C: 2.0}, false},
+		{MaxCost, Cost{C: 1.0, Penalties: FullScanPenalty}, false},
+		{Cost{C: 1.0, Penalties: HugeCostPenalty}, MaxCost, true},
+		{Cost{C: 2.0}, Cost{C: 1.0, Penalties: UnboundedCardinality}, true},
+		{Cost{C: 1.0, Penalties: UnboundedCardinality}, Cost{C: 2.0}, false},
 		// Auxiliary information should not affect the comparison.
 		{Cost{C: 1.0, aux: testAux{0}}, Cost{C: 1.0, aux: testAux{1}}, false},
 	}
@@ -55,9 +55,9 @@ func TestCostAdd(t *testing.T) {
 		{Cost{C: 0.0}, Cost{C: 0.0}, Cost{C: 0.0}},
 		{Cost{C: -1.0}, Cost{C: 1.0}, Cost{C: 0.0}},
 		{Cost{C: 1.5}, Cost{C: 2.5}, Cost{C: 4.0}},
-		{Cost{C: 1.0, Flags: FullScanPenalty}, Cost{C: 2.0}, Cost{C: 3.0, Flags: FullScanPenalty}},
-		{Cost{C: 1.0}, Cost{C: 2.0, Flags: HugeCostPenalty}, Cost{C: 3.0, Flags: HugeCostPenalty}},
-		{Cost{C: 1.0, Flags: UnboundedCardinality}, Cost{C: 2.0, Flags: HugeCostPenalty}, Cost{C: 3.0, Flags: HugeCostPenalty | UnboundedCardinality}},
+		{Cost{C: 1.0, Penalties: FullScanPenalty}, Cost{C: 2.0}, Cost{C: 3.0, Penalties: FullScanPenalty}},
+		{Cost{C: 1.0}, Cost{C: 2.0, Penalties: HugeCostPenalty}, Cost{C: 3.0, Penalties: HugeCostPenalty}},
+		{Cost{C: 1.0, Penalties: UnboundedCardinality}, Cost{C: 2.0, Penalties: HugeCostPenalty}, Cost{C: 3.0, Penalties: HugeCostPenalty | UnboundedCardinality}},
 		{Cost{C: 1.0, aux: testAux{1}}, Cost{C: 1.0, aux: testAux{2}}, Cost{C: 2.0, aux: testAux{3}}},
 		{Cost{C: 1.0, aux: testAux{200}}, Cost{C: 1.0, aux: testAux{100}}, Cost{C: 2.0, aux: testAux{255}}},
 	}

pkg/sql/opt/memo/expr_format.go

@@ -919,16 +919,16 @@ func (f *ExprFmtCtx) formatRelational(e RelExpr, tp treeprinter.Node) {
 		if cost.C != 0 {
 			tp.Childf("cost: %.9g", cost.C)
 		}
-		if cost.Flags != NoPenalties {
+		if cost.Penalties != NoPenalties {
 			var b strings.Builder
 			b.WriteString("cost-flags:")
-			if cost.Flags&FullScanPenalty != 0 {
+			if cost.Penalties&FullScanPenalty != 0 {
 				b.WriteString(" full-scan-penalty")
 			}
-			if cost.Flags&HugeCostPenalty != 0 {
+			if cost.Penalties&HugeCostPenalty != 0 {
 				b.WriteString(" huge-cost-penalty")
 			}
-			if cost.Flags&UnboundedCardinality != 0 {
+			if cost.Penalties&UnboundedCardinality != 0 {
 				b.WriteString(" unbounded-cardinality")
 			}
 			tp.Child(b.String())

pkg/sql/opt/xform/coster.go

@@ -190,7 +190,7 @@ var (
 	// that "violate" a hint like forcing a specific index or join algorithm.
 	// If the final expression has this cost or larger, it means that there was no
 	// plan that could satisfy the hints.
-	hugeCost = memo.Cost{C: 1e100, Flags: memo.HugeCostPenalty}
+	hugeCost = memo.Cost{C: 1e100, Penalties: memo.HugeCostPenalty}
 
 	// SmallDistributeCost is the per-operation cost overhead for scans which may
 	// access remote regions, but the scanned table is unpartitioned with no lease
@@ -217,8 +217,8 @@ var (
 	//               region instead of relying on costing, which may not guarantee
 	//               the correct plan is found?
 	LargeDistributeCostWithHomeRegion = memo.Cost{
-		C:     LargeDistributeCost.C / 2,
-		Flags: memo.HugeCostPenalty,
+		C:         LargeDistributeCost.C / 2,
+		Penalties: memo.HugeCostPenalty,
 	}
 )
 
@@ -645,7 +645,7 @@ func (c *coster) ComputeCost(candidate memo.RelExpr, required *physical.Required
 	if candidate.Relational().Cardinality.IsUnbounded() {
 		cost.C += cpuCostFactor
 		if c.evalCtx.SessionData().OptimizerPreferBoundedCardinality {
-			cost.Flags |= memo.UnboundedCardinality
+			cost.Penalties |= memo.UnboundedCardinality
 		}
 	}
 
@@ -909,7 +909,7 @@ func (c *coster) computeScanCost(scan *memo.ScanExpr, required *physical.Require
 		cost.IncrFullScanCount()
 		if scan.Flags.AvoidFullScan {
 			// Apply a penalty for a full scan if needed.
-			cost.Flags |= memo.FullScanPenalty
+			cost.Penalties |= memo.FullScanPenalty
 		}
 	}
 

pkg/sql/prep/statement.go

@@ -187,9 +187,9 @@ func (p *planCosts) NumCustom() int {
 // average cost of the custom plans.
 func (p *planCosts) IsGenericOptimal() bool {
 	// Check cost flags and full scan counts.
-	if gc := p.generic.FullScanCount(); gc > 0 || p.generic.Flags != memo.NoPenalties {
+	if gc := p.generic.FullScanCount(); gc > 0 || p.generic.Penalties != memo.NoPenalties {
 		for i := 0; i < p.custom.length; i++ {
-			if p.custom.costs[i].Flags < p.generic.Flags || gc > p.custom.costs[i].FullScanCount() {
+			if p.custom.costs[i].Penalties < p.generic.Penalties || gc > p.custom.costs[i].FullScanCount() {
 				return false
 			}
 		}