Dr. Breinlinger - Ueberblick

csv-Tabellenkalkulation im Terminal mit bash und (g)awk

Querverweise

Appetizer

2 Aufbereitungsvarianten derselben csv-Datei zu Darstellung oder Editierung (hier mit vim)

Warum CSV nicht nur im Terminal die bessere Tabellenkalkulation ist

Die Anzahl Excel--Dateien, aufgrund derer Unternehmen jeglicher Größenordnung täglich wichtigste Entscheidungen treffen, dürfte bei mehreren 100 Millionen liegen. Damit hängen große Teile der Weltwirtschaft an einem System, welches gegen die wichtigsten Paradigmen der IT verstößt

Vermengung von Logik, Code und Darstellung
- Formeln haben für einfache Logiken (etwa 2 kombinierte wenn-dann-Beziehungen) nicht nur eine kaum mehr leserliche Komplexität, sondern werden nicht einmal wiederverwendet, vielmehr genau so oft (falsch oder richtig selbst oder automatisch) kopiert, wie ingesamt benötigt.
- Die Formatierung von Feldern ist nicht nur abhängig von der Sprachversion, sondern beeinflusst die Logik UND wird dabei oft genug von gleich mehreren Bearbeitern für jedes Feld (falsch oder richtig) manuell festgelegt oder kopiert. Hinzu kommen jede Menge subtile Schreib- und Formatierungsfehler in bereits mittelgroßen, mehrfach zwischen Bearbeitern kopierten Dateien.
- Auch deswegen sind Mitarbeiter viel mehr mit Formatierung und "hübsch machen" von Dateien beschäftigt als fachlichem Inhalt und Korrektheit
- Während die Tabellenkalkulation für Maus-Bedienung eines Menschen ausgelegt ist, entstammen die Datenquellen zumeist Unternehmens-Backends und müssen erst (oft genug als CSV) aufbereitet und eingelesen werden. Gleichzeitig ist auch der erneute Export sehr fehleranfällig
  - Formatierungs- und Schreibfehler manueller Zwischenbearbeitung im GUI
  - Versionsabweichungen des Programmes und geänderte Sprach- und Darstellungseinstellungen bei Ketten von Bearbeitern
    - Zahldarstellungen (Tausendertrenner, Dezimalkennung, Ganz- oder Gleitkommazahl)
      - hierbei interne Verarbeitung meist englisch, Darstellung deutsch
    - viele verschiedene Datumsformatierungen zuzüglich derer Abkürzungen (Jahreszahl)
    - Text-, Währungs-, Zahl-, oder Datumsbedeutung eines Feldes
  - blind übernommene Exporteinstellungen (Feldtrenner und Textkennzeichen uneinheitlich, manuell eingefügte Zeilenumbrüche in Text-Feldern)
  - inkompatible Zeichensätze (ISO-8559-1, UTF-8, ASCII, Umlaute, Sonderzeichen, ...)
dieselben Abläufe (etwa entscheidungsrelevante Filtereinstellungen oder Pivotierungen) müssen immer wieder fehleranfällig für jede Datei (oft genug auch innerhalb derselben) manuell wiederholt werden

Mithin sind Tabellenkalkulationen in Unternehmen also nicht nur noch langsamer zu bedienen als bereits zu starten, sondern stellen als Systembruch durchgehender Bearbeitungsketten wie Verletzung jeglicher Grundregeln der Informatik vorsichtig ausgedrückt nicht gerade "the sharpest tool in the shed" dar.

Möchte man wesentliche Aspekte des vorigen in Unternehmen nicht ohnehin als absolute No-No einstufen, ergeben sich folgende "Vorteile" reiner CSV-Verarbeitung im Terminal:

nicht wahrnehmbare Start-/Ladezeit bei minimalem Ressourcenverbrauch
hohe Verarbeitungs- und Bediengeschwindigkeit (keine Mausbedienung, kein beständiger Oberflächen-Update)
rein maschinelle Formatierung (immer korrekt, keine Redundanz, keine oder eindeutig und schnell erkennbare Fehler)
Nettofenster == Bruttofenster (keine Bedienleisten oder Kacheln)
Funktionalität "at your hands" (keine verschachtelten Menüs mit versteckten Funktionen)
Automatisierung über sämtliche Datenquellen, Sprachen, Standards und Dateien kombinierbar (kein Scripting nur innerhalb derselben Datei wie etwa mit VBA)
- damit nahtlose Einbettung in die Workflows von Unternehmensbackends und -servern (nicht nur auf Anwender-Desktop verfügbar)
strikte Trennung von Darstellung, Datenmodell und Logik (bestmögliche Fehlerfreiheit, keine Ablenkung vom Wesentlichen)
- Code/Funktionalität nur an einer einzigen Stelle (keine Proliferation redundanter Formeln in jeder Zelle)
  - einfache Fehlersuche ohne Myriaden kopierter/automatisch eingefügter Formeln
  - Klare Logik einer Programmiersprache (keine kryptische-unleserliche Syntax bereits einfacher Anweisungsketten ("wenn, dann (wenn, dann, sonst ...), sonst ...")
- Konzentration auf Fachlichkeit statt Formatierung(sprobleme (verstärkt bei mehreren Bearbeitern)
auch multiple Filter- und Pivotanweisungen sind durch Kommandozeile irrtumsfrei gespeichert, damit dokumentiert und identisch (auch in weiteren Dateien) beliebig wiederholbar (kein immer neues und fehleranfälliges "manuelles Zusammenklicken")
Unabhängigkeit von Betriebssystem und Desktop (unter Windows etwa mit cygwin oder dem Linux-Subsystem)
- voller Funktionsumfang auch im Fernzugriff per ssh
allgemeines, von jedem Programm und jedem Betriebssystem verstandenes Austauschformat
Funktionsumfang beliebig erweiter- und damit anpassbar (keine Abhängigkeit von kommerziellen Produkten/Versionen/Lizenzen)
Schönheit und Klarheit des Minimalen; Reduktion auf Inhalt und Funktion
Beliebige Serialisierung/Kombination von Verarbeitungsketten/Workflows durch Pipes

csv-Verarbeitung für den Desktop

Diesem Zweck dient die folgende Sammlung an bash-(g)awk-Scripts, welche, jeweils auf der Kommandozeile mit Optionen aufgerufen, CSV-Datein für typische Fragestellungen verarbeiten.

Alle Scripte haben eine Option -h, um die Bedienung zu erläutern
Aus- und Eingaben sind beliebig verknüpfbar
Festzulegen ist, ob ein '.' der Zahldarstellung in csv-Quellen als Dezimalpunkt oder Tausendertrennzeichen zu interpretieren ist
Als Spaltentrennzeichen für csv-Dateien wird durchgehend ';' angenommen
Alle Programme sind bash-Scripts mit implizitem gawk-Script
Da csv-Dateien in den meisten Fällen aus Excel exportiert worden sein dürften, werden erstere konvertiert DOS => Unix, Zeichensaetze, Umlautersetzung ...
- Es gibt ein Ruby-Programm des Autors zur Wandlung ausgewählter Sheets aus Excel-Dateien in ';'-separierte csv-Darstellungen
- Einige Scripts bieten eine Option -n, um Konvertierung zu verhindern. In diesem Fall muss die Nutzdatei bereits als UTF-8 oder ASCII-Datei im Unix-Format vorliegen
Zahlformate werden bei Berechnungen intern in englische Darstellung gewandelt; mit der Option -d kann festgelegt werden, ob ';' oder ',' vor 3 Ziffern als Dezimalpunkt oder Tausendertrenner zu interpretieren ist
- alle anderen Fälle können automatisch bestimmt werden
Zu Beginn von common können Standardpfade festgelegt werden, welche als Default in das Home-Verzeichnis verweisen
Syntax und Verwendung aller Scripts können mit <script> -h angezeigt oder direkt der jeweiligen Funktion usage() im Quellcode entnommen werden
- Dabei dienen vermeintliche Langformen von (ausschließlich Kurz-)Optionen lediglich der Erläuterung (Beispiel: -i(nfile))
Alle Scripte verwenden die bash- und gawk--Includes common und commonroutines.awk des Downloadbereiches
Für Option -F von mycsvfilter wird in Verzeichnis /usr/local/bin außerdem die Filter-Konfigurationsdatei filter.config erwartet. Ein Beispiel findet sich ebenfalls im Downloadbereich
mycsvview und mycsvcalc verwenden selbst mycsvfilter und haben daher mit letzterem gleichlautende Optionen

Die Scripts sind

mycsvview
- Formatierte Darstellung von csv-Dateien
  - normierte Spaltenbreiten
  - Spalten- und Zeilennummern
  - Ausblenden von Spalten
  - Formatierung von Zahlen (Tausendertrennzeichen)
  - Kombiniertes Sortieren von Spalten; auf-/absteigend, numerisch oder alphabetisch
  - Kombinierte Filterung von Spalten nach regulären Ausdrücken wie festen Werten (cf. mycsvfilter
  - laufende Summen für beliebige Spalten
  - automatische Trennzeilen anhand Ausprägungswechsel in einer definierten Spalte
    - optional zusätzliche Bildung von Zwischensummen in beliebigen Spalten
mycsvcalc
- Summation von Spalten optional mit kombinierter Vorfilterung beliebiger Spalten nach regulären Ausdrücken (cf. mycsvfilter)
mycsvfilter
- Filterung von 1-n Zeilen anhand fester Werte oder regulärer awk-Ausdrücke
  - optional können komplexe Filter unter /usr/local/bin/filter.config vordefiniert werden
- Ausblenden von Spalten
- Summation von Spalten
- parallele Ausgabe auf stdout (für Pipes und in (Default-)Ausgabedatei
mycsvmerge
- Zusammenführung von Spalten je zweier csv-Dateien anhand zu definierender Schlüsselspalten beider Dateien
  - Wahlweise Einfügen, Konkatenieren oder optionales oder zwingendes Überschreiben
- Vergleich festzulegender Wertespalten zweier csv-Dateien anhand ebenso festzulegender Schlüsselspalten
mycsvedit
- Editierung von csv-Dateien in der Darstellung von mycsvview mit impliziter Rekonvertierung nach csv
mycsvsort
- alphabetische oder numerische, auf- oder absteigende Sortierung der 1-n Spalten

Anwendungsbeispiel

Betrachten wir dazu 4 Tabellen eines Warensortiments, welche via Artikelnummer oder Artikelbeschreibung und Markt verknüpft, gefiltert, sortiert, kalkuliert und visuell aufbereitet werden sollen

(Trennzeichen: ';')

1.csv: Artikelnummer, Filiale und deren Bestand
2.csv: Artikelnummer und Artikelbeschreibung
3.csv: Artikelnummer und verfügbares Zubehoer
4.csv: Artikelbeschreibung, Filiale und (nur) dort gültiger Preis

mit alternativ

mycsvview -n -l -s 1 datei.csv
- nutzerfreundliche Darstellung mit optimierter Spaltenbreite, Spalten-, Zeilennummern und automatischen Trennzeilen (hier bei Ausprägungswechsel in Spalte 1)
mycsvedit datei.csv
- Implizite Konvertierung für vim-Sitzung/Editierung in voriger Darstellung und automatische Rekonvertierung zu csv-Datei

mycsvmerge -i 2.csv:1:2 -o 1.csv:1:1
mycsvview -nl -s1 1_merged.csv

Einfuegen einer Spalte aus 2.csv in 1.csv anhand gemeinsamer Key-Spalte(n)
Ergebnis ist (implizit) 1_merged.csv

#-------------------------------------------------------------------------------
# Quelle
#   Datei 2
#   Key: Spalte 1 (Artikelnummer)
#   Value: Spalte 2 (Artikelbeschreibung)
# Ziel
#   Datei 1
#   Key: Spalte 1 (Artikelnummer)
#   Zielspalte: nach Spalte 1 einfuegen
#-------------------------------------------------------------------------------

mycsvmerge -i 4.csv:1u2:3 -o 1_merged.csv:2u3:hinten
mycsvview -nl -s1 1_merged.csv

Einfügen des (auch von der Filiale abhängigen) Verkaufspreises aus 4.csv, diesmal anhand zweier Key-Spalten: Artikelbeschreibung und Markt !
- Keyspalten werden für Vergleichbarkeit implizit stets normiert (Leerzeichen, Umlaute, Sonderzeichen, ...)
Angabe der Zielspalte in allgemeingültiger Forma als hinten

#-------------------------------------------------------------------------------
# Quelle
#   Datei 4
#   Key: Spalte 1 und Spalte 2 (Artikelbeschreibung und Markt)
#   Value: Spalte 3 (Verkaufspreis)
# Ziel
#   veraenderte Datei 1
#   Key: Spalte 2 und 3 (Artikelbeschreibung und Markt)
#   Zielspalte: hinten anfuegen
#-------------------------------------------------------------------------------

mycsvmerge -i 3.csv:1:2 -o 1_merged.csv:1:2
mycsvview -nl -s1 1_merged.csv

Einfügen optionalen Zubehörs aus Datei 3.csv hinter Artikelbeschreibung

#-------------------------------------------------------------------------------
# Quelle
#   Datei 3
#   Key: Spalte 1 (Artikelnummer)
#   Value: Spalte 2 (Zubehoer)
# Ziel
#   veraenderte Datei 1
#   Key: Spalte 1 (Artikelnummer)
#   Zielspalte: nach Spalte 2 einfuegen
#-------------------------------------------------------------------------------

mycsvfilter -f '3:.*teil.*' 1_merged.csv > 1_filtered.csv
mycsvview -nl -s1 1_filtered.csv

Filterung nach mehrteiligem Zubehör in Spalte 3 mit Umlenkung nach 1_filtered.csv
- Filterung mit regulären Ausdrücken wie in gawk spezifiziert

mycsvsort -k 1:4 1_filtered.csv > 1_sorted.csv
mycsvview -nl -s1 1_sorted.csv

Sortierung nach Spalte 1 (Artikelnummer) und Spalte 4 (Filiale) mit Umlenkung nach 1_sorted.csv

mycsvcalc -c 5:1:1000 -t "Bestandssumme" 1_sorted.csv

Kalkulation des Bestandes (Spalte 5 von Zeile 1 bis zu hypothetischer Zeile 1000)
- intern: implizite Wandlung von Zahlformaten in englische Darstellung

Script-Suite

... und hier die Werkzeuge ...

mycsvfilter

#!/bin/bash
#{{{{
#!/bin/bash
#-------------------------------------------------------------------------------------------
#<Beschreibung>
#  Filtert Spalten in CSV-Dateien oder blendet Spalten aus und addiert optional Spaltensummen
#</Beschreibung>
#-------------------------------------------------------------------------------------------

. /usr/local/bin/common

function usage(){ 
  cat <<EOF
    
     Cave: Eingabedatei wird konvertiert erwartet (ASCII|UTF-8, Unix, keine Umlaute ...)

           Ohne Eingabedatei wird von stdin gelesen

           Neben stdout wird per tee auch die Datei $outfile erzeugt

     $0 -f(ilter) <filter> [-e(xclude) <excludes>] [-c(calculate) <cols>] [-d(otOrCommaAsDecimal] [<infile>]

     -c: Summation von Spalten
         
         Trennung der Spalten durch :
           
           -c 2:6:8

         Cave: Summation NACH Filterung

     -d: Interpretation von .|, vor 3 Ziffern als Dezimaltrenner oder Tausendertrennzeichen (Default: Wert aus commonroutines.awk)
         
         0 oder 1

     -e: Ausblenden von Spalten
         
         Trennung der Spalten durch :
           
           -e 2:6:8

     -F: $0 -F <filtername> <Datei>
         
         convenience-Funktion: Verwenden eines in Datei $filterConfig beschriebenen Filters im Format
           <filternam>;<filter>

           Beispiel

             budget;2:!^400(0088|0001|0117|0273|0296|0336|0390|0520|0532|0597|0598|0615|0618|0923|1001|1017|1026|1027)

             Cave: ';' darf damit im Filter selbst neben '#', '!' und ':' als Sonderzeichen nicht vorkommen

     -f: Verkettung von Spalten und Filtern
         
         Trennug der Spalten-Filter durch "#"
         Trennung von Spalte und ihrem Filter durch ":"
         negative Filter mit Prefix "!"

         Cave: "0" entspricht numerisch 0, wird also von jeder 0-Darstellung (0.00, ...) erfuellt

         Cave: "empty" entspricht false in awk oder einem beliebigen 0-Wert (also [0,.])

         Cave: Enthaelt der Filter "typische" Regex-Sonderzeichen (cf. Code), wird er als Pattern interpretiert
            Rapp|Koch
            .*Koch
              Cave: * ist nicht Shell-Wildcard, sondern Quantifier, also nicht
                *
              sondern
                .*
            \.prod
            Sales\\sTask
            Sales[ \\t]sTask
              Cave: Ein '\' muss 2-mal angegeben werden, da das Pattern als dynamic regexp zunaechst als String verarbeitet wird

            Achtung: Folgende Filterungen sind synonym 
                     mycsvfilter -f '7:Intern#6:ja#21:A-CT1CSI[35].*'        Teamschnitt_generiert.csv 
                     mycsvfilter -f '7:Intern#6:ja#21:A-CT1CSI(3|5).*' Teamschnitt_generiert.csv

     Beispiel

     $0 -e 1:14:15 -f 6:match#1:!Sales#3:empty#4:!empty#5:0#7:!0#8:!(Breinlinger[^,]*,[[:space:]]*Heinz) Hugo.csv
        
        Ausblenden
          Spalten 1, 14 und 15 
        Filtern
          Spalte 6: "match"
          Spalte 1: Nicht "Sales"
          Spalte 3: leer (== kein Wert, also Leer-String)
          Spalte 4: nicht leer
          Spalte 5: 0
          Spalte 7: nicht 0
          Spalte 8: nicht Pattern


EOF
} 

commaOrDotAsDecimal=""
infile=""
outfile=${dataDir}/filtered.csv
convenienceFilter=""
filter=""
exclude=""
calculation=""
filterConfig=${binDir}/filter.config


while getopts "c:d:hHe:f:F:" opt; do
  case $opt in
    c) calculate=$OPTARG 
       if [[ "$calculate" =~ [^0-9:] ]]; then
         die "Ungueltige Spaltenliste: $calculate" > /dev/stderr
       fi ;;
    d) commaOrDotAsDecimal=$OPTARG 
       case $commaOrDotAsDecimal in
         0|1) ;;
           *) die "Ungueltiger Wert fuer Dezimal-/Tausendertrennvorgabe: $commaOrDotAsDecimal" > /dev/stderr ;;
       esac ;;
    F) convenienceFilter="$OPTARG" ;;
    h) usage; exit ;;
    H) defaultUsage; exit ;;
    e) exclude=$OPTARG 
       if [[ "$exclude" =~ [^0-9:] ]]; then
         die "Ungueltige Spaltenliste: $exclude" > /dev/stderr
       fi ;;
    f) filter="$OPTARG" ;;
    *) die "mycsvfilter: Keine gueltige Option $opt" > /dev/stderr ;;
  esac
done
shift $(( OPTIND -1 ))
infile="$1"


if [ -n "$infile" ]; then
  verifyFile $infile
