outerjoin

两个表或时间表之间的外联

全页折叠

语法

T = outerjoin(Tleft,Tright)
T = outerjoin(Tleft,Tright,Name,Value)
[T,ileft,iright] = outerjoin(___)

说明

T = outerjoin(Tleft,Tright) 使用键变量对 Tleft 和 Tright 进行外联，从而创建表或时间表 T。外联合并键变量具有匹配值的表行，但也包括来自一个输入表的键变量在另一个输入表中没有匹配项的行。例如，如果 Tleft 具有名为 Key1 和 Var1 的变量，Tright 具有变量 Key1 和 Var2，则 T=outerjoin(Tleft,Tright) 使用 Key1 作为键变量。

The output T has variables Key1_Tleft, Var1, Key1_Tright, and Var2, and combines all rows from both inputs, filling empty table elements with missing values.

默认情况下，键变量是：

  • 在 Tleft 和 Tright 中具有相同名称的变量，如果两个输入均为表，或如果 Tleft 是时间表而 Tright 是表。

  • 行时间的向量，如果 Tleft 和 Tright 均为时间表。

左表和右表中键变量的匹配值不必按相同顺序排列。外联可以在两个表的键变量之间执行一对多和多对一匹配。也就是说，在左表的键变量中出现一次的值在右表中可能有多个匹配项。同样，在右表的键变量中出现一次的值在左表中也可能有多个匹配项。

您只能对某些表和时间表组合执行外联。

  • 如果 Tleft 是表，则 Tright 必须是表。outerjoin 以表的形式返回 T。

  • 如果 Tleft 是时间表，则 Tright 可以是表，也可以是时间表。outerjoin 以时间表的形式为两种输入组合返回 T。

示例

T = outerjoin(Tleft,Tright,Name,Value) 通过一个或多个 Name,Value 对组参量指定的其他选项执行外联运算。

示例

[T,ileft,iright] = outerjoin(___) 还返回索引向量 ileft 和 iright，以分别指出 T 中的行与 Tleft 和 Tright 中的行之间的对应项。您可以将这些与以上语法中的任何输入参量结合使用。

示例

示例

全部折叠

打开实时脚本

创建表 Tleft。

Tleft = table([5;12;23;2;15;6],...
        {'cheerios';'pizza';'salmon';'oreos';'lobster';'pizza'},...
        'VariableNames',{'Age','FavoriteFood'},...
        'RowNames',{'Amy','Bobby','Holly','Harry','Marty','Sally'})
Tleft=6×2 table
             Age    FavoriteFood
             ___    ____________

    Amy       5     {'cheerios'}
    Bobby    12     {'pizza'   }
    Holly    23     {'salmon'  }
    Harry     2     {'oreos'   }
    Marty    15     {'lobster' }
    Sally     6     {'pizza'   }

创建表 Tright，使其与 Tleft 有一个名为 FavoriteFood 的共同变量。 

Tright = table({'cheerios';'oreos';'pizza';'salmon';'cake'},...
         [110;160;140;367;243],...
         {'A-';'D';'B';'B';'C-'},...
         'VariableNames',{'FavoriteFood','Calories','NutritionGrade'})
Tright=5×3 table
    FavoriteFood    Calories    NutritionGrade
    ____________    ________    ______________

    {'cheerios'}      110           {'A-'}    
    {'oreos'   }      160           {'D' }    
    {'pizza'   }      140           {'B' }    
    {'salmon'  }      367           {'B' }    
    {'cake'    }      243           {'C-'}

使用 outerjoin 函数创建新表 T，其数据来自表 Tleft 和 Tright。 

