package array

var (
	IntType     = arrow.PrimitiveTypes.Int64
	UintType    = arrow.PrimitiveTypes.Uint64
	FloatType   = arrow.PrimitiveTypes.Float64
	StringType  = arrow.BinaryTypes.String
	BooleanType = arrow.FixedWidthTypes.Boolean
)

Types ¶

type Array ¶

type Array interface {
	// DataType returns the type metadata for this instance.
	DataType() DataType

	// NullN returns the number of null values in the array.
	NullN() int

	// NullBitmapBytes returns a byte slice of the validity bitmap.
	NullBitmapBytes() []byte

	// IsNull returns true if value at index is null.
	// NOTE: IsNull will panic if NullBitmapBytes is not empty and 0 > i ≥ Len.
	IsNull(i int) bool

	// IsValid returns true if value at index is not null.
	// NOTE: IsValid will panic if NullBitmapBytes is not empty and 0 > i ≥ Len.
	IsValid(i int) bool

	Data() arrow.ArrayData

	// Len returns the number of elements in the array.
	Len() int

	// Retain increases the reference count by 1.
	// Retain may be called simultaneously from multiple goroutines.
	Retain()

	// Release decreases the reference count by 1.
	// Release may be called simultaneously from multiple goroutines.
	// When the reference count goes to zero, the memory is freed.
	Release()
}

Array represents an immutable sequence of values.

This type is derived from the arrow.Array interface.

func CopyValidValues ¶

func CopyValidValues(mem memory.Allocator, values Array, nullCheckArray Array) Array

Copies all valid (non-null) values from `values` using the bitmap of nullCheckArray. If the entire array is valid a new reference to `values` is returned (as an optimization)

func Slice ¶

func Slice(arr Array, i, j int) Array

Slice will construct a new slice of the array using the given start and stop index. The returned array must be released.

This is functionally equivalent to using array.NewSlice, but array.NewSlice will construct an array.String when the data type is a string rather than an array.Binary.

type Boolean ¶

type Boolean = array.Boolean

func And ¶

func And(l, r *Boolean, mem memory.Allocator) (*Boolean, error)

func AndConst ¶

