Options
All
  • Public
  • Public/Protected
  • All
Menu

apache-arrow

Index

Modules

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

BindFunc

BindFunc: function

Type declaration

Data

Data: DataTypes<T>[T["TType"]] & BaseData<T>

FixedSizeType

FixedSizeType: Int64 | Uint64 | Decimal | FixedSizeBinary

FlatListType

FlatListType: Utf8 | Binary

FlatType

FloatArray

FloatArray: Uint16Array | Float32Array | Float64Array

IntArray

IntArray: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array

IntBitWidth

IntBitWidth: 8 | 16 | 32 | 64

ListType

ListType: List<any>

MessageReader

MessageReader: function

Type declaration

NestedType

NestedType: Map_ | Struct | List<any> | FixedSizeList<any> | Union<any>

NextFunc

NextFunc: function

Type declaration

NumericType

NumericType: Int | Float | Date_ | Time | Interval | Timestamp

PredicateFunc

PredicateFunc: function

Type declaration

PrimitiveType

PrimitiveType: NumericType | FixedSizeType

SingleNestedType

SingleNestedType: List<any> | FixedSizeList<any>

TimeBitWidth

TimeBitWidth: 32 | 64

ValueFunc

ValueFunc: function

Type declaration

Const kUnknownNullCount

kUnknownNullCount: -1 = -1

Variables

Const MAGIC

MAGIC: Uint8Array = new Uint8Array(MAGIC_STR.length)

Const MAGIC_STR

MAGIC_STR: "ARROW1" = "ARROW1"

Const PADDING

PADDING: 4 = 4

Const carryBit16

carryBit16: number = 1 << 16

Const createVector

createVector: (Anonymous function) = ((VectorLoader: new <T extends DataType>(data: Data<T>) => TypeVisitor) => (<T extends DataType>(data: Data<T>) => TypeVisitor.visitTypeInline(new VectorLoader(data), data.type) as Vector<T>))(class VectorLoader<T extends DataType> extends TypeVisitor {constructor(private data: Data<T>) { super(); }visitNull (_type: Null) { return new NullVector(this.data); }visitInt (_type: Int) { return new IntVector(this.data); }visitFloat (_type: Float) { return new FloatVector(this.data); }visitBinary (_type: Binary) { return new BinaryVector(this.data); }visitUtf8 (_type: Utf8) { return new Utf8Vector(this.data); }visitBool (_type: Bool) { return new BoolVector(this.data); }visitDecimal (_type: Decimal) { return new DecimalVector(this.data); }visitDate (_type: Date_) { return new DateVector(this.data); }visitTime (_type: Time) { return new TimeVector(this.data); }visitTimestamp (_type: Timestamp) { return new TimestampVector(this.data); }visitInterval (_type: Interval) { return new IntervalVector(this.data); }visitList (_type: List) { return new ListVector(this.data); }visitStruct (_type: Struct) { return new StructVector(this.data); }visitUnion (_type: Union) { return new UnionVector(this.data); }visitFixedSizeBinary(_type: FixedSizeBinary) { return new FixedSizeBinaryVector(this.data); }visitFixedSizeList (_type: FixedSizeList) { return new FixedSizeListVector(this.data); }visitMap (_type: Map_) { return new MapVector(this.data); }visitDictionary (_type: Dictionary) { return new DictionaryVector(this.data); }})

Const decodeUtf8

decodeUtf8: function = ((decoder) =>decoder.decode.bind(decoder) as (input?: ArrayBufferLike | ArrayBufferView) => string)(new TextDecoder('utf-8'))

Type declaration

    • (input?: ArrayBufferLike | ArrayBufferView): string
    • Parameters

      • Optional input: ArrayBufferLike | ArrayBufferView

      Returns string

Const encodeUtf8

encodeUtf8: function = ((encoder) =>encoder.encode.bind(encoder) as (input?: string) => Uint8Array)(new TextEncoder('utf-8'))

Type declaration

    • (input?: undefined | string): Uint8Array
    • Parameters

      • Optional input: undefined | string

      Returns Uint8Array

Const kInt32DecimalDigits

kInt32DecimalDigits: 8 = 8

Const kPowersOfTen

kPowersOfTen: number[] = [1,10,100,1000,10000,100000,1000000,10000000,100000000]

Const magicAndPadding

magicAndPadding: number = magicLength + PADDING

Const magicLength

magicLength: number = MAGIC.length

Const magicX2AndPadding

magicX2AndPadding: number = magicLength * 2 + PADDING

Const utf8Encoder

utf8Encoder: TextEncoder = new TextEncoder('utf-8')

Functions

align

  • align(value: number, alignment: number): number
  • Parameters

    • value: number
    • alignment: number

    Returns number

arrayIterator

  • arrayIterator(arr: Array<any>): IterableIterator<any>

arraySet

  • arraySet(source: any[], target: any[], index: number): number

binaryDataFromJSON

  • binaryDataFromJSON(values: string[]): SharedArrayBuffer | ArrayBuffer

binaryFromField

  • binaryFromField(_type: _Binary): Binary

binaryFromJSON

  • binaryFromJSON(_type: any): Binary

