DslGrammar

Columns Selection DSL Grammar

(What is this notation?)

Definitions:

columnGroupReference: String| ColumnPath

colSelector: ColumnSelector

colsSelector: ColumnsSelector

column: ColumnAccessor| String| ColumnPath

columnGroup: SingleColumn<DataRow<*>> | String| ColumnPath

columnNoAccessor: String| ColumnPath

columnOrSet: column| columnSet

columnSet: ColumnSet<*>

columnsResolver: ColumnsResolver

condition: ColumnFilter

expression: Column Expression

ignoreCase: Boolean

index: Int

indexRange: IntRange

infer: Infer

kind: ColumnKind

kType: KType

name: String

number: Int

regex: Regex

singleColumn: SingleColumn<DataRow<*>>

T: Column type

text: String

What can be called directly in the Columns Selection DSL:

column..column

| this/it[column,.. ]

| this/it[{ condition}]

| all()

| all(Before|After|From|UpTo) ( (column)| { colSelector})

| allExcept{ colsSelector}

| allExcept(column,..)

| columnOrSetand[ {] columnOrSet[ }]

| columnOrSet.and(|{ columnOrSet}|)

| (col| valueCol| frameCol| colGroup)[<T>](column| index)

| (cols| valueCols| frameCols| colGroups) [ { condition}]

| cols[<T>](column,.. | index,.. | indexRange)

| colsAtAnyDepth()

| colsInGroups()

| colsOf<T>[ (kType)] [ { condition}]

| colsOfKind(kind,..)[ { condition}]

| drop(Last)(number)

| drop(Last)While{ condition}

| expr([name,][infer]) { expression}

| (first|last) [ { condition}]

| single()

| nameContains(text[, ignoreCase] | regex)

| name(Starts|Ends)With(text[, ignoreCase])

| columnnamed/intocolumn

| column(.named|.into)(column)

| none()

| take(Last)(number)

| take(Last)While{ condition}

| withoutNulls()

What can be called on a ColumnSet:

columnSet

    [index]

    | [index,.. | indexRange]

    | [{ condition}]

    | .all()

    | .all(Before|After|From|UpTo) ( (column)| { condition})

    | .and(|{ columnOrSet}|)

    | (.col| .valueCol| .frameCol| .colGroup)(index)

    | (.cols| .valueCols| .frameCols| .colGroups) [ { condition}]

    | .cols(index,.. | indexRange)

    | .colsAtAnyDepth()

    | .colsInGroups()

    | .colsOf<T>[ (kType)] [ { condition}]

    | .colsOfKind(kind,..)[ { condition}]

    | .distinct()

    | .drop(Last)(number)

    | .drop(Last)While{ condition}

    | except[{ ] columnsResolver[} ]

    | exceptcolumn

    | .except(column,..)

    | .filter{ condition}

    | (.first|.last) [ { condition}]

    | .single()

    | .name(Starts|Ends)With(text[, ignoreCase])

    | .nameContains(text[, ignoreCase] | regex)

    | .simplify()

    | .take(Last)(number)

    | .take(Last)While{ condition}

    | .withoutNulls()

What can be called on a Column Group (reference):

columnGroup

    | [column,..]

    | [{ condition}]

    | {colsSelector}

    | .allCols()

    | .allCols(Before|After|From|UpTo) ( (column)| { colSelector})

    | .allColsExcept{ colsSelector}

    | .allColsExcept(columnNoAccessor,..)

    | .and(|{ columnOrSet}|)

    | (.col| .valueCol| .frameCol| .colGroup)[<T>](column| index)

    | (.cols| .valueCols| .frameCols| .colGroups) [ { condition}]

    | .cols[<T>](column,.. | index,.. | indexRange)

    | .colsAtAnyDepth()

    | .colsInGroups()

    | .colsName(Starts|Ends)With(text[, ignoreCase])

    | .colsNameContains(text[, ignoreCase] | regex)

    | .colsOfKind(kind,..)[ { condition}]

    | .colsWithoutNulls()

    | .drop(Last)Cols(number)

    | .drop(Last)ColsWhile{ condition}

    | .except{ colsSelector}

    | .except(columnNoAccessor,..)

    | (.firstCol|.lastCol) [ { condition}]

    | .singleCol()

    | .select{ colsSelector}

    | .take(Last)Cols(number)

    | .take(Last)ColsWhile{ condition}

singleColumn

    .colsOf<T>[ (kType)] [ { condition}]

columnGroupReference

    .colsOf<T>(kType)[ { condition}]