Dans Powershell, quel est le meilleur moyen de joindre deux tables en une seule?

Rejoignez-Objet

La Rejoignez-Objet (alias Join) la fonction combine les colonnes à partir de deux tableaux d'objets dans un nouveau tableau d'objets qui peuvent être enregistrées dans un tableau (Export-CSV) ou de l'utiliser comme il est.

Function Join-Object {                                          # https://powersnippets.com/join-object/
[CmdletBinding()]Param (                                    # Version 02.02.00, by iRon
[Object[]]$RightTable, [Alias("Using")]$On, $Merge = @{}, [Parameter(ValueFromPipeLine = $True)][Object[]]$LeftTable, [String]$Equals
)
$Type = ($MyInvocation.InvocationName -Split "-")[0]
$PipeLine = $Input | ForEach {$_}; If ($PipeLine) {$LeftTable = $PipeLine}
If ($LeftTable -eq $Null) {If ($RightTable[0] -is [Array]) {$LeftTable = $RightTable[0]; $RightTable = $RightTable[-1]} Else {$LeftTable = $RightTable}}
$DefaultMerge = If ($Merge -is [ScriptBlock]) {$Merge; $Merge = @{}} ElseIf ($Merge."") {$Merge.""} Else {{$Left.$_, $Right.$_}}
If ($Equals) {$Merge.$Equals = {If ($Left.$Equals -ne $Null) {$Left.$Equals} Else {$Right.$Equals}}}
ElseIf ($On -is [String] -or $On -is [Array]) {@($On) | ForEach {If (!$Merge.$_) {$Merge.$_ = {$Left.$_}}}}
$LeftKeys  = @($LeftTable[0].PSObject.Properties  | ForEach {$_.Name})
$RightKeys = @($RightTable[0].PSObject.Properties | ForEach {$_.Name})
$Keys = $LeftKeys + $RightKeys | Select -Unique
$Keys | Where {!$Merge.$_} | ForEach {$Merge.$_ = $DefaultMerge}
$Properties = @{}; $LeftOut = @($True) * @($LeftTable).Length; $RightOut = @($True) * @($RightTable).Length
For ($LeftIndex = 0; $LeftIndex -lt $LeftOut.Length; $LeftIndex++) {$Left = $LeftTable[$LeftIndex]
For ($RightIndex = 0; $RightIndex -lt $RightOut.Length; $RightIndex++) {$Right = $RightTable[$RightIndex]
$Select = If ($On -is [String]) {If ($Equals) {$Left.$On -eq $Right.$Equals} Else {$Left.$On -eq $Right.$On}}
ElseIf ($On -is [Array]) {($On | Where {!($Left.$_ -eq $Right.$_)}) -eq $Null} ElseIf ($On -is [ScriptBlock]) {&$On} Else {$True}
If ($Select) {$Keys | ForEach {$Properties.$_ = 
If ($LeftKeys -NotContains $_) {$Right.$_} ElseIf ($RightKeys -NotContains $_) {$Left.$_} Else {&$Merge.$_}
}; New-Object PSObject -Property $Properties; $LeftOut[$LeftIndex], $RightOut[$RightIndex] = $Null
}   }   }
If ("LeftJoin",  "FullJoin" -Contains $Type) {
For ($LeftIndex = 0; $LeftIndex -lt $LeftOut.Length; $LeftIndex++) {
If ($LeftOut[$LeftIndex]) {$Keys | ForEach {$Properties.$_ = $LeftTable[$LeftIndex].$_}; New-Object PSObject -Property $Properties}
}   }
If ("RightJoin", "FullJoin" -Contains $Type) {
For ($RightIndex = 0; $RightIndex -lt $RightOut.Length; $RightIndex++) {
If ($RightOut[$RightIndex]) {$Keys | ForEach {$Properties.$_ = $RightTable[$RightIndex].$_}; New-Object PSObject -Property $Properties}
}   }
}; Set-Alias Join   Join-Object
Set-Alias InnerJoin Join-Object; Set-Alias InnerJoin-Object Join-Object -Description "Returns records that have matching values in both tables"
Set-Alias LeftJoin  Join-Object; Set-Alias LeftJoin-Object  Join-Object -Description "Returns all records from the left table and the matched records from the right table"
Set-Alias RightJoin Join-Object; Set-Alias RightJoin-Object Join-Object -Description "Returns all records from the right table and the matched records from the left table"
Set-Alias FullJoin  Join-Object; Set-Alias FullJoin-Object  Join-Object -Description "Returns all records when there is a match in either left or right table"

Syntaxe

<Object[]> | InnerJoin|LeftJoin|RightJoin|FullJoin <Object[]> [-On <String>|<Array>|<ScriptBlock>] [-Merge <HashTable>|<ScriptBlock>] [-Eq <String>]