boolFromField

  • boolFromField(_type: _Bool): Bool

boolFromJSON

  • boolFromJSON(_type: any): Bool

bufferFromRecordBatch

buffersFromJSON

buffersFromRecordBatch

checkForMagicArrowString

  • checkForMagicArrowString(buffer: Uint8Array, index?: number): boolean

col

  • col(n: string): Col<any>

custom

customMetadata

  • customMetadata(metadata?: any): Map<string, string>

dateFromField

  • dateFromField(_type: _Date): Date_

dateFromJSON

  • dateFromJSON(_type: any): Date_

decimalDataFromJSON

  • decimalDataFromJSON(values: string[]): SharedArrayBuffer | ArrayBuffer

decimalFromField

  • decimalFromField(_type: _Decimal): Decimal

decimalFromJSON

  • decimalFromJSON(_type: any): Decimal

dictionaryBatchFromJSON

dictionaryBatchFromMessage

dictionaryBatchesFromFooter

  • dictionaryBatchesFromFooter(f: _Footer): FileBlock[]

epochDaysToDate

  • epochDaysToDate(data: Int32Array, index: number): Date

epochDaysToMs

  • epochDaysToMs(data: Int32Array, index: number): number

epochMicrosecondsLongToMs

  • epochMicrosecondsLongToMs(data: Int32Array, index: number): number

epochMillisecondsLongToDate

  • epochMillisecondsLongToDate(data: Int32Array, index: number): Date

epochMillisecondsLongToMs

  • epochMillisecondsLongToMs(data: Int32Array, index: number): number

epochMillisecondsToDate

  • epochMillisecondsToDate(epochMs: number): Date

epochNanosecondsLongToDate

  • epochNanosecondsLongToDate(data: Int32Array, index: number): Date

epochNanosecondsLongToMs

  • epochNanosecondsLongToMs(data: Int32Array, index: number): number

epochSecondsToDate

  • epochSecondsToDate(data: Int32Array, index: number): Date

epochSecondsToMs

  • epochSecondsToMs(data: Int32Array, index: number): number

field

fieldFromJSON

fieldNodeFromRecordBatch

fieldNodesFromJSON

fieldNodesFromRecordBatch

fieldsFromField

fieldsFromJSON

fieldsFromSchema

fixedSizeBinaryFromField

fixedSizeBinaryFromJSON

fixedSizeListFromField

fixedSizeListFromJSON

flattenDataSources

  • flattenDataSources(xs: any[]): any[][]

floatFromField

floatingPointFromJSON

footerFromByteBuffer

  • footerFromByteBuffer(bb: ByteBuffer): Footer

getBit

  • getBit(_data: any, _index: number, byte: number, bit: number): 0 | 1
  • Parameters

    • _data: any
    • _index: number
    • byte: number
    • bit: number

    Returns 0 | 1

getBool

  • getBool(_data: any, _index: number, byte: number, bit: number): boolean
  • Parameters

    • _data: any
    • _index: number
    • byte: number
    • bit: number

    Returns boolean

int64DataFromJSON

  • int64DataFromJSON(values: string[]): SharedArrayBuffer | ArrayBuffer

intAsHex

  • intAsHex(value: number): string

intFromField

intFromJSON

intervalFromField

  • intervalFromField(_type: _Interval): Interval

intervalFromJSON

  • intervalFromJSON(_type: any): Interval

isArrayLike

  • isArrayLike(x: any): boolean

isAsyncIterable

  • isAsyncIterable(x: any): boolean

isIterable

  • isIterable(x: any): boolean

isObservable

  • isObservable(x: any): boolean

isPromise

  • isPromise(x: any): boolean

iterateBits

  • iterateBits<T>(bytes: Uint8Array, begin: number, length: number, context: any, get: function): IterableIterator<T>
  • Type parameters

    • T

    Parameters

    • bytes: Uint8Array
    • begin: number
    • length: number
    • context: any
    • get: function
        • (context: any, index: number, byte: number, bit: number): T
        • Parameters

          • context: any
          • index: number
          • byte: number
          • bit: number

          Returns T

    Returns IterableIterator<T>

leftPad

  • leftPad(str: string, fill: string, n: number): string
  • Parameters

    • str: string
    • fill: string
    • n: number

    Returns string

listFromField

  • listFromField(_type: _List, children: Field[]): List<any>

listFromJSON

  • listFromJSON(_type: any, children: Field[]): List<any>

lit

  • lit(v: any): Value<any>

mapFromField

  • mapFromField(_type: _Map, children: Field[]): Map_

mapFromJSON

  • mapFromJSON(_type: any, children: Field[]): Map_

messageFromByteBuffer

nullCountFromJSON

  • nullCountFromJSON(validity: number[]): number

nullFromField

  • nullFromField(_type: _Null): Null

nullFromJSON

  • nullFromJSON(_type: any): Null

packBools

  • packBools(values: Iterable<any>): Uint8Array
  • Parameters

    • values: Iterable<any>

    Returns Uint8Array

padding

  • padding(value: number, alignment: number): number
  • Parameters

    • value: number
    • alignment: number

    Returns number