T = outerjoin(Tleft,Tright)
T=7×5 table
    Age    FavoriteFood_Tleft    FavoriteFood_Tright    Calories    NutritionGrade
    ___    __________________    ___________________    ________    ______________

    NaN       {0×0 char  }          {'cake'    }          243         {'C-'    }  
      5       {'cheerios'}          {'cheerios'}          110         {'A-'    }  
     15       {'lobster' }          {0×0 char  }          NaN         {0×0 char}  
      2       {'oreos'   }          {'oreos'   }          160         {'D'     }  
     12       {'pizza'   }          {'pizza'   }          140         {'B'     }  
      6       {'pizza'   }          {'pizza'   }          140         {'B'     }  
     23       {'salmon'  }          {'salmon'  }          367         {'B'     }

表 T 包含对应 Tleft 中键变量的单独变量 FavoriteFood_Tleft，以及对应 Tright 中键变量的单独变量 FavoriteFood_Tright。

打开实时脚本

创建表 Tleft。

Tleft = table({'a' 'b' 'c' 'e' 'h'}',[1 2 3 11 17]',...
        'VariableNames',{'Key1' 'Var1'})
Tleft=5×2 table
    Key1     Var1
    _____    ____

    {'a'}      1 
    {'b'}      2 
    {'c'}      3 
    {'e'}     11 
    {'h'}     17

创建表 Tright，使变量 Key1 包含表 Tleft 和 Tright 的共同值，但同时也包含带有 Tleft 中不具备的 Key1 值的行。

Tright = table({'a','b','d','e'}',[4;5;6;7],...
         'VariableNames',{'Key1' 'Var2'})
Tright=4×2 table
    Key1     Var2
    _____    ____

    {'a'}     4  
    {'b'}     5  
    {'d'}     6  
    {'e'}     7

使用 outerjoin 函数创建新表 T，其数据来自表 Tleft 和 Tright。在输出表 T 中将键值合并成单一变量。

T = outerjoin(Tleft,Tright,'MergeKeys',true)
T=6×3 table
    Key1     Var1    Var2
    _____    ____    ____

    {'a'}      1       4 
    {'b'}      2       5 
    {'c'}      3     NaN 
    {'d'}    NaN       6 
    {'e'}     11       7 
    {'h'}     17     NaN

表 T 中来自 Tleft 的变量在 Tright 中不存在匹配值的相应行上包含缺失值。同样，T 中来自 Tright 的变量在 Tleft 中不存在匹配值的相应行上包含缺失值。

打开实时脚本

创建表 Tleft。

Tleft = table({'a' 'b' 'c' 'e' 'h'}',[1 2 3 11 17]',...
        'VariableNames',{'Key1' 'Var1'})
Tleft=5×2 table
    Key1     Var1
    _____    ____

    {'a'}      1 
    {'b'}      2 
    {'c'}      3 
    {'e'}     11 
    {'h'}     17

创建表 Tright，使变量 Key1 包含表 Tleft 和 Tright 的共同值，但同时也包含带有 Tleft 中不具备的 Key1 值的行。

Tright = table({'a','b','d','e'}',[4;5;6;7],...
         'VariableNames',{'Key1' 'Var2'})
Tright=4×2 table
    Key1     Var2
    _____    ____

    {'a'}     4  
    {'b'}     5  
    {'d'}     6  
    {'e'}     7

使用 outerjoin 函数创建新表 T，其数据来自表 Tleft 和 Tright。匹配键变量 Key1 拥有共同值的各行，但同时也保留键值无匹配项的各行。

还返回索引向量 ileft 和 iright，以分别指出 T 中的行与 Tleft 和 Tright 中的行之间的对应项。

[T,ileft,iright] = outerjoin(Tleft,Tright)
T=6×4 table
    Key1_Tleft    Var1    Key1_Tright    Var2
    __________    ____    ___________    ____

    {'a'     }      1     {'a'     }       4 
    {'b'     }      2     {'b'     }       5 
    {'c'     }      3     {0×0 char}     NaN 
    {0×0 char}    NaN     {'d'     }       6 
    {'e'     }     11     {'e'     }       7 
    {'h'     }     17     {0×0 char}     NaN 


ileft = 6×1

     1
     2
     3
     0
     4
     5


