Class RelationBuilder

new RelationBuilder(): RelationBuilder

withRelationCommon(common: RelationCommon): RelationBuilder

withProject(expressions: Expression[], input?: Relation): RelationBuilder

withFilter(condition: Expression, input?: Relation): RelationBuilder

withLocalRelation(localRelation: LocalRelation): RelationBuilder

withRange(
    start: bigint,
    end: bigint,
    step: bigint,
    numPartitions?: number,
): RelationBuilder

withRead(read: Read): RelationBuilder

withReadTable(
    table: string,
    options: CaseInsensitiveMap<string>,
    isStreaming?: boolean,
): RelationBuilder

withReadDataSource(
    format: undefined | string,
    schema: undefined | string,
    paths: string[],
    predicates: string[],
    options: CaseInsensitiveMap<string>,
    isStreaming?: boolean,
): RelationBuilder

withLimit(limit: number, input?: Relation): RelationBuilder

withOffset(offset: number, input?: Relation): RelationBuilder

withTail(limit: number, input?: Relation): RelationBuilder

withToDf(columns: string[], input?: Relation): RelationBuilder

withToSchema(schema: StructType, input?: Relation): RelationBuilder

withShowString(
    numRows: number,
    truncate: number,
    vertical: boolean,
    input?: Relation,
): RelationBuilder

withCatalog(catalog: Catalog): void

withCatalogBuilder(f: (builder: CatalogBuilder) => void): void

withHint(name: string, parameters: any[], input?: Relation): RelationBuilder

withAggregate(aggregate: Aggregate): RelationBuilder

withAggregateBuilder(f: (b: AggregateBuilder) => void): RelationBuilder

withUnpivot(
    ids: Column[],
    variableColumnName: string,
    valueColumnName: string,
    values?: Column[],
    input?: Relation,
): RelationBuilder

withTranspose(indexColumn?: Column, input?: Relation): RelationBuilder

withSetOperation(
    left?: Relation,
    right?: Relation,
    operation?: string,
    isAll?: boolean,
    byName?: boolean,
    allowMissingColumns?: boolean,
): RelationBuilder

withJoin(
    left?: Relation,
    right?: Relation,
    joinCondition?: Expression,
    joinType?: string,
    usingColumns?: string[],
): RelationBuilder

withAsOfJoin(
    left?: Relation,
    right?: Relation,
    leftAsOf?: Expression,
    rightAsOf?: Expression,
    joinExpr?: Expression,
    usingColumns?: string[],
    joinType?: string,
    tolerance?: Expression,
    allowExactMatches?: boolean,
    direction?: string,
): RelationBuilder

withLateralJoin(
    left?: Relation,
    right?: Relation,
    joinType?: string,
    condition?: Expression,
): RelationBuilder

withRepartition(
    numPartitions: number,
    shuffle: boolean,
    input?: Relation,
): RelationBuilder

withRepartitionByExpression(
    partitionExprs: Expression[],
    numPartitions?: number,
    input?: Relation,
): RelationBuilder

withStatCov(col1: string, col2: string, input?: Relation): RelationBuilder

withStatCorr(
    col1: string,
    col2: string,
    method?: string,
    input?: Relation,
): RelationBuilder

withStatCrosstab(col1: string, col2: string, input?: Relation): RelationBuilder

withStatFreqItems(
    cols: string[],
    support?: number,
    input?: Relation,
): RelationBuilder

withStatSampleBy(
    col: Column,
    fractions: Map<any, number>,
    seed?: number,
    input?: Relation,
): RelationBuilder

withStatApproxQuantile(
    cols: string[],
    probabilities: number[],
    relativeError: number,
    input?: Relation,
): RelationBuilder

withNAFill(
    cols: undefined | string[],
    values: (string | number | boolean)[],
    input?: Relation,
): RelationBuilder

withNADrop(
    cols: undefined | string[],
    minNonNulls: undefined | number,
    input?: Relation,
): RelationBuilder

withNAReplace(
    cols: undefined | string[],
    replacementMap: { [key: string]: null | string | number | boolean },
    input?: Relation,
): RelationBuilder

withMapPartitions(
    pythonCode: string,
    outputSchema: StructType,
    input?: Relation,
    pythonVersion?: string,
): RelationBuilder

withGroupMap(
    groupingExpressions: Expression[],
    pythonCode: string,
    outputSchema: StructType,
    input?: Relation,
    pythonVersion?: string,
): RelationBuilder

withCoGroupMap(
    input: Relation,
    inputGroupingExpressions: Expression[],
    other: Relation,
    otherGroupingExpressions: Expression[],
    pythonCode: string,
    outputSchema: StructType,
    pythonVersion?: string,
): RelationBuilder

build(): Relation