Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Table<T, T>

Type parameters

  • T: {} = any

  • T: {} = any

Hierarchy

Implements

  • Clonable<Chunked<Struct<T>>>
  • Sliceable<Chunked<Struct<T>>>
  • Applicative<Struct<T>, Chunked<Struct<T>>>
  • DataFrame<T>
  • Clonable<Table<T>>
  • Sliceable<Table<T>>
  • Applicative<Struct<T>, Table<T>>

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • new Table(batches: RecordBatch<T>[]): Table
  • new Table(...batches: RecordBatch<T>[]): Table
  • new Table(schema: Schema<T>, batches: RecordBatch<T>[]): Table
  • new Table(schema: Schema<T>, ...batches: RecordBatch<T>[]): Table

  • Parameters

    • batches: RecordBatch<T>[]

    Returns Table

  • Parameters

    • Rest ...batches: RecordBatch<T>[]

    Returns Table

  • Parameters

    • schema: Schema<T>
    • batches: RecordBatch<T>[]

    Returns Table

  • Parameters

    • schema: Schema<T>
    • Rest ...batches: RecordBatch<T>[]

    Returns Table

Properties

Readonly TArray

TArray: Struct<T>["TArray"]

Readonly TType

TType: Struct<T>["TType"]

Readonly TValue

TValue: Struct<T>["TValue"]

Readonly [Symbol.isConcatSpreadable]

[Symbol.isConcatSpreadable]: boolean

Accessors

ArrayType

  • get ArrayType(): any

VectorName

  • get VectorName(): string

byteLength

  • get byteLength(): number

chunks

  • get chunks(): RecordBatch<T>[]

data

  • get data(): Data<Struct<T>>

dictionary

  • get dictionary(): ChunkedDict<Struct<T>> | null

indices

  • get indices(): ChunkedKeys<Struct<T>> | null

length

  • get length(): number

nullCount

  • get nullCount(): number

numChildren

  • get numChildren(): number

numCols

  • get numCols(): number

schema

stride

  • get stride(): number

type

  • get type(): T

typeId

  • get typeId(): Struct<T>["TType"]

Methods

[Symbol.iterator]

  • [Symbol.iterator](): IterableIterator<RowLike<T>>

  • Returns IterableIterator<RowLike<T>>

assign

clone

  • clone(chunks?: RecordBatch<T>[], offsets?: Uint32Array): Table<T>

  • Parameters

    • Optional chunks: RecordBatch<T>[]
    • Optional offsets: Uint32Array

    Returns Table<T>

concat

count

  • count(): number

countBy

  • countBy(name: Col | string): CountByResult

  • Parameters

    • name: Col | string

    Returns CountByResult

filter

  • filter(predicate: Predicate): FilteredDataFrame<T>

  • Parameters

    • predicate: Predicate

    Returns FilteredDataFrame<T>

get

  • get(index: number): Struct<T>["TValue"]

  • Parameters

    • index: number

    Returns Struct<T>["TValue"]

getChildAt

  • getChildAt<R>(index: number): Column<R> | null

getColumn

  • getColumn<R>(name: R): Column<T[R]>

getColumnAt

  • getColumnAt<R>(index: number): Column<R> | null

getColumnIndex

  • getColumnIndex<R>(name: R): number

  • Type parameters

    • R: keyof T

    Parameters

    • name: R

    Returns number

indexOf

  • indexOf(element: Struct<T>["TValue"], offset?: undefined | number): number

  • Parameters

    • element: Struct<T>["TValue"]
    • Optional offset: undefined | number

    Returns number

isValid

  • isValid(index: number): boolean

scan

  • scan(next: (idx: number, batch: RecordBatch) => void, bind?: undefined | BindFunc): void

  • Parameters

    • next: (idx: number, batch: RecordBatch) => void
        • (idx: number, batch: RecordBatch): void

        • Parameters

          • idx: number
          • batch: RecordBatch

          Returns void

    • Optional bind: undefined | BindFunc

    Returns void

scanReverse

  • scanReverse(next: (idx: number, batch: RecordBatch) => void, bind?: undefined | BindFunc): void

  • Parameters

    • next: (idx: number, batch: RecordBatch) => void
        • (idx: number, batch: RecordBatch): void

        • Parameters

          • idx: number
          • batch: RecordBatch

          Returns void

    • Optional bind: undefined | BindFunc

    Returns void

search

  • search(index: number): [number, number] | null
  • search<N>(index: number, then?: N): ReturnType<N>

  • Parameters

    • index: number

    Returns [number, number] | null

  • Type parameters

    • N: SearchContinuation<Chunked<Struct<T>>>

    Parameters

    • index: number
    • Optional then: N

    Returns ReturnType<N>

select

  • select<K>(...columnNames: K[]): Table<{}>

  • Type parameters

    • K: keyof T = any

    Parameters

    • Rest ...columnNames: K[]

    Returns Table<{}>

selectAt

  • selectAt<K>(...columnIndices: number[]): Table<{}>

  • Type parameters

    • K: T[keyof T] = any

    Parameters

    • Rest ...columnIndices: number[]

    Returns Table<{}>

