WOLFRAM

Wolfram Language & System Documentation Center

ColumnwiseCombine[{tab1,…}ckey]

combines Tabular objects tab1,… by joining all combinations of rows where the values of the columns with key ckey from each of the tabi are the same.

ColumnwiseCombine[{tab1,…}{ckey1,ckey2,…}]

combines rows where the values of all of the columns having keys ckeyj have the same values.

ColumnwiseCombine[{tab1ckey1,tab2ckey2,…}]

joins rows with common values in columns with key ckeyi in tabi.

ColumnwiseCombine[<|p1tab1,p2tab2,…|>]

prefixes column key ckeyij in tabi in the result using ExtendedKey[pi,ckeyij].

ColumnwiseCombine[<|p1tab1,p2tab2,…|>tfun]

includes joined rows for all combinations of rows where tfun[<|p1tab1[j1], p2tab2[j2], …|>] is True for all 1≤j1≤Length[tab1], 1≤j2≤Length[tab2], ….

ColumnwiseCombine[tabs,required]

includes all rows in the Tabular objects specified by required by combining with rows of all missing elements from the other Tabular objects if needed.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Matching Keys  
Required Rows  
Key Prefixes and Collisions  
Match Test Functions  
Applications  
Properties & Relations  
See Also
Related Guides
History
Cite this Page

ColumnwiseCombine

ColumnwiseCombine[{tab1,…}ckey]

combines Tabular objects tab1,… by joining all combinations of rows where the values of the columns with key ckey from each of the tabi are the same.

ColumnwiseCombine[{tab1,…}{ckey1,ckey2,…}]

combines rows where the values of all of the columns having keys ckeyj have the same values.

ColumnwiseCombine[{tab1ckey1,tab2ckey2,…}]

joins rows with common values in columns with key ckeyi in tabi.

ColumnwiseCombine[<|p1tab1,p2tab2,…|>]

prefixes column key ckeyij in tabi in the result using ExtendedKey[pi,ckeyij].

ColumnwiseCombine[<|p1tab1,p2tab2,…|>tfun]

includes joined rows for all combinations of rows where tfun[<|p1tab1[j1], p2tab2[j2], …|>] is True for all 1≤j1≤Length[tab1], 1≤j2≤Length[tab2], ….

ColumnwiseCombine[tabs,required]

includes all rows in the Tabular objects specified by required by combining with rows of all missing elements from the other Tabular objects if needed.

Details and Options

  • ColumnwiseCombine is typically used to combine several Tabular objects into a single one.
  • With two Tabular objects tab1 and tab2, ColumnwiseCombine is effectively SQL JOIN.
  • The specification required for requiring rows from the {tab1,…,tabn} includes:
  • {} or "Inner"only include rows with matches
    Range[n] or "Outer"include all rows from all the tabulars
    1 or "Left"include all rows from the first tabular
    n or "Right"include all rows from the last tabular
    {i1,i2,…} include all rows from tabii,tabi2,…
    {pi1,pi2,…}use the prefixes to identify the tabulars
  • ColumnwiseCombine[p1tab1,p2tab2,…|>(True&)] yields a cross join.

Examples

open all close all

Basic Examples  (4)

Combine rows where the values in column "a" are the same:

Wolfram Language code: {tab1 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]], tab2 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> TypeSpecifier["Time"]["Integer64", "Instant", -6.]]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {4, {{{43200000000000, 50400000000000, 57600000000000, 64800000000000}, {}, None}}, None}, "ElementType" -> "Time"["Integer64", "Instant", -6.], "CachedOriginalExpression" -> {TimeObject[{6, 0, 0.}, "Instant", -6.], TimeObject[{8, 0, 0}, "Instant", -6.], TimeObject[{10, 0, 0}, "Instant", -6.], TimeObject[{12, 0, 0}, "Instant", -6.]}]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> "a"]

Combine three Tabular objects from rows that match in columns "a" and "b":

Wolfram Language code: {tab1, tab2, tab3} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8, 11}, "nororbutand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "e" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 2, 5}, "orand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[{tab1, tab2, tab3} -> {"a", "b"}]

