From 7247c646b55b1f0a5eac5b6da67a07808ab2eece Mon Sep 17 00:00:00 2001 From: Matthew Nibecker Date: Fri, 22 Nov 2024 11:21:33 -0500 Subject: [PATCH] Rename: NullsView to BoolView Rename NullsView to BoolView since this can be used for creating views of Bool vectors as well. In addition have all an false value views of a boolean vector return a non-nil vector. When dealing with boolean values there's a difference between a false values and a nil vector. Also have NewView of a boolean vector create a new boolean vector. --- runtime/vam/expr/arith.go | 4 +- runtime/vam/expr/arithfuncs.go | 720 ++++++++++-------------------- runtime/vam/expr/cast/bool.go | 2 +- runtime/vam/expr/cast/bytes.go | 2 +- runtime/vam/expr/cast/number.go | 6 +- runtime/vam/expr/cast/string.go | 2 +- runtime/vam/expr/genarithfuncs.go | 7 +- vector/bool.go | 2 +- vector/view.go | 22 +- 9 files changed, 265 insertions(+), 502 deletions(-) diff --git a/runtime/vam/expr/arith.go b/runtime/vam/expr/arith.go index 59c65db48d..71437894a3 100644 --- a/runtime/vam/expr/arith.go +++ b/runtime/vam/expr/arith.go @@ -63,7 +63,9 @@ func (a *Arith) eval(vecs ...vector.Any) (out vector.Any) { } }() } - return f(lhs, rhs) + out = f(lhs, rhs) + vector.SetNulls(out, vector.Or(vector.NullsOf(lhs), vector.NullsOf(rhs))) + return out } func (a *Arith) evalDivideByZero(kind vector.Kind, lhs, rhs vector.Any) vector.Any { diff --git a/runtime/vam/expr/arithfuncs.go b/runtime/vam/expr/arithfuncs.go index c3fef5965c..0ef8a2ba4c 100644 --- a/runtime/vam/expr/arithfuncs.go +++ b/runtime/vam/expr/arithfuncs.go @@ -10,9 +10,8 @@ import ( func arithAddIntFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(k)) } @@ -24,9 +23,8 @@ func arithAddIntFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -38,9 +36,8 @@ func arithAddIntFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -51,9 +48,8 @@ func arithAddIntFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + rconst) } @@ -65,9 +61,8 @@ func arithAddIntDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -81,9 +76,8 @@ func arithAddIntDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -97,9 +91,8 @@ func arithAddIntDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -112,9 +105,8 @@ func arithAddIntDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -126,9 +118,8 @@ func arithAddIntViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -142,9 +133,8 @@ func arithAddIntViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -158,9 +148,8 @@ func arithAddIntViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -173,9 +162,8 @@ func arithAddIntViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -186,9 +174,8 @@ func arithAddIntConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsInt() r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(k)) } @@ -201,9 +188,8 @@ func arithAddIntConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -216,9 +202,8 @@ func arithAddIntConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -230,17 +215,15 @@ func arithAddIntConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsInt() r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewInt64(lconst + rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithAddUintFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(k)) } @@ -252,9 +235,8 @@ func arithAddUintFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -266,9 +248,8 @@ func arithAddUintFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -279,9 +260,8 @@ func arithAddUintFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + rconst) } @@ -293,9 +273,8 @@ func arithAddUintDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -309,9 +288,8 @@ func arithAddUintDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -325,9 +303,8 @@ func arithAddUintDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -340,9 +317,8 @@ func arithAddUintDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -354,9 +330,8 @@ func arithAddUintViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -370,9 +345,8 @@ func arithAddUintViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -386,9 +360,8 @@ func arithAddUintViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -401,9 +374,8 @@ func arithAddUintViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -414,9 +386,8 @@ func arithAddUintConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsUint() r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(k)) } @@ -429,9 +400,8 @@ func arithAddUintConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -444,9 +414,8 @@ func arithAddUintConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -458,17 +427,15 @@ func arithAddUintConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsUint() r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewUint64(lconst + rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithAddFloatFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(k)) } @@ -480,9 +447,8 @@ func arithAddFloatFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -494,9 +460,8 @@ func arithAddFloatFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -507,9 +472,8 @@ func arithAddFloatFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + rconst) } @@ -521,9 +485,8 @@ func arithAddFloatDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -537,9 +500,8 @@ func arithAddFloatDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -553,9 +515,8 @@ func arithAddFloatDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -568,9 +529,8 @@ func arithAddFloatDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -582,9 +542,8 @@ func arithAddFloatViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -598,9 +557,8 @@ func arithAddFloatViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -614,9 +572,8 @@ func arithAddFloatViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -629,9 +586,8 @@ func arithAddFloatViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -642,9 +598,8 @@ func arithAddFloatConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsFloat() r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(k)) } @@ -657,9 +612,8 @@ func arithAddFloatConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -672,9 +626,8 @@ func arithAddFloatConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -686,17 +639,15 @@ func arithAddFloatConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsFloat() r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewFloat64(lconst + rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithAddStringFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.String) r := rhs.(*vector.String) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(k)) } @@ -708,9 +659,8 @@ func arithAddStringFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -722,9 +672,8 @@ func arithAddStringFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + r.Value(uint32(rx[k]))) } @@ -735,9 +684,8 @@ func arithAddStringFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.String) r := rhs.(*vector.Const) rconst, _ := r.AsString() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) + rconst) } @@ -749,9 +697,8 @@ func arithAddStringDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.String) lx := ld.Index r := rhs.(*vector.String) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -765,9 +712,8 @@ func arithAddStringDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -781,9 +727,8 @@ func arithAddStringDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -796,9 +741,8 @@ func arithAddStringDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsString() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -810,9 +754,8 @@ func arithAddStringViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.String) lx := ld.Index r := rhs.(*vector.String) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(k)) } @@ -826,9 +769,8 @@ func arithAddStringViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -842,9 +784,8 @@ func arithAddStringViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + r.Value(uint32(rx[k]))) } @@ -857,9 +798,8 @@ func arithAddStringViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsString() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) + rconst) } @@ -870,9 +810,8 @@ func arithAddStringConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsString() r := rhs.(*vector.String) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(k)) } @@ -885,9 +824,8 @@ func arithAddStringConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -900,9 +838,8 @@ func arithAddStringConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.String) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewStringEmpty(n, nulls) + out := vector.NewStringEmpty(n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst + r.Value(uint32(rx[k]))) } @@ -914,17 +851,15 @@ func arithAddStringConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsString() r := rhs.(*vector.Const) rconst, _ := r.AsString() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewString(lconst + rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithSubIntFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(k)) } @@ -936,9 +871,8 @@ func arithSubIntFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(uint32(rx[k]))) } @@ -950,9 +884,8 @@ func arithSubIntFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(uint32(rx[k]))) } @@ -963,9 +896,8 @@ func arithSubIntFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - rconst) } @@ -977,9 +909,8 @@ func arithSubIntDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(k)) } @@ -993,9 +924,8 @@ func arithSubIntDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1009,9 +939,8 @@ func arithSubIntDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1024,9 +953,8 @@ func arithSubIntDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - rconst) } @@ -1038,9 +966,8 @@ func arithSubIntViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(k)) } @@ -1054,9 +981,8 @@ func arithSubIntViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1070,9 +996,8 @@ func arithSubIntViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1085,9 +1010,8 @@ func arithSubIntViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - rconst) } @@ -1098,9 +1022,8 @@ func arithSubIntConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsInt() r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(k)) } @@ -1113,9 +1036,8 @@ func arithSubIntConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(uint32(rx[k]))) } @@ -1128,9 +1050,8 @@ func arithSubIntConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(uint32(rx[k]))) } @@ -1142,17 +1063,15 @@ func arithSubIntConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsInt() r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewInt64(lconst - rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithSubUintFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(k)) } @@ -1164,9 +1083,8 @@ func arithSubUintFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(uint32(rx[k]))) } @@ -1178,9 +1096,8 @@ func arithSubUintFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(uint32(rx[k]))) } @@ -1191,9 +1108,8 @@ func arithSubUintFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - rconst) } @@ -1205,9 +1121,8 @@ func arithSubUintDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(k)) } @@ -1221,9 +1136,8 @@ func arithSubUintDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1237,9 +1151,8 @@ func arithSubUintDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1252,9 +1165,8 @@ func arithSubUintDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - rconst) } @@ -1266,9 +1178,8 @@ func arithSubUintViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(k)) } @@ -1282,9 +1193,8 @@ func arithSubUintViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1298,9 +1208,8 @@ func arithSubUintViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1313,9 +1222,8 @@ func arithSubUintViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - rconst) } @@ -1326,9 +1234,8 @@ func arithSubUintConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsUint() r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(k)) } @@ -1341,9 +1248,8 @@ func arithSubUintConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(uint32(rx[k]))) } @@ -1356,9 +1262,8 @@ func arithSubUintConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(uint32(rx[k]))) } @@ -1370,17 +1275,15 @@ func arithSubUintConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsUint() r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewUint64(lconst - rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithSubFloatFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(k)) } @@ -1392,9 +1295,8 @@ func arithSubFloatFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(uint32(rx[k]))) } @@ -1406,9 +1308,8 @@ func arithSubFloatFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - r.Value(uint32(rx[k]))) } @@ -1419,9 +1320,8 @@ func arithSubFloatFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) - rconst) } @@ -1433,9 +1333,8 @@ func arithSubFloatDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(k)) } @@ -1449,9 +1348,8 @@ func arithSubFloatDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1465,9 +1363,8 @@ func arithSubFloatDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1480,9 +1377,8 @@ func arithSubFloatDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - rconst) } @@ -1494,9 +1390,8 @@ func arithSubFloatViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(k)) } @@ -1510,9 +1405,8 @@ func arithSubFloatViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1526,9 +1420,8 @@ func arithSubFloatViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - r.Value(uint32(rx[k]))) } @@ -1541,9 +1434,8 @@ func arithSubFloatViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) - rconst) } @@ -1554,9 +1446,8 @@ func arithSubFloatConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsFloat() r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(k)) } @@ -1569,9 +1460,8 @@ func arithSubFloatConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(uint32(rx[k]))) } @@ -1584,9 +1474,8 @@ func arithSubFloatConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst - r.Value(uint32(rx[k]))) } @@ -1598,17 +1487,15 @@ func arithSubFloatConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsFloat() r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewFloat64(lconst - rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithMulIntFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(k)) } @@ -1620,9 +1507,8 @@ func arithMulIntFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(uint32(rx[k]))) } @@ -1634,9 +1520,8 @@ func arithMulIntFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(uint32(rx[k]))) } @@ -1647,9 +1532,8 @@ func arithMulIntFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * rconst) } @@ -1661,9 +1545,8 @@ func arithMulIntDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(k)) } @@ -1677,9 +1560,8 @@ func arithMulIntDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1693,9 +1575,8 @@ func arithMulIntDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1708,9 +1589,8 @@ func arithMulIntDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * rconst) } @@ -1722,9 +1602,8 @@ func arithMulIntViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(k)) } @@ -1738,9 +1617,8 @@ func arithMulIntViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1754,9 +1632,8 @@ func arithMulIntViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1769,9 +1646,8 @@ func arithMulIntViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * rconst) } @@ -1782,9 +1658,8 @@ func arithMulIntConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsInt() r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(k)) } @@ -1797,9 +1672,8 @@ func arithMulIntConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(uint32(rx[k]))) } @@ -1812,9 +1686,8 @@ func arithMulIntConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(uint32(rx[k]))) } @@ -1826,17 +1699,15 @@ func arithMulIntConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsInt() r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewInt64(lconst * rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithMulUintFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(k)) } @@ -1848,9 +1719,8 @@ func arithMulUintFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(uint32(rx[k]))) } @@ -1862,9 +1732,8 @@ func arithMulUintFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(uint32(rx[k]))) } @@ -1875,9 +1744,8 @@ func arithMulUintFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * rconst) } @@ -1889,9 +1757,8 @@ func arithMulUintDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(k)) } @@ -1905,9 +1772,8 @@ func arithMulUintDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1921,9 +1787,8 @@ func arithMulUintDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1936,9 +1801,8 @@ func arithMulUintDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * rconst) } @@ -1950,9 +1814,8 @@ func arithMulUintViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(k)) } @@ -1966,9 +1829,8 @@ func arithMulUintViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1982,9 +1844,8 @@ func arithMulUintViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -1997,9 +1858,8 @@ func arithMulUintViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * rconst) } @@ -2010,9 +1870,8 @@ func arithMulUintConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsUint() r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(k)) } @@ -2025,9 +1884,8 @@ func arithMulUintConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(uint32(rx[k]))) } @@ -2040,9 +1898,8 @@ func arithMulUintConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(uint32(rx[k]))) } @@ -2054,17 +1911,15 @@ func arithMulUintConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsUint() r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewUint64(lconst * rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithMulFloatFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(k)) } @@ -2076,9 +1931,8 @@ func arithMulFloatFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(uint32(rx[k]))) } @@ -2090,9 +1944,8 @@ func arithMulFloatFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * r.Value(uint32(rx[k]))) } @@ -2103,9 +1956,8 @@ func arithMulFloatFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) * rconst) } @@ -2117,9 +1969,8 @@ func arithMulFloatDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(k)) } @@ -2133,9 +1984,8 @@ func arithMulFloatDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -2149,9 +1999,8 @@ func arithMulFloatDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -2164,9 +2013,8 @@ func arithMulFloatDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * rconst) } @@ -2178,9 +2026,8 @@ func arithMulFloatViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(k)) } @@ -2194,9 +2041,8 @@ func arithMulFloatViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -2210,9 +2056,8 @@ func arithMulFloatViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * r.Value(uint32(rx[k]))) } @@ -2225,9 +2070,8 @@ func arithMulFloatViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) * rconst) } @@ -2238,9 +2082,8 @@ func arithMulFloatConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsFloat() r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(k)) } @@ -2253,9 +2096,8 @@ func arithMulFloatConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(uint32(rx[k]))) } @@ -2268,9 +2110,8 @@ func arithMulFloatConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst * r.Value(uint32(rx[k]))) } @@ -2282,17 +2123,15 @@ func arithMulFloatConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsFloat() r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewFloat64(lconst * rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithDivIntFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(k)) } @@ -2304,9 +2143,8 @@ func arithDivIntFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(uint32(rx[k]))) } @@ -2318,9 +2156,8 @@ func arithDivIntFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(uint32(rx[k]))) } @@ -2331,9 +2168,8 @@ func arithDivIntFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / rconst) } @@ -2345,9 +2181,8 @@ func arithDivIntDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(k)) } @@ -2361,9 +2196,8 @@ func arithDivIntDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2377,9 +2211,8 @@ func arithDivIntDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2392,9 +2225,8 @@ func arithDivIntDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / rconst) } @@ -2406,9 +2238,8 @@ func arithDivIntViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(k)) } @@ -2422,9 +2253,8 @@ func arithDivIntViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2438,9 +2268,8 @@ func arithDivIntViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2453,9 +2282,8 @@ func arithDivIntViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / rconst) } @@ -2466,9 +2294,8 @@ func arithDivIntConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsInt() r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(k)) } @@ -2481,9 +2308,8 @@ func arithDivIntConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(uint32(rx[k]))) } @@ -2496,9 +2322,8 @@ func arithDivIntConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(uint32(rx[k]))) } @@ -2510,17 +2335,15 @@ func arithDivIntConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsInt() r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewInt64(lconst / rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithDivUintFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(k)) } @@ -2532,9 +2355,8 @@ func arithDivUintFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(uint32(rx[k]))) } @@ -2546,9 +2368,8 @@ func arithDivUintFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(uint32(rx[k]))) } @@ -2559,9 +2380,8 @@ func arithDivUintFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / rconst) } @@ -2573,9 +2393,8 @@ func arithDivUintDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(k)) } @@ -2589,9 +2408,8 @@ func arithDivUintDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2605,9 +2423,8 @@ func arithDivUintDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2620,9 +2437,8 @@ func arithDivUintDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / rconst) } @@ -2634,9 +2450,8 @@ func arithDivUintViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(k)) } @@ -2650,9 +2465,8 @@ func arithDivUintViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2666,9 +2480,8 @@ func arithDivUintViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2681,9 +2494,8 @@ func arithDivUintViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / rconst) } @@ -2694,9 +2506,8 @@ func arithDivUintConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsUint() r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(k)) } @@ -2709,9 +2520,8 @@ func arithDivUintConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(uint32(rx[k]))) } @@ -2724,9 +2534,8 @@ func arithDivUintConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(uint32(rx[k]))) } @@ -2738,17 +2547,15 @@ func arithDivUintConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsUint() r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewUint64(lconst / rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithDivFloatFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(k)) } @@ -2760,9 +2567,8 @@ func arithDivFloatFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(uint32(rx[k]))) } @@ -2774,9 +2580,8 @@ func arithDivFloatFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / r.Value(uint32(rx[k]))) } @@ -2787,9 +2592,8 @@ func arithDivFloatFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Float) r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) / rconst) } @@ -2801,9 +2605,8 @@ func arithDivFloatDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(k)) } @@ -2817,9 +2620,8 @@ func arithDivFloatDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2833,9 +2635,8 @@ func arithDivFloatDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2848,9 +2649,8 @@ func arithDivFloatDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / rconst) } @@ -2862,9 +2662,8 @@ func arithDivFloatViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Float) lx := ld.Index r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(k)) } @@ -2878,9 +2677,8 @@ func arithDivFloatViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2894,9 +2692,8 @@ func arithDivFloatViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / r.Value(uint32(rx[k]))) } @@ -2909,9 +2706,8 @@ func arithDivFloatViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) / rconst) } @@ -2922,9 +2718,8 @@ func arithDivFloatConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsFloat() r := rhs.(*vector.Float) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(k)) } @@ -2937,9 +2732,8 @@ func arithDivFloatConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(uint32(rx[k]))) } @@ -2952,9 +2746,8 @@ func arithDivFloatConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Float) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewFloatEmpty(super.TypeFloat64, n, nulls) + out := vector.NewFloatEmpty(super.TypeFloat64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst / r.Value(uint32(rx[k]))) } @@ -2966,17 +2759,15 @@ func arithDivFloatConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsFloat() r := rhs.(*vector.Const) rconst, _ := r.AsFloat() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewFloat64(lconst / rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithModIntFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % r.Value(k)) } @@ -2988,9 +2779,8 @@ func arithModIntFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % r.Value(uint32(rx[k]))) } @@ -3002,9 +2792,8 @@ func arithModIntFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % r.Value(uint32(rx[k]))) } @@ -3015,9 +2804,8 @@ func arithModIntFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Int) r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % rconst) } @@ -3029,9 +2817,8 @@ func arithModIntDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(k)) } @@ -3045,9 +2832,8 @@ func arithModIntDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3061,9 +2847,8 @@ func arithModIntDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3076,9 +2861,8 @@ func arithModIntDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % rconst) } @@ -3090,9 +2874,8 @@ func arithModIntViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Int) lx := ld.Index r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(k)) } @@ -3106,9 +2889,8 @@ func arithModIntViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3122,9 +2904,8 @@ func arithModIntViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3137,9 +2918,8 @@ func arithModIntViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % rconst) } @@ -3150,9 +2930,8 @@ func arithModIntConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsInt() r := rhs.(*vector.Int) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst % r.Value(k)) } @@ -3165,9 +2944,8 @@ func arithModIntConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst % r.Value(uint32(rx[k]))) } @@ -3180,9 +2958,8 @@ func arithModIntConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Int) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewIntEmpty(super.TypeInt64, n, nulls) + out := vector.NewIntEmpty(super.TypeInt64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst % r.Value(uint32(rx[k]))) } @@ -3194,17 +2971,15 @@ func arithModIntConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsInt() r := rhs.(*vector.Const) rconst, _ := r.AsInt() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewInt64(lconst % rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } func arithModUintFlatFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % r.Value(k)) } @@ -3216,9 +2991,8 @@ func arithModUintFlatDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % r.Value(uint32(rx[k]))) } @@ -3230,9 +3004,8 @@ func arithModUintFlatView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % r.Value(uint32(rx[k]))) } @@ -3243,9 +3016,8 @@ func arithModUintFlatConst(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Uint) r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(k) % rconst) } @@ -3257,9 +3029,8 @@ func arithModUintDictFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(k)) } @@ -3273,9 +3044,8 @@ func arithModUintDictDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3289,9 +3059,8 @@ func arithModUintDictView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3304,9 +3073,8 @@ func arithModUintDictConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % rconst) } @@ -3318,9 +3086,8 @@ func arithModUintViewFlat(lhs, rhs vector.Any) vector.Any { l := ld.Any.(*vector.Uint) lx := ld.Index r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(k)) } @@ -3334,9 +3101,8 @@ func arithModUintViewDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3350,9 +3116,8 @@ func arithModUintViewView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % r.Value(uint32(rx[k]))) } @@ -3365,9 +3130,8 @@ func arithModUintViewConst(lhs, rhs vector.Any) vector.Any { lx := ld.Index r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(l.Value(uint32(lx[k])) % rconst) } @@ -3378,9 +3142,8 @@ func arithModUintConstFlat(lhs, rhs vector.Any) vector.Any { l := lhs.(*vector.Const) lconst, _ := l.AsUint() r := rhs.(*vector.Uint) - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst % r.Value(k)) } @@ -3393,9 +3156,8 @@ func arithModUintConstDict(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.Dict) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst % r.Value(uint32(rx[k]))) } @@ -3408,9 +3170,8 @@ func arithModUintConstView(lhs, rhs vector.Any) vector.Any { rd := rhs.(*vector.View) r := rd.Any.(*vector.Uint) rx := rd.Index - nulls := vector.Or(l.Nulls, r.Nulls) n := lhs.Len() - out := vector.NewUintEmpty(super.TypeUint64, n, nulls) + out := vector.NewUintEmpty(super.TypeUint64, n, nil) for k := uint32(0); k < n; k++ { out.Append(lconst % r.Value(uint32(rx[k]))) } @@ -3422,9 +3183,8 @@ func arithModUintConstConst(lhs, rhs vector.Any) vector.Any { lconst, _ := l.AsUint() r := rhs.(*vector.Const) rconst, _ := r.AsUint() - nulls := vector.Or(l.Nulls, r.Nulls) val := super.NewUint64(lconst % rconst) - return vector.NewConst(val, lhs.Len(), nulls) + return vector.NewConst(val, lhs.Len(), nil) } var arithFuncs = map[int]func(vector.Any, vector.Any) vector.Any{ diff --git a/runtime/vam/expr/cast/bool.go b/runtime/vam/expr/cast/bool.go index 34b6efac99..245619c66c 100644 --- a/runtime/vam/expr/cast/bool.go +++ b/runtime/vam/expr/cast/bool.go @@ -22,7 +22,7 @@ func castToBool(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) { } out.Nulls = vector.NullsOf(vec) if index != nil { - out.Nulls = vector.NullsView(out.Nulls, index) + out.Nulls = vector.NewBoolView(out.Nulls, index) } return out, nil, true } diff --git a/runtime/vam/expr/cast/bytes.go b/runtime/vam/expr/cast/bytes.go index 483b4d4018..9c8834d34e 100644 --- a/runtime/vam/expr/cast/bytes.go +++ b/runtime/vam/expr/cast/bytes.go @@ -9,7 +9,7 @@ func castToBytes(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) { n := lengthOf(vec, index) nulls := vector.NullsOf(vec) if index != nil { - nulls = vector.NullsView(nulls, index) + nulls = vector.NewBoolView(nulls, index) } out := vector.NewBytesEmpty(n, nulls) var b zcode.Builder diff --git a/runtime/vam/expr/cast/number.go b/runtime/vam/expr/cast/number.go index 10a6f9a604..ed401b72c6 100644 --- a/runtime/vam/expr/cast/number.go +++ b/runtime/vam/expr/cast/number.go @@ -26,19 +26,19 @@ func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, [ case super.IsSigned(id): vals, errs := toNumeric[int64](vec, typ, index) if len(errs) > 0 { - nulls = vector.NullsView(nulls, inverseIndex(errs, nulls)) + nulls = vector.NewBoolView(nulls, inverseIndex(errs, nulls)) } return vector.NewInt(typ, vals, nulls), errs, true case super.IsUnsigned(id): vals, errs := toNumeric[uint64](vec, typ, index) if len(errs) > 0 { - nulls = vector.NullsView(nulls, inverseIndex(errs, nulls)) + nulls = vector.NewBoolView(nulls, inverseIndex(errs, nulls)) } return vector.NewUint(typ, vals, nulls), errs, true case super.IsFloat(id): vals, errs := toNumeric[float64](vec, typ, index) if errs != nil { - nulls = vector.NullsView(nulls, inverseIndex(errs, nulls)) + nulls = vector.NewBoolView(nulls, inverseIndex(errs, nulls)) } return vector.NewFloat(typ, vals, nulls), errs, true default: diff --git a/runtime/vam/expr/cast/string.go b/runtime/vam/expr/cast/string.go index bad969fff4..b516f2c74b 100644 --- a/runtime/vam/expr/cast/string.go +++ b/runtime/vam/expr/cast/string.go @@ -14,7 +14,7 @@ import ( func castToString(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) { nulls := vector.NullsOf(vec) if index != nil { - nulls = vector.NullsView(nulls, index) + nulls = vector.NewBoolView(nulls, index) } n := lengthOf(vec, index) var bytes []byte diff --git a/runtime/vam/expr/genarithfuncs.go b/runtime/vam/expr/genarithfuncs.go index afe6bee2fc..9e430b6d01 100644 --- a/runtime/vam/expr/genarithfuncs.go +++ b/runtime/vam/expr/genarithfuncs.go @@ -71,20 +71,19 @@ func genFunc(name, op, typ string, lhs, rhs vector.Form) string { s := fmt.Sprintf("func %s(lhs, rhs vector.Any) vector.Any {\n", name) s += genVarInit("l", typ, lhs) s += genVarInit("r", typ, rhs) - s += "nulls := vector.Or(l.Nulls, r.Nulls)\n" if lhs == vector.FormConst && rhs == vector.FormConst { if typ == "String" { s += fmt.Sprintf("val := super.NewString(lconst %s rconst)\n", op) } else { s += fmt.Sprintf("val := super.New%s64(lconst %s rconst)\n", typ, op) } - s += "return vector.NewConst(val, lhs.Len(), nulls)\n" + s += "return vector.NewConst(val, lhs.Len(), nil)\n" } else { s += "n := lhs.Len()\n" if typ == "String" { - s += "out := vector.NewStringEmpty(n, nulls)\n" + s += "out := vector.NewStringEmpty(n, nil)\n" } else { - s += fmt.Sprintf("out := vector.New%sEmpty(super.Type%s64, n, nulls)\n", typ, typ) + s += fmt.Sprintf("out := vector.New%sEmpty(super.Type%s64, n, nil)\n", typ, typ) } s += genLoop(op, typ, lhs, rhs) s += "return out\n" diff --git a/vector/bool.go b/vector/bool.go index 96c6203061..038d76d570 100644 --- a/vector/bool.go +++ b/vector/bool.go @@ -174,7 +174,7 @@ func NullsOf(v Any) *Bool { case *Union: return v.Nulls case *View: - return NullsView(NullsOf(v.Any), v.Index) + return NewBoolView(NullsOf(v.Any), v.Index) } panic(v) } diff --git a/vector/view.go b/vector/view.go index 6b450d3e8a..624a9f072a 100644 --- a/vector/view.go +++ b/vector/view.go @@ -13,8 +13,10 @@ var _ Any = (*View)(nil) func NewView(val Any, index []uint32) Any { switch val := val.(type) { + case *Bool: + return NewBoolView(val, index) case *Const: - return NewConst(val.val, uint32(len(index)), NullsView(val.Nulls, index)) + return NewConst(val.val, uint32(len(index)), NewBoolView(val.Nulls, index)) case *Dict: index2 := make([]byte, len(index)) var nulls *Bool @@ -33,10 +35,10 @@ func NewView(val Any, index []uint32) Any { } return NewDict(val.Any, index2, nil, nulls) case *Error: - return NewError(val.Typ, NewView(val.Vals, index), NullsView(val.Nulls, index)) + return NewError(val.Typ, NewView(val.Vals, index), NewBoolView(val.Nulls, index)) case *Union: tags, values := viewForUnionOrDynamic(index, val.Tags, val.TagMap.Forward, val.Values) - return NewUnion(val.Typ, tags, values, NullsView(val.Nulls, index)) + return NewUnion(val.Typ, tags, values, NewBoolView(val.Nulls, index)) case *Dynamic: return NewDynamic(viewForUnionOrDynamic(index, val.Tags, val.TagMap.Forward, val.Values)) case *View: @@ -52,19 +54,19 @@ func NewView(val Any, index []uint32) Any { return &View{val, index} } -func NullsView(nulls *Bool, index []uint32) *Bool { - if nulls == nil { +func NewBoolView(vec *Bool, index []uint32) *Bool { + if vec == nil { return nil } - var out *Bool + out := NewBoolEmpty(uint32(len(index)), nil) for k, slot := range index { - if nulls.Value(slot) { - if out == nil { - out = NewBoolEmpty(uint32(len(index)), nil) - } + if vec.Value(slot) { out.Set(uint32(k)) } } + if vec.Nulls != nil { + out.Nulls = NewBoolView(vec.Nulls, index) + } return out }