fi
verifyFile "$filterConfig"
[ -z "$filter" -a -z "$convenienceFilter" -a -z "$exclude" ] && die "Kein Filter/Ausschluss angegeben" > /dev/stderr

#-------------------------------------------------------------------------------------------
# Main
#   Hinweis: Ohne Filter und ohne Excludes unterscheiden sich Ein- und Ausgabe nicht
#-------------------------------------------------------------------------------------------

#-------------------------------------------------------------------------------------------
# Filter mit Namensbezeichner in Konfigurationsdatei suchen
#-------------------------------------------------------------------------------------------
if [ -n "$convenienceFilter" ]; then
  found=""
  while IFS=\; read key value; do
    if [ "$key" == $convenienceFilter ]; then
      printf "Filter %s => %s gefunden ...\n" "$key" "$value" > /dev/stderr
      filter="$value"
      found="yes"
      break
    fi
  done < <(sed '/^\s*#/d' $filterConfig)       # Kommentarzeilen ueberspringen
  [ -z "$found" ] && die "Konnte Filter $convenienceFilter nicht finden" > /dev/stderr
fi

awk -F ";" -v filter="$filter" -v exclude="$exclude" -v calculate="$calculate" -v codad=$commaOrDotAsDecimal '
  @include "/usr/local/bin/commonroutines.awk"
  BEGIN{
    if(codad == 1){
      commaOrDotAsDecimal=1;
    }
    else if(codad == 0){
      commaOrDotAsDecimal=0;
    }
    else{
      # andernfalls greift Voreinstellung in commonroutines.awk
    }
    #-------------------------------------------------------------------------------------------------
    OFS=";";
    #-------------------------------------------------------------------------------------------------
    # Spalten fuer Addition ermitteln
    #-------------------------------------------------------------------------------------------------
    numCalculations=split(calculate,dummyArr,":");
    for(i=1;i<=numCalculations;i++){
      col=dummyArr[i];
      calculateHash[col]="j";
      printf("Spalte: %3.3s => Addition\n",col) >> "/dev/stderr" ;
    }
    #-------------------------------------------------------------------------------------------------
    # Ausblendungen ermitteln
    #-------------------------------------------------------------------------------------------------
    numExcludes=split(exclude,dummyArr,":");
    for(i=1;i<=numExcludes;i++){
      col=dummyArr[i];
      excludeHash[col]="j";
      printf("Spalte: %3.3s => Ausschluss\n",col) >> "/dev/stderr" ;
    }
    #-------------------------------------------------------------------------------------------------
    # Spalten-Filter-Kombinationen trennen
    #   1:!empty#3:Hugo => 
    #     1:!empty
    #     3:Hugo
    #-------------------------------------------------------------------------------------------------
    numFilters=split(filter,filterArr,"#");
    #-------------------------------------------------------------------------------------------------
    # Nun Spalten und ihre Filter ermitteln
    #   1:!empty =>
    #     1
    #     !empty
    #-------------------------------------------------------------------------------------------------
    for(i=1;i<=numFilters;i++){
      dummy=filterArr[i];                  # 1:!empty
      numElements=split(dummy,dummyArr,":");
      if(numElements != 2){
        die("Konnte Spaltenfilter nicht in 2 Teile zerlegen: " dummy) > /dev/stderr ;
      }
      col=dummyArr[1];
      colFil=dummyArr[2];
      #-----------------------------------------------------------------------------------------------
      # Liegt ein negativer Filter vor ?
      #   !empty => empty und Eintrag in Negativregister
      #-----------------------------------------------------------------------------------------------
      if(substr(colFil,1,1) == "!"){
        colFil=substr(colFil,2);  # !empty => empty
        negHash[col]="j";
      }
      colFilHash[col]=colFil;     
    }
    #-------------------------------------------------------------------------------------------------
    # Debug
    #-------------------------------------------------------------------------------------------------
    for(col in colFilHash){
      kindOfFilter=(col in negHash) ? "negative" : "positive";
      printf("Spalte: %3.3s => Filter: |%s| (%s)\n",col,colFilHash[col],kindOfFilter) >> "/dev/stderr" ;
    }
    #-------------------------------------------------------------------------------------------------
  }
  #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  {
    #-------------------------------------------------------------------------------------------------
    # Filter anwenden
    #-------------------------------------------------------------------------------------------------
    for(col in colFilHash){
      if(int(col) > NF){
        die("Feldzahl " NF " ueberschritten (" col ")") > /dev/stderr ;
      }
      value=$(col);
      #-----------------------------------------------------------------------------------------------
      # Hat Spalte einen Filter ?
      #-----------------------------------------------------------------------------------------------
      if(col in colFilHash){
        filter=colFilHash[col];
        #---------------------------------------------------------------------------------------------
        # Ist der Filter negativ ?
        #---------------------------------------------------------------------------------------------
        if(col in negHash){
          if(filter == "empty"){
            if((! value) || (value ~ /^[0,.]+$/)){     # Kein Wert oder irgendeine 0-Darstellung [0,.]
              next;
            }
          }
          else{
            #-----------------------------------------------------------------------------------------
            # Ist Filter ein Pattern ?
            #-----------------------------------------------------------------------------------------
            if(filter ~ /[].*+|\\]/){
              # printf("Korrekt erkannter Filter: |%s|\n",filter) >> "/dev/stderr" ;
              if(value ~ filter){
                next;
              }
            }
            #-----------------------------------------------------------------------------------------
            # Nein => vollstaendiger Vergleich (String oder Zahl)
            #-----------------------------------------------------------------------------------------
            else{
              if(value == filter){
                next;
              }
            }
          }
        }
        #---------------------------------------------------------------------------------------------
        # Positiv-Filter
        #---------------------------------------------------------------------------------------------
        else{
          if(filter == "empty"){
            if(value && (! (value ~ /^[0,.]+$/))){      # Wert und keine Art der 0-Darstellung [0,.]
              next;
            }
          }
          else{
            #-----------------------------------------------------------------------------------------
            # Ist Filter ein Pattern ?
            #-----------------------------------------------------------------------------------------
            if(filter ~ /[].*+|\\]/){
              # printf("Korrekt erkannter Filter: |%s|\n",filter) >> "/dev/stderr" ;
              if(! (value ~ filter)){
                next;
              }
            }
            #-----------------------------------------------------------------------------------------
            # Nein => vollstaendiger Vergleich (String oder Zahl)
            #-----------------------------------------------------------------------------------------
            else{
              if(value != filter){
                next;
              }
            }
          }
        }
      }
    }
    #----------------------------------------------------------------------------------------------------------------------------------
    # Kein Filter traf zu => ggf. Summation ausgwaehlter Spalten (sofern nicht ausgeblendet) und Ausgabe nicht auszublendender Spalten
    #----------------------------------------------------------------------------------------------------------------------------------
    for(i=1;i<=NF;i++){
      #------------------------------------------------------------------------------------
      # Spalte auszublenden ?
      #------------------------------------------------------------------------------------
      if(i is in excludeHash){
        $i="";
      }
      #------------------------------------------------------------------------------------
      # Spaltenwert addieren ?
      #------------------------------------------------------------------------------------
      else if(i in calculateHash){
        number=trim($i); 
        if(isNumber(number)){
          sum[i]+=convertNumber(number);
        }
        else{
          printf("Spalte %3.3s Zeile %5.5s: Keine Zahl: %s\n",i,FNR,number) > "/dev/stderr" ;
        }
      }
    }
    print;
  }
  #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  END{
    printf("%150.150s\n",hashLine) > "/dev/stderr" ;
    for(col in sum){
      printf("Summe Spalte %3.3s: %15.1f\n",col,sum[col]) > "/dev/stderr" ;
    }
    printf("%150.150s\n",hashLine) > "/dev/stderr" ;
  }
' "$infile" | tee $outfile
checkReturn "awk-Fehler"

#-------------------------------------------------------------------------------------------------------------------------------------------------
#}}}}

mycsvsort

#!/bin/bash
#{{{{
#!/bin/bash
#-------------------------------------------------------------------------------------------
#<Beschreibung>
#  Sortiert eine CSV-Datei nach Eingabespalten
#</Beschreibung>
#-------------------------------------------------------------------------------------------

. /usr/local/bin/common

function usage(){ 
  cat <<EOF

     $0 -[k|K] <Zahl>[:<Zahl>]... [-r(everse)] <infile>

     Sortiert die Spalten einer CSV-Datei in der angegebenen Reihenfolge alphabetisch oder numerisch auf die Standardausgabe

     -k: Spalten in der angegebenen Reihenfolge, durch ':' getrennt alphabetisch sortieren
     -K: wie vordem, jedoch numerisch
     -r: absteigende Sortierung

     Beispiel

     $0 -k 2:4:3 -n Hugo.csv

EOF
} 

infile=""
outfile=""
keyString=""
numerically=""
reverse=""


while getopts "hHk:K:r" opt; do
  case $opt in
      h) usage; exit ;;
      r) reverse="-r" ;;
      H) defaultUsage; exit ;;
    k|K) keyString=$OPTARG 
         case $keyString in
           *[0-9:]*) if [[ "$keyString" =~ : ]]; then
                       keyString="-k ${keyString//:/ -k }"                     # 1:2          =>   -k 1 -k 2
                     else
                       keyString="-k $keyString"
                     fi 
                     keyString=$( sed 's/\([0-9]\+\)/&,&/g' <<< $keyString) ;; # -k 1 -k 2    =>   -k 1,1 -k 2,2 
                  *) die "Ungueltige Spaltenangabe: $keyString" ;;
         esac 
         [ "$opt" == "K" ] && numerically="yes" ;;
      n) numerically="-n" ;;
      *) die "mycsvsort: Keine gueltige Option $opt" ;;
  esac
done
shift $(( OPTIND -1 ))
infile="$1"


