snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/dal/optimization.go

@@ -0,0 +1,148 @@
+package dal
+
+import "fmt"
+
+type (
+	// opCost provides a general idea of expensive an operation is for a
+	// specific pipeline step.
+	//
+	// dsSize provides a general idea of how large an underlaying dataset is.
+	opCost int
+	dsSize int
+
+	OpAnalysis struct {
+		ScanCost   opCost
+		SearchCost opCost
+		FilterCost opCost
+		SortCost   opCost
+
+		OutputSize dsSize
+	}
+
+	ppStepWrap struct {
+		step PipelineStep
+
+		parent *ppStepWrap
+		child  []*ppStepWrap
+	}
+)
+
+var (
+	pipelineOptimizers = []func(Pipeline) (Pipeline, error){
+		pipelineClobberSteps,
+	}
+)
+
+const (
+	// operation computation indicators
+	CostUnknown opCost = iota
+	CostFree
+	CostCheep
+	CostAcceptable
+	CostExpensive
+	CostInfinite
+)
+
+const (
+	// dataset size indicators
+	SizeUnknown dsSize = iota
+	SizeTiny
+	SizeSmall
+	SizeMedium
+	SizeLarge
+)
+
+const (
+	OpAnalysisIterate   string = "iterate"
+	OpAnalysisAggregate string = "aggregate"
+	OpAnalysisJoin      string = "join"
+)
+
+// wrapPpSteps wraps the pipeline steps in a more processing friendly format
+// and returns a slice of leave nodes
+//
+// @todo the pipeline representation might change which will make this obsolete
+func wrapPpSteps(pp Pipeline) (leaves []*ppStepWrap) {
+	ix := make(map[PipelineStep]*ppStepWrap)
+
+	for _, p := range pp {
+		ix[p] = &ppStepWrap{step: p}
+	}
+
+	for _, p := range pp {
+		switch c := p.(type) {
+		case *Aggregate:
+			ix[p].child = append(ix[p].child, ix[c.rel])
+			ix[c.rel].parent = ix[p]
+
+		case *Join:
+			ix[p].child = append(ix[p].child, ix[c.relLeft])
+			ix[c.relLeft].parent = ix[p]
+
+			ix[p].child = append(ix[p].child, ix[c.relRight])
+			ix[c.relRight].parent = ix[p]
+
+		case *Link:
+			ix[p].child = append(ix[p].child, ix[c.relLeft])
+			ix[c.relLeft].parent = ix[p]
+
+			ix[p].child = append(ix[p].child, ix[c.relRight])
+			ix[c.relRight].parent = ix[p]
+
+		case *Datasource:
+			continue
+
+		default:
+			panic(fmt.Errorf("impossible state: unknown pipeline step type %v", p))
+		}
+	}
+
+	for _, a := range ix {
+		if len(a.child) == 0 {
+			leaves = append(leaves, a)
+		}
+	}
+
+	return
+}
+
+// unwrapPpSteps unwraps the wrapped pipeline step into the classic Pipeline
+//
+// @todo the pipeline representation might change which will make this obsolete
+func unwrapPpSteps(n *ppStepWrap, seen map[*ppStepWrap]bool) (out Pipeline) {
+	for i, c := range n.child {
+		switch s := n.step.(type) {
+		case *Aggregate:
+			s.rel = c.step
+			s.RelSource = c.step.Identifier()
+		case *Join:
+			if i == 0 {
+				s.relLeft = c.step
+				s.RelLeft = c.step.Identifier()
+			} else {
+				s.relRight = c.step
+				s.RelRight = c.step.Identifier()
+			}
+		case *Link:
+			if i == 0 {
+				s.relLeft = c.step
+				s.RelLeft = c.step.Identifier()
+			} else {
+				s.relRight = c.step
+				s.RelRight = c.step.Identifier()
+			}
+		}
+	}
+
+	// @todo potentially cancancel sooner
+	if !seen[n] {
+		out = append(out, n.step)
+	}
+	seen[n] = true
+
+	if n.parent != nil {
+		out = append(unwrapPpSteps(n.parent, seen), out...)
+	}
+
+	return
+}