conditional.gen.go.tmpl

package values

import (
	fluxarray "github.com/influxdata/flux/array"
	"github.com/apache/arrow/go/v7/arrow/memory"
	"github.com/influxdata/flux/codes"
	"github.com/influxdata/flux/internal/errors"
	"github.com/influxdata/flux/semantic"
)


// VectorConditional delegates the branch selection and necessary array building
// to specialized (by input type) functions in the `array` package, then wraps
// the output as a Value.
//
// For cases where `t` is constant (either by happening to be all the same value,
// or by being a `VectorRepeatValue`) the caller should skip this function and
// return either the consequent or alternate
// directly.
// With constant `t` is expected to be handled higher up, this function will error
// if it receives a `VectorRepeatValue` for this parameter.
//
// Cases where either or both of the consequent `c` and alternate `a` are
// `VectorRepeatValue`s are supported.
//
// Similar to the vec repeat situation, cases where either `c` or `a` are
// invalid (aka null), we treat this as if we have a null constant for the given
// branch. Items selected from the branch will produce nulls in the output.
// For cases where both `c` and `a` are null, we short circuit immediately
// returning a new untyped null Value.
func VectorConditional(t Vector, c, a Value, mem memory.Allocator) (Value, error) {
	// We will know the output type only when at least one branch is not null.
	// When both branches are null, the output can only be null (aka Invalid).
	var elemType semantic.MonoType
	if c.IsNull() && a.IsNull() {
		return Null, nil // early return an untyped null
	} else if c.IsNull() {
		elemType = a.Vector().ElementType()
	} else {
		elemType = c.Vector().ElementType()
	}

	if _, ok := t.(*VectorRepeatValue); ok {
		panic("t is constant, should be handled higher up, such as in conditionalVectorEvaluator.Eval")
	}

	switch elemType.Nature() {
	{{range .}}
	case semantic.{{if eq .Name "Uint"}}UInt{{else}}{{if eq .Name "Boolean"}}Bool{{else}}{{.Name}}{{end}}{{end}}:
		var (
		x *fluxarray.{{.ValueName}}
			err error
		)

		var cvr, avr *{{.PrimitiveType}}
		crepeat := false
		if vr, ok := c.(*VectorRepeatValue); ok {
			crepeat = true
			{{if eq .Name "Time"}}
				prim := vr.val.Time().Time().UnixNano()
			{{else}}
				prim := vr.val.{{.ValueType}}()
			{{end}}
				cvr = &prim
		} else if c.IsNull() {
			crepeat = true // leave cvr as nil, but insist we treat it as a constant.
		}

		arepeat := false
		if vr, ok := a.(*VectorRepeatValue); ok {
			arepeat = true
			{{if eq .Name "Time"}}
				prim := vr.val.Time().Time().UnixNano()
			{{else}}
				prim := vr.val.{{.ValueType}}()
			{{end}}
			avr = &prim
		} else if a.IsNull() {
			arepeat = true // leave avr as nil, but insist we treat it as a constant.
		}

		if crepeat && arepeat {
			x, err = fluxarray.{{.ValueName}}ConditionalCConstAConst(
				t.Arr().(*fluxarray.Boolean),
				cvr,
				avr,
				mem,
			)
		} else if crepeat {
			x, err = fluxarray.{{.ValueName}}ConditionalCConst(
				t.Arr().(*fluxarray.Boolean),
				cvr,
				a.Vector().Arr().(*fluxarray.{{.ValueName}}),
				mem,
			)
		} else if arepeat {
			x, err = fluxarray.{{.ValueName}}ConditionalAConst(
				t.Arr().(*fluxarray.Boolean),
				c.Vector().Arr().(*fluxarray.{{.ValueName}}),
				avr,
				mem,
			)
		} else {
			x, err = fluxarray.{{.ValueName}}Conditional(
				t.Arr().(*fluxarray.Boolean),
					c.Vector().Arr().(*fluxarray.{{.ValueName}}),
					a.Vector().Arr().(*fluxarray.{{.ValueName}}),
					mem,
				)
		}
		if err != nil {
			return nil, err
		}
		return NewVectorValue(x, {{.MonoType}}), nil
	{{end}}
	default:
		return nil, errors.Newf(codes.Invalid, "unsupported type for vector: %v", elemType)
	}
}