package extensions

Import Path
	github.com/apache/arrow-go/v18/arrow/extensions (on go.dev)

Dependency Relation
	imports 21 packages, and imported by one package

Involved Source Files

	    bool8.go
	  d doc.go
		Package extensions provides implementations of Arrow canonical extension
		types as defined in the Arrow specification.
		https://arrow.apache.org/docs/format/CanonicalExtensions.html

	    extensions.go
	    json.go
	    opaque.go
	    uuid.go
	    variant.go
Package-Level Type Names (total 13)

	/* sort by: alphabet | popularity */
	 type Bool8Array (struct)
		Bool8Array is logically an array of boolean values but uses
		8 bits to store values instead of 1 bit as in the native BooleanArray.

		Fields (only one)
			ExtensionArrayBase array.ExtensionArrayBase
		Methods (total 18)
			(*Bool8Array) BoolValues() []bool
			(*Bool8Array) Data() arrow.ArrayData
			(*Bool8Array) DataType() arrow.DataType
				DataType returns the type metadata for this instance.

			(*Bool8Array) ExtensionType() arrow.ExtensionType
				ExtensionType returns the same thing as DataType, just already casted
				to an ExtensionType interface for convenience.

			(*Bool8Array) GetOneForMarshal(i int) interface{}
			(*Bool8Array) IsNull(i int) bool
				IsNull returns true if value at index is null.
				NOTE: IsNull will panic if NullBitmapBytes is not empty and 0 > i ≥ Len.

			(*Bool8Array) IsValid(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.

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

			(*Bool8Array) MarshalJSON() ([]byte, error)
			(*Bool8Array) NullBitmapBytes() []byte
				NullBitmapBytes returns a byte slice of the validity bitmap.

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

			(*Bool8Array) Offset() int
			(*Bool8Array) Release()
				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.

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

			(*Bool8Array) Storage() arrow.Array
				Storage returns the underlying storage array

			(*Bool8Array) String() string
			(*Bool8Array) Value(i int) bool
			(*Bool8Array) ValueStr(i int) string
		Implements (at least 7)
			*Bool8Array : github.com/apache/arrow-go/v18/arrow.Array[T]
			*Bool8Array : github.com/apache/arrow-go/v18/arrow/array.ExtensionArray
			*Bool8Array : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*Bool8Array : github.com/goccy/go-json.Marshaler
			*Bool8Array : encoding/json.Marshaler
			*Bool8Array : expvar.Var
			*Bool8Array : fmt.Stringer

	 type Bool8Builder (struct)
		Bool8Builder is a convenience builder for the Bool8 extension type,
		allowing arrays to be built with boolean values rather than the underlying storage type.

		Fields (total 2)
			ExtensionBuilder *array.ExtensionBuilder
			ExtensionBuilder.Builder array.Builder
		Methods (total 25)
			(*Bool8Builder) Append(v bool)
			( Bool8Builder) AppendEmptyValue()
				AppendEmptyValue adds a new zero value of the appropriate type

			( Bool8Builder) AppendEmptyValues(n int)
				AppendEmptyValues adds new n zero values of the appropriate type

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

			( Bool8Builder) AppendNulls(n int)
				AppendNulls adds new n null values to the array being built.

			(*Bool8Builder) AppendValueFromString(s string) error
			(*Bool8Builder) AppendValues(v []bool, valid []bool)
			( Bool8Builder) Cap() int
				Cap returns the total number of elements that can be stored
				without allocating additional memory.

			( Bool8Builder) IsNull(i int) bool
				IsNull returns if a previously appended value at a given index is null or not.

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

			( Bool8Builder) NewArray() arrow.Array
				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.

			( Bool8Builder) NewExtensionArray() array.ExtensionArray
				NewExtensionArray creates an Extension array from the memory buffers used
				by the builder and resets the ExtensionBuilder so it can be used to build
				a new ExtensionArray of the same type.

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

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

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

			( Bool8Builder) Resize(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.

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

			( Bool8Builder) SetNull(i int)
				SetNull sets the value at index i to null.

			( Bool8Builder) StorageBuilder() array.Builder
				StorageBuilder returns the builder for the underlying storage type.

			( Bool8Builder) Type() arrow.DataType
			(*Bool8Builder) Unmarshal(dec *json.Decoder) error
			( Bool8Builder) UnmarshalJSON([]byte) error
			(*Bool8Builder) UnmarshalOne(dec *json.Decoder) error
			(*Bool8Builder) UnsafeAppend(v bool)
			( Bool8Builder) UnsafeAppendBoolToBitmap(bool)
		Implements (at least 6)
			*Bool8Builder : github.com/apache/arrow-go/v18/arrow/array.Builder
			 Bool8Builder : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			 Bool8Builder : github.com/goccy/go-json.Unmarshaler
			 Bool8Builder : github.com/polarsignals/frostdb/pqarrow/builder.ColumnBuilder
			*Bool8Builder : github.com/polarsignals/frostdb/pqarrow/builder.ListLikeBuilder
			 Bool8Builder : encoding/json.Unmarshaler
		As Outputs Of (at least one exported)
			func NewBool8Builder(mem memory.Allocator) *Bool8Builder

	 type Bool8Type (struct)
		Bool8Type represents a logical boolean that is stored using 8 bits.

		Fields (total 2)
			ExtensionBase arrow.ExtensionBase
			ExtensionBase.Storage arrow.DataType
				Storage is the underlying storage type

		Methods (total 14)
			(*Bool8Type) ArrayType() reflect.Type
			(*Bool8Type) Deserialize(storageType arrow.DataType, data string) (arrow.ExtensionType, error)
			(*Bool8Type) ExtensionEquals(other arrow.ExtensionType) bool
			(*Bool8Type) ExtensionName() string
			(*Bool8Type) Fields() []arrow.Field
			(*Bool8Type) Fingerprint() string
			(*Bool8Type) ID() arrow.Type
				ID always returns arrow.EXTENSION and should not be overridden

			(*Bool8Type) Layout() arrow.DataTypeLayout
			(*Bool8Type) Name() string
				Name should always return "extension" and should not be overridden

			(*Bool8Type) NewBuilder(mem memory.Allocator) array.Builder
			(*Bool8Type) NumFields() int
			(*Bool8Type) Serialize() string
			(*Bool8Type) StorageType() arrow.DataType
				StorageType returns the underlying storage type and exists so that functions
				written against the ExtensionType interface can access the storage type.

			(*Bool8Type) String() string
		Implements (at least 7)
			*Bool8Type : github.com/apache/arrow-go/v18/arrow.DataType
			*Bool8Type : github.com/apache/arrow-go/v18/arrow.ExtensionType
			*Bool8Type : github.com/apache/arrow-go/v18/arrow.NestedType
			*Bool8Type : github.com/apache/arrow-go/v18/arrow/array.CustomExtensionBuilder
			*Bool8Type : github.com/polarsignals/frostdb/query/logicalplan.Named
			*Bool8Type : expvar.Var
			*Bool8Type : fmt.Stringer
		As Outputs Of (at least one exported)
			func NewBool8Type() *Bool8Type

	 type JSONArray (struct)
		JSONArray is logically an array of UTF-8 encoded JSON strings.
		Its values are unmarshaled to native Go values.

		Fields (only one)
			ExtensionArrayBase array.ExtensionArrayBase
		Methods (total 19)
			(*JSONArray) Data() arrow.ArrayData
			(*JSONArray) DataType() arrow.DataType
				DataType returns the type metadata for this instance.

			(*JSONArray) ExtensionType() arrow.ExtensionType
				ExtensionType returns the same thing as DataType, just already casted
				to an ExtensionType interface for convenience.

			(*JSONArray) GetOneForMarshal(i int) interface{}
				GetOneForMarshal implements arrow.Array.

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

			(*JSONArray) IsValid(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.

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

			(*JSONArray) MarshalJSON() ([]byte, error)
				MarshalJSON implements json.Marshaler.
				Marshaling json.RawMessage is a no-op, except that nil values will
				be marshaled as a JSON null.

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

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

			(*JSONArray) Offset() int
			(*JSONArray) Release()
				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.

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

			(*JSONArray) Storage() arrow.Array
				Storage returns the underlying storage array

			(*JSONArray) String() string
			(*JSONArray) Value(i int) any
			(*JSONArray) ValueBytes(i int) []byte
			(*JSONArray) ValueJSON(i int) json.RawMessage
				ValueJSON wraps the underlying string value as a json.RawMessage,
				or returns nil if the array value is null.

			(*JSONArray) ValueStr(i int) string
		Implements (at least 7)
			*JSONArray : github.com/apache/arrow-go/v18/arrow.Array[T]
			*JSONArray : github.com/apache/arrow-go/v18/arrow/array.ExtensionArray
			*JSONArray : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*JSONArray : github.com/goccy/go-json.Marshaler
			*JSONArray : encoding/json.Marshaler
			*JSONArray : expvar.Var
			*JSONArray : fmt.Stringer

	 type JSONType (struct)
		JSONType represents a UTF-8 encoded JSON string as specified in RFC8259.

		Fields (total 2)
			ExtensionBase arrow.ExtensionBase
			ExtensionBase.Storage arrow.DataType
				Storage is the underlying storage type

		Methods (total 14)
			(*JSONType) ArrayType() reflect.Type
			(*JSONType) Deserialize(storageType arrow.DataType, data string) (arrow.ExtensionType, error)
			(*JSONType) ExtensionEquals(other arrow.ExtensionType) bool
			(*JSONType) ExtensionName() string
			(*JSONType) Fields() []arrow.Field
			(*JSONType) Fingerprint() string
			(*JSONType) ID() arrow.Type
				ID always returns arrow.EXTENSION and should not be overridden

			(*JSONType) Layout() arrow.DataTypeLayout
			(*JSONType) Name() string
				Name should always return "extension" and should not be overridden

			(*JSONType) NumFields() int
			(*JSONType) ParquetLogicalType() schema.LogicalType
				ParquetLogicalType implements pqarrow.ExtensionCustomParquetType.

			(*JSONType) Serialize() string
			(*JSONType) StorageType() arrow.DataType
				StorageType returns the underlying storage type and exists so that functions
				written against the ExtensionType interface can access the storage type.

			(*JSONType) String() string
		Implements (at least 6)
			*JSONType : github.com/apache/arrow-go/v18/arrow.DataType
			*JSONType : github.com/apache/arrow-go/v18/arrow.ExtensionType
			*JSONType : github.com/apache/arrow-go/v18/arrow.NestedType
			*JSONType : github.com/polarsignals/frostdb/query/logicalplan.Named
			*JSONType : expvar.Var
			*JSONType : fmt.Stringer
		As Outputs Of (at least one exported)
			func NewJSONType(storageType arrow.DataType) (*JSONType, error)

	 type OpaqueArray (struct)
		OpaqueArray is a placeholder for data from an external (usually
		non-Arrow) system that could not be interpreted.

		Fields (only one)
			ExtensionArrayBase array.ExtensionArrayBase
		Methods (total 16)
			(*OpaqueArray) Data() arrow.ArrayData
			(*OpaqueArray) DataType() arrow.DataType
				DataType returns the type metadata for this instance.

			(*OpaqueArray) ExtensionType() arrow.ExtensionType
				ExtensionType returns the same thing as DataType, just already casted
				to an ExtensionType interface for convenience.

			(*OpaqueArray) GetOneForMarshal(i int) interface{}
			(*OpaqueArray) IsNull(i int) bool
				IsNull returns true if value at index is null.
				NOTE: IsNull will panic if NullBitmapBytes is not empty and 0 > i ≥ Len.

			(*OpaqueArray) IsValid(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.

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

			(*OpaqueArray) MarshalJSON() ([]byte, error)
			(*OpaqueArray) NullBitmapBytes() []byte
				NullBitmapBytes returns a byte slice of the validity bitmap.

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

			(*OpaqueArray) Offset() int
			(*OpaqueArray) Release()
				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.

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

			(*OpaqueArray) Storage() arrow.Array
				Storage returns the underlying storage array

			(*OpaqueArray) String() string
			(*OpaqueArray) ValueStr(i int) string
				ValueStr returns the value at index i as a string.
				This needs to be implemented by the extension array type.

		Implements (at least 7)
			*OpaqueArray : github.com/apache/arrow-go/v18/arrow.Array[T]
			*OpaqueArray : github.com/apache/arrow-go/v18/arrow/array.ExtensionArray
			*OpaqueArray : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*OpaqueArray : github.com/goccy/go-json.Marshaler
			*OpaqueArray : encoding/json.Marshaler
			*OpaqueArray : expvar.Var
			*OpaqueArray : fmt.Stringer

	 type OpaqueType (struct)
		OpaqueType is a placeholder for a type from an external (usually
		non-Arrow) system that could not be interpreted.

		Fields (total 4)
			ExtensionBase arrow.ExtensionBase
			ExtensionBase.Storage arrow.DataType
				Storage is the underlying storage type

			TypeName string
			VendorName string
		Methods (total 13)
			(*OpaqueType) ArrayType() reflect.Type
			(*OpaqueType) Deserialize(storageType arrow.DataType, data string) (arrow.ExtensionType, error)
			(*OpaqueType) ExtensionEquals(other arrow.ExtensionType) bool
			(*OpaqueType) ExtensionName() string
			(*OpaqueType) Fields() []arrow.Field
			(*OpaqueType) Fingerprint() string
			(*OpaqueType) ID() arrow.Type
				ID always returns arrow.EXTENSION and should not be overridden

			(*OpaqueType) Layout() arrow.DataTypeLayout
			(*OpaqueType) Name() string
				Name should always return "extension" and should not be overridden

			(*OpaqueType) NumFields() int
			(*OpaqueType) Serialize() string
			(*OpaqueType) StorageType() arrow.DataType
				StorageType returns the underlying storage type and exists so that functions
				written against the ExtensionType interface can access the storage type.

			(*OpaqueType) String() string
		Implements (at least 6)
			*OpaqueType : github.com/apache/arrow-go/v18/arrow.DataType
			*OpaqueType : github.com/apache/arrow-go/v18/arrow.ExtensionType
			*OpaqueType : github.com/apache/arrow-go/v18/arrow.NestedType
			*OpaqueType : github.com/polarsignals/frostdb/query/logicalplan.Named
			*OpaqueType : expvar.Var
			*OpaqueType : fmt.Stringer
		As Outputs Of (at least one exported)
			func NewOpaqueType(storageType arrow.DataType, name, vendorName string) *OpaqueType

	 type UUIDArray (struct)
		UUIDArray is a simple array which is a FixedSizeBinary(16)

		Fields (only one)
			ExtensionArrayBase array.ExtensionArrayBase
		Methods (total 18)
			(*UUIDArray) Data() arrow.ArrayData
			(*UUIDArray) DataType() arrow.DataType
				DataType returns the type metadata for this instance.

			(*UUIDArray) ExtensionType() arrow.ExtensionType
				ExtensionType returns the same thing as DataType, just already casted
				to an ExtensionType interface for convenience.

			(*UUIDArray) GetOneForMarshal(i int) interface{}
			(*UUIDArray) IsNull(i int) bool
				IsNull returns true if value at index is null.
				NOTE: IsNull will panic if NullBitmapBytes is not empty and 0 > i ≥ Len.

			(*UUIDArray) IsValid(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.

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

			(*UUIDArray) MarshalJSON() ([]byte, error)
			(*UUIDArray) NullBitmapBytes() []byte
				NullBitmapBytes returns a byte slice of the validity bitmap.

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

			(*UUIDArray) Offset() int
			(*UUIDArray) Release()
				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.

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

			(*UUIDArray) Storage() arrow.Array
				Storage returns the underlying storage array

			(*UUIDArray) String() string
			(*UUIDArray) Value(i int) uuid.UUID
			(*UUIDArray) ValueStr(i int) string
			(*UUIDArray) Values() []uuid.UUID
		Implements (at least 7)
			*UUIDArray : github.com/apache/arrow-go/v18/arrow.Array[T]
			*UUIDArray : github.com/apache/arrow-go/v18/arrow/array.ExtensionArray
			*UUIDArray : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*UUIDArray : github.com/goccy/go-json.Marshaler
			*UUIDArray : encoding/json.Marshaler
			*UUIDArray : expvar.Var
			*UUIDArray : fmt.Stringer

	 type UUIDBuilder (struct)

		Fields (total 2)
			ExtensionBuilder *array.ExtensionBuilder
			ExtensionBuilder.Builder array.Builder
		Methods (total 26)
			(*UUIDBuilder) Append(v uuid.UUID)
			(*UUIDBuilder) AppendBytes(v [16]byte)
			( UUIDBuilder) AppendEmptyValue()
				AppendEmptyValue adds a new zero value of the appropriate type

			( UUIDBuilder) AppendEmptyValues(n int)
				AppendEmptyValues adds new n zero values of the appropriate type

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

			( UUIDBuilder) AppendNulls(n int)
				AppendNulls adds new n null values to the array being built.

			(*UUIDBuilder) AppendValueFromString(s string) error
			(*UUIDBuilder) AppendValues(v []uuid.UUID, valid []bool)
			( UUIDBuilder) Cap() int
				Cap returns the total number of elements that can be stored
				without allocating additional memory.

			( UUIDBuilder) IsNull(i int) bool
				IsNull returns if a previously appended value at a given index is null or not.

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

			( UUIDBuilder) NewArray() arrow.Array
				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.

			( UUIDBuilder) NewExtensionArray() array.ExtensionArray
				NewExtensionArray creates an Extension array from the memory buffers used
				by the builder and resets the ExtensionBuilder so it can be used to build
				a new ExtensionArray of the same type.

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

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

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

			( UUIDBuilder) Resize(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.

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

			( UUIDBuilder) SetNull(i int)
				SetNull sets the value at index i to null.

			( UUIDBuilder) StorageBuilder() array.Builder
				StorageBuilder returns the builder for the underlying storage type.

			( UUIDBuilder) Type() arrow.DataType
			(*UUIDBuilder) Unmarshal(dec *json.Decoder) error
			(*UUIDBuilder) UnmarshalJSON(data []byte) error
			(*UUIDBuilder) UnmarshalOne(dec *json.Decoder) error
			(*UUIDBuilder) UnsafeAppend(v uuid.UUID)
			( UUIDBuilder) UnsafeAppendBoolToBitmap(bool)
		Implements (at least 5)
			*UUIDBuilder : github.com/apache/arrow-go/v18/arrow/array.Builder
			 UUIDBuilder : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*UUIDBuilder : github.com/goccy/go-json.Unmarshaler
			 UUIDBuilder : github.com/polarsignals/frostdb/pqarrow/builder.ColumnBuilder
			*UUIDBuilder : encoding/json.Unmarshaler
		As Outputs Of (at least one exported)
			func NewUUIDBuilder(mem memory.Allocator) *UUIDBuilder

	 type UUIDType (struct)
		UUIDType is a simple extension type that represents a FixedSizeBinary(16)
		to be used for representing UUIDs

		Fields (total 2)
			ExtensionBase arrow.ExtensionBase
			ExtensionBase.Storage arrow.DataType
				Storage is the underlying storage type

		Methods (total 18)
			(*UUIDType) ArrayType() reflect.Type
				ArrayType returns TypeOf(UUIDArray{}) for constructing UUID arrays

			(*UUIDType) BitWidth() int
			(*UUIDType) Bytes() int
			(*UUIDType) Deserialize(storageType arrow.DataType, data string) (arrow.ExtensionType, error)
				Deserialize expects storageType to be FixedSizeBinaryType{ByteWidth: 16}

			(*UUIDType) ExtensionEquals(other arrow.ExtensionType) bool
				ExtensionEquals returns true if both extensions have the same name

			(*UUIDType) ExtensionName() string
			(*UUIDType) Fields() []arrow.Field
			(*UUIDType) Fingerprint() string
			(*UUIDType) ID() arrow.Type
				ID always returns arrow.EXTENSION and should not be overridden

			(*UUIDType) Layout() arrow.DataTypeLayout
			(*UUIDType) MarshalJSON() ([]byte, error)
			(*UUIDType) Name() string
				Name should always return "extension" and should not be overridden

			(*UUIDType) NewBuilder(mem memory.Allocator) array.Builder
			(*UUIDType) NumFields() int
			(*UUIDType) ParquetLogicalType() schema.LogicalType
				ParquetLogicalType implements pqarrow.ExtensionCustomParquetType.

			(*UUIDType) Serialize() string
			(*UUIDType) StorageType() arrow.DataType
				StorageType returns the underlying storage type and exists so that functions
				written against the ExtensionType interface can access the storage type.

			(*UUIDType) String() string
		Implements (at least 11)
			*UUIDType : github.com/apache/arrow-go/v18/arrow.DataType
			*UUIDType : github.com/apache/arrow-go/v18/arrow.ExtensionType
			*UUIDType : github.com/apache/arrow-go/v18/arrow.FixedWidthDataType
			*UUIDType : github.com/apache/arrow-go/v18/arrow.NestedType
			*UUIDType : github.com/apache/arrow-go/v18/arrow/array.CustomExtensionBuilder
			*UUIDType : github.com/goccy/go-json.Marshaler
			*UUIDType : github.com/K-Phoen/grabana/datasource.Datasource
			*UUIDType : github.com/polarsignals/frostdb/query/logicalplan.Named
			*UUIDType : encoding/json.Marshaler
			*UUIDType : expvar.Var
			*UUIDType : fmt.Stringer
		As Outputs Of (at least one exported)
			func NewUUIDType() *UUIDType

	 type VariantArray (struct)
		VariantArray is an extension Array type containing Variant values which may
		potentially be shredded into multiple fields.

		Fields (only one)
			ExtensionArrayBase array.ExtensionArrayBase
		Methods (total 22)
			(*VariantArray) Data() arrow.ArrayData
			(*VariantArray) DataType() arrow.DataType
				DataType returns the type metadata for this instance.

			(*VariantArray) ExtensionType() arrow.ExtensionType
				ExtensionType returns the same thing as DataType, just already casted
				to an ExtensionType interface for convenience.

			(*VariantArray) GetOneForMarshal(i int) any
			(*VariantArray) IsNull(i int) bool
				IsNull will also take into account the special case where there is an
				encoded null variant in the untyped values array for this index and return
				appropriately.

			(*VariantArray) IsShredded() bool
				IsShredded returns true if the variant has shredded columns.

			(*VariantArray) IsValid(i int) bool
			(*VariantArray) Len() int
				Len returns the number of elements in the array.

			(*VariantArray) MarshalJSON() ([]byte, error)
			(*VariantArray) Metadata() arrow.TypedArray[[]byte]
				Metadata returns the metadata column of the variant array, containing the
				metadata for each variant value.

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

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

			(*VariantArray) Offset() int
			(*VariantArray) Release()
				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.

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

			(*VariantArray) Shredded() arrow.Array
				Shredded returns the typed array for the shredded values of the variant array,
				following the rules of the Parquet Variant specification. As such, this array will
				always be either a struct, a list, or a primitive array.
				
				The reason for exposing this is to allow users to quickly access one of the shredded
				fields without having to decode the entire variant value.

			(*VariantArray) Storage() arrow.Array
				Storage returns the underlying storage array

			(*VariantArray) String() string
			(*VariantArray) UntypedValues() arrow.TypedArray[[]byte]
				UntypedValues returns the untyped variant values for each element of the array,
				if the array is not shredded this will contain the variant bytes for each value.
				If the array is shredded, this will contain any variant values that are either
				partially shredded objects or are not shredded at all (e.g. a value that doesnt
				match the types of the shredding).
				
				The shredded array and the untyped values array together are used to encode a
				single value. If this is not encoding shredded object fields, then a given index
				will never be null in both arrays. (A null value will be an encoded null variant value
				in this array with a null in the shredded array).
				
				If both arrays are null for a given index (only valid for shredded object fields),
				it means that the value is missing entirely (as opposed to existing and having a
				value of null).

			(*VariantArray) Value(i int) (variant.Value, error)
			(*VariantArray) ValueStr(i int) string
			(*VariantArray) Values() ([]variant.Value, error)
		Implements (at least 7)
			*VariantArray : github.com/apache/arrow-go/v18/arrow.Array[T]
			*VariantArray : github.com/apache/arrow-go/v18/arrow/array.ExtensionArray
			*VariantArray : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*VariantArray : github.com/goccy/go-json.Marshaler
			*VariantArray : encoding/json.Marshaler
			*VariantArray : expvar.Var
			*VariantArray : fmt.Stringer

	 type VariantBuilder (struct)
		VariantBuilder is an array builder for both shredded or non-shredded variant extension
		arrays. It allows you to append variant values, and will appropriately shred them
		if it is able to do so based on the underlying storage type.

		Fields (total 2)
			ExtensionBuilder *array.ExtensionBuilder
			ExtensionBuilder.Builder array.Builder
		Methods (total 23)
			(*VariantBuilder) Append(v variant.Value)
			( VariantBuilder) AppendEmptyValue()
				AppendEmptyValue adds a new zero value of the appropriate type

			( VariantBuilder) AppendEmptyValues(n int)
				AppendEmptyValues adds new n zero values of the appropriate type

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

			( VariantBuilder) AppendNulls(n int)
				AppendNulls adds new n null values to the array being built.

			( VariantBuilder) AppendValueFromString(string) error
				AppendValueFromString adds a new value from a string. Inverse of array.ValueStr(i int) string

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

			( VariantBuilder) IsNull(i int) bool
				IsNull returns if a previously appended value at a given index is null or not.

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

			( VariantBuilder) NewArray() arrow.Array
				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.

			( VariantBuilder) NewExtensionArray() array.ExtensionArray
				NewExtensionArray creates an Extension array from the memory buffers used
				by the builder and resets the ExtensionBuilder so it can be used to build
				a new ExtensionArray of the same type.

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

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

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

			( VariantBuilder) Resize(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.

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

			( VariantBuilder) SetNull(i int)
				SetNull sets the value at index i to null.

			( VariantBuilder) StorageBuilder() array.Builder
				StorageBuilder returns the builder for the underlying storage type.

			( VariantBuilder) Type() arrow.DataType
			(*VariantBuilder) Unmarshal(dec *json.Decoder) error
			(*VariantBuilder) UnmarshalJSON(data []byte) error
			(*VariantBuilder) UnmarshalOne(dec *json.Decoder) error
			( VariantBuilder) UnsafeAppendBoolToBitmap(bool)
		Implements (at least 5)
			*VariantBuilder : github.com/apache/arrow-go/v18/arrow/array.Builder
			 VariantBuilder : github.com/apache/arrow-go/v18/arrow/scalar.Releasable
			*VariantBuilder : github.com/goccy/go-json.Unmarshaler
			 VariantBuilder : github.com/polarsignals/frostdb/pqarrow/builder.ColumnBuilder
			*VariantBuilder : encoding/json.Unmarshaler
		As Outputs Of (at least one exported)
			func NewVariantBuilder(mem memory.Allocator, dt *VariantType) *VariantBuilder

	 type VariantType (struct)
		VariantType is the arrow extension type for representing Variant values as
		defined by the Parquet Variant specification for encoding and shredding values.
		The underlying storage must be a struct type with a minimum of two fields
		("metadata" and "value") and an optional third field ("typed_value").
		
		See the documentation for [NewVariantType] for the rules for creating a variant
		type.

		Fields (total 2)
			ExtensionBase arrow.ExtensionBase
			ExtensionBase.Storage arrow.DataType
				Storage is the underlying storage type

		Methods (total 18)
			(*VariantType) ArrayType() reflect.Type
			(*VariantType) Deserialize(storageType arrow.DataType, _ string) (arrow.ExtensionType, error)
			(*VariantType) ExtensionEquals(other arrow.ExtensionType) bool
			(*VariantType) ExtensionName() string
			(*VariantType) Fields() []arrow.Field
			(*VariantType) Fingerprint() string
			(*VariantType) ID() arrow.Type
				ID always returns arrow.EXTENSION and should not be overridden

			(*VariantType) Layout() arrow.DataTypeLayout
			(*VariantType) Metadata() arrow.Field
			(*VariantType) Name() string
				Name should always return "extension" and should not be overridden

			(*VariantType) NewBuilder(mem memory.Allocator) array.Builder
			(*VariantType) NumFields() int
			(*VariantType) ParquetLogicalType() schema.LogicalType
			(*VariantType) Serialize() string
			(*VariantType) StorageType() arrow.DataType
				StorageType returns the underlying storage type and exists so that functions
				written against the ExtensionType interface can access the storage type.

			(*VariantType) String() string
			(*VariantType) TypedValue() arrow.Field
			(*VariantType) Value() arrow.Field
		Implements (at least 7)
			*VariantType : github.com/apache/arrow-go/v18/arrow.DataType
			*VariantType : github.com/apache/arrow-go/v18/arrow.ExtensionType
			*VariantType : github.com/apache/arrow-go/v18/arrow.NestedType
			*VariantType : github.com/apache/arrow-go/v18/arrow/array.CustomExtensionBuilder
			*VariantType : github.com/polarsignals/frostdb/query/logicalplan.Named
			*VariantType : expvar.Var
			*VariantType : fmt.Stringer
		As Outputs Of (at least 3)
			func NewDefaultVariantType() *VariantType
			func NewShreddedVariantType(dt arrow.DataType) *VariantType
			func NewVariantType(storage arrow.DataType) (*VariantType, error)
		As Inputs Of (at least one exported)
			func NewVariantBuilder(mem memory.Allocator, dt *VariantType) *VariantBuilder


Package-Level Functions (total 10)

	 func NewBool8Builder(mem memory.Allocator) *Bool8Builder
		NewBool8Builder creates a new Bool8Builder, exposing a convenient and efficient interface
		for writing boolean values to the underlying int8 storage array.

	 func NewBool8Type() *Bool8Type
		NewBool8Type creates a new Bool8Type with the underlying storage type set correctly to Int8.

	 func NewDefaultVariantType() *VariantType
		NewDefaultVariantType creates a basic, non-shredded variant type. The underlying
		storage type will be struct<metadata: binary non-null, value: binary non-null>.

	 func NewJSONType(storageType arrow.DataType) (*JSONType, error)
		NewJSONType creates a new JSONType with the specified storage type.
		storageType must be one of String, LargeString, StringView.

	 func NewOpaqueType(storageType arrow.DataType, name, vendorName string) *OpaqueType
		NewOpaqueType creates a new OpaqueType with the provided storage type, type name, and vendor name.

	 func NewShreddedVariantType(dt arrow.DataType) *VariantType
		NewShreddedVariantType creates a new VariantType extension type using the provided
		type to define a shredded schema by setting the `typed_value` field accordingly and
		properly constructing the shredded fields for structs, lists and so on.
		
		For example:
		
			NewShreddedVariantType(arrow.StructOf(
			     arrow.Field{Name: "latitude", Type: arrow.PrimitiveTypes.Float64},
			     arrow.Field{Name: "longitude", Type: arrow.PrimitiveTypes.Float32}))
		
		Will create a variant type with the following structure:
		
			arrow.StructOf(
			     arrow.Field{Name: "metadata", Type: arrow.BinaryTypes.Binary, Nullable: false},
			     arrow.Field{Name: "value", Type: arrow.BinaryTypes.Binary, Nullable: true},
			     arrow.Field{Name: "typed_value", Type: arrow.StructOf(
			       arrow.Field{Name: "latitude", Type: arrow.StructOf(
			         arrow.Field{Name: "value", Type: arrow.BinaryTypes.Binary, Nullable: true},
			         arrow.Field{Name: "typed_value", Type: arrow.PrimitiveTypes.Float64, Nullable: true}),
			         Nullable: false},
			     arrow.Field{Name: "longitude", Type: arrow.StructOf(
			         arrow.Field{Name: "value", Type: arrow.BinaryTypes.Binary, Nullable: true},
			         arrow.Field{Name: "typed_value", Type: arrow.PrimitiveTypes.Float32, Nullable: true}),
			         Nullable: false},
			 ), Nullable: true})
		
		This is intended to be a convenient way to create a shredded variant type from a definition
		of the fields to shred. If the provided data type is nil, it will create a default
		variant type.

	 func NewUUIDBuilder(mem memory.Allocator) *UUIDBuilder
		NewUUIDBuilder creates a new UUIDBuilder, exposing a convenient and efficient interface
		for writing uuid.UUID (or [16]byte) values to the underlying FixedSizeBinary storage array.

	 func NewUUIDType() *UUIDType
		NewUUIDType is a convenience function to create an instance of UUIDType
		with the correct storage type

	 func NewVariantBuilder(mem memory.Allocator, dt *VariantType) *VariantBuilder
		NewVariantBuilder creates a new VariantBuilder for the given variant type which may
		or may not be shredded.

	 func NewVariantType(storage arrow.DataType) (*VariantType, error)
		NewVariantType creates a new variant type based on the provided storage type.
		
		The rules for a variant storage type are:
		 1. MUST be a struct
		 2. MUST have non-nullable field named "metadata" that is binary/largebinary/binary_view
		 3. Must satisfy exactly one of the following:
		    a. MUST have non-nullable field named "value" that is binary/largebinary/binary_view
		    b. MUST have an nullable field named "value" that is binary/largebinary/binary_view
		    and another nullable field named "typed_value" that is either a primitive type or
		    a list/large_list/list_view or struct which also satisfies the following requirements:
		    i. The elements must be NON-NULLABLE
		    ii. There must either be a single NON-NULLABLE field named "value" which is
		    binary/largebinary/binary_view or have an nullable "value" field and an nullable
		    "typed_value" field that follows the rules laid out in (b).
		
		The metadata field may also be dictionary encoded

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.