[ -z "$infile" ] && die "Keine Eingabedatei"
[ -z "$keyString" ] && die "Keine Spaltenangabe"
for file in $infile; do
  verifyFile $file
done

#-------------------------------------------------------------------------------------------
# Main
# Cave: Bei alphabetischer Sortierung ist Option -i (ignore non-printable...) zwingend !
#       Bei numerischer Sortierung dagegen darf -i nicht ebenfalls angegeben sein
#-------------------------------------------------------------------------------------------
echo "Spalten: $keyString" numerically ${numerically:-no} ${reverse:+reverse} > /dev/stderr
if [ -z "$numerically" ]; then
  sort -i $reverse -t \; $keyString "$infile" 
else
  sort -n $reverse -t \; $keyString "$infile"
fi
checkReturn "sort-Fehler"
#}}}}

mycsvcalc

#!/bin/bash
#{{{{
#!/bin/bash
#-------------------------------------------------------------------------------------------
#<Beschreibung>
#  Addiert Felder einer Spalte in einer csv-Datei
#</Beschreibung>
#-------------------------------------------------------------------------------------------

. /usr/local/bin/common

function usage(){ 
  cat <<EOF

     $0 -c <Spalte>:<Startzeile>:<Endzeile> [-f <Spalte>:<Pattern>] [-F <filterName>] [-d(dotOrCommaAsDecimal] <infile> [-t(ext) <Prolog-Text>] [-T(ext) <Epilog-Text>] [-l(ogFile <log>]

        $0 -c 8:14:27 -f '7:^[0-9]+Sales#8:!Willi#9:Heinz.*Breinlinger' Hugo.csv

          Addiere Zeilen 14 bis 27 in Spalte 8, sofern Spalte 7 die Filterbedingung erfuellt

        -f: analog mycsvfilter (cf. mycsvfilter -h)
        -F: analog mycsvfilter (cf. mycsvfilter -h)

        -c: Zu addierende Spalten im Formant <Spalte>:<Startzeile>:<Endzeile>

            Cave: Die Endzeile darf groesser als die Zeilenzahl der Datei sein

        -d: Interpretation von "." oder "," vor 3 Ziffern als Dezimaltrenner (andernfalls als Tausendertrennzeichen)

        -t: Anstelle des Defaults auszugebender Prolog (vor Summe)
        -T: Moeglicher Epilog (nach Summe)
        -l: Alternative Log-Datei in Verzeichnis $logDir
            Default ist $logFile

EOF
} 

commaOrDotAsDecimal=""
infile=""
calc=""
infile=""
col=""
firstRow=""
lastRow=""
epilog=""
prolog="Ergebnis: "
filter=""
convenienceFilter=""
logFile=${logDir}/logmycsvcalc.txt


while getopts "d:f:F:hHc:t:T:l:" opt; do
  case $opt in
    h) usage; exit ;;
    H) defaultUsage; exit ;;
    c) calc=$OPTARG              
       [[ "$calc" =~ [0-9]\+:[0-9]\+:[0-9]\+ ]] && die "Kalkulationsangabe ungueltig: $calc" 
       col=${calc%%:*}        # 1:2:3 => 1
       lastRow=${calc##*:}    # 1:2:3 => 3
       dummy=${calc#*:}       # 1:2:3 => 2:3
       firstRow=${dummy%%:*}  #   2:3 => 2
       [ $lastRow -le $firstRow ] && die "Endzeile <= Startzeile" ;;
    d) commaOrDotAsDecimal=$OPTARG 
       case $commaOrDotAsDecimal in
         0|1) ;;
           *) die "Ungueltiger Wert fuer Dezimal-/Tausendertrennvorgabe: $commaOrDotAsDecimal" ;;
       esac ;;
    l) logFile=${logDir}/$OPTARG ;;
    f) filter="$OPTARG";;
    F) convenienceFilter="$OPTARG";;
    t) prolog="$OPTARG" ;;
    T) epilog="$OPTARG" ;;
    *) die "Keine gueltige Option" ;;
  esac
done
shift $((OPTIND - 1))
infile="$1"


[ -z "$infile" ] && die "Eingabedatei fehlt"
[ -z "$calc" ] && die "Kalkulationsangabe fehlt" 
for file in "$infile"; do
  verifyFile $file
done

#-------------------------------------------------------------------------------------------
# Achtung: Bei Filterung verlieren Start- und Endzeile der Addition ihre Gueltigkeit,
#          weswegen die Eingabedatei VOR Filterung auf den gewollten Zeilenbereich
#          zu beschraenken ist
#-------------------------------------------------------------------------------------------
sed -n ${firstRow},${lastRow}p "$infile" > dummy1
infile=dummy1
checkReturn "sed-Fehler"
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Filterung
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if [ -n "$filter" ]; then
  mycsvfilter -f "$filter" $infile > dummy2
  checkReturn "mycsvfilter-Fehler"
  infile=dummy2
elif [ -n "$convenienceFilter" ]; then
  mycsvfilter -F "$convenienceFilter" $infile > dummy2
  checkReturn "mycsvfilter-Fehler"
  infile=dummy2
fi
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

awk -F ";" -v colCalc=$col -v codad=$commaOrDotAsDecimal -v prolog="$prolog" -v epilog="$epilog" -v logFile="$logFile" '
  @include "/usr/local/bin/commonroutines.awk"
  BEGIN{
    if(codad == 1){
      commaOrDotAsDecimal=1;
    }
    else if(codad == 0){
      commaOrDotAsDecimal=0;
    }
    else{
      # andernfalls greift Voreinstellung in commonroutines.awk
    }
    #-------------------------------------------------------------------------------------------------
    OFS=";";
    sum=0;
    counter=0;
    #-------------------------------------------------------------------------------------------------
    printf("\n") > logFile;     # implizit Ueberschreiben eines vorherigen Logs
  }
  #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  {
    if(colCalc > NF){
      die("Feldzahl " NF "kleiner als zu summierende Spalte " colCalc);
    }
    sum+=convertNumber($colCalc);
    counter++;
    print >> logFile;
  }
  #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  END{
    printf("%-80.80s: %\047 15.2f (%4d Datensaetze) %s\n",prolog,sum,counter,epilog);          # \047 ist octal fuer hier nicht verwendbares Hochkomma (\ und 2-3 Ziffern sind octal in awk)
    printf("%-80.80s: %\047 15.2f (%4d Datensaetze) %s\n",prolog,sum,counter,epilog)  >> logFile;
  } ' "$infile"
checkReturn "awk-Fehler"

#-------------------------------------------------------------------------------------------------------------------------------------------------
# commonOut "=> $logFile"
#}}}}

mycsvmerge

#!/bin/bash
#{{{{
#!/bin/bash
#-------------------------------------------------------------------------------------------
#<Beschreibung>
#  Funktion 1: Merge (mehrere Key-Spalten, 1-n Value-Spalten in Datei 1, eine Zielspalte in Datei 2 => Ausgabe in Datei 2_merged.csv)
#    Merged Spalten einer csv-Datei in eine andere csv-Datei, sofern beide Dateien eine oder 
#    mehrere gemeinsame Key-Spalte(n) besitzen
#      - Sonderfunktion: Ist die Value-Spalte aus Datei 1 '999' wird in Datei 2 hinter deren Zielspalte nur ausgegeben, ob
#        die Key-Kombination in Datei 1 vorhanden war.
#  Funktion 2: Comparison (mehrere Key-Spalten, mehrere Value-Spalten in Datei 1 und Datei 2 => Ausgabe in diff.csv)
#    Schreibt hinter die Value-Spalten aus Datei 2
#      ob die Key-Kombination in der ersten Datei enthalten war,
#      genau dann jeweils
#        die korrespondierenden values uebereinstimmten oder abwichen
#  Cave: Nicht in Datei 2 gefundene keys aus Datei 1 (und umgekehrt) werden auf stderr ausgegeben (ggf. umleiten)
#</Beschreibung>
#-------------------------------------------------------------------------------------------

. /usr/local/bin/common