iright = 6×1

     1
     2
     0
     3
     4
     0

索引向量 ileft 和 iright 包含的零值表示表 T 中的该行分别在表 Tleft 或 Tright 中不存在对应行。

打开实时脚本

创建表 Tleft。

Tleft = table({'a' 'b' 'c' 'e' 'h'}',[1 2 3 11 17]',...
        'VariableNames',{'Key1' 'Var1'})
Tleft=5×2 table
    Key1     Var1
    _____    ____

    {'a'}      1 
    {'b'}      2 
    {'c'}      3 
    {'e'}     11 
    {'h'}     17

创建表 Tright，使变量 Key1 包含表 Tleft 和 Tright 的共同值，但同时也包含带有 Tleft 中不具备的 Key1 值的行。

Tright = table({'a','b','d','e'}',[4;5;6;7],...
         'VariableNames',{'Key1' 'Var2'})
Tright=4×2 table
    Key1     Var2
    _____    ____

    {'a'}     4  
    {'b'}     5  
    {'d'}     6  
    {'e'}     7

使用 outerjoin 函数创建新表 T，其数据来自表 Tleft 和 Tright。忽略 Tright 中其键值在 Tleft 中不存在匹配项的各行。

还返回索引向量 ileft 和 iright，以分别指出 T 中的行与 Tleft 和 Tright 中的行之间的对应项。

[T,ileft,iright] = outerjoin(Tleft,Tright,'Type','left')
T=5×4 table
    Key1_Tleft    Var1    Key1_Tright    Var2
    __________    ____    ___________    ____

      {'a'}         1     {'a'     }       4 
      {'b'}         2     {'b'     }       5 
      {'c'}         3     {0×0 char}     NaN 
      {'e'}        11     {'e'     }       7 
      {'h'}        17     {0×0 char}     NaN 


ileft = 5×1

     1
     2
     3
     4
     5


iright = 5×1

     1
     2
     0
     4
     0

ileft 的所有值都非零，表示 T 中的所有行在 Tleft 中拥有对应行。

打开实时脚本

创建两个时间表 Tleft 和 Tright。它们有一些相同的行时间，但还有一些对方所没有的行时间。

