MemoryTable | /table.ts | pg_mem@3.0.2

class MemoryTable

import { MemoryTable } from "https://dotland.deno.dev/x/pg_mem@3.0.2/table.ts";

Constructors

new

MemoryTable(

schema: _ISchema,

t: _Transaction,

_schema: Schema,

)

Properties

private

optional

_reg: Reg

private

changeHandlers: Map<_Column | null, ChangeSub>

private

constraintsByName: Map<string, _IConstraint>

private

cstGen: number

private

dataId: symbol

private

drophandlers: Set<DropHandler>

private

handlers: Map<TableEvent, Set<() => void>>

private

hasPrimary: BIndex | null

private

indexByHashAndName: Map<string, Map<string, { index: BIndex; expressions: IValue[]; }>>

private

indexHandlers: Set<IndexHandler>

private

it: number

private

readonly: boolean

private

serialsId: symbol

private

truncateHandlers: Set<TruncateHandler>

readonly

columnMgr: ColumnManager

readonly

columns

readonly

debugId

hidden: boolean

readonly

isExecutionWithNoResult: boolean

name: string

readonly

primaryIndex: IndexDef | null

readonly

reg: Reg

readonly

selection: Alias

readonly

type

Methods

private

_subChange(

key: keyof ChangeSub,

columns: "all" | (string | _Column)[],

check: ChangeHandler,

): ISubscription

private

changePlan(

t: _Transaction,

old: Row | null,

neu: Row | null,

_opts: ChangeOpts | nil,

): ChangePlan

private

checkNoConstraint(name: string)

private

determineIndexRelName(

indexName: string | nil,

ihash: string,

ifNotExists: boolean | nil,

sufix: string,

): string | nil

private

indexElt(t: _Transaction, toInsert: Row)

addCheck(

_t: _Transaction,

check: Expr,

constraintName?: string,

): _IConstraint

addColumn(column: SchemaField | CreateColumnDef, t: _Transaction): _Column

addConstraint(cst: TableConstraint, t: _Transaction): _IConstraint | nil

addForeignKey(cst: TableConstraintForeignKey, t: _Transaction): _IConstraint | nil

bin(t: _Transaction)

constraintNameGen(constraintName?: string)

createIndex(t: _Transaction, expressions: CreateIndexDef): _IConstraint | nil

createIndex(

t: _Transaction,

expressions: Name[],

type: "primary" | "unique",

indexName?: string | nil,

): _IConstraint

delete(t: _Transaction, toDelete: Row)

doInsert(

t: _Transaction,

toInsert: Row,

opts?: ChangeOpts,

): Row | null

drop(t: _Transaction, cascade: boolean)

dropIndex(t: _Transaction, uName: string)

entropy(t: _Transaction)

enumerate(t: _Transaction): Iterable<Row>

explain(e: _Explainer): _SelectExplanation

find(template?: Row, columns?: (keyof Row)[]): Row[]

getColumn(column: string | ExprRef): IValue

getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil

getColumnRef(column: string): ColRef

getColumnRef(column: string, nullIfNotFound?: boolean): ColRef | nil

getColumns(): Iterable<ColumnDef>

getConstraint(constraint: string): _IConstraint | nil

getIndex(...forValues: IValue[]): _IIndex | nil

hasItem(item: Row, t: _Transaction)

insert(toInsert: Row): Row | null

isOriginOf(a: IValue): boolean

listIndices(): IndexDef[]

on(event: TableEvent, handler: () => any): ISubscription

onBeforeChange(columns: "all" | (string | _Column)[], check: ChangeHandler): ISubscription

onCheckChange(columns: string[], check: ChangeHandler): ISubscription

onDrop(sub: DropHandler): ISubscription

onIndex(sub: IndexHandler): ISubscription

onTruncate(sub: TruncateHandler): ISubscription

raise(event: TableEvent)

remapData(t: _Transaction, modify: (newCopy: Row) => any)

rename(name: string)

setBin(t: _Transaction, val: Raw)

setHidden()

setReadonly()

stats(t: _Transaction): Stats | null

truncate(t: _Transaction, _opts?: TruncateOpts): void

update(t: _Transaction, toUpdate: Row): Row