function usage(){ 
  cat <<EOF

     Cave: Option -c => concatenate (bei merge)
           Option -C => compare (anstelle merge)

     Cave: Nicht in Datei 2 vorhandene Keys aus Datei 1 (und umgekehrt) werden auf stderr ausgegeben (ggf. umleiten)

     Funktion 1: Merge
       - mehrere key-Spalten in Datei 1 und Datei 2 (werden zusammengefasst)
       - mehrere value-Spalten in Datei 1 (werden zusammengefasst)
       - eine Zielspalte in Datei 2
         - einfuegen dahinter oder Konkatenierung mit dieser
       - Ausgabe der erweiterten Datei 2 in Datei 2_merged.csv

       $0 -i(nsert) <csv1>:<keycol(s)>:<valuecol(s)> -o(ut) <csv2>:<keycol(s)>:<targetColFile2> [-c(oncatenate|-r(eplace)|-R(eplaceforce)] [-n(oconvert)]

       -n: Keine Konvertierung (Booster auf eigene Gefahr !)

       Fuegt die Werte aus Spalten der ersten hinter oder in die Spalte einer zweiten csv-Datei ein.

       <keycol(s)> ist dabei entweder die (bezueglich Auspraegungen) gemeinsame Schluessel-Spalte beider Dateien fuer
       die Zuordnung der Werte aus <valuecol(s)> oder ein Ausdruck fuer mehrere jeweils gemeinsame Schluessel-Spalten der Form
         <Zahl>u(nd)<Zahl>u(nd)<Zahl>...

       Ebenso bezeichnet <valuecol(s)> entweder eine einzige oder mehrere Spalten <Zahl>u(nd)<Zahl>

       Bei Option -c wird die Spalte mit der Zielspalte konkateniert, anderfalls dahinter eingefuegt
       Bei Option -r wird die Spalte in die Zielspalte eingefuegt und ueberschreibt ggf. dortige Leer-Werte
       Bei Option -R werden im Unterschied zu -r auch bestehende Werte der Zielspalte ueberschrieben

       Convenience: 
         Ist die Zielspalte "hinten", wird hinter der letzten Spalte in csv2 eingefuegt.
         Ist die Zielspalte "vorne", wird vor der ersten Spalte in csv2 eingefuegt.
           Cave: Letzeres ist die einzige Moeglichkeit hierzu da '0' in awk \$0 entspricht und alle Spalten referenziert

       Beispiel:
         
         $0 -i Steinbruch.csv:1:2 -o Zieldatei.csv:1:5 -c
           
           Key:    jeweils Spalte 1 
           Value:  Spalte 2 in erster Datei
           Target: Spalte 5 in zweiter Datei (Konkatenierung)
                   Bei alternativer Option -r wuerde Spalte 5 ueberschrieben

         $0 -i Steinbruch.csv:1u3:2 -o Zieldatei.csv:2u4:5 

            Key: Spalten 1 und 3 in erster und 2 und 4 in zweiter Datei
                 Einfuegen der Spalte 2 der ersten Datei nach Spalte 5 der zweiten Datei (keine Konkatenierung)

         $0 -i Steinbruch.csv:1u3u9:2u4u7 -o Zieldatei.csv:2u3u4:vorne 

            Key: Spalten 1,3,9 in erster und 2,3,4 in zweiter Datei
                 Einfuegen der Spalten 2,4,7 der ersten Datei vor erster Spalte der zweiten Datei (implizit/logisch keine Konkatenierung)

         $0 -i Steinbruch.csv:1u3u9:2u4u7 -o Zieldatei.csv:2u3u4:hinten

            dito, jedoch automatische Bestimmung der Zielspalte

       Cave: Ausgabedatei ist immer *_merged.csv; selbst wenn die Eingabedatei bereits "merged" war ...

       Besonderheit: Ist die Value-Spalte aus Datei 1 '999' wird in Datei 2 hinter (oder in) deren Zielspalte nur ausgegeben, ob
                     die Key-Kombination in Datei 1 vorhanden war.

     Funktion 2: Comparison (Option -C)
       - mehrere Key-Spalten in Datei 1 und Datei 2 (werden zusammengefasst)
       - mehrere Value-Spalten in Datei 1 und Datei 2 (werden NICHT zusammengefallst, sondern getrennt betrachtet)
       - Markierung fehlender oder Einfuegen abweichender Werte genau hinter die jeweilige value-Spalte in Datei 2
       - Ausgabe in diff.csv
         Cave: Nur key- und value-Spalten beider Dateien werden ausgegeben

       $0 -i(nsert) <csv1>:<keycol(s)>:<valuecol(s)> -o(ut) <csv2>:<keycol(s)>:<valuecol(s)> -C(ompare) [-m(atchonly] [-n(oconvert]
       
        -C: Unterschied zu Funktion 1 => compare anstelle merge
        -m: Ausgabe von 'match' bei Uebereinstimmung, sonst des abweichenden Wertes bei Daten aus Datei 1
            Cave: Fuer Match werden Werte normiert 

       Beispiel
         
         $0 -i Referenz.csv:1u2u3:4u5u6 -o Pruefling.csv:2u1u3:5u6u7 -C 

EOF
} 

dummy=""
col=""
csv1=""
csv2=""
keyColFile1=""
keyColFile2=""
valColFile1=""
targetColFile2=""
insert=""
tmp="dummy.csv"
csvMerged=""
csvDiff="diff.csv"
compare=""
matchOnly=""
noConvert=""


while getopts "CchHi:o:mnrR" opt; do
  case $opt in
    c) insert="concatenate" ;;
    C) compare="yes" ;;
    h) usage; exit ;;
    H) defaultUsage; exit ;;
    i) csv1="${OPTARG%%:*}" 
       valColFile1="${OPTARG##*:}" 
       dummy="${OPTARG#*:}"
       keyColFile1="${dummy%:*}"
       for col in "$keyColFile1" "$valColFile1"; do
         [[ ! "$col" =~ [0-9u] ]] && die "csv1: Konnte Parameter $OPTARG nicht zerlegen" 
       done 
       [ "$keyColFile1" == "$valColFile1" ] && die "Key- und Value-Spalte der ersten Datei duerfen nicht uebereinstimmen" ;;
    m) matchOnly="yes" ;;
    o) csv2="${OPTARG%%:*}" 
       targetColFile2="${OPTARG##*:}" 
       dummy="${OPTARG#*:}"
       keyColFile2="${dummy%:*}"
       for col in "$keyColFile2" "$targetColFile2"; do
         if [[ ! "$col" =~ [0-9u] ]]; then
           if [ "$col" != "hinten" -a "$col" != "vorne" ]; then                          # ja, waere fuer $keyColFile2 oder bei Option "compare" falsch, ist aber verschmerzbar ;-)
             die "csv2: Konnte Parameter $OPTARG nicht zerlegen" 
           fi
         fi
       done  ;;
    n) noConvert="j" ;;
    r) insert="replace" ;;
    R) insert="replaceforce" ;;
    *) die "Keine gueltige Option" ;;
  esac
done


[ -z "$csv1" -o -z "$csv2" ] && die "Bitte 2 csv-Dateien angeben"
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
for file in "$csv1" "$csv2"; do
  [[ ! "$file" =~ .csv$ ]] && die "$file ist keine csv-Datei"
  verifyFile "$file"
  [ -z "$noConvert" ] && convertReplaceUml "$file"
done
[[ "$keyColFile1" =~ u ]] && [[ ! "$keyColFile2" =~ u ]] && die "Fuer die zweite Datei muessen ebenfalls mehrere Schluessel-Spalten angegeben werden"
[[ ! "$keyColFile1" =~ u ]] && [[ "$keyColFile2" =~ u ]] && die "Die zweite Datei darf ebenfalls nur eine Schluessel-Spalte besitzen"
if [[ "$csv2" =~ merged ]]; then
  csvMerged="$csv2"
else
  csvMerged="${csv2%.csv}"_merged.csv
fi
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
cat <<EOF
  Datei 1            : $csv1
  Key 1              : $keyColFile1
  Value 1            : $valColFile1
  Datei 2            : $csv2
  Key 2              : $keyColFile2
  Zielspalte/Value 2 : $targetColFile2
EOF