serialize

  • serialize(encoding?: string, stream?: boolean): Uint8Array

  • Parameters

    • Default value encoding: string = "binary"
    • Default value stream: boolean = true

    Returns Uint8Array

set

  • set(index: number, value: Struct<T>["TValue"] | null): void

  • Parameters

    • index: number
    • value: Struct<T>["TValue"] | null

    Returns void

slice

  • slice(begin?: undefined | number, end?: undefined | number): Table<T>

  • Parameters

    • Optional begin: undefined | number
    • Optional end: undefined | number

    Returns Table<T>

toArray

  • toArray(): Struct<T>["TArray"]

Static concat

  • concat<T>(...vectors: (Vector<T> | Vector<T>[])[]): Chunked<T>

Static empty

  • nocollapse

    Type parameters

    • T: {} = {}

    Parameters

    • Default value schema: Schema<T> = new Schema<T>([])

    Returns Table<T>

Static flatten

Static from

  • from(): Table<{}>
  • from<T>(source: RecordBatchReader<T>): Table<T>
  • from<T>(source: { batches?: any[]; dictionaries?: any[]; schema: any }): Table<T>
  • from<T>(source: FromArg2): Table<T>
  • from<T>(source: PromiseLike): Promise<Table<T>>
  • from<T>(source: PromiseLike): Promise<Table<T>>
  • from<T>(source: FromArg4): Promise<Table<T>>
  • from<T>(source: FromArg5): Promise<Table<T>>
  • from<T>(source: PromiseLike<RecordBatchReader<T>>): Promise<Table<T>>
  • from<T, TNull>(options: VectorBuilderOptions<Struct<T>, TNull>): Table<T>
  • from<T, TNull>(options: VectorBuilderOptionsAsync<Struct<T>, TNull>): Promise<Table<T>>
  • nocollapse

    Returns Table<{}>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    Returns Table<T>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: { batches?: any[]; dictionaries?: any[]; schema: any }
      • Optional batches?: any[]
      • Optional dictionaries?: any[]
      • schema: any

    Returns Table<T>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: FromArg2

    Returns Table<T>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: PromiseLike

    Returns Promise<Table<T>>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: PromiseLike

    Returns Promise<Table<T>>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: FromArg4

    Returns Promise<Table<T>>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: FromArg5

    Returns Promise<Table<T>>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    Returns Promise<Table<T>>

  • nocollapse

    Type parameters

    • T: {} = any

    • TNull = any

    Parameters

    • options: VectorBuilderOptions<Struct<T>, TNull>

    Returns Table<T>

  • nocollapse

    Type parameters

    • T: {} = any

    • TNull = any

    Parameters

    • options: VectorBuilderOptionsAsync<Struct<T>, TNull>

    Returns Promise<Table<T>>

Static fromAsync

  • fromAsync<T>(source: FromArgs): Promise<Table<T>>
  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    • source: FromArgs

    Returns Promise<Table<T>>

Static fromStruct

Static new

  • summary

    Create a new Table from a collection of Columns or Vectors, with an optional list of names or Fields.

    Table.new accepts an Object of Columns or Vectors, where the keys will be used as the field names for the Schema:

    const i32s = Int32Vector.from([1, 2, 3]);
const f32s = Float32Vector.from([.1, .2, .3]);
const table = Table.new({ i32: i32s, f32: f32s });
assert(table.schema.fields[0].name === 'i32');

    It also accepts a a list of Vectors with an optional list of names or Fields for the resulting Schema. If the list is omitted or a name is missing, the numeric index of each Vector will be used as the name:

    const i32s = Int32Vector.from([1, 2, 3]);
const f32s = Float32Vector.from([.1, .2, .3]);
const table = Table.new([i32s, f32s], ['i32']);
assert(table.schema.fields[0].name === 'i32');
assert(table.schema.fields[1].name === '1');

    If the supplied arguments are Columns, Table.new will infer the Schema from the Columns:

    const i32s = Column.new('i32', Int32Vector.from([1, 2, 3]));
const f32s = Column.new('f32', Float32Vector.from([.1, .2, .3]));
const table = Table.new(i32s, f32s);
assert(table.schema.fields[0].name === 'i32');
assert(table.schema.fields[1].name === 'f32');

    If the supplied Vector or Column lengths are unequal, Table.new will extend the lengths of the shorter Columns, allocating additional bytes to represent the additional null slots. The memory required to allocate these additional bitmaps can be computed as:

    let additionalBytes = 0;
for (let vec in shorter_vectors) {
    additionalBytes += (((longestLength - vec.length) + 63) & ~63) >> 3;
}

    For example, an additional null bitmap for one million null values would require 125,000 bytes (((1e6 + 63) & ~63) >> 3), or approx. 0.11MiB

    Type parameters

    • T: {} = any

    Parameters

    Returns Table<T>

  • nocollapse

    Type parameters

    Parameters

    • children: T

    Returns Table<{}>

  • nocollapse

    Type parameters

    • T: {} = any

    Parameters

    Returns Table<T>

Generated using TypeDoc