Include all the rows of tab1, tab2 and tab3:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2, tab3} -> {"a", "b"}, "Outer"]

Combine three Tabular objects from rows that match in column "a" using prefixes to avoid collision in column "b":

Wolfram Language code: {tab1, tab2, tab3} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8, 11}, "nororbutand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "e" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 2, 5}, "orand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2, "γ" -> tab3|> -> "a"]

Give the result without the column "a" merged:

Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1 -> "a", "β" -> tab2 -> "a", "γ" -> tab3 -> "a"|>]

Include any combinations of rows that have matches in column "c" from tab1 and column "b" from tab3:

Wolfram Language code: {tab1 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], tab2 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 8, 10}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], tab3 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "e" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2, "γ" -> tab3|> -> Function[#α["c"] === #γ["b"]]]

Scope  (17)

Matching Keys  (2)

Give rows where the all of the values in columns "a" and "b" are the same:

Wolfram Language code: tab1 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]];
Wolfram Language code: tab2 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]];
Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}]

The order the keys are specified is used in the result but does not affect which rows match:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> {"b", "a"}]

Give all row combinations where the all of the values in columns "a" and "b" in tab1 and "A" and "B" in tab2 are the same:

Wolfram Language code: tab1 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]];
Wolfram Language code: tab2 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["A" -> Association["ElementType" -> "Integer64"], "B" -> Association["ElementType" -> "Integer64"], "D" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 2, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 2, 4, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 11, 10, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]];
Wolfram Language code: ColumnwiseCombine[{tab1 -> {"a", "b"}, tab2 -> {"A", "B"}}]

There are no combinations of rows that have values matching in both "a" and "B" and "b" and "A":

Wolfram Language code: ColumnwiseCombine[{tab1 -> {"a", "b"}, tab2 -> {"B", "A"}}]

There is a single row combination that matches in column "a" from tab1 and "A" and "B" from tab2:

Wolfram Language code: ColumnwiseCombine[{tab1 -> {"a", "a"}, tab2 -> {"A", "B"}}]

The combination is row 3 from tab1 and row 2 from tab2:

Wolfram Language code: {aa3 = {tab1[3, "a"], tab1[3, "a"]}, AB2 = {tab2[2, "A"], tab2[2, "B"]}, aa3 == AB2}

Required Rows  (8)

Include only rows where values in both columns "a" and "b" match:

Wolfram Language code: {tab1, tab2} = { Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combi = ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, "Inner"]

This is the default and also equivalent to not requiring all rows from either tab1 or tab2:

Wolfram Language code: combi === ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}] === ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, {}]

Include an instance of all rows from both tab1 and tab2. Where there is not a match, values are filled in as missing:

Wolfram Language code: {tab1, tab2} = { Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combo = ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, "Outer"]

Using {1,2} for the specification is equivalent:

Wolfram Language code: combo === ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, {1, 2}]

With the specification {2,1}, the unmatched rows from tab2 are included before those of tab1:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, {2, 1}]

Include an instance of all rows from tab1:

Wolfram Language code: {tab1, tab2} = { Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combl = ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, {1}]

Using "Left" for the specification is equivalent since tab1 is the leftmost in the list:

Wolfram Language code: combl === ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, "Left"]

Include an instance of all rows from tab2:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combr = ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, {2}]

Using "Right" for the specification is equivalent since tab1 is the leftmost in the list:

Wolfram Language code: combr === ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}, "Right"]

Include only combinations of rows from three Tabular objects where the values of column "a" match:

Wolfram Language code: tabs = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-1, 0, 1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combi = ColumnwiseCombine[tabs -> {"a"}, "Inner"]

This is the default and also equivalent to specifying no row requirement:

Wolfram Language code: combi === ColumnwiseCombine[tabs -> "a"] === ColumnwiseCombine[tabs -> "a", {}]

Include an instance of all rows from three Tabular objects:

Wolfram Language code: tabs = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-1, 0, 1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combo = ColumnwiseCombine[tabs -> {"a"}, "Outer"]

