caching: column cardinality

runtime/queries/column_api_test.go

@@ -92,3 +92,17 @@ func BenchmarkColumnTimeRange(b *testing.B) {
 		require.NotEmpty(b, q.Result)
 	}
 }
+
+func BenchmarkColumnCardinality(b *testing.B) {
+	rt, instanceID := testruntime.NewInstanceForProject(b, "ad_bids")
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		q := &ColumnCardinality{
+			TableName:  "ad_bids",
+			ColumnName: "publisher",
+		}
+		err := q.Resolve(context.Background(), rt, instanceID, 0)
+		require.NoError(b, err)
+		require.NotEmpty(b, q.Result)
+	}
+}

runtime/queries/column_cardinality.go

@@ -0,0 +1,59 @@
+package queries
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rilldata/rill/runtime"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type ColumnCardinality struct {
+	TableName  string
+	ColumnName string
+	Result     float64
+}
+
+var _ runtime.Query = &ColumnCardinality{}
+
+func (q *ColumnCardinality) Key() string {
+	return fmt.Sprintf("ColumnCardinality:%s:%s", q.TableName, q.ColumnName)
+}
+
+func (q *ColumnCardinality) Deps() []string {
+	return []string{q.TableName}
+}
+
+func (q *ColumnCardinality) MarshalResult() any {
+	return q.Result
+}
+
+func (q *ColumnCardinality) UnmarshalResult(v any) error {
+	res, ok := v.(float64)
+	if !ok {
+		return fmt.Errorf("ColumnCardinality: mismatched unmarshal input")
+	}
+	q.Result = res
+	return nil
+}
+
+func (q *ColumnCardinality) Resolve(ctx context.Context, rt *runtime.Runtime, instanceID string, priority int) error {
+	sanitizedColumnName := quoteName(q.ColumnName)
+	requestSql := fmt.Sprintf("SELECT approx_count_distinct(%s) as count from %s", sanitizedColumnName, quoteName(q.TableName))
+	rows, err := rt.Execute(ctx, instanceID, priority, requestSql)
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+	var count float64
+	for rows.Next() {
+		err = rows.Scan(&count)
+		if err != nil {
+			return err
+		}
+		q.Result = count
+		return nil
+	}
+	return status.Error(codes.Internal, "no rows returned")
+}

runtime/queries/column_time_range.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/marcboeker/go-duckdb"
 	runtimev1 "github.com/rilldata/rill/proto/gen/rill/runtime/v1"
 	"github.com/rilldata/rill/runtime"
 	"google.golang.org/grpc/codes"
@@ -64,7 +65,7 @@ func (q *ColumnTimeRange) Resolve(ctx context.Context, rt *runtime.Runtime, inst
 		if v := rowMap["min"]; v != nil {
 			summary.Min = timestamppb.New(v.(time.Time))
 			summary.Max = timestamppb.New(rowMap["max"].(time.Time))
-			summary.Interval, err = server.handleInterval(rowMap["interval"])
+			summary.Interval, err = handleInterval(rowMap["interval"])
 			if err != nil {
 				return err
 			}
@@ -74,3 +75,20 @@ func (q *ColumnTimeRange) Resolve(ctx context.Context, rt *runtime.Runtime, inst
 	}
 	return status.Error(codes.Internal, "no rows returned")
 }
+
+func handleInterval(interval any) (*runtimev1.TimeRangeSummary_Interval, error) {
+	switch i := interval.(type) {
+	case duckdb.Interval:
+		var result = new(runtimev1.TimeRangeSummary_Interval)
+		result.Days = i.Days
+		result.Months = i.Months
+		result.Micros = i.Micros
+		return result, nil
+	case int64:
+		// for date type column interval is difference in num days for two dates
+		var result = new(runtimev1.TimeRangeSummary_Interval)
+		result.Days = int32(i)
+		return result, nil
+	}
+	return nil, fmt.Errorf("cannot handle interval type %T", interval)
+}

runtime/server/queries_columns.go

@@ -2,12 +2,8 @@ package server
 
 import (
 	"context"
-	"fmt"
-
-	"github.com/marcboeker/go-duckdb"
 
 	runtimev1 "github.com/rilldata/rill/proto/gen/rill/runtime/v1"
-	"github.com/rilldata/rill/runtime/drivers"
 	"github.com/rilldata/rill/runtime/queries"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -176,50 +172,20 @@ func (s *Server) GetTimeRangeSummary(ctx context.Context, request *runtimev1.Get
 	}, nil
 }
 
-func handleInterval(interval any) (*runtimev1.TimeRangeSummary_Interval, error) {
-	switch i := interval.(type) {
-	case duckdb.Interval:
-		var result = new(runtimev1.TimeRangeSummary_Interval)
-		result.Days = i.Days
-		result.Months = i.Months
-		result.Micros = i.Micros
-		return result, nil
-	case int64:
-		// for date type column interval is difference in num days for two dates
-		var result = new(runtimev1.TimeRangeSummary_Interval)
-		result.Days = int32(i)
-		return result, nil
-	}
-	return nil, fmt.Errorf("cannot handle interval type %T", interval)
-}
-
 func (s *Server) GetCardinalityOfColumn(ctx context.Context, request *runtimev1.GetCardinalityOfColumnRequest) (*runtimev1.GetCardinalityOfColumnResponse, error) {
-	sanitizedColumnName := quoteName(request.ColumnName)
-	rows, err := s.query(ctx, request.InstanceId, &drivers.Statement{
-		Query:    fmt.Sprintf("SELECT approx_count_distinct(%s) as count from %s", sanitizedColumnName, request.TableName),
-		Priority: int(request.Priority),
-	})
+	q := &queries.ColumnCardinality{
+		TableName:  request.TableName,
+		ColumnName: request.ColumnName,
+	}
+	err := s.runtime.Query(ctx, request.InstanceId, q, int(request.Priority))
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-	var count float64
-	for rows.Next() {
-		err = rows.Scan(&count)
-		if err != nil {
-			return nil, err
-		}
-		return &runtimev1.GetCardinalityOfColumnResponse{
-			CategoricalSummary: &runtimev1.CategoricalSummary{
-				Case: &runtimev1.CategoricalSummary_Cardinality{
-					Cardinality: count,
-				},
+	return &runtimev1.GetCardinalityOfColumnResponse{
+		CategoricalSummary: &runtimev1.CategoricalSummary{
+			Case: &runtimev1.CategoricalSummary_Cardinality{
+				Cardinality: q.Result,
 			},
-		}, nil
-	}
-	return nil, status.Error(codes.Internal, "no rows returned")
-}
-
-func quoteName(columnName string) string {
-	return fmt.Sprintf("\"%s\"", columnName)
+		},
+	}, nil
 }