func AndConst(fixed *bool, arr *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanBooleanEqual ¶

func BooleanBooleanEqual(l *Boolean, r *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanBooleanEqualLConst ¶

func BooleanBooleanEqualLConst(l bool, r *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanBooleanEqualRConst ¶

func BooleanBooleanEqualRConst(l *Boolean, r bool, mem memory.Allocator) (*Boolean, error)

func BooleanBooleanNotEqual ¶

func BooleanBooleanNotEqual(l *Boolean, r *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanBooleanNotEqualLConst ¶

func BooleanBooleanNotEqualLConst(l bool, r *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanBooleanNotEqualRConst ¶

func BooleanBooleanNotEqualRConst(l *Boolean, r bool, mem memory.Allocator) (*Boolean, error)

func BooleanConditional ¶

func BooleanConditional(t *Boolean, c, a *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanConditionalAConst ¶

func BooleanConditionalAConst(t *Boolean, c *Boolean, a *bool, mem memory.Allocator) (*Boolean, error)

func BooleanConditionalCConst ¶

func BooleanConditionalCConst(t *Boolean, c *bool, a *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanConditionalCConstAConst ¶

func BooleanConditionalCConstAConst(t *Boolean, c, a *bool, mem memory.Allocator) (*Boolean, error)

func BooleanExists ¶

func BooleanExists(v *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanNot ¶

func BooleanNot(v *Boolean, mem memory.Allocator) (*Boolean, error)

func BooleanRepeat ¶

func BooleanRepeat(v bool, isNull bool, n int, mem memory.Allocator) *Boolean

func FloatExists ¶

func FloatExists(v *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatEqual ¶

func FloatFloatEqual(l *Float, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatEqualLConst ¶

func FloatFloatEqualLConst(l float64, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatEqualRConst ¶

func FloatFloatEqualRConst(l *Float, r float64, mem memory.Allocator) (*Boolean, error)

func FloatFloatGreaterThan ¶

func FloatFloatGreaterThan(l *Float, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatGreaterThanEqual ¶

func FloatFloatGreaterThanEqual(l *Float, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatGreaterThanEqualLConst ¶

func FloatFloatGreaterThanEqualLConst(l float64, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatGreaterThanEqualRConst ¶

func FloatFloatGreaterThanEqualRConst(l *Float, r float64, mem memory.Allocator) (*Boolean, error)

func FloatFloatGreaterThanLConst ¶

func FloatFloatGreaterThanLConst(l float64, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatGreaterThanRConst ¶

func FloatFloatGreaterThanRConst(l *Float, r float64, mem memory.Allocator) (*Boolean, error)

func FloatFloatLessThan ¶

func FloatFloatLessThan(l *Float, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatLessThanEqual ¶

func FloatFloatLessThanEqual(l *Float, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatLessThanEqualLConst ¶

func FloatFloatLessThanEqualLConst(l float64, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatLessThanEqualRConst ¶

func FloatFloatLessThanEqualRConst(l *Float, r float64, mem memory.Allocator) (*Boolean, error)

func FloatFloatLessThanLConst ¶

func FloatFloatLessThanLConst(l float64, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatLessThanRConst ¶

func FloatFloatLessThanRConst(l *Float, r float64, mem memory.Allocator) (*Boolean, error)

func FloatFloatNotEqual ¶

func FloatFloatNotEqual(l *Float, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatNotEqualLConst ¶

func FloatFloatNotEqualLConst(l float64, r *Float, mem memory.Allocator) (*Boolean, error)

func FloatFloatNotEqualRConst ¶

func FloatFloatNotEqualRConst(l *Float, r float64, mem memory.Allocator) (*Boolean, error)

func FloatIntEqual ¶

func FloatIntEqual(l *Float, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntEqualLConst ¶

func FloatIntEqualLConst(l float64, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntEqualRConst ¶

func FloatIntEqualRConst(l *Float, r int64, mem memory.Allocator) (*Boolean, error)

func FloatIntGreaterThan ¶

func FloatIntGreaterThan(l *Float, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntGreaterThanEqual ¶

func FloatIntGreaterThanEqual(l *Float, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntGreaterThanEqualLConst ¶

func FloatIntGreaterThanEqualLConst(l float64, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntGreaterThanEqualRConst ¶

func FloatIntGreaterThanEqualRConst(l *Float, r int64, mem memory.Allocator) (*Boolean, error)

func FloatIntGreaterThanLConst ¶

func FloatIntGreaterThanLConst(l float64, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntGreaterThanRConst ¶

func FloatIntGreaterThanRConst(l *Float, r int64, mem memory.Allocator) (*Boolean, error)

func FloatIntLessThan ¶

func FloatIntLessThan(l *Float, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntLessThanEqual ¶

func FloatIntLessThanEqual(l *Float, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntLessThanEqualLConst ¶

func FloatIntLessThanEqualLConst(l float64, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntLessThanEqualRConst ¶

func FloatIntLessThanEqualRConst(l *Float, r int64, mem memory.Allocator) (*Boolean, error)

func FloatIntLessThanLConst ¶

func FloatIntLessThanLConst(l float64, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntLessThanRConst ¶

func FloatIntLessThanRConst(l *Float, r int64, mem memory.Allocator) (*Boolean, error)

func FloatIntNotEqual ¶

func FloatIntNotEqual(l *Float, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntNotEqualLConst ¶

func FloatIntNotEqualLConst(l float64, r *Int, mem memory.Allocator) (*Boolean, error)

func FloatIntNotEqualRConst ¶

func FloatIntNotEqualRConst(l *Float, r int64, mem memory.Allocator) (*Boolean, error)

func FloatUintEqual ¶

func FloatUintEqual(l *Float, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintEqualLConst ¶

func FloatUintEqualLConst(l float64, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintEqualRConst ¶

func FloatUintEqualRConst(l *Float, r uint64, mem memory.Allocator) (*Boolean, error)

func FloatUintGreaterThan ¶

func FloatUintGreaterThan(l *Float, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintGreaterThanEqual ¶

func FloatUintGreaterThanEqual(l *Float, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintGreaterThanEqualLConst ¶

func FloatUintGreaterThanEqualLConst(l float64, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintGreaterThanEqualRConst ¶

func FloatUintGreaterThanEqualRConst(l *Float, r uint64, mem memory.Allocator) (*Boolean, error)

func FloatUintGreaterThanLConst ¶

func FloatUintGreaterThanLConst(l float64, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintGreaterThanRConst ¶

func FloatUintGreaterThanRConst(l *Float, r uint64, mem memory.Allocator) (*Boolean, error)

func FloatUintLessThan ¶

func FloatUintLessThan(l *Float, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintLessThanEqual ¶

func FloatUintLessThanEqual(l *Float, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintLessThanEqualLConst ¶

func FloatUintLessThanEqualLConst(l float64, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintLessThanEqualRConst ¶

func FloatUintLessThanEqualRConst(l *Float, r uint64, mem memory.Allocator) (*Boolean, error)

func FloatUintLessThanLConst ¶

func FloatUintLessThanLConst(l float64, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintLessThanRConst ¶

func FloatUintLessThanRConst(l *Float, r uint64, mem memory.Allocator) (*Boolean, error)

func FloatUintNotEqual ¶

func FloatUintNotEqual(l *Float, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintNotEqualLConst ¶

func FloatUintNotEqualLConst(l float64, r *Uint, mem memory.Allocator) (*Boolean, error)

func FloatUintNotEqualRConst ¶

func FloatUintNotEqualRConst(l *Float, r uint64, mem memory.Allocator) (*Boolean, error)

func IntExists ¶

func IntExists(v *Int, mem memory.Allocator) (*Boolean, error)

func IntFloatEqual ¶

func IntFloatEqual(l *Int, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatEqualLConst ¶

func IntFloatEqualLConst(l int64, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatEqualRConst ¶

func IntFloatEqualRConst(l *Int, r float64, mem memory.Allocator) (*Boolean, error)

func IntFloatGreaterThan ¶

func IntFloatGreaterThan(l *Int, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatGreaterThanEqual ¶

func IntFloatGreaterThanEqual(l *Int, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatGreaterThanEqualLConst ¶

func IntFloatGreaterThanEqualLConst(l int64, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatGreaterThanEqualRConst ¶

func IntFloatGreaterThanEqualRConst(l *Int, r float64, mem memory.Allocator) (*Boolean, error)

func IntFloatGreaterThanLConst ¶

func IntFloatGreaterThanLConst(l int64, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatGreaterThanRConst ¶

func IntFloatGreaterThanRConst(l *Int, r float64, mem memory.Allocator) (*Boolean, error)

func IntFloatLessThan ¶

func IntFloatLessThan(l *Int, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatLessThanEqual ¶

func IntFloatLessThanEqual(l *Int, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatLessThanEqualLConst ¶

func IntFloatLessThanEqualLConst(l int64, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatLessThanEqualRConst ¶

func IntFloatLessThanEqualRConst(l *Int, r float64, mem memory.Allocator) (*Boolean, error)

func IntFloatLessThanLConst ¶

func IntFloatLessThanLConst(l int64, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatLessThanRConst ¶

func IntFloatLessThanRConst(l *Int, r float64, mem memory.Allocator) (*Boolean, error)

func IntFloatNotEqual ¶

func IntFloatNotEqual(l *Int, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatNotEqualLConst ¶

func IntFloatNotEqualLConst(l int64, r *Float, mem memory.Allocator) (*Boolean, error)

func IntFloatNotEqualRConst ¶

func IntFloatNotEqualRConst(l *Int, r float64, mem memory.Allocator) (*Boolean, error)

func IntIntEqual ¶

func IntIntEqual(l *Int, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntEqualLConst ¶

func IntIntEqualLConst(l int64, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntEqualRConst ¶

func IntIntEqualRConst(l *Int, r int64, mem memory.Allocator) (*Boolean, error)

func IntIntGreaterThan ¶

func IntIntGreaterThan(l *Int, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntGreaterThanEqual ¶

func IntIntGreaterThanEqual(l *Int, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntGreaterThanEqualLConst ¶

func IntIntGreaterThanEqualLConst(l int64, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntGreaterThanEqualRConst ¶

func IntIntGreaterThanEqualRConst(l *Int, r int64, mem memory.Allocator) (*Boolean, error)

func IntIntGreaterThanLConst ¶

func IntIntGreaterThanLConst(l int64, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntGreaterThanRConst ¶

func IntIntGreaterThanRConst(l *Int, r int64, mem memory.Allocator) (*Boolean, error)

func IntIntLessThan ¶

func IntIntLessThan(l *Int, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntLessThanEqual ¶

func IntIntLessThanEqual(l *Int, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntLessThanEqualLConst ¶

func IntIntLessThanEqualLConst(l int64, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntLessThanEqualRConst ¶

func IntIntLessThanEqualRConst(l *Int, r int64, mem memory.Allocator) (*Boolean, error)

func IntIntLessThanLConst ¶

func IntIntLessThanLConst(l int64, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntLessThanRConst ¶

func IntIntLessThanRConst(l *Int, r int64, mem memory.Allocator) (*Boolean, error)

func IntIntNotEqual ¶

func IntIntNotEqual(l *Int, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntNotEqualLConst ¶

func IntIntNotEqualLConst(l int64, r *Int, mem memory.Allocator) (*Boolean, error)

func IntIntNotEqualRConst ¶

func IntIntNotEqualRConst(l *Int, r int64, mem memory.Allocator) (*Boolean, error)

func IntUintEqual ¶

func IntUintEqual(l *Int, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintEqualLConst ¶

func IntUintEqualLConst(l int64, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintEqualRConst ¶

func IntUintEqualRConst(l *Int, r uint64, mem memory.Allocator) (*Boolean, error)

func IntUintGreaterThan ¶

func IntUintGreaterThan(l *Int, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintGreaterThanEqual ¶

func IntUintGreaterThanEqual(l *Int, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintGreaterThanEqualLConst ¶

func IntUintGreaterThanEqualLConst(l int64, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintGreaterThanEqualRConst ¶

func IntUintGreaterThanEqualRConst(l *Int, r uint64, mem memory.Allocator) (*Boolean, error)

func IntUintGreaterThanLConst ¶

func IntUintGreaterThanLConst(l int64, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintGreaterThanRConst ¶

func IntUintGreaterThanRConst(l *Int, r uint64, mem memory.Allocator) (*Boolean, error)

func IntUintLessThan ¶

func IntUintLessThan(l *Int, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintLessThanEqual ¶

func IntUintLessThanEqual(l *Int, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintLessThanEqualLConst ¶

func IntUintLessThanEqualLConst(l int64, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintLessThanEqualRConst ¶

func IntUintLessThanEqualRConst(l *Int, r uint64, mem memory.Allocator) (*Boolean, error)

func IntUintLessThanLConst ¶

func IntUintLessThanLConst(l int64, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintLessThanRConst ¶

func IntUintLessThanRConst(l *Int, r uint64, mem memory.Allocator) (*Boolean, error)

func IntUintNotEqual ¶

func IntUintNotEqual(l *Int, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintNotEqualLConst ¶

func IntUintNotEqualLConst(l int64, r *Uint, mem memory.Allocator) (*Boolean, error)

func IntUintNotEqualRConst ¶

func IntUintNotEqualRConst(l *Int, r uint64, mem memory.Allocator) (*Boolean, error)

func Or ¶

func Or(l, r *Boolean, mem memory.Allocator) (*Boolean, error)

func OrConst ¶

func OrConst(fixed *bool, arr *Boolean, mem memory.Allocator) (*Boolean, error)

func StringExists ¶

func StringExists(v *String, mem memory.Allocator) (*Boolean, error)

func StringStringEqual ¶

func StringStringEqual(l *String, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringEqualLConst ¶

func StringStringEqualLConst(l string, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringEqualRConst ¶

func StringStringEqualRConst(l *String, r string, mem memory.Allocator) (*Boolean, error)

func StringStringGreaterThan ¶

func StringStringGreaterThan(l *String, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringGreaterThanEqual ¶

func StringStringGreaterThanEqual(l *String, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringGreaterThanEqualLConst ¶

func StringStringGreaterThanEqualLConst(l string, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringGreaterThanEqualRConst ¶

func StringStringGreaterThanEqualRConst(l *String, r string, mem memory.Allocator) (*Boolean, error)

func StringStringGreaterThanLConst ¶

func StringStringGreaterThanLConst(l string, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringGreaterThanRConst ¶

func StringStringGreaterThanRConst(l *String, r string, mem memory.Allocator) (*Boolean, error)

func StringStringLessThan ¶

func StringStringLessThan(l *String, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringLessThanEqual ¶

func StringStringLessThanEqual(l *String, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringLessThanEqualLConst ¶

func StringStringLessThanEqualLConst(l string, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringLessThanEqualRConst ¶

func StringStringLessThanEqualRConst(l *String, r string, mem memory.Allocator) (*Boolean, error)

func StringStringLessThanLConst ¶

func StringStringLessThanLConst(l string, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringLessThanRConst ¶

func StringStringLessThanRConst(l *String, r string, mem memory.Allocator) (*Boolean, error)

func StringStringNotEqual ¶

func StringStringNotEqual(l *String, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringNotEqualLConst ¶

func StringStringNotEqualLConst(l string, r *String, mem memory.Allocator) (*Boolean, error)

func StringStringNotEqualRConst ¶

func StringStringNotEqualRConst(l *String, r string, mem memory.Allocator) (*Boolean, error)

func UintExists ¶

func UintExists(v *Uint, mem memory.Allocator) (*Boolean, error)

func UintFloatEqual ¶

func UintFloatEqual(l *Uint, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatEqualLConst ¶

func UintFloatEqualLConst(l uint64, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatEqualRConst ¶

func UintFloatEqualRConst(l *Uint, r float64, mem memory.Allocator) (*Boolean, error)

func UintFloatGreaterThan ¶

func UintFloatGreaterThan(l *Uint, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatGreaterThanEqual ¶

func UintFloatGreaterThanEqual(l *Uint, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatGreaterThanEqualLConst ¶

func UintFloatGreaterThanEqualLConst(l uint64, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatGreaterThanEqualRConst ¶

func UintFloatGreaterThanEqualRConst(l *Uint, r float64, mem memory.Allocator) (*Boolean, error)

func UintFloatGreaterThanLConst ¶

func UintFloatGreaterThanLConst(l uint64, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatGreaterThanRConst ¶

func UintFloatGreaterThanRConst(l *Uint, r float64, mem memory.Allocator) (*Boolean, error)

func UintFloatLessThan ¶

func UintFloatLessThan(l *Uint, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatLessThanEqual ¶

func UintFloatLessThanEqual(l *Uint, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatLessThanEqualLConst ¶

func UintFloatLessThanEqualLConst(l uint64, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatLessThanEqualRConst ¶

func UintFloatLessThanEqualRConst(l *Uint, r float64, mem memory.Allocator) (*Boolean, error)

func UintFloatLessThanLConst ¶

func UintFloatLessThanLConst(l uint64, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatLessThanRConst ¶

func UintFloatLessThanRConst(l *Uint, r float64, mem memory.Allocator) (*Boolean, error)

func UintFloatNotEqual ¶

func UintFloatNotEqual(l *Uint, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatNotEqualLConst ¶

func UintFloatNotEqualLConst(l uint64, r *Float, mem memory.Allocator) (*Boolean, error)

func UintFloatNotEqualRConst ¶

func UintFloatNotEqualRConst(l *Uint, r float64, mem memory.Allocator) (*Boolean, error)

func UintIntEqual ¶

func UintIntEqual(l *Uint, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntEqualLConst ¶

func UintIntEqualLConst(l uint64, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntEqualRConst ¶

func UintIntEqualRConst(l *Uint, r int64, mem memory.Allocator) (*Boolean, error)

func UintIntGreaterThan ¶

func UintIntGreaterThan(l *Uint, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntGreaterThanEqual ¶

func UintIntGreaterThanEqual(l *Uint, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntGreaterThanEqualLConst ¶

func UintIntGreaterThanEqualLConst(l uint64, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntGreaterThanEqualRConst ¶

func UintIntGreaterThanEqualRConst(l *Uint, r int64, mem memory.Allocator) (*Boolean, error)

func UintIntGreaterThanLConst ¶

func UintIntGreaterThanLConst(l uint64, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntGreaterThanRConst ¶

func UintIntGreaterThanRConst(l *Uint, r int64, mem memory.Allocator) (*Boolean, error)

func UintIntLessThan ¶

func UintIntLessThan(l *Uint, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntLessThanEqual ¶

func UintIntLessThanEqual(l *Uint, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntLessThanEqualLConst ¶

func UintIntLessThanEqualLConst(l uint64, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntLessThanEqualRConst ¶

func UintIntLessThanEqualRConst(l *Uint, r int64, mem memory.Allocator) (*Boolean, error)

func UintIntLessThanLConst ¶

func UintIntLessThanLConst(l uint64, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntLessThanRConst ¶

func UintIntLessThanRConst(l *Uint, r int64, mem memory.Allocator) (*Boolean, error)

func UintIntNotEqual ¶

func UintIntNotEqual(l *Uint, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntNotEqualLConst ¶

func UintIntNotEqualLConst(l uint64, r *Int, mem memory.Allocator) (*Boolean, error)

func UintIntNotEqualRConst ¶

func UintIntNotEqualRConst(l *Uint, r int64, mem memory.Allocator) (*Boolean, error)

func UintUintEqual ¶

func UintUintEqual(l *Uint, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintEqualLConst ¶

func UintUintEqualLConst(l uint64, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintEqualRConst ¶

func UintUintEqualRConst(l *Uint, r uint64, mem memory.Allocator) (*Boolean, error)

func UintUintGreaterThan ¶

func UintUintGreaterThan(l *Uint, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintGreaterThanEqual ¶

func UintUintGreaterThanEqual(l *Uint, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintGreaterThanEqualLConst ¶

func UintUintGreaterThanEqualLConst(l uint64, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintGreaterThanEqualRConst ¶

func UintUintGreaterThanEqualRConst(l *Uint, r uint64, mem memory.Allocator) (*Boolean, error)

func UintUintGreaterThanLConst ¶

func UintUintGreaterThanLConst(l uint64, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintGreaterThanRConst ¶

func UintUintGreaterThanRConst(l *Uint, r uint64, mem memory.Allocator) (*Boolean, error)

func UintUintLessThan ¶

func UintUintLessThan(l *Uint, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintLessThanEqual ¶

func UintUintLessThanEqual(l *Uint, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintLessThanEqualLConst ¶

func UintUintLessThanEqualLConst(l uint64, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintLessThanEqualRConst ¶

func UintUintLessThanEqualRConst(l *Uint, r uint64, mem memory.Allocator) (*Boolean, error)

func UintUintLessThanLConst ¶

func UintUintLessThanLConst(l uint64, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintLessThanRConst ¶

func UintUintLessThanRConst(l *Uint, r uint64, mem memory.Allocator) (*Boolean, error)

func UintUintNotEqual ¶

func UintUintNotEqual(l *Uint, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintNotEqualLConst ¶

func UintUintNotEqualLConst(l uint64, r *Uint, mem memory.Allocator) (*Boolean, error)

func UintUintNotEqualRConst ¶

func UintUintNotEqualRConst(l *Uint, r uint64, mem memory.Allocator) (*Boolean, error)

type BooleanBuilder ¶

type BooleanBuilder struct {
	// contains filtered or unexported fields
}

func NewBooleanBuilder ¶

func NewBooleanBuilder(mem memory.Allocator) *BooleanBuilder

func (*BooleanBuilder) Append ¶

func (b *BooleanBuilder) Append(v bool)

func (*BooleanBuilder) AppendNull ¶

func (b *BooleanBuilder) AppendNull()

func (*BooleanBuilder) AppendValues ¶

func (b *BooleanBuilder) AppendValues(v []bool, valid []bool)

func (*BooleanBuilder) Cap ¶

func (b *BooleanBuilder) Cap() int

func (*BooleanBuilder) CopyValidValues ¶

func (b *BooleanBuilder) CopyValidValues(values *Boolean, nullCheckArray Array)

func (*BooleanBuilder) Len ¶

func (b *BooleanBuilder) Len() int

func (*BooleanBuilder) NewArray ¶

func (b *BooleanBuilder) NewArray() Array

func (*BooleanBuilder) NewBooleanArray ¶

func (b *BooleanBuilder) NewBooleanArray() *Boolean

func (*BooleanBuilder) NullN ¶

func (b *BooleanBuilder) NullN() int

func (*BooleanBuilder) Release ¶

func (b *BooleanBuilder) Release()

func (*BooleanBuilder) Reserve ¶

func (b *BooleanBuilder) Reserve(n int)

func (*BooleanBuilder) Resize ¶

func (b *BooleanBuilder) Resize(n int)

func (*BooleanBuilder) Retain ¶

func (b *BooleanBuilder) Retain()

func (*BooleanBuilder) UnsafeAppend ¶

func (b *BooleanBuilder) UnsafeAppend(v bool)

func (*BooleanBuilder) UnsafeAppendBoolToBitmap ¶

func (b *BooleanBuilder) UnsafeAppendBoolToBitmap(isValid bool)

type Builder ¶

type Builder interface {
	// Retain increases the reference count by 1.
	// Retain may be called simultaneously from multiple goroutines.
	Retain()

	// Release decreases the reference count by 1.
	Release()

	// Len returns the number of elements in the array builder.
	Len() int

	// Cap returns the total number of elements that can be stored
	// without allocating additional memory.
	Cap() int

	// NullN returns the number of null values in the array builder.
	NullN() int

	// AppendNull adds a new null value to the array being built.
	AppendNull()

	// Reserve ensures there is enough space for appending n elements
	// by checking the capacity and calling Resize if necessary.
	Reserve(n int)

	// Resize adjusts the space allocated by b to n elements. If n is greater than b.Cap(),
	// additional memory will be allocated. If n is smaller, the allocated memory may reduced.
	Resize(n int)

	// NewArray creates a new array from the memory buffers used
	// by the builder and resets the Builder so it can be used to build
	// a new array.
	NewArray() Array
}

Builder provides an interface to build arrow arrays.

This type is derived from the arrow array.Builder interface.

type DataType ¶

type DataType = arrow.DataType

type Float ¶

type Float = array.Float64

func FloatAdd ¶

func FloatAdd(l, r *Float, mem memory.Allocator) (*Float, error)

func FloatAddLConst ¶

func FloatAddLConst(l float64, r *Float, mem memory.Allocator) (*Float, error)

func FloatAddRConst ¶

func FloatAddRConst(l *Float, r float64, mem memory.Allocator) (*Float, error)

func FloatConditional ¶

func FloatConditional(t *Boolean, c, a *Float, mem memory.Allocator) (*Float, error)

func FloatConditionalAConst ¶

func FloatConditionalAConst(t *Boolean, c *Float, a *float64, mem memory.Allocator) (*Float, error)

func FloatConditionalCConst ¶

func FloatConditionalCConst(t *Boolean, c *float64, a *Float, mem memory.Allocator) (*Float, error)

func FloatConditionalCConstAConst ¶

func FloatConditionalCConstAConst(t *Boolean, c, a *float64, mem memory.Allocator) (*Float, error)

func FloatDiv ¶

func FloatDiv(l, r *Float, mem memory.Allocator) (*Float, error)

func FloatDivLConst ¶

func FloatDivLConst(l float64, r *Float, mem memory.Allocator) (*Float, error)

func FloatDivRConst ¶

func FloatDivRConst(l *Float, r float64, mem memory.Allocator) (*Float, error)

func FloatMod ¶

func FloatMod(l, r *Float, mem memory.Allocator) (*Float, error)

func FloatModLConst ¶

func FloatModLConst(l float64, r *Float, mem memory.Allocator) (*Float, error)

func FloatModRConst ¶

func FloatModRConst(l *Float, r float64, mem memory.Allocator) (*Float, error)

func FloatMul ¶

func FloatMul(l, r *Float, mem memory.Allocator) (*Float, error)

func FloatMulLConst ¶

func FloatMulLConst(l float64, r *Float, mem memory.Allocator) (*Float, error)

func FloatMulRConst ¶

func FloatMulRConst(l *Float, r float64, mem memory.Allocator) (*Float, error)

func FloatPow ¶

func FloatPow(l, r *Float, mem memory.Allocator) (*Float, error)

func FloatPowLConst ¶

func FloatPowLConst(l float64, r *Float, mem memory.Allocator) (*Float, error)

func FloatPowRConst ¶

func FloatPowRConst(l *Float, r float64, mem memory.Allocator) (*Float, error)

func FloatRepeat ¶

func FloatRepeat(v float64, isNull bool, n int, mem memory.Allocator) *Float

func FloatSub ¶

func FloatSub(l, r *Float, mem memory.Allocator) (*Float, error)

func FloatSubLConst ¶

func FloatSubLConst(l float64, r *Float, mem memory.Allocator) (*Float, error)

func FloatSubRConst ¶

func FloatSubRConst(l *Float, r float64, mem memory.Allocator) (*Float, error)

func FloatUnarySub ¶

func FloatUnarySub(v *Float, mem memory.Allocator) (*Float, error)

func IntPow ¶

func IntPow(l, r *Int, mem memory.Allocator) (*Float, error)

func IntPowLConst ¶

func IntPowLConst(l int64, r *Int, mem memory.Allocator) (*Float, error)

func IntPowRConst ¶

func IntPowRConst(l *Int, r int64, mem memory.Allocator) (*Float, error)

func ToFloatConv ¶

func ToFloatConv(mem memory.Allocator, arr Array) (*Float, error)

func UintPow ¶

func UintPow(l, r *Uint, mem memory.Allocator) (*Float, error)

func UintPowLConst ¶

func UintPowLConst(l uint64, r *Uint, mem memory.Allocator) (*Float, error)

func UintPowRConst ¶

func UintPowRConst(l *Uint, r uint64, mem memory.Allocator) (*Float, error)

type FloatBuilder ¶

type FloatBuilder struct {
	// contains filtered or unexported fields
}

func NewFloatBuilder ¶

func NewFloatBuilder(mem memory.Allocator) *FloatBuilder

func (*FloatBuilder) Append ¶

func (b *FloatBuilder) Append(v float64)

func (*FloatBuilder) AppendNull ¶

func (b *FloatBuilder) AppendNull()

func (*FloatBuilder) AppendValues ¶

func (b *FloatBuilder) AppendValues(v []float64, valid []bool)

func (*FloatBuilder) Cap ¶

func (b *FloatBuilder) Cap() int

func (*FloatBuilder) CopyValidValues ¶

func (b *FloatBuilder) CopyValidValues(values *Float, nullCheckArray Array)

func (*FloatBuilder) Len ¶

func (b *FloatBuilder) Len() int

func (*FloatBuilder) NewArray ¶

func (b *FloatBuilder) NewArray() Array

func (*FloatBuilder) NewFloatArray ¶

func (b *FloatBuilder) NewFloatArray() *Float

func (*FloatBuilder) NullN ¶

func (b *FloatBuilder) NullN() int

func (*FloatBuilder) Release ¶

func (b *FloatBuilder) Release()

func (*FloatBuilder) Reserve ¶

func (b *FloatBuilder) Reserve(n int)

func (*FloatBuilder) Resize ¶

func (b *FloatBuilder) Resize(n int)

func (*FloatBuilder) Retain ¶

func (b *FloatBuilder) Retain()

func (*FloatBuilder) UnsafeAppend ¶

func (b *FloatBuilder) UnsafeAppend(v float64)

func (*FloatBuilder) UnsafeAppendBoolToBitmap ¶

func (b *FloatBuilder) UnsafeAppendBoolToBitmap(isValid bool)

type Int ¶

type Int = array.Int64

func IntAdd ¶

func IntAdd(l, r *Int, mem memory.Allocator) (*Int, error)

func IntAddLConst ¶

func IntAddLConst(l int64, r *Int, mem memory.Allocator) (*Int, error)

func IntAddRConst ¶

func IntAddRConst(l *Int, r int64, mem memory.Allocator) (*Int, error)

func IntConditional ¶

func IntConditional(t *Boolean, c, a *Int, mem memory.Allocator) (*Int, error)

func IntConditionalAConst ¶

func IntConditionalAConst(t *Boolean, c *Int, a *int64, mem memory.Allocator) (*Int, error)

func IntConditionalCConst ¶

func IntConditionalCConst(t *Boolean, c *int64, a *Int, mem memory.Allocator) (*Int, error)

func IntConditionalCConstAConst ¶

func IntConditionalCConstAConst(t *Boolean, c, a *int64, mem memory.Allocator) (*Int, error)

func IntDiv ¶

func IntDiv(l, r *Int, mem memory.Allocator) (*Int, error)

func IntDivLConst ¶

func IntDivLConst(l int64, r *Int, mem memory.Allocator) (*Int, error)

func IntDivRConst ¶

func IntDivRConst(l *Int, r int64, mem memory.Allocator) (*Int, error)

func IntMod ¶

func IntMod(l, r *Int, mem memory.Allocator) (*Int, error)

func IntModLConst ¶

func IntModLConst(l int64, r *Int, mem memory.Allocator) (*Int, error)

func IntModRConst ¶

func IntModRConst(l *Int, r int64, mem memory.Allocator) (*Int, error)

func IntMul ¶

func IntMul(l, r *Int, mem memory.Allocator) (*Int, error)

func IntMulLConst ¶

func IntMulLConst(l int64, r *Int, mem memory.Allocator) (*Int, error)

func IntMulRConst ¶

func IntMulRConst(l *Int, r int64, mem memory.Allocator) (*Int, error)

func IntRepeat ¶

func IntRepeat(v int64, isNull bool, n int, mem memory.Allocator) *Int

func IntSub ¶

func IntSub(l, r *Int, mem memory.Allocator) (*Int, error)

func IntSubLConst ¶

func IntSubLConst(l int64, r *Int, mem memory.Allocator) (*Int, error)

func IntSubRConst ¶

func IntSubRConst(l *Int, r int64, mem memory.Allocator) (*Int, error)

func IntUnarySub ¶

func IntUnarySub(v *Int, mem memory.Allocator) (*Int, error)

type IntBuilder ¶

type IntBuilder struct {
	// contains filtered or unexported fields
}

func NewIntBuilder ¶

func NewIntBuilder(mem memory.Allocator) *IntBuilder

func (*IntBuilder) Append ¶

func (b *IntBuilder) Append(v int64)

func (*IntBuilder) AppendNull ¶

func (b *IntBuilder) AppendNull()

func (*IntBuilder) AppendValues ¶

func (b *IntBuilder) AppendValues(v []int64, valid []bool)

func (*IntBuilder) Cap ¶

func (b *IntBuilder) Cap() int

func (*IntBuilder) CopyValidValues ¶

func (b *IntBuilder) CopyValidValues(values *Int, nullCheckArray Array)

func (*IntBuilder) Len ¶

func (b *IntBuilder) Len() int

func (*IntBuilder) NewArray ¶

func (b *IntBuilder) NewArray() Array

func (*IntBuilder) NewIntArray ¶

func (b *IntBuilder) NewIntArray() *Int

func (*IntBuilder) NullN ¶

func (b *IntBuilder) NullN() int

func (*IntBuilder) Release ¶

func (b *IntBuilder) Release()

func (*IntBuilder) Reserve ¶

func (b *IntBuilder) Reserve(n int)

func (*IntBuilder) Resize ¶

func (b *IntBuilder) Resize(n int)

func (*IntBuilder) Retain ¶

func (b *IntBuilder) Retain()

func (*IntBuilder) UnsafeAppend ¶

func (b *IntBuilder) UnsafeAppend(v int64)

func (*IntBuilder) UnsafeAppendBoolToBitmap ¶

func (b *IntBuilder) UnsafeAppendBoolToBitmap(isValid bool)

type String ¶

type String struct {
	// contains filtered or unexported fields
}

func NewStringFromBinaryArray ¶

func NewStringFromBinaryArray(data *array.Binary) *String

NewStringFromBinaryArray creates an instance of String from an Arrow Binary array.

Note: Generally client code should be using the types for arrays defined in Flux. This method allows string data created outside of Flux (such as from Arrow Flight) to be used in Flux.

func StringAdd ¶

func StringAdd(l, r *String, mem memory.Allocator) (*String, error)

func StringAddLConst ¶

func StringAddLConst(l string, r *String, mem memory.Allocator) (*String, error)

func StringAddRConst ¶

func StringAddRConst(l *String, r string, mem memory.Allocator) (*String, error)

func StringConditional ¶

func StringConditional(t *Boolean, c, a *String, mem memory.Allocator) (*String, error)

func StringConditionalAConst ¶

func StringConditionalAConst(t *Boolean, c *String, a *string, mem memory.Allocator) (*String, error)

func StringConditionalCConst ¶

func StringConditionalCConst(t *Boolean, c *string, a *String, mem memory.Allocator) (*String, error)

func StringConditionalCConstAConst ¶

func StringConditionalCConstAConst(t *Boolean, c, a *string, mem memory.Allocator) (*String, error)

func StringRepeat ¶

func StringRepeat(v string, n int, mem memory.Allocator) *String

func (*String) DataType ¶

func (a *String) DataType() DataType

func (*String) IsConstant ¶

func (a *String) IsConstant() bool

func (*String) Slice ¶

func (a *String) Slice(i, j int) Array

func (*String) Value ¶

func (a *String) Value(i int) string

Value returns a string view of the bytes in the array. The string is only valid for the lifetime of the array. Care should be taken not to store this string without also retaining the array.

type StringBuilder ¶

type StringBuilder struct {
	// contains filtered or unexported fields
}

func NewStringBuilder ¶

func NewStringBuilder(mem memory.Allocator) *StringBuilder

func (*StringBuilder) Append ¶

func (b *StringBuilder) Append(v string)

Append appends a string to the array being built. A reference to the input string will not be retained by the builder. The string will be copied, if necessary.

func (*StringBuilder) AppendBytes ¶

func (b *StringBuilder) AppendBytes(buf []byte)

func (*StringBuilder) AppendNull ¶

func (b *StringBuilder) AppendNull()

func (*StringBuilder) AppendValues ¶

func (b *StringBuilder) AppendValues(v []string, valid []bool)

func (*StringBuilder) Cap ¶

func (b *StringBuilder) Cap() int

func (*StringBuilder) CopyValidValues ¶

func (b *StringBuilder) CopyValidValues(values *String, nullCheckArray Array)

func (*StringBuilder) Len ¶

func (b *StringBuilder) Len() int

func (*StringBuilder) NewArray ¶

func (b *StringBuilder) NewArray() Array

func (*StringBuilder) NewStringArray ¶

func (b *StringBuilder) NewStringArray() *String

func (*StringBuilder) NullN ¶

func (b *StringBuilder) NullN() int

func (*StringBuilder) Release ¶

func (b *StringBuilder) Release()

func (*StringBuilder) Reserve ¶

func (b *StringBuilder) Reserve(n int)

func (*StringBuilder) ReserveData ¶

func (b *StringBuilder) ReserveData(n int)

func (*StringBuilder) Resize ¶

func (b *StringBuilder) Resize(n int)

func (*StringBuilder) Retain ¶

func (b *StringBuilder) Retain()

type Uint ¶

type Uint = array.Uint64

func UintAdd ¶

func UintAdd(l, r *Uint, mem memory.Allocator) (*Uint, error)

func UintAddLConst ¶

func UintAddLConst(l uint64, r *Uint, mem memory.Allocator) (*Uint, error)

func UintAddRConst ¶

func UintAddRConst(l *Uint, r uint64, mem memory.Allocator) (*Uint, error)

func UintConditional ¶

func UintConditional(t *Boolean, c, a *Uint, mem memory.Allocator) (*Uint, error)

func UintConditionalAConst ¶

func UintConditionalAConst(t *Boolean, c *Uint, a *uint64, mem memory.Allocator) (*Uint, error)

func UintConditionalCConst ¶

func UintConditionalCConst(t *Boolean, c *uint64, a *Uint, mem memory.Allocator) (*Uint, error)

func UintConditionalCConstAConst ¶

func UintConditionalCConstAConst(t *Boolean, c, a *uint64, mem memory.Allocator) (*Uint, error)

func UintDiv ¶

func UintDiv(l, r *Uint, mem memory.Allocator) (*Uint, error)

func UintDivLConst ¶

func UintDivLConst(l uint64, r *Uint, mem memory.Allocator) (*Uint, error)

func UintDivRConst ¶

func UintDivRConst(l *Uint, r uint64, mem memory.Allocator) (*Uint, error)

func UintMod ¶

func UintMod(l, r *Uint, mem memory.Allocator) (*Uint, error)

func UintModLConst ¶

func UintModLConst(l uint64, r *Uint, mem memory.Allocator) (*Uint, error)

func UintModRConst ¶

func UintModRConst(l *Uint, r uint64, mem memory.Allocator) (*Uint, error)

func UintMul ¶

func UintMul(l, r *Uint, mem memory.Allocator) (*Uint, error)

func UintMulLConst ¶

func UintMulLConst(l uint64, r *Uint, mem memory.Allocator) (*Uint, error)

func UintMulRConst ¶

func UintMulRConst(l *Uint, r uint64, mem memory.Allocator) (*Uint, error)

func UintRepeat ¶

func UintRepeat(v uint64, isNull bool, n int, mem memory.Allocator) *Uint

func UintSub ¶

func UintSub(l, r *Uint, mem memory.Allocator) (*Uint, error)

func UintSubLConst ¶

func UintSubLConst(l uint64, r *Uint, mem memory.Allocator) (*Uint, error)

func UintSubRConst ¶

func UintSubRConst(l *Uint, r uint64, mem memory.Allocator) (*Uint, error)

type UintBuilder ¶

type UintBuilder struct {
	// contains filtered or unexported fields
}

func NewUintBuilder ¶

func NewUintBuilder(mem memory.Allocator) *UintBuilder

func (*UintBuilder) Append ¶

func (b *UintBuilder) Append(v uint64)

func (*UintBuilder) AppendNull ¶

func (b *UintBuilder) AppendNull()

func (*UintBuilder) AppendValues ¶

func (b *UintBuilder) AppendValues(v []uint64, valid []bool)

func (*UintBuilder) Cap ¶

func (b *UintBuilder) Cap() int

func (*UintBuilder) CopyValidValues ¶

func (b *UintBuilder) CopyValidValues(values *Uint, nullCheckArray Array)

func (*UintBuilder) Len ¶

func (b *UintBuilder) Len() int

func (*UintBuilder) NewArray ¶

func (b *UintBuilder) NewArray() Array

func (*UintBuilder) NewUintArray ¶

func (b *UintBuilder) NewUintArray() *Uint

func (*UintBuilder) NullN ¶

func (b *UintBuilder) NullN() int

func (*UintBuilder) Release ¶

func (b *UintBuilder) Release()

func (*UintBuilder) Reserve ¶

func (b *UintBuilder) Reserve(n int)

func (*UintBuilder) Resize ¶

func (b *UintBuilder) Resize(n int)

func (*UintBuilder) Retain ¶

func (b *UintBuilder) Retain()

func (*UintBuilder) UnsafeAppend ¶

func (b *UintBuilder) UnsafeAppend(v uint64)

func (*UintBuilder) UnsafeAppendBoolToBitmap ¶

func (b *UintBuilder) UnsafeAppendBoolToBitmap(isValid bool)

Source Files ¶

array.go binary.gen.go binary.go builder.gen.go builder.go conditional.gen.go repeat.gen.go repeat.go unary.gen.go

Version: v0.196.1 (latest)
Published: Feb 19, 2025
Platform: linux/amd64
Imports: 13 packages
Last checked: 1 day ago –

Tools for package owners.

?	: This menu
/	: Search site
f	: Jump to identifier
g then g	: Go to top of page
g then b	: Go to end of page
G	: Go to end of page
g then i	: Go to index
g then e	: Go to examples