allColsExcept

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ userData.allColsExcept{ "age" andheight }}

df.select{ city andname.allColsExcept{ firstName }}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ userData.allColsExcept("age", "height")}

df.select{ city andname.allColsExcept("firstName", "middleName")}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ userData.allColsExcept(pathOf("age"), "extraData"["item1"])}

df.select{ city andname.allColsExcept(pathOf("firstName"), "middleNames"["first"])}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ "userData".allColsExcept{ "age" andheight }}

df.select{ city and"name".allColsExcept{ firstName }}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ "userData".allColsExcept("age", "height")}

df.select{ city and"name".allColsExcept("firstName", "middleName")}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ "userData".allColsExcept(pathOf("age"), "extraData"["item1"])}

df.select{ city and"name".allColsExcept(pathOf("firstName"), "middleNames"["first"])}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ pathOf("userData").allColsExcept{ "age" andheight }}

df.select{ city and"pathTo"["myColGroup"].allColsExcept{ firstName }}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ pathOf("userData").allColsExcept("age", "height")}

df.select{ city and"pathTo"["myColGroup"].allColsExcept("firstName", "middleName")}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ pathOf("userData").allColsExcept(pathOf("age"), "extraData"["item1"])}

df.select{ city and"pathTo"["myColGroup"].allColsExcept(pathOf("firstName"), "middleNames"["first"])}

Parameters

See also

this.allColsExcept { other }

this.allColsExcept { others.toColumnSet() }

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ userData.allColsExcept(Person::age, Person::height)}

df.select{ city andname.allColsExcept(Person::firstName, Person::middleName)}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ "userData".allColsExcept(Person::age, Person::height)}

df.select{ city and"name".allColsExcept(Person::firstName, Person::middleName)}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ DataSchemaPerson::userData.allColsExcept{ "age" andheight }}

df.select{ city andPerson::name.allColsExcept{ firstName }}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ DataSchemaPerson::userData.allColsExcept("age", "height")}

df.select{ city andPerson::name.allColsExcept("firstName", "middleName")}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ DataSchemaPerson::userData.allColsExcept(Person::age, Person::height)}

df.select{ city andPerson::name.allColsExcept(Person::firstName, Person::middleName)}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ DataSchemaPerson::userData.allColsExcept(pathOf("age"), "extraData"["item1"])}

df.select{ city andPerson::name.allColsExcept(pathOf("firstName"), "middleNames"["first"])}

Parameters

See also

(All) (Cols) Except

Exclude a selection of columns from the current selection using the Columns Selection DSL.

For more information: See (All) (Cols) Except on the documentation website.

Check out: Grammar

On ColumnSets

This function can be explained the easiest with ColumnSets. Let's say we want all Int columns apart from age and height.

We can do:

df.select{ colsOf<Int>() except(age andheight) }

which will 'subtract' the ColumnSet created by age andheight from the ColumnSet created by colsOf<Int>().

This operation can also be used to exclude columns from Column Groups.

For instance:

df.select{ colsAtAnyDepth{ "a" init.name() } exceptuserData.age }

Note that the selection of columns to exclude from column sets is always done relative to the outer scope. Use the Extension Properties API to prevent scoping issues if possible.

Special case: If a column that needs to be removed appears multiple times in the ColumnSet, it is excepted each time it is encountered (including inside ColumnGroups). You could say the receiver ColumnSet is simplified before the operation is performed:

cols(a, a, a.b, a.b).except(a.b)

== cols(a).except(a.b)

In the ColumnsSelectionDsl

Instead of having to write all() except{ ... } in the DSL, you can use allExcept{ ... } to achieve the same result.

For example:

df.select{ allExcept{ userData.age andheight } }

On ColumnGroups: All Cols Except

The variant of this function on ColumnGroups is a bit different as it changes the scope relative to the column group.

In other words:

df.select{ myColGroup.allColsExcept{ colA andcolB } }

is shorthand for

df.select{ myColGroup.select{ all() except{ colA andcolB } } }

or

df.select{ myColGroup.allCols() except{ myColGroup.colA andmyColGroup.colB } }

Also note the name change, similar to allCols, this makes it clearer that you're selecting columns inside the group, 'lifting' them out.

On ColumnGroups: Except

This variant can be used to exclude some nested columns from a ColumnGroup in the selection. In contrast to allColsExcept, this function does not 'lift' the columns out of the group, preserving the structure.

So:

df.select{ colGroup.except{ col } }

is shorthand for:

df.select{ cols(colGroup) exceptcolGroup.col }

Examples for this overload

df.select{ pathOf("userData").allColsExcept(Person::age, Person::height)}

df.select{ city and"pathTo"["myColGroup"].allColsExcept(Person::firstName, Person::middleName)}

Parameters

See also