Tleft = timetable(seconds([1;2;4;6]),[1 2 3 11]')
Tleft=4×1 timetable
    Time     Var1
    _____    ____

    1 sec      1 
    2 sec      2 
    4 sec      3 
    6 sec     11 


Tright = timetable(seconds([2;4;6;7]),[4 5 6 7]')
Tright=4×1 timetable
    Time     Var1
    _____    ____

    2 sec     4  
    4 sec     5  
    6 sec     6  
    7 sec     7

通过外联合并 Tleft 和 Tright。T1 匹配具有相同行时间的行，但也包含没有匹配项的行。

T1 = outerjoin(Tleft,Tright)
T1=5×2 timetable
    Time     Var1_Tleft    Var1_Tright
    _____    __________    ___________

    1 sec         1            NaN    
    2 sec         2              4    
    4 sec         3              5    
    6 sec        11              6    
    7 sec       NaN              7

合并 Tleft 和 Tright，但忽略 Tright 中行时间与 Tleft 中的任何行时间都不匹配的行。

T2 = outerjoin(Tleft,Tright,'Type','left')
T2=4×2 timetable
    Time     Var1_Tleft    Var1_Tright
    _____    __________    ___________

    1 sec         1            NaN    
    2 sec         2              4    
    4 sec         3              5    
    6 sec        11              6

输入参数

全部折叠

左表，指定为表或时间表。

右表，指定为表或时间表。

名称-值参数

全部折叠

以 Name1=Value1,...,NameN=ValueN 的形式指定可选参量对组，其中 Name 是参量名称，Value 是对应的值。名称-值参量必须出现在其他参量之后，但对各个参量对组的顺序没有要求。

在 R2021a 之前，使用逗号分隔每个名称和值，并用引号将 Name 引起来。

示例: 'Keys',2 使用 Tleft 中的第二个变量和 Tright 中的第二个变量作为键变量。

用作键值的变量，指定为逗号分隔的对组，包含 'Keys' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

您不能将 'Keys' 名称-值对组参量与 'LeftKeys' 和 'RightKeys' 名称-值对组参量配合使用。

行标签向量可以作为键。有关详细信息，请参阅算法部分。

示例: 'Keys',[1 3] 使用 Tleft 和 Tright 中的第一个和第三个变量作为键变量。

示例: 'Keys',{'X','Y'} 使用 Tleft 和 Tright 中名为 X 和 Y 的变量作为键变量。

示例: 如果 Tleft 和 Tright 均为具有行名称的表，则 'Keys','Row' 使用 Tleft 和 Tright 的行名称向量作为键变量。

用作 Tleft 中的键值的变量，指定为逗号分隔的对组，包含 'LeftKeys' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

必须将 'LeftKeys' 名称-值对组参量与 'RightKeys' 名称-值对组参量结合使用。'LeftKeys' 和 'RightKeys' 都必须指定相同数量的键变量。outerjoin 根据顺序对键值配对。

行标签向量可以作为键。有关详细信息，请参阅算法部分。

示例: 'LeftKeys',1 仅使用 Tleft 中的第一个变量作为键变量。

用作 Tright 中的键值的变量，指定为逗号分隔的对组，包含 'RightKeys' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

必须将 'RightKeys' 名称-值对组参量与 'LeftKeys' 名称-值对组参量结合使用。'LeftKeys' 和 'RightKeys' 都必须指定相同数量的键变量。outerjoin 根据顺序对键值配对。

行标签向量可以作为键。有关详细信息，请参阅算法部分。

示例: 'RightKeys',3 仅使用 Tright 中的第三个变量作为键变量。

合并键标志，指定为由 'MergeKeys' 和 false、true、0 或 1 中的任一值组成的以逗号分隔的对组。

false

对于来自表 Tleft 和 Tright 的每个键变量对组，outerjoin 在输出表 T 中包含两个单独的变量。

此行为是默认行为。

true

对于来自表 Tleft 和 Tright 的每个键变量对组，outerjoin 在输出表 T 中包含一个单独的变量。

outerjoin 通过合并来自 Tleft 和 Tright 的键值创建单一变量，当 Tleft 中存在对应行时即采用 Tleft 中的值，否则采用 Tright 中的值。

  • 如果您指定 'LeftVariables' 或 'RightVariables' 以只包含某个键变量对组中的一个键，outerjoin 将在输出表中包含合并的键 - 包含来自两个键变量的值。

  • 如果您指定 'LeftVariables' 和 'RightVariables' 以排除某个键变量对组中的全部两个键，则 outerjoin 不会在输出表中包含合并的键变量。

要包含在 T 中的来自 Tleft 的变量，指定为逗号分隔的对组，包含 'LeftVariables' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

可以使用 'LeftVariables' 在输出 T 中包含或排除键变量和非键变量。

默认情况下，outerjoin 包含来自 Tleft 的所有变量。

要包含在 T 中的来自 Tright 的变量，指定为逗号分隔的对组，包含 'RightVariables' 和一个正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

可以使用 'RightVariables' 在输出 T 中包含或排除键变量和非键变量。

默认情况下，outerjoin 包含来自 Tright 的所有变量。

外联运算的类型，指定为以逗号分隔的对组，包含 'Type' 以及 'full'（表示全外联）、'left'（左外联）或 'right'（右外联）之一。

  • 对于输入 Tleft 和 Tright 的全外联，输出 T 组合来自两个输入的所有行，用缺失值填充空表元素。

  • 对于左外联，输出 T 包含 Tleft 中的所有行，但排除 Tright 中键值与 Tleft 中的任何键值都不匹配的行。

  • 对于右外联，T 包含 Tright 中的所有行，但排除 Tleft 中键值与 Tright 中的任何键值都不匹配的行。

默认情况下，outerjoin 执行全外联，并包含来自 Tleft 和 Tright 的未匹配行。

输出参量

全部折叠

来自 Tleft 和 Tright 的外联，以表形式返回。对于表 Tleft 和 Tright 中拥有相同键值组合的每个行对组，输出表 T 包含相对应的一行。如果 Tleft 和 Tright 含有名称相同的变量，则 outerjoin 在 T 中对应的变量名称上添加唯一后缀。T 中来自 Tleft 的变量在 Tright 中不存在匹配值的相应行上包含缺失值。同样，T 中来自 Tright 的变量在 Tleft 中不存在匹配值的相应行上包含缺失值。

（对于各种数据类型，缺失值等效于“非数字”，例如 NaN、NaT、空字符串或未定义的分类值。）

一般说来，如果表 Tleft 中有 m 行、表 Tright 中有 n 行都包含相同的键变量值组合，则表 T 包含该组合的 m*n 行。T 还包含另一个输入表中不存在任何匹配行的一个输入表中键值组合所对应的行。

T 包含根据键变量值排序的 Tleft(ileft,LeftVars) 和 Tright(iright,RightVars) 的水平串联。在默认情况下，LeftVars 包括 Tleft 的所有变量，RightVars 包括 Tright 中的所有变量。否则，LeftVars 包含 'LeftVariables' 名称-值对组参量所指定的变量，RightVars 包含 'RightVariables' 名称-值对组参量所指定的变量。

您可以在该表中存储说明、变量单位、变量名称和行名称等附加元数据。有关详细信息，请参阅 table 的“属性”部分。

Tleft 的索引，以列向量形式返回。ileft 的每个元素标识表 Tleft 中与输出表 T 中的行对应的行。向量 ileft 包含的零指示 T 在 Tleft 中无对应行的各行。

Tright 的索引，以列向量形式返回。iright 的每个元素标识表 Tright 中与输出表 T 中的行对应的行。向量 iright 包含的零指示 T 在 Tright 中无对应行的各行。

详细信息

全部折叠

算法

  • 来自输入表或时间表的行标签向量可以用作键变量。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 'Row'（如果是表的行名称）、行时间的时间表向量的名称，或者 T.Properties.DimensionNames{1} 的值，其中 T 是表或时间表。

    通常，outerjoin 将行标签从输入表 Tleft 复制到输出表 T。

    • 如果 Tleft 没有行标签，则 T 没有行标签。

    • 如果 Tleft 有行标签，则 outerjoin 复制 Tleft 的行标签，以创建 T 的行标签。

      • 如果您指定 Tleft 和 Tright 中的行标签作为键对组，则 outerjoin 可根据需要将 Tright 中的行标签合并到 T 的行标签。

      • 如果您指定 Tleft 的行标签作为键，但不指定 Tright 的行标签作为匹配的键，则 outerjoin 会根据需要在 T 中创建默认行标签。通常，默认行标签是 NaN 或缺失值

      • 如果 Tleft 和 Tright 都是表，而您未将任何输入的行名称指定为键，则 outerjoin 不会在 T 中创建行名称。

      • 如果 Tleft 和 Tright 均为时间表，但您没有将任一输入的行时间指定为键，则 outerjoin 会将行时间从 Tleft 复制到 T。它还在需要时用 NaN 或 NaT 填充行时间。

    您不能使用 Tleft 的行标签作为左键、使用 Tright 的变量作为右键来执行外联。要执行外联，请将 Tleft 的行标签转换为表变量，并使用新表变量作为键。

扩展功能

全部展开

基于线程的环境
使用 MATLAB® backgroundPool 在后台运行代码或使用 Parallel Computing Toolbox™ ThreadPool 加快代码运行速度。

版本历史记录

在 R2013b 中推出

另请参阅

函数

实时编辑器任务