performance tuning

this changes the sortByCost logic so it puts more weight on the
expression type, and only takes cardinality into account when it has to
sort two expressions of the same operator cost.
in the benchmarks this seems to lead to better results.

Author: replay

expr/tagquery/expression.go

@@ -115,7 +115,10 @@ type Expression interface {
 	// GetOperator returns the operator of this expression
 	GetOperator() ExpressionOperator
 
-	GetCostMultiplier() uint32
+	// GetOperatorCost returns a value which should roughly reflect the cost of this operator compared
+	// to other operators. F.e. = is cheaper than =~. Keep in mind that this is only a very rough
+	// estimate and will never be accurate.
+	GetOperatorCost() uint32
 
 	// OperatesOnTag returns whether this expression operators on the tag key
 	// (if not, it operates on the value).

expr/tagquery/expression_equal.go

@@ -22,7 +22,7 @@ func (e *expressionEqual) GetOperator() ExpressionOperator {
 	return EQUAL
 }
 
-func (e *expressionEqual) GetCostMultiplier() uint32 {
+func (e *expressionEqual) GetOperatorCost() uint32 {
 	return 1
 }
 

expr/tagquery/expression_has_tag.go

@@ -22,8 +22,8 @@ func (e *expressionHasTag) GetOperator() ExpressionOperator {
 	return HAS_TAG
 }
 
-func (e *expressionHasTag) GetCostMultiplier() uint32 {
-	return 2
+func (e *expressionHasTag) GetOperatorCost() uint32 {
+	return 10
 }
 
 func (e *expressionHasTag) OperatesOnTag() bool {

expr/tagquery/expression_match.go

@@ -33,8 +33,8 @@ func (e *expressionMatch) GetOperator() ExpressionOperator {
 	return MATCH
 }
 
-func (e *expressionMatch) GetCostMultiplier() uint32 {
-	return 0
+func (e *expressionMatch) GetOperatorCost() uint32 {
+	return 10
 }
 
 func (e *expressionMatch) RequiresNonEmptyValue() bool {

expr/tagquery/expression_match_all.go

@@ -32,7 +32,7 @@ func (e *expressionMatchAll) GetOperator() ExpressionOperator {
 	return MATCH_ALL
 }
 
-func (e *expressionMatchAll) GetCostMultiplier() uint32 {
+func (e *expressionMatchAll) GetOperatorCost() uint32 {
 	return 50
 }
 

expr/tagquery/expression_match_none.go

@@ -32,7 +32,7 @@ func (e *expressionMatchNone) GetOperator() ExpressionOperator {
 	return MATCH_NONE
 }
 
-func (e *expressionMatchNone) GetCostMultiplier() uint32 {
+func (e *expressionMatchNone) GetOperatorCost() uint32 {
 	return 0
 }
 

expr/tagquery/expression_match_tag.go

@@ -24,7 +24,7 @@ func (e *expressionMatchTag) GetOperator() ExpressionOperator {
 	return MATCH_TAG
 }
 
-func (e *expressionMatchTag) GetCostMultiplier() uint32 {
+func (e *expressionMatchTag) GetOperatorCost() uint32 {
 	return 20
 }
 

expr/tagquery/expression_not_equal.go

@@ -22,7 +22,7 @@ func (e *expressionNotEqual) GetOperator() ExpressionOperator {
 	return NOT_EQUAL
 }
 
-func (e *expressionNotEqual) GetCostMultiplier() uint32 {
+func (e *expressionNotEqual) GetOperatorCost() uint32 {
 	return 1
 }
 

expr/tagquery/expression_not_has_tag.go

@@ -22,8 +22,8 @@ func (e *expressionNotHasTag) GetOperator() ExpressionOperator {
 	return NOT_HAS_TAG
 }
 
-func (e *expressionNotHasTag) GetCostMultiplier() uint32 {
-	return 2
+func (e *expressionNotHasTag) GetOperatorCost() uint32 {
+	return 10
 }
 
 func (e *expressionNotHasTag) OperatesOnTag() bool {

expr/tagquery/expression_not_match.go

@@ -33,7 +33,7 @@ func (e *expressionNotMatch) GetOperator() ExpressionOperator {
 	return NOT_MATCH
 }
 
-func (e *expressionNotMatch) GetCostMultiplier() uint32 {
+func (e *expressionNotMatch) GetOperatorCost() uint32 {
 	return 10
 }
 

expr/tagquery/expression_prefix.go

@@ -22,7 +22,7 @@ func (e *expressionPrefix) GetOperator() ExpressionOperator {
 	return PREFIX
 }
 
-func (e *expressionPrefix) GetCostMultiplier() uint32 {
+func (e *expressionPrefix) GetOperatorCost() uint32 {
 	return 2
 }
 

expr/tagquery/expression_prefix_tag.go

@@ -22,8 +22,8 @@ func (e *expressionPrefixTag) GetOperator() ExpressionOperator {
 	return PREFIX_TAG
 }
 
-func (e *expressionPrefixTag) GetCostMultiplier() uint32 {
-	return 3
+func (e *expressionPrefixTag) GetOperatorCost() uint32 {
+	return 15
 }
 
 func (e *expressionPrefixTag) OperatesOnTag() bool {

idx/memory/tag_query.go

@@ -43,7 +43,8 @@ func NewTagQueryContext(query tagquery.Query) TagQueryContext {
 
 func (q *TagQueryContext) prepareExpressions(idx TagIndex) {
 	type expressionCost struct {
-		cost          uint32
+		operatorCost  uint32
+		cardinality   uint32
 		expressionIdx int
 	}
 	costs := make([]expressionCost, len(q.query.Expressions))
@@ -53,20 +54,29 @@ func (q *TagQueryContext) prepareExpressions(idx TagIndex) {
 
 		if expr.OperatesOnTag() {
 			if expr.MatchesExactly() {
-				costs[i].cost = uint32(len(idx[expr.GetKey()])) * expr.GetCostMultiplier()
+				costs[i].operatorCost = expr.GetOperatorCost()
+				costs[i].cardinality = uint32(len(idx[expr.GetKey()]))
 			} else {
-				costs[i].cost = uint32(len(idx)) * expr.GetCostMultiplier()
+				costs[i].operatorCost = expr.GetOperatorCost()
+				costs[i].cardinality = uint32(len(idx))
 			}
 		} else {
 			if expr.MatchesExactly() {
-				costs[i].cost = uint32(len(idx[expr.GetKey()][expr.GetValue()])) * expr.GetCostMultiplier()
+				costs[i].operatorCost = expr.GetOperatorCost()
+				costs[i].cardinality = uint32(len(idx[expr.GetKey()][expr.GetValue()]))
 			} else {
-				costs[i].cost = uint32(len(idx[expr.GetKey()])) * expr.GetCostMultiplier()
+				costs[i].operatorCost = expr.GetOperatorCost()
+				costs[i].cardinality = uint32(len(idx[expr.GetKey()]))
 			}
 		}
 	}
 
-	sort.Slice(costs, func(i, j int) bool { return costs[i].cost < costs[j].cost })
+	sort.Slice(costs, func(i, j int) bool {
+		if costs[i].operatorCost == costs[j].operatorCost {
+			return costs[i].cardinality < costs[j].cardinality
+		}
+		return costs[i].operatorCost < costs[j].operatorCost
+	})
 
 	// the number of filters / default decisions is equal to the number of expressions - 1
 	// because one of the expressions will be chosen to be the one that we start with.