ops

type AllOf[R Row, V any] []RowOperation[R, V]

type AllOf1[R Row, V1 any] struct {
	Op1 RowOperation[R, V1]
}

type AllOf2[R Row, V1, V2 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
}

type AllOf3[R Row, V1, V2, V3 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
}

type AllOf4[R Row, V1, V2, V3, V4 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
	Op4 RowOperation[R, V4]
}

type AllOf5[R Row, V1, V2, V3, V4, V5 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
	Op4 RowOperation[R, V4]
	Op5 RowOperation[R, V5]
}

type AllOf6[R Row, V1, V2, V3, V4, V5, V6 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
	Op4 RowOperation[R, V4]
	Op5 RowOperation[R, V5]
	Op6 RowOperation[R, V6]
}

type AllOf7[R Row, V1, V2, V3, V4, V5, V6, V7 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
	Op4 RowOperation[R, V4]
	Op5 RowOperation[R, V5]
	Op6 RowOperation[R, V6]
	Op7 RowOperation[R, V7]
}

type AllOf8[R Row, V1, V2, V3, V4, V5, V6, V7, V8 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
	Op4 RowOperation[R, V4]
	Op5 RowOperation[R, V5]
	Op6 RowOperation[R, V6]
	Op7 RowOperation[R, V7]
	Op8 RowOperation[R, V8]
}

type AllOf9[R Row, V1, V2, V3, V4, V5, V6, V7, V8, V9 any] struct {
	Op1 RowOperation[R, V1]
	Op2 RowOperation[R, V2]
	Op3 RowOperation[R, V3]
	Op4 RowOperation[R, V4]
	Op5 RowOperation[R, V5]
	Op6 RowOperation[R, V6]
	Op7 RowOperation[R, V7]
	Op8 RowOperation[R, V8]
	Op9 RowOperation[R, V9]
}

type AnyOf[R Row, V any] []RowOperation[R, V]

type AnyOf1[R Row, V any] [1]RowOperation[R, V]

type AnyOf2[R Row, V any] [2]RowOperation[R, V]

type AnyOf3[R Row, V any] [3]RowOperation[R, V]

type AnyOf4[R Row, V any] [4]RowOperation[R, V]

type AnyOf5[R Row, V any] [5]RowOperation[R, V]

type AnyOf6[R Row, V any] [6]RowOperation[R, V]

type AnyOf7[R Row, V any] [7]RowOperation[R, V]

type AnyOf8[R Row, V any] [8]RowOperation[R, V]

type AnyOf9[R Row, V any] [9]RowOperation[R, V]

type AnyOp[R Row, V any] struct {
	Op Operation[R, V]
}

type AnyRowOp[R Row, V any] struct {
	Op RowOperation[R, V]
}

type Const[R Row, V any] struct {
	Value V
}

type GroupBy[R Row, K cmp.Ordered, V, U any] struct {
	Key   KeyFn[V, K]
	Merge MergeFn[V, U]
	On    Operation[R, V]
}

type Join[S Row, L, R, V any] struct {
	Left  Operation[S, L]
	Right Operation[S, R]
	Join  JoinFn[L, R, V]
}

type JoinFn[L, R, V any] func(left L, right R) (V, bool)

type KeyFn[V any, K any] func(value V) K

type MergeFn[V any, U any] func(agg U, value V) U

type None = struct{}

type Operation[R Row, V any] interface {
	Execute(store.Store[R]) store.Iterator[V]
}

type Read[R Row, V any] struct {
	Slot int
}

type ReadAll[R Row, V any] struct{}

type ReadAllExecutor[R Row, V any] interface {
	ExecuteReadAll(s store.Store[R], op ReadAll[R, V]) (store.Iterator[RowValue[R, V]], bool)
}

type ReadExecutor[R Row, V any] interface {
	ExecuteRead(s store.Store[R], op Read[R, V]) (store.Iterator[RowValue[R, V]], bool)
}

type ReadOptional[R Row, V any] struct {
	Slot int
}

type ReadOptionalExecutor[R Row, V any] interface {
	ExecuteReadOptional(s store.Store[R], op ReadOptional[R, V]) (store.Iterator[RowValue[R, store.Maybe[V]]], bool)
}

type ReadSlots[R Row, V Slotted] struct{}

type ReadSlotsExecutor[R Row, V Slotted] interface {
	ExecuteReadSlots(s store.Store[R], op ReadSlots[R, V]) (store.Iterator[RowValue[R, V]], bool)
}

type ReadWithDefault[R Row, V any] struct {
	Slot    int
	Default V
}

type ReadWithDefaultExecutor[R Row, V any] interface {
	ExecuteReadWithDefault(s store.Store[R], op ReadWithDefault[R, V]) (store.Iterator[RowValue[R, V]], bool)
}

type Row = store.Row

type RowOperation[R Row, V any] = Operation[R, RowValue[R, V]]

type RowQuery[R Row, V any] struct {
	Op RowOperation[R, V]
}

type RowValue[R, V any] struct {
	Row   R
	Value V
}

type Select[R Row, V, U any] struct {
	Select SelectFn[V, U]
	On     Operation[R, V]
}

type SelectFn[V, U any] func(value V) (U, bool)

type Slotted interface {
	GetSlot() int
}

type Unwrap[R Row, V Unwrapper[U], U any] struct {
	Op RowOperation[R, V]
}

type Unwrapper[V any] interface {
	Unwrap() V
}

type Values1[V1 any] struct {
	V1 V1
}

type Values2[V1, V2 any] struct {
	V1 V1
	V2 V2
}

type Values3[V1, V2, V3 any] struct {
	V1 V1
	V2 V2
	V3 V3
}

type Values4[V1, V2, V3, V4 any] struct {
	V1 V1
	V2 V2
	V3 V3
	V4 V4
}

type Values5[V1, V2, V3, V4, V5 any] struct {
	V1 V1
	V2 V2
	V3 V3
	V4 V4
	V5 V5
}

type Values6[V1, V2, V3, V4, V5, V6 any] struct {
	V1 V1
	V2 V2
	V3 V3
	V4 V4
	V5 V5
	V6 V6
}

type Values7[V1, V2, V3, V4, V5, V6, V7 any] struct {
	V1 V1
	V2 V2
	V3 V3
	V4 V4
	V5 V5
	V6 V6
	V7 V7
}

type Values8[V1, V2, V3, V4, V5, V6, V7, V8 any] struct {
	V1 V1
	V2 V2
	V3 V3
	V4 V4
	V5 V5
	V6 V6
	V7 V7
	V8 V8
}

type Values9[V1, V2, V3, V4, V5, V6, V7, V8, V9 any] struct {
	V1 V1
	V2 V2
	V3 V3
	V4 V4
	V5 V5
	V6 V6
	V7 V7
	V8 V8
	V9 V9
}

type Without[R Row, V any] struct {
	Source RowOperation[R, V]
}