chore: update cost estimates for intersectionarrow lr (#2848)

Author: tstirrat15

pkg/query/statistics.go

@@ -104,22 +104,32 @@ func (s StaticStatistics) Cost(iterator Iterator) (Estimate, error) {
 
 		// Calculate CheckCost based on execution direction
 		var checkCost int
+		var iterResourcesCost int
+		var iterSubjectsCost int
 		switch it.direction {
 		case leftToRight:
 			// IterSubjects on left, then Check on right for each result
 			checkCost = ls.IterSubjectsCost + (ls.Cardinality * rs.CheckCost)
+			// IterResources on left, then IterResources on right for each result
+			iterResourcesCost = ls.IterResourcesCost + (ls.Cardinality * rs.IterResourcesCost)
+			// IterSubjects on left, then IterSubjects on right for each result
+			iterSubjectsCost = ls.IterSubjectsCost + (ls.Cardinality * rs.IterSubjectsCost)
 		case rightToLeft:
 			// IterResources on right, then Check on left for each result
 			checkCost = rs.IterResourcesCost + (rs.Cardinality * ls.CheckCost)
+			// IterResources on right, then IterResources on left for each result
+			iterResourcesCost = rs.IterResourcesCost + (rs.Cardinality * ls.IterResourcesCost)
+			// IterSubjects on right, then IterSubjects on left for each result
+			iterSubjectsCost = rs.IterSubjectsCost + (rs.Cardinality * ls.IterSubjectsCost)
 		}
 
 		return Estimate{
 			// Worst case, an arrow is the size of the cartesian product (full outer join) as we join the two subiterators.
 			Cardinality:       ls.Cardinality * rs.Cardinality,
 			CheckCost:         checkCost,
 			CheckSelectivity:  ls.CheckSelectivity * rs.CheckSelectivity,
-			IterResourcesCost: ls.IterResourcesCost + (ls.Cardinality * rs.IterResourcesCost),
-			IterSubjectsCost:  ls.IterSubjectsCost + (ls.Cardinality * rs.IterSubjectsCost),
+			IterResourcesCost: iterResourcesCost,
+			IterSubjectsCost:  iterSubjectsCost,
 		}, nil
 	case *IntersectionArrow:
 		ls, err := s.Cost(it.left)
@@ -133,11 +143,15 @@ func (s StaticStatistics) Cost(iterator Iterator) (Estimate, error) {
 		// IntersectionArrow also does IterSubjects on left, then Check on right,
 		// but only yields results when ALL subjects satisfy (more selective), estimated based on the fanout from IterSubjects
 		selectivity := math.Pow(ls.CheckSelectivity, float64(s.Fanout)) * rs.CheckSelectivity
+		checkCost := ls.IterSubjectsCost + (ls.Cardinality * rs.CheckCost)
 		return Estimate{
-			Cardinality:       int(float64(ls.Cardinality*rs.Cardinality) * selectivity),
-			CheckCost:         ls.IterSubjectsCost + (ls.Cardinality * rs.CheckCost),
-			CheckSelectivity:  selectivity,
-			IterResourcesCost: ls.IterResourcesCost + (ls.Cardinality * rs.IterResourcesCost),
+			Cardinality:      int(float64(ls.Cardinality*rs.Cardinality) * selectivity),
+			CheckCost:        checkCost,
+			CheckSelectivity: selectivity,
+			// We have to iterResources on both the left and the right side to get the potential
+			// candidates, but we then need to check each of the candidates, so we pay an additional
+			// check cost.
+			IterResourcesCost: ls.IterResourcesCost + (ls.Cardinality * rs.IterResourcesCost) + checkCost,
 			IterSubjectsCost:  ls.IterSubjectsCost + (ls.Cardinality * rs.IterSubjectsCost),
 		}, nil
 	case *Union:

pkg/query/statistics_test.go

@@ -82,6 +82,41 @@ func TestStaticStatistics_Cost(t *testing.T) {
 
 			// CheckSelectivity: left * right = 0.9 * 0.9 = 0.81
 			require.InDelta(t, 0.81, est.CheckSelectivity, 0.001)
+
+			// IterResourcesCost: left.IterResourcesCost + (left.Cardinality + right.IterResourcesCost)
+			// = 2 + 2 * 1 = 4
+			require.Equal(t, 4, est.IterResourcesCost)
+		})
+
+		t.Run("reversed arrow", func(t *testing.T) {
+			left := NewFixedIterator(
+				MustPathFromString("document:doc1#parent@folder:folder1"),
+				MustPathFromString("document:doc2#parent@folder:folder2"),
+			)
+			right := NewFixedIterator(
+				MustPathFromString("folder:folder1#viewer@user:alice"),
+			)
+			arrow := NewArrow(left, right)
+
+			// Set arrow direction to the other way
+			arrow.direction = rightToLeft
+
+			est, err := stats.Cost(arrow)
+			require.NoError(t, err)
+
+			// Cardinality: left.Cardinality * right.Cardinality = 2 * 1 = 2
+			require.Equal(t, 2, est.Cardinality)
+
+			// CheckCost: right.IterResourcesCost + (right.Cardinality * left.CheckCost)
+			// = 1 + (1 * 2) = 2
+			require.Equal(t, 2, est.CheckCost)
+
+			// CheckSelectivity: left * right = 0.9 * 0.9 = 0.81
+			require.InDelta(t, 0.81, est.CheckSelectivity, 0.001)
+
+			// IterResourcesCost: right.IterResourcesCost + (right.Cardinality + left.IterResourcesCost)
+			// = 1 + 1 * 2 = 3
+			require.Equal(t, 3, est.IterResourcesCost)
 		})
 
 		t.Run("with relation iterator", func(t *testing.T) {
@@ -131,6 +166,10 @@ func TestStaticStatistics_Cost(t *testing.T) {
 		// CheckCost: left.IterSubjectsCost + (left.Cardinality * right.CheckCost)
 		// = 3 + (3 * 1) = 6
 		require.Equal(t, 6, est.CheckCost)
+
+		// IterResourcesCost: left.IterResourcesCost + (left.Cardinality * right.IterResourcesCost) + checkCost
+		// = 3 + (3 * 1) + 6 = 12
+		require.Equal(t, 12, est.IterResourcesCost)
 	})
 
 	t.Run("Union", func(t *testing.T) {
@@ -407,6 +446,9 @@ func TestStaticStatistics_Cost(t *testing.T) {
 
 			// CheckSelectivity: main * exclusionFactor = 0.9 * 0.1 = 0.09
 			require.InDelta(t, 0.09, est.CheckSelectivity, 0.001)
+
+			// IterResourcesCost: sum of both = 3 + 1 = 4
+			require.Equal(t, 4, est.IterResourcesCost)
 		})
 
 		t.Run("exclusion with relation iterator", func(t *testing.T) {