Using {1,2,3} for the specification is equivalent:

Wolfram Language code: combo === ColumnwiseCombine[tabs -> "a", {1, 2, 3}]

Show the result of all possible specifications for the required rows for three Tabular objects:

Wolfram Language code: tabs = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-1, 0, 1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: possible = Permutations[{1, 2, 3}, {0, 3}]
Wolfram Language code: Map[Labeled[ColumnwiseCombine[tabs -> "a", #], #]&, possible]

When there are no matches, using "Outer" effectively stacks the Tabular objects:

Wolfram Language code: tabs = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["c" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["e" -> Association["ElementType" -> "Integer64"], "f" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-1, 0, 1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combo = ColumnwiseCombine[tabs -> Function[False], "Outer"]

This is equivalent to using Join:

Wolfram Language code: Join@@tabs

Key Prefixes and Collisions  (2)

Find combinations of rows where column "a" matches:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> "a"]

Using the key prefixes given with Association is necessary because there is a collision with column "b" where the values do not match:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> "a"]

When the match column names are given with specific Tabular objects, the matched columns are included with the prefixed names:

Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1 -> "a", "β" -> tab2 -> "a"|>]

Include all the rows from two Tabular objects, merging row combinations where the values of column "b" match:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> "b", "Outer"]

A mix of columns to match and merge and just to match may be used:

Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1 -> "b", "β" -> tab2 -> "b"|> -> "a"]

When the match column names are given with specific Tabular objects, the matched columns are included with the prefixed names and have missing elements where there is not a match:

Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1 -> "b", "β" -> tab2 -> "b"|> -> "a", "Outer"]

Match Test Functions  (5)

Do a cross join (where any combination of rows is considered a match and included) of three Tabular objects:

Wolfram Language code: tabs = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["c" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["e" -> Association["ElementType" -> "Integer64"], "f" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-1, 0, 1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: cj = ColumnwiseCombine[tabs -> Function[True]]

In this case, the specification for required rows makes no difference, since all rows are included anyway:

Wolfram Language code: cj === ColumnwiseCombine[tabs -> Function[True], "Outer"]

Specify that the values from column "a" of tab1 or column "c" of tab2 are the same:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["c" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: comb = ColumnwiseCombine[{tab1, tab2} -> Function[#[[1]]["a"] === #[[2]]["c"]]]

This is equivalent to using column names:

Wolfram Language code: comb === ColumnwiseCombine[{tab1 -> "a", tab2 -> "c"}]

The function gets a single argument for each possible combination of rows; for row i from tab1 and row j from tab2, the argument is a list of Association objects, {Normal[tab1[i]],Normal[tab2[j]]}:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> Function[Echo[#];#[[1]]["a"] === #[[2]]["c"]]]

With Apply, the function gets two arguments and positional parameters may be used:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> Apply[Function[#1["a"] === #2["c"]]]]

When the first argument is given as an association, the function gets an Association argument:

Wolfram Language code: ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> Function[Echo[#];#α["a"] === #β["c"]]]

Find the combinations of rows where values in column "a" is the same and values in column "b" have the same length:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8, 11}, "nororbutand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: comb = ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> Function[(#α["a"] === #β["a"]) && (StringLength[#α["b"]] === StringLength[#β["b"]])]]

Find the combinations of rows where the parity of the values in column "a" is the opposite of the values in column "b":

Wolfram Language code: {tab1, tab2} = { Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 6, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: comb = ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> Function[EvenQ[#α["a"]] === EvenQ[#β["a"]] === OddQ[#α["b"]] === OddQ[#β["b"]]]]

Include all rows:

Wolfram Language code: comb = ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> Function[EvenQ[#α["a"]] === EvenQ[#β["a"]] === OddQ[#α["b"]] === OddQ[#β["b"]]], "Outer"]

Include any combinations of rows that have matches in column "a" from tab1 and tab2, "c" from tab1 and column "b" from tab3:

Wolfram Language code: tabs = <|"α" -> Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "c" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{7, 8, 9}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], "β" -> Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{2, 4, 8, 10}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association[ "Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], "γ" -> Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"], "e" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 8}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]|>;
Wolfram Language code: ColumnwiseCombine[tabs -> Function[#α["a"] === #β["a"] && #α["c"] === #γ["b"]]]

Include all rows:

Wolfram Language code: ColumnwiseCombine[tabs -> Function[#α["a"] === #β["a"] && #α["c"] === #γ["b"]], "Outer"]

Applications  (2)

Compare data from an imported table of country data with Wolfram "Country" entity data:

Wolfram Language code: imported = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["CountryCode" -> Association["ElementType" -> "String"], "latitude" -> Association["ElementType" -> "Real64"], "longitude" -> Association["ElementType" -> "Real64"], "name" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488}, "ADAEAFAGAIALAMANAOAQARASATAUAWAZBABBBDBEBFBGBHBIBJBMBNBOBR\ BSBTBVBWBYBZCACCCDCFCGCHCICKCLCMCNCOCRCUCVCXCYCZDEDJDKDMDODZECEEEGEHERESETFIFJFKFMFOFRGAGBGDGEGFGGG\ HGIGLGMGNGPGQGRGSGTGUGWGYGZHKHMHNHRHTHUIDIEILIMINIOIQIRISITJEJMJOJPKEKGKHKIKMKNKPKRKWKYKZLALBLCLILK\ LRLSLTLULVLYMAMCMDMEMGMHMKMLMMMNMOMPMQMRMSMTMUMVMWMXMYMZNCNENFNGNINLNONPNRNUNZOMPAPEPFPGPHPKPLPMPNP\ RPSPTPWPYQARERORSRURWSASBSCSDSESGSHSISJSKSLSMSNSOSRSTSVSYSZTCTDTFTGTHTJTKTLTMTNTOTRTTTVTWTZUAUGUMUS\ UYUZVAVCVEVGVIVNVUWFWSXKYEYTZAZMZW"}, {}, DataStructure["BitVector", {"Data" -> ByteArray["/////////////////////////+///////////////w=="], "Capacity" -> 245, "BitCount" -> 244}]}, "ElementType" -> "String", "CachedOriginalExpression" -> {"AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BM", "BN", "BO", "BR", "BS", "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "GZ", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", Missing["NotAvailable"], "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "XK", "YE", "YT", "ZA", "ZM", "ZW"}]], TabularColumn[Association["Data" -> {{42.546245, 23.424076, 33.93911, 17.060816, 18.220554, 41.153332, 40.069099, 12.226079, -11.202692, -75.250973, -38.416097, -14.270972, 47.516231, -25.274398, 12.52111, 40.143105, 43.915886, 13.193887, 23.684994, 50.503887, 12.238333, 42.733883, 25.930414, -3.373056, 9.30769, 32.321384, 4.535277, -16.290154, -14.235004, 25.03428, 27.514162, -54.423199, -22.328474, 53.709807, 17.189877, 56.130366, -12.164165, -4.038333, 6.611111, -0.228021, 46.818188, 7.539989, -21.236736, -35.6 ... 676, 21.005859, 105.318756, 29.873888, 45.079162, 160.156194, 55.491977, 30.217636, 18.643501, 103.819836, -10.030696, 14.995463, 23.670272, 19.699024, -11.779889, 12.457777, -14.452362, 46.199616, -56.027783, 6.613081, -88.89653, 38.996815, 31.465866, -71.797928, 18.732207, 69.348557, 0.824782, 100.992541, 71.276093, -171.855881, 125.727539, 59.556278, 9.537499, -175.198242, 35.243322, -61.222503, 177.64933, 120.960515, 34.888822, 31.16558, 32.290275, Missing["NotAvailable"], -95.712891, -55.765835, 64.585262, 12.453389, -61.287228, -66.58973, -64.639968, -64.896335, 108.277199, 166.959158, -177.156097, -172.104629, 20.902977, 48.516388, 45.166244, 22.937506, 27.849332, 29.154857}]], TabularColumn[ Association["Data" -> {{2, {0, 7, 27, 38, 57, 65, 72, 79, 99, 105, 115, 124, 138, 145, 154, 159, 169, 191, 199, 209, 216, 228, 236, 243, 250, 255, 262, 268, 275, 281, 288, 294, 307, 315, 322, 328, 334, 357, 368, 392, 408, 419, 433, 445, 450, 458, 463, 471, 481, 485, 495, 511, 517, 531, 538, 546, 553, 561, 579, 586, 593, 600, 605, 619, 626, 631, 639, 646, 650, 683, 693, 706, 712, 717, 731, 738, 745, 758, 766, 771, 780, 789, 795, 801, 811, 828, 834, 878, 887, 891, 904, 910, 920, 929, 962, 970, 977, 982, 989, 998, 1005, 1011, 1022, 1027, 1057, 1061, 1065, 1072, 1077, 1083, 1090, 1096, 1101, 1106, 1116, 1124, 1132, 1139, 1160, 1171, 1182, 1188, 1202, 1212, 1216, 1223, 1234, 1247, 1256, 1263, 1270, 1279, 1289, 1295, 1300, 1307, 1313, 1320, 1330, 1340, 1356, 1373, 1377, 1392, 1400, 1405, 1429, 1439, 1449, 1459, 1464, 1473, 1481, 1487, 1493, 1501, 1511, 1518, 1531, 1536, 1550, 1557, 1566, 1577, 1583, 1588, 1593, 1597, 1608, 1612, 1618, 1622, 1638, 1654, 1665, 1673, 1679, 1704, 1720, 1731, 1754, 1762, 1767, 1775, 1780, 1788, 1795, 1801, 1807, 1813, 1825, 1840, 1850, 1855, 1861, 1870, 1882, 1890, 1912, 1920, 1932, 1942, 1949, 1956, 1964, 1988, 1999, 2004, 2013, 2037, 2041, 2068, 2072, 2080, 2090, 2097, 2108, 2120, 2127, 2132, 2138, 2157, 2163, 2169, 2177, 2184, 2190, 2217, 2230, 2237, 2247, 2259, 2291, 2300, 2322, 2341, 2348, 2355, 2372, 2377, 2383, 2388, 2395, 2407, 2413, 2421}, "AndorraUnited Arab \ EmiratesAfghanistanAntigua and BarbudaAnguillaAlbaniaArmeniaNetherlands \ AntillesAngolaAntarcticaArgentinaAmerican SamoaAustriaAustraliaArubaAzerbaijanBosnia and \ HerzegovinaBarbadosBangladeshBelgiumBurkina \ FasoBulgariaBahrainBurundiBeninBermudaBruneiBoliviaBrazilBahamasBhutanBouvet \ IslandBotswanaBelarusBelizeCanadaCocos [Keeling] IslandsCongo [DRC]Central African RepublicCongo \ [Republic]SwitzerlandCôte d'IvoireCook IslandsChileCameroonChinaColombiaCosta RicaCubaCape \ VerdeChristmas IslandCyprusCzech RepublicGermanyDjiboutiDenmarkDominicaDominican \ RepublicAlgeriaEcuadorEstoniaEgyptWestern SaharaEritreaSpainEthiopiaFinlandFijiFalkland Islands \ [Islas Malvinas]MicronesiaFaroe IslandsFranceGabonUnited KingdomGrenadaGeorgiaFrench \ GuianaGuernseyGhanaGibraltarGreenlandGambiaGuineaGuadeloupeEquatorial GuineaGreeceSouth Georgia and \ the South Sandwich IslandsGuatemalaGuamGuinea-BissauGuyanaGaza StripHong KongHeard Island and \ McDonald IslandsHondurasCroatiaHaitiHungaryIndonesiaIrelandIsraelIsle of ManIndiaBritish Indian \ Ocean \ TerritoryIraqIranIcelandItalyJerseyJamaicaJordanJapanKenyaKyrgyzstanCambodiaKiribatiComorosSaint \ Kitts and NevisNorth KoreaSouth KoreaKuwaitCayman IslandsKazakhstanLaosLebanonSaint \ LuciaLiechtensteinSri \ LankaLiberiaLesothoLithuaniaLuxembourgLatviaLibyaMoroccoMonacoMoldovaMontenegroMadagascarMarshall \ IslandsMacedonia [FYROM]MaliMyanmar [Burma]MongoliaMacauNorthern Mariana \ IslandsMartiniqueMauritaniaMontserratMaltaMauritiusMaldivesMalawiMexicoMalaysiaMozambiqueNamibiaNew \ CaledoniaNigerNorfolk IslandNigeriaNicaraguaNetherlandsNorwayNepalNauruNiueNew \ ZealandOmanPanamaPeruFrench PolynesiaPapua New GuineaPhilippinesPakistanPolandSaint Pierre and \ MiquelonPitcairn IslandsPuerto RicoPalestinian \ TerritoriesPortugalPalauParaguayQatarRéunionRomaniaSerbiaRussiaRwandaSaudi ArabiaSolomon \ IslandsSeychellesSudanSwedenSingaporeSaint HelenaSloveniaSvalbard and Jan MayenSlovakiaSierra \ LeoneSan MarinoSenegalSomaliaSurinameSão Tomé and PríncipeEl SalvadorSyriaSwazilandTurks and Caicos \ IslandsChadFrench Southern \ TerritoriesTogoThailandTajikistanTokelauTimor-LesteTurkmenistanTunisiaTongaTurkeyTrinidad and \ TobagoTuvaluTaiwanTanzaniaUkraineUgandaU.S. Minor Outlying IslandsUnited \ StatesUruguayUzbekistanVatican CitySaint Vincent and the GrenadinesVenezuelaBritish Virgin \ IslandsU.S. Virgin IslandsVietnamVanuatuWallis and FutunaSamoaKosovoYemenMayotteSouth \ AfricaZambiaZimbabwe"}, {}, None}, "ElementType" -> "String"]]}}]]]];
Wolfram Language code: countryData = Tabular[EntityValue["Country", {"CountryCode", "Name", "Population", "Area"}, "PropertyAssociation"]]

Get the cases where the country names are inconsistent:

Wolfram Language code: comb = ColumnwiseCombine[<|"imported" -> imported, "CountryData" -> countryData|> -> Function[SameQ[#imported["CountryCode"], #CountryData["CountryCode"]] && UnsameQ[#imported["name"], #CountryData["Name"]]]]

Show just the names and country codes:

Wolfram Language code: comb[All, {ExtendedKey["CountryData", "CountryCode"], "Name", "name"}]

Combine the two tables by matching country code:

Wolfram Language code: ColumnwiseCombine[{countryData, imported} -> "CountryCode"]

Add an extra column showing the survival rate by sex and class in a subset of the Titanic dataset:

Wolfram Language code: titanic = Take[ResourceData["Sample Tabular Data: Titanic"], 1 ;; -1 ;; 100]

Aggregate by sex and class:

Wolfram Language code: rates = AggregateRows[titanic, "sc survival rate" -> Function[Mean[Boole[#survived]]], {"sex", "class"}]

Combine these tables to get the new column:

Wolfram Language code: ColumnwiseCombine[{titanic, rates} -> {"sex", "class"}]

Properties & Relations  (4)

When there are no matches, using "Outer" effectively joins the Tabular objects:

Wolfram Language code: tabs = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-2, 0, 2, 4}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["c" -> Association["ElementType" -> "Integer64"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{1, -1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["e" -> Association["ElementType" -> "Integer64"], "f" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 0}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{-1, 0, 1}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: combo = ColumnwiseCombine[tabs -> {}, "Outer"]

This is equivalent to using Join:

Wolfram Language code: Join@@tabs

With only two Tabular objects and no column collisions, ColumnwiseCombine and JoinAcross do the same operation:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8, 11}, "nororbutand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> {"a", "b"}]
Wolfram Language code: JoinAcross[tab1, tab2, {"a", "b"}]

When there is a key collision, JoinAcross uses a key collision function (default left):

Wolfram Language code: JoinAcross[tab1, tab2, {"a"}]
Wolfram Language code: JoinAcross[tab1, tab2, {"a"}, KeyCollisionFunction -> Function[{ExtendedKey["left", #], ExtendedKey["right", #]}]]

With ColumnwiseCombine, key collisions are not allowed without key prefixes:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2} -> "a"]
Wolfram Language code: ColumnwiseCombine[<|left -> tab1, right -> tab2|> -> "a"]

Compare ternary ColumnwiseCombine with nested JoinAcross:

Wolfram Language code: tab1 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]];
Wolfram Language code: tab2 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8, 11}, "nororbutand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]];
Wolfram Language code: tab3 = Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "e" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 2, 5}, "orand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]];
Wolfram Language code: ColumnwiseCombine[{tab1, tab2, tab3} -> {"a", "b"}, "Inner"]

Define a function to successively combine pairs:

Wolfram Language code: pairwiseCombine[tabs_ -> ckeys_, req_] := Fold[JoinAcross[#1, #2, ckeys, req] &, First[tabs], Rest[tabs]]

When the column names are consistent and no extra rows are required, this is consistent with ColumnwiseCombine:

Wolfram Language code: pairwiseCombine[{tab1, tab2, tab3} -> {"a", "b"}, "Inner"]

However, when extra rows are required, the results may be different:

Wolfram Language code: ColumnwiseCombine[{tab1, tab2, tab3} -> {"a", "b"}, "Outer"]
Wolfram Language code: pairwiseCombine[{tab1, tab2, tab3} -> {"a", "b"}, "Outer"]

ColumnwiseCombine is effectively an outer product of rows:

Wolfram Language code: {tab1, tab2} = {Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{3, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8}, "andorbut"}, {}, None}, "ElementType" -> "String"]]}}]]]], Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"], "d" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{0, 1, 1, 2}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 5, 8, 11}, "nororbutand"}, {}, None}, "ElementType" -> "String"]], TabularColumn[Association["Data" -> {{9, 10, 11, 12}, {}, None}, "ElementType" -> "Integer64"]]}}]]]]};
Wolfram Language code: testf = Function[#α["a"] === #β["a"] && StringLength[#α["b"]] === StringLength[#β["b"]]]; ColumnwiseCombine[<|"α" -> tab1, "β" -> tab2|> -> testf]

Use Outer to find which combinations of rows give True:

Wolfram Language code: {n1, n2} = Normal[{tab1, tab2}]
Wolfram Language code: prod = Outer[testf[<|"α" -> #1, "β" -> #2|>]&, n1, n2]

These are the row combinations that match:

Wolfram Language code: matches = Position[prod, True]

Make a Tabular object with merged columns:

Wolfram Language code: Tabular[MapApply[Join[n1[[#1]], n2[[#2]]]&, matches]]

Use ExtendedKey to form the same result as ColumnwiseCombine:

Wolfram Language code: extendKeys[p_, row_] := KeyMap[ExtendedKey[p, #]&, row];
Wolfram Language code: Tabular[MapApply[Join[extendKeys["α", n1[[#1]]], extendKeys["β", n2[[#2]]]]&, matches]]
Wolfram Research (2025), ColumnwiseCombine, Wolfram Language function, https://reference.wolfram.com/language/ref/ColumnwiseCombine.html.

Text

Wolfram Research (2025), ColumnwiseCombine, Wolfram Language function, https://reference.wolfram.com/language/ref/ColumnwiseCombine.html.

CMS

Wolfram Language. 2025. "ColumnwiseCombine." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/ColumnwiseCombine.html.

APA

Wolfram Language. (2025). ColumnwiseCombine. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ColumnwiseCombine.html

BibTeX

@misc{reference.wolfram_2026_columnwisecombine, author="Wolfram Research", title="{ColumnwiseCombine}", year="2025", howpublished="\url{https://reference.wolfram.com/language/ref/ColumnwiseCombine.html}", note=[Accessed: 12-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_columnwisecombine, organization={Wolfram Research}, title={ColumnwiseCombine}, year={2025}, url={https://reference.wolfram.com/language/ref/ColumnwiseCombine.html}, note=[Accessed: 12-June-2026]}