InnerJoin|LeftJoin|RightJoin|FullJoin <Object[]>,<Object[]> [-On <String>|<Array>|<ScriptBlock>] [-Merge <HashTable>|<ScriptBlock>] [-Eq <String>]

InnerJoin|LeftJoin|RightJoin|FullJoin -LeftTable <Object[]> -RightTable <Object[]> [-On <String>|<Array>|<ScriptBlock>] [-Merge <HashTable>|<ScriptBlock>] [-Eq <String>]

Commandes

La Join-Object (alias Join) la fonction est une fonction avec plusieurs alias qui joint deux tables (chacun composé d'un tableau de PSCustomObjects) similaire à la Jointure SQL instructions. La valeur par défaut type de jointure est un InnerJoin.

• InnerJoin-Object (alias InnerJoin)
  
  Renvoie les enregistrements qui ont des valeurs correspondantes dans les deux tables.

• LeftJoin-Object (alias LeftJoin)
  
  Renvoie tous les enregistrements de la table de gauche et les enregistrements correspondants de la table de droite.

• RightJoin-Object (alias RightJoin)
  
  Renvoie tous les enregistrements de la table de droite et les enregistrements correspondants de la table de droite.

• FullJoin-Object (alias FullJoin)
  
  Renvoie tous les enregistrements lorsqu'il existe une correspondance à gauche ou à droite de la table.

Notes

1. Tous Join commandes sont compatibles avec PowerShell version 2 et plus.

Paramètres

-LeftTable <Object[]> et -RightTable <Object[]>

La -LeftTable et RightTable paramètres définissent la gauche et la droite de la table pour être rejoint. Il y a trois syntaxis pour la fourniture de tables:

• En utilisant le PowerShell pipeline:
  <LeftTable> | Join <RightTable>

• La fourniture de deux tables dans un tableau (séparés par une virgule) à la première position argument:
  Join <LeftTable>,<RightTable>

• La fourniture de deux tables avec des arguments nommés:
  Join -Left <LeftTable> -Right <RightTable>

Notes

1. Si une seule table est fourni (Join <Table>), une auto auto-jointure sera effectuée sur la table.

-On <String>|<Array>|<ScriptBlock> et -Equals <String>

La -On (alias Using) ce paramètre définit la condition de spécifier comment joindre les tables et les lignes à inclure dans le (intérieure) jeu de résultats. Le -On paramètre prend en charge les formats suivants:

• String -Equals <String>
  Si le -On valeur est un String et la -Equals <String> paramètres est fournie, à la propriété dans la colonne de gauche définies par le -On valeur doit être égale à la propriété dans la colonne de droite définie par le -equals valeur pour être inclus dans l' (intérieure) jeu de résultats.

• String ou Array
  Si la valeur est un String ou Array la -On paramètre est similaire à SQL using clause. Cela signifie que tous les biens exiger l'égalité (à gauche et à droite) pour être inclus dans l' (intérieure) jeu de résultats. Les biens seront de sortie qu'une seule valeur par défaut (voir aussi -Expressions).

• ScriptBlock
  Toute expression conditionnelle où $Left définit la gauche de la ligne, $Right définit la ligne droite.

Notes

1. La ScriptBlock type a le plus de possibilités de comparaison mais est considérable, plus lent que les autres types.

2. Si le -On paramètre est omis ou à partir d'un type inconnu, un la croix-rejoindre sera effectuée.

-Merge <HashTable>|<ScriptBlock>

Définit comment les colonnes avec le même nom doivent être fusionnés. Le -Merge paramètre accepte de types: un HashTable contenant le précis de fusion expression pour chaque colonne ou ScriptBlock contenant la valeur par défaut de fusion et d'expression pour toutes les colonnes qui n'ont pas de fusion expression définie.

D'où l'expression:

• $_ tient chaque nom de colonne.
• $Left détient la gauche de la ligne et de $Right titulaire de la ligne droite.
• $Left.$_ tient chaque de gauche et $Right.$_ tient chaque valeur de droite.
• $LeftIndex détient le courant de gauche index de ligne et $RightIndex détient le courant de la ligne droite de l'index.

Notes:

1. Expressions n'est effectuée que si les deux de gauche (Left.$_) et de droite (Left.$_) sont existants (y compris les valeurs qui sont $Null) sinon juste à la sortie de la valeur est retournée.

2. Si aucune expression n'est définie pour une colonne de l'expression {$Left.$_, $Right.$_} est utilisé.
   Cela signifie que les deux valeurs sont affectées (dans un tableau) de la propriété actuelle.

3. L'expression de colonnes définies par l' -On <String>, -Equals <String>et -Sur <Array> est: {$Left.$_} et ne peut être annulée par une colonne spécifique expression définie dans une table de hachage.
   Cela signifie qu'une seule valeur ($Left ou $Right qui n'est pas égal à $Null) est affectée à la propriété actuelle.