/usr/bin/awk -F ";" -v csv1="$csv1" -v keyColFile1="$keyColFile1" -v valColFile1="$valColFile1" -v keyColFile2="$keyColFile2" -v targetColFile2="$targetColFile2" -v insert="$insert" -v compare="$compare" -v matchOnly="$matchOnly" '
@include "/usr/local/bin/commonroutines.awk"
BEGIN{ 
  getResourceNorming();  # Muster fuer Ressourcenmappings einlesen fuer den Fall, dass Spalten Ressourcen entsprechen
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # Ausgabe-Trennzeichen fuer keys und values festlegen
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  keySeparator=" - ";
  if(compare == "yes"){
    valSeparator="|";
  }
  else{
    valSeparator =" - ";
  }
  emptyVal="<>";  # Cave: Hochkommata wuerden ggf. folgende csv2csv-Wandlung behindern
  notFoundVal="-";
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # 1 oder mehrere Value-Spalten in Datei 1 ?
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  if(valColFile1 ~ /u/){
    numValColsFile1=split(valColFile1,valColArrFile1,"u");
  }
  else{
    numValColsFile1=1;
    valColArrFile1[1]=valColFile1;
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # 1 oder mehrere Key-Spalten in Datei 1 ?
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  if(keyColFile1 ~ /u/){
    numKeyColsFile1=split(keyColFile1,keyColArrFile1,"u");
  }
  else{
    numKeyColsFile1=1;
    keyColArrFile1[1]=keyColFile1;
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # 1 oder mehrere Key-Spalten in Datei 2 ?
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  if(keyColFile2 ~ /u/){
    numKeyColsFile2=split(keyColFile2,keyColArrFile2,"u");
    if(numKeyColsFile1 != numKeyColsFile2){
      die("Anzahl der Key-Spalten in Datei 1 und 2 weichen ab");
    }
  }
  else{
    numKeyColsFile2=1;
    keyColArrFile2[1]=keyColFile2;
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # Hash der Key-Spalten und Value-Spalten fuer Datei 1 aufbauen
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  while(getline < csv1){
    sub("\r","",$0);  # Newline entfernen
    key="";
    for(i=1;i<=numKeyColsFile1;i++){
      key=(key != "") ? key keySeparator normString($(keyColArrFile1[i])) : normString($(keyColArrFile1[i]));
    }
    if(key){
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # Sonderfunktion "999" => Kein Spaltenuebertrag sondern nur Markierung eines Matches in/hinter
      #                         Zielspalte in Datei 2
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      if((numValColsFile1 == 1) && (valColArrFile1[1] == "999")){
        tmpVal="Match";
      }
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # Regulaere Funktion => Werte der value-Spalten sammeln
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      else{
        tmpVal="";
        for(i=1;i<=numValColsFile1;i++){
          dummy=$(valColArrFile1[i]);
          dummy=(dummy ~ /^[[:space:]]*$/) ? emptyVal : dummy;
          tmpVal=(tmpVal != "") ? tmpVal valSeparator dummy : dummy; 
        }
      }
      valHash[key]=tmpVal;
    }
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  lastColInFile2=0;
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # Debugging
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#  for(key in valHash){
#    printf("Key: %s - Value: %s\n",key,valHash[key]);
#  }
} 
#################################################################################################
#---------------------------------------------------------------------------------------------
# Ausgabe der zweiten Datei mit Anreicherungen aus erster Datei oder Ausgabe einer Vergleichsdatei
#---------------------------------------------------------------------------------------------
{ 
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # Letzte Spalte bestimmen 
  # Feldzahl muss ueber alle Zeilen konstant sein
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  if(NR == 1){
    lastColInFile2=NF;
  }
  else if(NF != lastColInFile2){
    die("Zeile "NR": Spaltenzahl "NF" weicht von Spaltenzahl der ersten Zeile "lastColInFile2" ab");
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  if((compare != "yes") && (! (targetColFile2 ~ /(vorne|hinten)/)) && (targetColFile2 > NF)){
    print("Zielspalte " targetColFile2 " ueberschreitet Feldzahl " NF " auf Zeile " FNR) >> "/dev/stderr" ;
    next;
  }
  sub("\r","",$0);  # Newline entfernen
  key="";
  for(i=1;i<=numKeyColsFile2;i++){
    key=key ? key keySeparator normString($(keyColArrFile2[i])) : normString($(keyColArrFile2[i]));
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # Fuer evtl. zusammengesetzten key value aus Datei 1 ermitteln
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  if(key in valHash){
    val=valHash[key];
    usedHash[key]="yes";
  }
  else{
    val="";
    # failureHash[key]="yes";
    failureHash[key]=$0;
  }
  #-------------------------------------------------------------------------------------------
  # Compare ?
  #-------------------------------------------------------------------------------------------
  if(compare == "yes"){
    valColFile2=targetColFile2; # Zielspalte ist nun der falsche Begriff => value-Spalte
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # 1 oder mehrere value-Spalten ?
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    if(valColFile2 ~ /u/){
      numValColsFile2=split(valColFile2,valColArrFile2,"u");
    }
    else{
      numValColsFile2=1;
      valColArrFile2[1]=valColFile2;
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    if(numValColsFile1 != numValColsFile2){
      die("mismatch of number of value-columns Datei 1: " numValColsFile1 " <=> Datei 2: " numValColsFile2);
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # Key-Spalten ausgeben
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    for(i=1;i<=numKeyColsFile2;i++){
      printf("%s;",$(keyColArrFile2[i]));
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # Value-Spalten "interleaved" ausgeben, auf Wunsch jedoch Werte aus Datei 1 nur, sofern kein Match
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    numValsFile1=split(val,valArrFile1,valSeparator);
    for(i=1;i<=numValColsFile2;i++){
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # Value aus Datei 2
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      dummy=$(valColArrFile2[i]);
      dummy=(dummy ~ /^[[:space:]]*$/) ? emptyVal : dummy;
      printf("%s;",dummy);
      normedValFile2=normString($(valColArrFile2[i]));
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # Value aus Datei 1
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      if(numValsFile1 >= i){
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        # Nur Match-Kennzeichen und Wert lediglich bei Abweichung ausgeben ?
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        if(matchOnly == "yes"){
          normedValFile1=normString(valArrFile1[i]);
          if(normedValFile2 != normedValFile1){
            printf("%s;",valArrFile1[i]);
          }
          else{
            printf("match;");
          }
        }
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        # Nicht Match-Pruefung, sondern Wert ausgeben
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        else{
          printf("%s;",valArrFile1[i]);
        }
      }
      else{
        printf("%s;",notFoundVal);
      }
    }
    printf("\n"); 
  }
  #-------------------------------------------------------------------------------------------
  # Merge
  #-------------------------------------------------------------------------------------------
  else{
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # Virtuelle Zielspalte "0" => alle zu uebertragenen Werte der ersten Datei als erstes ausgeben
    #                             , anschliessend alle Werte der zweiten Datei hinten anhaengen
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    if(targetColFile2 == "vorne"){
      printf("%s;",val)                     # Wert oder Werte aus csv1
      for(i=1;i<NF;i++){
        printf("%s;",$i);                   # Alle Zeilenwerte bis auf den letzten aus csv2
      }
      printf("%s\n",$NF);                  # Letzte Spalte ohne Semikolon
      next;
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # Zielspalte aus ermittelter Gesamtspaltenzahl ermitteln ?
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    if(targetColFile2 == "hinten"){
      targetColFile2=lastColInFile2;
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # Felder vor Zielspalte ausgeben
    # Cave:
    #   Falls die Zielspalte ausserhalb der letzten Zeilenspalte liegt, muessen Leerspalten
    #   eingefuegt werden.
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    if(targetColFile2 <= NF){
      for(i=1;i<targetColFile2;i++){
        printf("%s;",$i);
      }
    }
    #-   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   
    # Zielspalte liegt ausserhalb der letzten Zeilenspalte => 
    #   alle Nutzspalten und anschliessend Leerspalten bis vor Zielspalte ausgeben
    #-   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   -   
    else{
      for(i=1;i<=NF;i++){
        printf("%s;",$i);
      }
      for(i=NF+1;i<targetColFile2;i++){
        printf("%s;","");
      }
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # Entweder merge oder replace oder nach Zielspalte ausgeben
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    if(insert ~ /(concatenate|replace)/){
      newVal="";
      #-------------------------------------------------------------------------------------
      # Verkettung ?
      #-------------------------------------------------------------------------------------
      if(insert == "concatenate"){
        val=(val) ? val : emptyVal;
        newVal=$targetColFile2 valSeparator val;
      }
      #-------------------------------------------------------------------------------------
      # Ersetzung bei Leerwert (sofern Ersetzung nicht selbst ein Leerwert ist) ?
      #-------------------------------------------------------------------------------------
      else if(insert == "replace"){
        if(trueVal(val)){
          newVal=(trueVal($targetColFile2)) ? $targetColFile2 : val;   # nur etwaigen Leer- oder Nullwert ueberschreiben
        }
        else{
          newVal=$targetColFile2;                                      # bisherigen Wert beibehalten, da Ersetzung nutzlos
        }
      }
      #-------------------------------------------------------------------------------------
      # Zwingende Ersetzung ?
      #-------------------------------------------------------------------------------------
      else if(insert == "replaceforce"){
        newVal=(val) ? val : "";
      }
      else{
        die("Internal Error: Ungueltiger Wert fuer insert: "insert);
      }
      #-------------------------------------------------------------------------------------------------------
      # Ausgabe von Verkettung oder Ersetzung (oder altem Wert)
      #-------------------------------------------------------------------------------------------------------
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # Zielspalte vor letztem Feld ?
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      if(targetColFile2 < NF){
        printf("%s;",newVal);                      # Ausgabe mit Semikolon, da nicht letzte Spalte
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        # restliche Felder ausgeben 
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        for(i=targetColFile2+1;i<NF;i++){          # Ausgabe bis einschliesslich der vorletzten Spalte (auch nichts)
          printf("%s;",$i);
        }
        printf("%s\n",$NF);                       # Letzte Spalte ohne Semikolon
      }
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # Zielspalte == letztes Feld
      #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      else{
        printf("%s\n",newVal);                     # Abschluss, da letzte Spalte
      }
    }
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # keine Verkettung, sondern Hintanfuegen
    #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    else{
      if(targetColFile2 < NF){
        printf("%s;%s;",$targetColFile2,val);      # Ausgabe mit Semikolon, da nicht letzte Spalte
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        # restliche Felder ausgeben 
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        for(i=targetColFile2+1;i<NF;i++){          # Ausgabe bis einschliesslich der vorletzten Spalte (auch nichts)
          printf("%s;",$i);
        }
        printf("%s\n",$NF);                       # Letzte Spalte ohne Semikolon
        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      }
      else{
        printf("%s;%s\n",$targetColFile2,val);   # Abschluss, da letzte Spalte
      }
    }
  }
} 
#---------------------------------------------------------------------------------------------
# Verifikation, ob alle potentiellen Anreicherungen verwertet wurden
#---------------------------------------------------------------------------------------------
END{ 
  for(key in valHash){
    if(! (key in usedHash)){
      gsub(keySeparator,";",key)   # Key-Folge als csv-Folge schreiben
      printf("Ueberhang_Datei_1;%s\n",key) > "/dev/stderr";
    }
  }
  #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  for(key in failureHash){
    gsub(keySeparator,";",key)   # Key-Folge als csv-Folge schreiben
    printf("Ueberhang_Datei_2;%s\n",key) > "/dev/stderr";
  }
} 
#---------------------------------------------------------------------------------------------
' < "$csv2" > $tmp
checkReturn "awk-Fehler"

#-------------------------------------------------------------------------------------------
if [ -n "$compare" ]; then
  mv "$tmp" "$csvDiff"
  checkReturn "mv-Fehler"
  [ -z "$noConvert" ] && convertReplaceUml "$csvDiff"
  commonOut "=> $csvDiff"
else
  mv "$tmp" "$csvMerged"
  checkReturn "mv-Fehler"
  [ -z "$noConvert" ] && convertReplaceUml "$csvMerged"
  commonOut "=> $csvMerged"
fi
#}}}}

mycsvview

#!/bin/bash
#{{{{
#!/bin/bash
#-------------------------------------------------------------------------------------------
#<Beschreibung>
#  Erwartet
#    csv-Datei oder Standardeingabe
#  Erzeugt
#    Formatierte Ausgabe derselben
#</Beschreibung>
#-------------------------------------------------------------------------------------------

. /usr/local/bin/common

function usage(){ 
  cat <<EOF

     $0 <csv-Datei> [-n(umber)] [-d(dotOrCommaAsDecimal] [-R(unning total) <col>[:<col>...]] [-w(idth) <Breite>] [-e(xclude) <Spalte>... [-f <Spalte>:<Pattern>#... ] [-F <filtername>] [-k|K <col1[:col2...]>] [-r(eversesort)] [-b(eautify) <col1[:col2...]>]  [-s(eparatorLine] <col>[:<col>...] [-l(inenumbers] [<infile>]

     Cave: Eingabedatei wird konvertiert erwartet (ASCII|UTF-8, Unix, keine Umlaute ...)

           Ohne Eingabedatei wird von stdin gelesen

     Erzeugt optimal formatierte Ausgabe der csv-Datei nach pretty

     -b: Formatierung von Zahlen der angegebenen Spalte mit Tausendertrennzeichen
     -d: Interpretation von "." oder "," vor 3 Ziffern als Dezimaltrenner (andernfalls als Tausendertrennzeichen)
     -e: Ausblenden von Spalten (cf. mycsvfilter -h)
     -k: Sortierung analog mycsvsort (alphabetisch)
     -K: Sortierung analog mycsvsort (numerisch)
     -f: Filterung analog mycsvfilter (cf. mycsvfilter -h)
     -F: Filterung analog mycsvfilter (cf. mycsvfilter -h)
     -n: Erzeugt eine Kopfzeile mit Nummern aller Spalten => Hilfe fuer Folgeverarbeitung via Script
     -r: in Verbindung mit -k|K: absteigende Sortierung
     -R: Ausgabe der laufenden Summen aller durch ":" getrennten Spalten nach ebenjenen
     -w: Optionale Spaltenbegrenzung auf maximal <Breite> Zeichen
     -s: Erzeugt eine Trennzeile, wenn sich der Inhalt von Spalte <col> aendert
         - Variante 1
           -s <col>        
             Trennzeile abhaengig von Inhaltswechsel in Spalte <col>
         - Variante 2
           -s <col1>:<col2>[:.....] 
             wie vordem, jedoch zusaetzlich Summation von Spalte <col> zwischen 2 Trennzeilen
     -l: Stellt der Ausgabe die Originalzeilennummern voran
         Wichtig, wenn mit -s Trennzeilen eingefuegt wurden und via mycsvcalc parallel 
         bestimmte Zeilen einer Spalte addiert werden sollen

     Beispiel

       $0 -n -l -s 2:5:7:8 -w 40 -b 5 Hugo.csv

EOF
} 

infile=""
commaOrDotAsDecimal=""
filter=""
beautify=""
convenienceFilter=""
exclude=""
outfile="pretty"
headline="n"
numerically=""
sepCol=""
rTotals=""
partialSums=""
lineNumbers=""
width="999" # 999 == keine Feldlaengenbegrenzung
filOp=""
reverse=""
ecxlOp=""
sortString=""
convFilOp=""


while getopts "b:d:e:f:F:hHlnR:rw:s:k:K:" opt; do
  case $opt in
      b) beautify=$OPTARG 
         if [[ "$beautify" =~ [^0-9:] ]]; then
           die "Ungueltige Spaltenliste: $beautify" > /dev/stderr
         fi ;;
      d) commaOrDotAsDecimal=$OPTARG 
         case $commaOrDotAsDecimal in
           0|1) ;;
             *) die "Ungueltiger Wert fuer Dezimal-/Tausendertrennvorgabe: $commaOrDotAsDecimal" ;;
         esac ;;
      e) exclude="$OPTARG";;
      f) filter="$OPTARG";;
      F) convenienceFilter="$OPTARG";;
      h) usage; exit ;;
    k|K) sortString="$OPTARG" 
         [ "$opt" == "K" ] && numerically="yes" ;;
      l) lineNumbers="j" ;;
      H) defaultUsage; exit ;;
      r) reverse="-r" ;;
      R) rTotals=$OPTARG 
         if [[ "$rTotals" =~ [^0-9:] ]]; then
           die "Ungueltige Spaltenliste: $rTotals" > /dev/stderr
         fi ;;
      s) dummy=$OPTARG ;
         [[ "$dummy" =~ [^0-9:] ]] && die "Ungueltige Umbruchangabe $dummy" 
         #--------------------------------------------------------------------------------------------
         # Nur eine einzige Spalte angebeben (== nur Trennzeile einfuegen) oder deren mehrere (== Trennzeile und Teilsummen) ?
         #--------------------------------------------------------------------------------------------
         case "$dummy" in
           *:*) sepCol=${dummy%%:*}        # 1:2:3 => 1
                partialSums=${dummy#*:} ;;  # 1:2:3 => 2:3
             *) sepCol="$dummy" ;;
         esac ;;
      w) width=$OPTARG 
         case "$width" in
           *[^0-9]*) die "Keine Zahl $width"
         esac ;;
      n) headline="y" ;;
      *) die "mycsvview: Keine gueltige Option $opt" ;;
  esac
