Type Alias PlanNode

Type Declaration

• { table: TableView; type: "scan" }
• { columns: (string | ExprNode)[]; input: PlanNode; type: "project" }
• { input: PlanNode; predicate: ExprNode; type: "filter" }
• {
      by: { descending: boolean; expr: ExprNode; nullsLast?: boolean }[];
      input: PlanNode;
      type: "sort";
  }
• { input: PlanNode; n: number; offset?: number; type: "limit" }
• { expr: ExprNode; input: PlanNode; name: string; type: "withColumn" }
• {
      columns: { expr: ExprNode; name: string }[];
      input: PlanNode;
      type: "withColumns";
  }
• { columns: string[]; input: PlanNode; type: "drop" }
• { input: PlanNode; mapping: Record<string, string>; type: "rename" }
• {
      aggs: { expr: ExprNode; name: string }[];
      input: PlanNode;
      keys: string[];
      type: "groupBy";
  }
• {
      how: JoinKind;
      left: PlanNode;
      leftOn: string[];
      lSuffix?: string;
      right: PlanNode;
      rightOn: string[];
      rSuffix?: string;
      type: "join";
      validate?: "1:1" | "1:m" | "m:1";
  }

  • how: JoinKind

  • left: PlanNode

  • leftOn: string[]

  • OptionallSuffix?: string

    Applied to colliding left non-key columns; empty/omitted keeps the left name (pandas-like).

  • right: PlanNode

  • rightOn: string[]

  • OptionalrSuffix?: string

    Applied to colliding right non-key columns; default _right.

  • type: "join"

  • Optionalvalidate?: "1:1" | "1:m" | "m:1"

    Assert join-key uniqueness before joining (pandas-style).

• {
      left: PlanNode;
      leftOn: string;
      right: PlanNode;
      rightOn: string;
      strategy: "backward" | "forward" | "nearest";
      type: "asofJoin";
  }
• {
      columns?: string[];
      input: PlanNode;
      type: "fillNull";
      value?: number | string | boolean;
      values?: Record<string, number | string | boolean>;
  }

  • Optionalcolumns?: string[]

  • input: PlanNode

  • type: "fillNull"

  • Optionalvalue?: number | string | boolean

  • Optionalvalues?: Record<string, number | string | boolean>

    Per-column fill values; when set, value / columns are ignored.

• { columns?: string[]; input: PlanNode; type: "ffill" }
• { columns?: string[]; input: PlanNode; type: "bfill" }
• { columns?: string[]; input: PlanNode; type: "dropNull" }
• {
      idVars: string[];
      input: PlanNode;
      type: "melt";
      valueName: string;
      valueVars: string[];
      varName: string;
  }
• {
      agg: AggKind;
      columns: string;
      index: string[];
      input: PlanNode;
      type: "pivot";
      values: string;
  }
• { frames: PlanNode[]; how: "vertical" | "horizontal"; type: "concat" }
• {
      expr?: ExprNode;
      fn: "rank" | "lag" | "lead" | "cumsum" | "rowNumber";
      input: PlanNode;
      method?: RankMethod;
      name: string;
      offset?: number;
      orderBy?: { descending: boolean; expr: ExprNode }[];
      partitionBy?: string[];
      type: "window";
  }

  • Optionalexpr?: ExprNode

  • fn: "rank" | "lag" | "lead" | "cumsum" | "rowNumber"

  • input: PlanNode

  • Optionalmethod?: RankMethod

    rank only; default 'average'

  • name: string

  • Optionaloffset?: number

  • OptionalorderBy?: { descending: boolean; expr: ExprNode }[]

  • OptionalpartitionBy?: string[]

  • type: "window"

• {
      agg: AggKind;
      column: string;
      input: PlanNode;
      name: string;
      type: "rolling";
      window: number;
  }
• {
      agg: AggKind;
      column: string;
      input: PlanNode;
      name: string;
      type: "expanding";
  }
• { end?: number; input: PlanNode; start: number; type: "slice" }
• { indices: number[]; input: PlanNode; type: "take" }
• {
      fraction?: number;
      input: PlanNode;
      n?: number;
      seed?: number;
      type: "sample";
  }
• { column: string; input: PlanNode; type: "explode" }
• { column: string; input: PlanNode; separator?: string; type: "unnest" }
• { headerColumn?: string; input: PlanNode; type: "transpose" }
• { columns?: string[]; input: PlanNode; type: "interpolate" }
• {
      columns?: string[];
      input: PlanNode;
      keep: "first" | "last" | "none";
      type: "unique";
  }
• { column: string; input: PlanNode; normalize: boolean; type: "valueCounts" }
• { input: PlanNode; quantileMethod?: QuantileMethod; type: "describe" }
• {
      columns?: string[];
      input: PlanNode;
      kind: "corr" | "cov";
      method: CorrMethod;
      type: "corr";
  }

  • Optionalcolumns?: string[]

  • input: PlanNode

  • kind: "corr" | "cov"

  • method: CorrMethod

  • type: "corr"

    Pairwise correlation / covariance matrix over numeric columns (pairwise-complete rows, n−1).