fnRelativerSpaltenvergleich.pq

let
 /*
   Beginn der Funktionsdefinition, mit Funktionsnamen, Funktionsparametern und Typ des Funktionsrückgabewertes
 */
  fnInsertDiffColumn = (ColumnName as text, MyTable as table) as table =>
    let
        /*
          Parameter für das Testen der Funktion, während der Entwicklungsphase
        */
        /*        
          MyTable = 
            #table(type table[
                     A = number, 
                     B = number, 
                     C = number, 
                     D = number
                         ], 
                   {
                     {1, 1, 3, 7}, 
                     {1,3, 5, 9}
                   }
             ),
          ColumnName = "C",
        */

      AktuelleSpaltenüberschriftenUrsprungstabelle = Table.ColumnNames(MyTable), 
       /*
         Prüfen, ob der angegebene Buchstabe überhaupt in der 
         Tabelle vorhanden ist
       */
       Check_SpalteVorhanden = List.Contains(
                                  AktuelleSpaltenüberschriftenUrsprungstabelle, 
                                  ColumnName
                                ), 

       /*
         Prüfen, ob links von der angegebenen Spalte überhaupt 
         zwei Spalten stehen
       */
       Check_SpaltenPosition = List.PositionOf(
                                 AktuelleSpaltenüberschriftenUrsprungstabelle, 
                                 ColumnName
                               ) > 1,

        /*
          Falls auch nur ein Check 'false' ergibt, kann die Operation 
          nicht durchgeführt werden
        */
        All_Checks = Check_SpalteVorhanden and Check_SpaltenPosition ,

       //Nach Prüfungen fortfahren
        Output = 
                //Wenn alle Checks 'true' sind, dann mit dem Programm fortfahren
                if All_Checks = true then 
                    let
                        /*
                          Übernahme des Spaltennamens aus dem Parameter 'ColumnName'
                        */
                        SpaltenNameVorDemDieNeueSpalteEingefügtWerdenSoll = ColumnName,
                        
                        /*
                          Ermittlung der Position der Spalte, die an die Funktion übergeben werden soll.
                          Links neben Ihr sollen dann die beiden Spalten verglichen werden 
                        */
                        PositionDerSpalteErmittelnVorDerEingefügtWerdenSoll = 
                            List.PositionOf(
                                AktuelleSpaltenüberschriftenUrsprungstabelle, 
                                SpaltenNameVorDemDieNeueSpalteEingefügtWerdenSoll
                            ),
                        /*
                          Ermittlung der Position der linken der beiden Spalten
                        */
                        ErsteDiffSpalte = AktuelleSpaltenüberschriftenUrsprungstabelle{PositionDerSpalteErmittelnVorDerEingefügtWerdenSoll-2},
                        
                        /*
                          Ermittlung der Position der rechten der beiden Spalten
                        */
                        ZweiteDiffSpalte = AktuelleSpaltenüberschriftenUrsprungstabelle{PositionDerSpalteErmittelnVorDerEingefügtWerdenSoll-1},
                        
                        /*
                          Berechnung der 'Abgleichspalte' Diese steht bis dato noch am Ende der Tabelle.
                          Die Position der Spalte wird in einem weiteren Schritt geändert, dass sie direkt
                          neben den zu vergleichenden Spalten steht.
                        */
                        SpalteBerechnen = 
                           Table.AddColumn(
                              MyTable, 
                              "Spaltenabgleich", 
                              each Record.Field(_, ErsteDiffSpalte) = Record.Field(_, ZweiteDiffSpalte)
                           ),
                        /*
                          Ermittlung der Spaltenüberschriften (als Liste) der aktuell vorliegenden Tabelle
                        */
                        SpaltenDerTabelleMitBerechneterSpalte = Table.ColumnNames(SpalteBerechnen),
                        //Jetzt an die gewünschte Stelle verschieben
                        Umsortieren =  
                            Table.ReorderColumns(
                                SpalteBerechnen,
                                List.RemoveLastN(
                                    List.InsertRange(
                                        SpaltenDerTabelleMitBerechneterSpalte, 
                                        PositionDerSpalteErmittelnVorDerEingefügtWerdenSoll, 
                                        {List.Last(
                                            SpaltenDerTabelleMitBerechneterSpalte
                                         )
                                        }
                                    ), 
                                    1
                                )
                            ),
                        //Herstellung der richtigen Datentyps für die neue Spalte 'Spaltenabgleich'
                        Result = Table.TransformColumnTypes(Umsortieren, {{"Spaltenabgleich", type logical}})
                    in  
                        Result
                 else 
                 /*
                  Die Checks haben 'false' zurückgeliefert. Daher muss eine Fehlermeldung 
                  ausgegeben werden. Dafür nutze ich die Funktion Error.Record() 
                */
                   error Error.Record(
                       //Error reason
                       "Ein Fehler ist aufgetreten",
                       //Error Message
                       "Entweder existiert die angegebene Spalte nicht, oder es " &
                       "gibt keine zwei Spalten links neben ihr!",
                       //Error detail
                       "Keine Details vorhanden"
                   )
    in 
        //Das fertige Ergebnis.
        Output,
    /*
       Dieser Teil der Funktion, dient der internen Dokumentation der Funktion. Du kannst hier lesen, wie das ganze funktioniert:
       https://ssbi-blog.de/writing-documentation-for-custom-m-functions/
    */
    fnType = type function(
              ColumnName as text,
              MyTable as table 
            ) as list meta [
                Documentation.Name = "fnInsertDiffColumn",
                Documentation.LongDescription = 
                   "Diese Funktion fügt in einer Tabelle X, vor einer definierten " &
                   "Spalte Y eine Spalte ein, die prüft, ob die beiden Spalte LINKS neben Y identisch sind!",
                Documentation.Author = "Lars Schreiber, ssbi-blog.de"
            ]
in   
Value.ReplaceType(fnInsertDiffColumn, fnType)