done
shift $(( OPTIND -1 ))
infile="$1"


if [ -n "$infile" ]; then
  verifyFile "$infile"
fi


#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Sortierung
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if [ -n "$sortString" ]; then
  if [ -z "$numerically" ]; then
    optSort="-k"
  else
    optSort="-K"
  fi
  eval mycsvsort $optSort "$sortString" "$reverse" "$infile" > dummy1
  checkReturn "mycsvsort-Fehler"
  infile=dummy1
fi


#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Filterung
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if [ -n "$filter" ]; then
  [ -n "$exclude" ] && exclOp="-e"
  eval mycsvfilter -f \"${filter}\" $exclOp "$exclude" "$infile" > dummy2
  checkReturn "mycsvfilter-Fehler"
  infile=dummy2
elif [ -n "$convenienceFilter" ]; then
  [ -n "$exclude" ] && exclOp="-e"
  eval mycsvfilter -F ${convenienceFilter} $exclOp "$exclude" "$infile" > dummy2
  checkReturn "mycsvfilter-Fehler"
  infile=dummy2
elif [ -n "$exclude" ]; then
  eval mycsvfilter -e "$exclude" "$infile" > dummy2
  checkReturn "mycsvfilter-Fehler"
  infile=dummy2
fi


awk  -v codad=$commaOrDotAsDecimal -v infile="$infile" -v headline="$headline" -v width="$width" -v sepCol="$sepCol" -v lineNumbers="$lineNumbers" -v beautify="$beautify" -v partialSums="$partialSums" -v rTotals="$rTotals" '
  @include "/usr/local/bin/commonroutines.awk"
  BEGIN{
    if(codad == 1){
      commaOrDotAsDecimal=1;
    }
    else if(codad == 0){
      commaOrDotAsDecimal=0;
    }
    else{
      # andernfalls greift Voreinstellung in commonroutines.awk
    }
    #-------------------------------------------------------------------------------------------------
    FS=";";
    OFS=";";                              # Cave: Unabdingbar, da bei Zuweisung $col=... => Neuordnung von $0 mit OFS (Default ist Komma)
    maxFields=0;
    lineNum=1;
    sumLen=12;                         # Fixe Laenge fuer laufende Summen
    #-------------------------------------------------------------------------------------------------
    # Spalten fuer Bildung laufender Summen ermitteln
    #-------------------------------------------------------------------------------------------------
    numRTotals=split(rTotals,dummyArr,":");
    for(i=1;i<=numRTotals;i++){
      col=dummyArr[i];
      rTotalHash[col]="j";
      printf("Spalte: %3.3s => Laufende Summe\n",col) >> "/dev/stderr" ;
    }
    #-------------------------------------------------------------------------------------------------
    # Zu formatierende Zahl-Spalten ermitteln
    #-------------------------------------------------------------------------------------------------
    numBeautifiers=split(beautify,dummyArr,":");
    for(i=1;i<=numBeautifiers;i++){
      col=dummyArr[i];
      beautyHash[col]="j";
      printf("Spalte: %3.3s => Zahl-Formatierung\n",col) >> "/dev/stderr" ;
    }
    #-------------------------------------------------------------------------------------------------
    # Teilsummenspalten ermitteln und Partialsummen-Hash initialisieren
    #-------------------------------------------------------------------------------------------------
    numPartialSums=split(partialSums,dummyArr,":");
    for(i=1;i<=numPartialSums;i++){
      col=dummyArr[i];
      partialSumHash[col]=0;
      printf("Spalte: %3.3s => Teilsumme\n",col) >> "/dev/stderr" ;
    }
  }
  #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  {
    #------------------------------------------------------------------------------------------
    # Als erstes Zahl-Spalten formatieren, da Formatierung die Feldlaenge beeinflusst
    #------------------------------------------------------------------------------------------
    for(col in beautyHash){
      if((col+0) > NF){    # force conversion to number
        die("Feldzahl "NF" unterschreitet Formatierungsspalte "col);
      }
      $col=beautifyNumber($col);         # Cave: OFS-Angabe oben zwingend, da durch Zuweisung Neuordnung von $0 mit OFS ... cf. oben
    }
    #------------------------------------------------------------------------------------------
    lineArr[lineNum++]=$0;
    #------------------------------------------------------------------------------------------
    # Maximale Feldzahl ermitteln
    #------------------------------------------------------------------------------------------
    if(NF > maxFields){
      maxFields=NF;
    }
    #------------------------------------------------------------------------------------------
    # Spaltenbreiten aktualisieren, fuer Spalten mit Teilsummen Defaultbreite setzen und 
    # andernfalls Breite auf etwaigen Vorgabewert begrenzen
    #------------------------------------------------------------------------------------------
    for(i=1;i<=NF;i++){
      if(i in partialSumHash){
        fieldLen[i]=sumLen;
      }
      else{
        len=length($i);
        if(len>fieldLen[i]){
          fieldLen[i]=(len > width) ? width : len;
        }
      }
    }
  }
  #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  END{
    #-------------------------------------------------------------------------------------------
    # Debug
    #-------------------------------------------------------------------------------------------