popcnt_array

  • popcnt_array(arr: TypedArray, byteOffset?: undefined | number, byteLength?: undefined | number): number
  • Parameters

    • arr: TypedArray
    • Optional byteOffset: undefined | number
    • Optional byteLength: undefined | number

    Returns number

popcnt_bit_range

  • popcnt_bit_range(data: Uint8Array, lhs: number, rhs: number): number
  • Compute the population count (the number of bits set to 1) for a range of bits in a Uint8Array.

    Parameters

    • data: Uint8Array
    • lhs: number

      The range's left-hand side (or start) bit

    • rhs: number

      The range's right-hand side (or end) bit

    Returns number

popcnt_uint32

  • popcnt_uint32(uint32: number): number

read

  • read(sources: Iterable<Uint8Array | Buffer | string> | any | string): IterableIterator<RecordBatch>

readAsync

  • readAsync(sources: AsyncIterable<Uint8Array | Buffer | string>): AsyncIterableIterator<RecordBatch>

readBuffers

  • readBuffers<T>(sources: Iterable<T> | Uint8Array | Buffer | string): IterableIterator<object>
  • Type parameters

    • T: Uint8Array | Buffer | string

    Parameters

    • sources: Iterable<T> | Uint8Array | Buffer | string

    Returns IterableIterator<object>

readBuffersAsync

  • readBuffersAsync<T>(sources: AsyncIterable<T>): AsyncIterableIterator<object>
  • Type parameters

    • T: Uint8Array | Buffer | string

    Parameters

    • sources: AsyncIterable<T>

    Returns AsyncIterableIterator<object>

readFileMessages

  • readFileMessages(footer: Footer): (Anonymous function)

readFileSchema

  • readFileSchema(bb: ByteBuffer): null | Footer

readJSON

  • readJSON(json: any): IterableIterator<object | object>

readMessage

readMessages

readRecordBatch

readRecordBatches

  • readRecordBatches(messages: Iterable<object>): IterableIterator<RecordBatch>

readRecordBatchesAsync

  • readRecordBatchesAsync(messages: AsyncIterable<object>): AsyncIterableIterator<RecordBatch>

readSchema

  • readSchema(bb: ByteBuffer): object

readStreamMessages

readStreamSchema

  • readStreamSchema(bb: ByteBuffer): null | Schema

recordBatchFromJSON

recordBatchFromMessage

recordBatchesFromFooter

  • recordBatchesFromFooter(f: _Footer): FileBlock[]

schemaFromJSON

  • schemaFromJSON(s: any): Schema

schemaFromMessage

setBool

  • setBool(bytes: Uint8Array, index: number, value: any): boolean
  • Parameters

    • bytes: Uint8Array
    • index: number
    • value: any

    Returns boolean

stringify

  • stringify(x: any): string

structFromField

  • structFromField(_type: _Struct, children: Field[]): Struct

structFromJSON

  • structFromJSON(_type: any, children: Field[]): Struct

tableRowsToString

  • tableRowsToString(table: Table, separator?: string): IterableIterator<string>
  • Parameters

    • table: Table
    • Default value separator: string = " | "

    Returns IterableIterator<string>

timeFromField

  • timeFromField(_type: _Time): Time

timeFromJSON

  • timeFromJSON(_type: any): Time

timestampFromField

  • timestampFromField(_type: _Timestamp): Timestamp

timestampFromJSON

toByteBuffer

  • toByteBuffer(bytes?: Uint8Array | Buffer | string): ByteBuffer

toTypedArray

  • toTypedArray<T>(ArrayType: TypedArrayConstructor<T>, values?: T | ArrayLike<number> | Iterable<number> | null): T

typeFromField

  • typeFromField(f: _Field, children?: Field[]): DataType<any> | null

typeFromJSON

typedArraySet

unionFromField

  • unionFromField(_type: _Union, children: Field[]): Union<any>

unionFromJSON

  • unionFromJSON(_type: any, children: Field[]): Union<any>

utf8FromField

  • utf8FromField(_type: _Utf8): Utf8

utf8FromJSON

  • utf8FromJSON(_type: any): Utf8

Object literals

Const namesToTypeMap

namesToTypeMap: object

NONE

NONE: NONE = Type.NONE

binary

binary: Binary = Type.Binary

bool

bool: Bool = Type.Bool

date

date: Date = Type.Date

decimal

decimal: Decimal = Type.Decimal

fixedsizebinary

fixedsizebinary: FixedSizeBinary = Type.FixedSizeBinary

fixedsizelist

fixedsizelist: FixedSizeList = Type.FixedSizeList

floatingpoint

floatingpoint: FloatingPoint = Type.FloatingPoint

int

int: Int = Type.Int

interval

interval: Interval = Type.Interval

list

list: List = Type.List

map

map: Map = Type.Map

null

null: Null = Type.Null

struct

struct: Struct_ = Type.Struct_

time

time: Time = Type.Time

timestamp

timestamp: Timestamp = Type.Timestamp

union

union: Union = Type.Union

utf8

utf8: Utf8 = Type.Utf8

Generated using TypeDoc