4. À utiliser la colonne expressions spécifiques et définir une expression par défaut utiliser une longueur de zéro nom de la clé pour l'expression par défaut, par exemple -Merge @{"" = {$Left.$_}; "Column Name" = {$Right.$_}}

Exemples

Donné les tableaux suivants:

   $Employee                               $Department
+---------+---------+-------------+    +-------------+---------+---------+
|  Name   | Country | Department  |    |    Name     | Country | Manager |
+---------+---------+-------------+    +-------------+---------+---------+
| Aerts   | Belgium | Sales       |    | Engineering | Germany | Meyer   |
| Bauer   | Germany | Engineering |    | Marketing   | England | Morris  |
| Cook    | England | Sales       |    | Sales       | France  | Millet  |
| Duval   | France  | Engineering |    +-------------+---------+---------+
| Evans   | England | Marketing   |
| Fischer | Germany | Engineering |
+---------+---------+-------------+

PS C:\> # InnerJoin on Department = Name
PS C:\> $Employee | InnerJoin $Department Department -eq Name | Format-Table
Department  Name    Manager Country
----------  ----    ------- -------
Sales       Aerts   Millet  {Belgium, France}
Engineering Bauer   Meyer   {Germany, Germany}
Sales       Cook    Millet  {England, France}
Engineering Duval   Meyer   {France, Germany}
Marketing   Evans   Morris  {England, England}
Engineering Fischer Meyer   {Germany, Germany}
PS C:\> # LeftJoin using country (selecting Department.Name and Department.Country)
PS C:\> $Employee | LeftJoin ($Department | Select Manager,Country) Country | Format-Table
Department  Name    Manager Country
----------  ----    ------- -------
Engineering Bauer   Meyer   Germany
Sales       Cook    Morris  England
Engineering Duval   Millet  France
Marketing   Evans   Morris  England
Engineering Fischer Meyer   Germany
Sales       Aerts           Belgium
PS C:\> # InnerJoin on Employee.Department = Department.Name and Employee.Country = Department.Country (returning only the left name and - country)
PS C:\> $Employee | InnerJoin $Department {$Left.Department -eq $Right.Name -and $Left.Country -eq $Right.Country} {$Left.$_}
Department  Name    Manager Country
----------  ----    ------- -------
Engineering Bauer   Meyer   Germany
Marketing   Evans   Morris  England
Engineering Fischer Meyer   Germany
PS C:\> # Cross Join
PS C:\> $Employee | InnerJoin $Department | Format-Table
Department  Name                   Manager Country
----------  ----                   ------- -------
Sales       {Aerts, Engineering}   Meyer   {Belgium, Germany}
Sales       {Aerts, Marketing}     Morris  {Belgium, England}
Sales       {Aerts, Sales}         Millet  {Belgium, France}
Engineering {Bauer, Engineering}   Meyer   {Germany, Germany}
Engineering {Bauer, Marketing}     Morris  {Germany, England}
Engineering {Bauer, Sales}         Millet  {Germany, France}
Sales       {Cook, Engineering}    Meyer   {England, Germany}
Sales       {Cook, Marketing}      Morris  {England, England}
Sales       {Cook, Sales}          Millet  {England, France}
Engineering {Duval, Engineering}   Meyer   {France, Germany}
Engineering {Duval, Marketing}     Morris  {France, England}
Engineering {Duval, Sales}         Millet  {France, France}
Marketing   {Evans, Engineering}   Meyer   {England, Germany}
Marketing   {Evans, Marketing}     Morris  {England, England}
Marketing   {Evans, Sales}         Millet  {England, France}
Engineering {Fischer, Engineering} Meyer   {Germany, Germany}
Engineering {Fischer, Marketing}   Morris  {Germany, England}
Engineering {Fischer, Sales}       Millet  {Germany, France}

Service de mise à jour de la liste (remplacer les services existants sur le nom et en ajouter de nouvelles)

Import-CSV .\Svc.csv | LeftJoin (Get-Service) Name {$Right.$_} | Export-CSV .\Svc.csv

Processus de mise à jour de la liste et insérez uniquement des processus avec un CPU plus

Import-CSV .\CPU.csv | LeftJoin (Get-Process) ID {If ($Left.CPU -gt $Right.CPU) {$Left.$_} Else {$Right.$_}} | Export-CSV .\CPU.csv

_{Pour la dernière Join-Object version, voir la PowerShell Galerie ou le site du projet: https://github.com/iRon7/Join-Object}

OriginalL'auteur iRon