#    for(i=1;i<=maxFields;i++){
#      printf("Feldlaenge %d: %d\n",i,fieldLen[i]);
#    }
    #-------------------------------------------------------------------------------------------
    # Anfangswerte setzen, u.a. fuer Inhalt derjenigen Spalte, deren Inhaltsaenderung eine
    # Trennzeile bewirken soll, und ggf. laufende Summen
    #-------------------------------------------------------------------------------------------
    oldValue="";
    fnr=0;
    valueHasChanged=0;
    for(col in partialSumHash){
      partialSumHash[col]=0;
    }
    for(col in rTotalHash){
      rTotalHash[col]=0;
    }
    #-------------------------------------------------------------------------------------------
    # Um auch nach der letzten (Nutz-)Zeile eine etwaige Partialsumme auszugeben, wird dem 
    # Zeilen-Array als Kunstgriff eine weitere Leerzeile hinzugefuegt. 
    #-------------------------------------------------------------------------------------------
    if(numPartialSums > 0){
      for(i=1;i<maxFields;i++){                             # Ein Trennzeichen weniger als Feldzahl
        dummyLine=(dummyLine) ? dummyLine ";" : ";" ;
      }
      lineArr[length(lineArr)+1]=dummyLine;     
    }
    #-------------------------------------------------------------------------------------------
    # Trennzeilenlaenge errechnen
    #-------------------------------------------------------------------------------------------
    sepLen=1;
    for(i=1;i<=maxFields;i++){
      sepLen+=1;                 # fuer jedes Spaltentrennzeichen inkrementieren
      sepLen+=fieldLen[i];
    }
    if(lineNumbers){
      sepLen+=4                  # 4-stellige Zeilennummern und Spaltentrenner
    }
    sepLen+=numRTotals;          # fuer jede Spalte einer laufenden Summe einen Spaltentrenner hinzufuegen
    sepLen+=numRTotals*sumLen # Laengen aller Spalten mit laufenden Summen hinzufuegen
    #-------------------------------------------------------------------------------------------
    # Headerzeile ausgeben
    #-------------------------------------------------------------------------------------------
    if(headline == "y"){
      if(lineNumbers){
        printf("    ");
      }
      for(i=1;i<=(maxFields);i++){
        width=fieldLen[i];
        #------------------------------------------------------------------------------------------
        # Erhaelt Spalte eine laufende Summe ?
        #------------------------------------------------------------------------------------------
        if(i in rTotalHash){
          printf("|%*.*s|%*.*s",width,width,i,sumLen,sumLen,"lfdSum");
        }
        else{
          printf("|%*.*s",width,width,i);
        } 
      }
      printf("|\n");
    }
    #-------------------------------------------------------------------------------------------
    # Zeilen ausgeben
    #-------------------------------------------------------------------------------------------
    for(j in lineArr){    # Laufvariable j, da Laufvariable i unten oefter verwendet wird
      line=lineArr[j];
      fnr++;
      split(line,colArr,";");
      numFields=length(colArr);
      #--------------------------------------------------------------------------------------------
      # Trennzeile einfuegen und etwaige Partialsummen ausgeben ?
      #--------------------------------------------------------------------------------------------
      for(i=1;i<=numFields;i++){
        if(i == sepCol){
          value=colArr[i];
          if(value != oldValue){
            oldValue=value;
            valueHasChanged=1;
          }
          break;   # Es gibt nur eine Spalte, anhand derer eine Trennzeile festgelegt wird
        }
      }
      if(valueHasChanged){
        #------------------------------------------------------------------------------------------
        # Trennzeile einfuegen
        #------------------------------------------------------------------------------------------
        printf("%*.*s\n",sepLen,sepLen,dashLine);
        #------------------------------------------------------------------------------------------
        # Etwaige Partialsummen ausgeben
        # Cave: Bedingung "j>2", um fruehestens vor der dritten Nutzzeile eine Zwischensumme der dann zweiten Zeile auszugeben und eine Titelzeile zu ueberspringen     
        #------------------------------------------------------------------------------------------
        if((numPartialSums > 0) && ((j+0) > 2)){ 
          #----------------------------------------------------------------------------------------
          # Vorne Platz fuer Zeilennummern lassen ?
          #----------------------------------------------------------------------------------------
          if(lineNumbers){
            printf("%4s","SUM");
          }
          for(i=1;i<=numFields;i++){
            if(i in partialSumHash){
              value=sci2Decimal(partialSumHash[i]);
              #---------------------------------------------------------------------------------------
              # beautify ?
              #---------------------------------------------------------------------------------------
              value=(i in beautyHash) ? beautifyNumber(value) : value;
            }
            else{
              value="";
            }
            width=fieldLen[i];
            printf(" %*.*s",width,width,value);     # Leerzeichen anstelle "|"
          }
          printf(" \n");                            # Leerzeichen anstelle "|"
          #------------------------------------------------------------------------------------------
          # weitere Trennzeile ausgeben
          #------------------------------------------------------------------------------------------
          printf("%*.*s\n",sepLen,sepLen,dashLine);
        }
        #------------------------------------------------------------------------------------------
        # Reinitialisierung nach Trennzeile und ggf. Partialsummen
        #------------------------------------------------------------------------------------------
        valueHasChanged=0;
        for(col in partialSumHash){
          partialSumHash[col]=0;
        }
      }
      #--------------------------------------------------------------------------------------------
      # Handelt es sich bei gewuenschten Partialsummen um die letzte, als Ausgabekunstgriff ebenjener
      # eingefuegte Leerzeile, soll diese nicht ausgeben werden
      #--------------------------------------------------------------------------------------------
      if((numPartialSums > 0) && (j == length(lineArr))){
        break;
      }
      #--------------------------------------------------------------------------------------------
      # ggf. Partialsummen errechnen
      #--------------------------------------------------------------------------------------------
      for(col in partialSumHash){
        number=colArr[col];
        if(isNumber(number)){
          partialSumHash[col]+=convertNumber(number);
        }
        else{
          printf("Teilsummen: Info: Keine Zahl: %s\n",number) >> "/dev/stderr" ;
        }
      }
      #--------------------------------------------------------------------------------------------
      # ggf. laufende Summen errechnen
      #--------------------------------------------------------------------------------------------
      for(col in rTotalHash){
        number=colArr[col];
        if(isNumber(number)){
          rTotalHash[col]+=convertNumber(number);
        }
        else{
          printf("laufende Summen: Info: Keine Zahl: %s\n",number) >> "/dev/stderr" ;
        }
      }
      #--------------------------------------------------------------------------------------------
      # Zeilennummern voranstellen ?
      #--------------------------------------------------------------------------------------------
      if(lineNumbers){
        printf("%4d",fnr);
      }
      #--------------------------------------------------------------------------------------------
      # Spalten ausgeben, ggf. mit Spalten laufender Summen
      #--------------------------------------------------------------------------------------------
      for(i=1;i<=numFields;i++){
        width=fieldLen[i];
        #------------------------------------------------------------------------------------------
        # Erhaelt Spalte eine laufende Summe ?
        #------------------------------------------------------------------------------------------
        if(i in rTotalHash){
          printf("|%*.*s|%*.*s",width,width,colArr[i],sumLen,sumLen,beautifyNumber(sci2Decimal(rTotalHash[i])));
        }
        else{
          printf("|%*.*s",width,width,colArr[i]);
        }
      }
      printf("|\n");
    }                                                  # Iteration ueber alle auszugebenden Zeilen
  }
' "$infile" > "$outfile"
checkReturn "awk-Fehler"

commonOut "=> $outfile"
#}}}}

mycsvedit

#!/bin/bash
#{{{{
#!/bin/bash
#-------------------------------------------------------------------------------------------
#<Beschreibung>
#  Editiert eine CSV-Datei in formatierter Spaltendarstellung
#</Beschreibung>
#-------------------------------------------------------------------------------------------

. /usr/local/bin/common

function usage(){ 
  cat <<EOF

     $0 <file>

     Editiert eine csv-Datei mit Spaltenformatierung und speichert das Ergebnis wieder in die 
     unformatierte Originaldatei.
     Zuvor wird von der Original-Datei ein Backup angelegt.

     Cave: Die Datei muss bereits im richtigen Zeichensatz (und UNIX-Format) vorliegen.

EOF
} 

infile=""
backup=""
formattedFile=pretty
timeStamp=$(getTimeStamp)


while getopts "hH" opt; do
  case $opt in
    h) usage; exit ;;
    H) defaultUsage; exit ;;
    *) die "Keine gueltige Option" ;;
  esac
done
shift $(( OPTIND -1 ))
infile="$1"


[ -z "$infile" ] && die "Keine Datei angegeben"
[[ ! "$infile" =~ \.csv$ ]] && die "Keine csv-Datei $infile"
for file in $infile; do
  verifyFile $file
done

#-------------------------------------------------------------------------------------------
backup=${infile}_${timeStamp}.bak         # Backup
cp "$infile" "$backup"
checkReturn "cp-Fehler"
mycsvview "$infile"                       # Formatieren
checkReturn "mycsvview-Fehler"
vim "$formattedFile"                      # Editieren
sed '                                     # "Entformatieren"
  s/[ ]\+|[ ]\+/|/g                       # "  |   "      => |
  s/[ ]\+|/|/g                            # "     |"      => |
  s/|[ ]\+/|/g                            # "|     "      => |
  s/^|//                                  # | an Zeilenanfang ...
  s/|$//                                  # und -ende loeschen
  s/|/;/g                                 # "|"           => ;
' $formattedFile > "$infile"              # und implizit Originaldatei mit Editions-Ergebnis ueberschreiben
checkReturn "sed-Fehler"
commonOut "=> $infile"
#-------------------------------------------------------------------------------------------
diff "$infile" "$backup"                  # Ergebnisvergleich
#-------------------------------------------------------------------------------------------
commonOut "=> $infile"
#}}}}

Impressum und Datenschutzerklärung