Shell (awk, sed, "bármi") kérdés: listából sql-t

Az adott problémát valóban meg lehet oldani egyetlen awk paranccsal. Az awk parancs segítségével egyszerre beolvashatjuk a fájlt és előállíthatjuk a kívánt SQL parancsokat. Az alábbi megoldás az awk parancsban végzi el az összes szükséges műveletet:

bash

awk ' { if ($2 == "dbs01" || ($2 == "vcenter01" && $3 == "web99")) { if ($1 > backup[$2 " " $3]) { backup[$2 " " $3] = $1 } } } END { for (h in backup) { split(h, arr, " ") hostname = (arr[2] == "dbs01") ? arr[2] : arr[3] print "UPDATE servers set backup='\''" backup[h] "'\'' WHERE hostname='\''" hostname "'\'';" } }' input.txt > updates.sql

Az input.txt tartalmazza az eredeti adatokat. Az awk parancs végrehajtása után az updates.sql fájl tartalmazni fogja az összes szükséges SQL frissítést.

Működés részletesen:

1. Beolvasás: Az awk soronként olvassa be a fájlt.
2. Feltétel ellenőrzése: Ellenőrzi, hogy az aktuális sor dbs01 vagy web99 tartalmaz-e.
3. Legnagyobb időbélyeg tárolása: Ha az aktuális sor időbélyege nagyobb, mint az előzőleg tárolt időbélyeg az adott hosztnévhez, akkor frissíti az időbélyeget.
4. SQL parancsok generálása: Az END blokkban létrehozza az SQL frissítési parancsokat.

Használat:

1. Másold be a fenti awk parancsot egy shell scriptbe vagy futtasd közvetlenül a terminálban.
2. Az input.txt fájl tartalmazza a bemeneti adatokat az eredeti formában.
3. A kimeneti fájl (updates.sql) tartalmazni fogja az SQL frissítési parancsokat.

Ez a megoldás egyszerűbb és hatékonyabb, mivel az awk segítségével egy lépésben megoldja a feladatot, és nem szükséges több iterációt futtatni a lista feldolgozásához.

Inkább awk milliószor ilyenre mint python. Nekem a python nyakatekert hovatovább értelmetlen funkcionalitással bír. :-) Ha már ilyen veleményekkel dobálózós nap van. Ezért is írtam meg tisztán awk-ban. 

Ez igy eleg gyasz. Ha ennyit tud az LLM, akkor meg a hobbista szintemet sem veszelyezteti :)

Ennyi kell (nem shelyes szintaktikailag):

BEGIN {

%%beallitod legalabb a field separatort, ha mast nem is%%

}

{

hostname = %%valamelyik oszlop, ezt talald ki%%

timestamp = %%masik oszlop%%

if (hostname in myarray) {

  if (timestamp > myarray[hostname]) myarray[hostname] = timestamp

} else {

  myarray[hostname] = timestamp

}

}

END {

%%kiirod, ahogy akarod%%
%%for (hostname in myarray) print hostname, myarray[hostname]

}

Lehet, hogy lehet optimalizalni, de nem tudom fejbol a nem letezo tombelem viselkedeset.

Az AWK tombje asszociativ. Folosleges extra koroket futni miatta. Persze, ha tobb hostneved van, mint egen a csillag, akkor kifuthatsz a memoriabol. De akkora halozathoz fizessenek meg hozzaertobb szakembert, mint en :)

 SELECT hostname, MAX(timestamp) AS max_timestamp
    FROM mytable
    GROUP BY hostname

Kiválasztja a legutolsó mentés sorát a hostname groupban, 
a HOSTNAME egyedi ,de lehet bontani,  ha jól értem a dolgot .

nyers lista 18k sor, és a végén csak 746 
 

kapsz egy 746 soros listát.

sort, uniq, grep, last segitsegevel is megoldhato, de en az AWK-ot valasztanam.

Ha az SQL parancsban a

set backup='xyz' WHERE hostname='ABC'

részbe tényleg kellenek az aposztrófok (márpedig valszeg igen), akkor azt parancssorban beírni nagyon kacifántos lesz. Igazság szerint baromi sokat nyersz az olvashatósággal, ha egy awk-parancsfájlba írod (mert ott legalább a shell elől nem kell takarni a dolgokat), és awk -f fnév.txt  formában indítod.

$ cat fnév.txt

$1 > m[ $NF ] { m[ $NF ] = $1 }

END { for ( i in m ) { print "UPDATE servers set backup='" m[ i ] "' WHERE hostname='" i "' ; " }

Ha jobban megnézed m[ i ] előtt van egy aposztróf-idézőjel, a WHERE előtt egy idézőjel-aposztróf, a hostname után pedig megint egy aposztróf-idézőjel, és i után megint egy idézőjel-aposztróf sorozat. (És ezt most képzeld el shellben begépelni :-) )

Értem, hogy vicc, de rossz. :-D

1) print $1"="$2"\n"

mivel a print a - szóközökkel(és nem vesszővel) elválasztott - paramétereit "összeragasztva" írja ki, ezért írható így, de ez már olvasható is:

print $1 "=" $2 "\n"

2) mivel a print - ha csak le nem tiltod, vagy át nem állítod - automatikusan küld egy ORS-t (alapérték "\n"), ezért minden kiírás után 2 soremelés lesz (azaz szöveg, üres sor, szöveg, üres sor, ... ). Ez nem nagyon látszik, hogy miért kell. Ha ehhez még azt is hozzáteszem, hogy ez az egész bekerül egy shell for ciklusának "lista" részébe, ahol viszont definíció szerint az elválasztó karakterek (szóköz, tabulátor, soremelés!!!!) darabszáma rohadtul nem számít (mert lenyeli őket a shell), én ezt betudom annak, hogy azt hitted, kell a print végén kérni soremelést. De nem, szóval szerintem felesleges.

3) egy cat | tr erősen szószátyár, helyette erőforrás-spórolósabb a "tr < indata.txt" forma. (Más parancsok viszont fájlnév paramétert is elfogadnak, tehát az átirányítás is valószínűleg megspórolható.)

4) Ha jól sejtem, MS-környezetből jön a szöveges fájl, ezért dobod ki a UNIX/Linux alatt felesleges kocsivissza jeleket. Szintén spórolásból érdemes elgondolkodni, hogy ha már úgy is meghívsz egy sed-et, akkor nem olcsóbb-e azzal megcsináltatni ezt is (a tr helyett), ehhez csak annyi kell, hogy a sed kapjon még egy -e 's/\r//g' opciót, és csak ez után jöjjön a -e 's/vcenter' rész.

5) a sort | grep olcsóbb, ha felcseréled őket - ekkor nem kell még a később eldobandó üres sorokat is rendezgetni - viszont ha sed | grep | sort van, akkor megint olcsóbb a grep -v helyett szintén egy plusz sed opcióval megcsináltatni ugyanezt a vcenteres opció után azaz

sed .... -s 's/vcenter...' -e '/^$/d' |

6) mindazonáltal, a grep-nek odaadott regexp közönséges (basic) regexp, felesleges a -E (extended) opció (mármint az lenne, ha maradna)

7) legvégül pedig minek rendezed a sed kimenetét, ha amúgy az x=y formájú elemekől asszociatív tömb x indexe és az ahhoz tartozó y érték lesz, és magával a tömbbel se csinálsz semmi olyasmit, ahol fontos lenne ez a bizonyos sorrend. Tudtommal dokumentáció szerint az asszociatív tömb indexeit *valamilyen* sorrendben kapod vissza, egyáltalán nincs definiálva, hogy abba a sorrendben, ahogy bevitted, de még ha úgy is kapnád, a felhasználásánál kb tök mindegy a sorrend. E miatt én a sort-ot ki is hagynám az egészből.

Szóval én kicsit kevesebb erőforrást használva így írnám:

for kv in $(awk '{ print $1 "=" $2 }' <(sed -e 's/\r//g' -e 's/vcenter..//g' -e '/^$/d' indata.txt ) ); do

Ha a bash használók hozzászoknának, hogy a declare helyett a bash-ban natívan meglevő, a bash előtt egy évszázaddal a ksh-ban bevezetett typeset parancsot használnák, már eggyel hordozhatóbb lenne a kódjuk :-)

Az első if-ben nem kell az x után a "" :-)

De hogy mi a francnak rendezed te is ....

De ruby-ban lényegesen kényelmesebb:

#!/usr/bin/env ruby
h=Hash.new
File.open(ARGV[0]).each do |line|
  time,host=line.chop.split(/ .* /)
  h[host]=time unless h.has_key?(host) and h[host]>time
end
h.each do |host,time|
  puts "UPDATE servers set backup='#{time}' WHERE hostname='#{host}';"
end

És awk-kal is lehet szebben. Lehet pipe végére tenni, vagy paraméterként is megeszi a fájlnevet.
És ebben a formában még az aposztrofokkal sem kell bajlódni:
 

#!/usr/bin/env -S awk -f
{
  if ( (! $1 in a) || ($1>a[$NF]) ) {
    a[$NF]=$1
  }
}
END{
  for (k in a) {
    print "UPDATE servers set backup='"a[k]"' WHERE hostname='"k"';"
  }
}

Basszus... sok lett a kávé:)
Leráztam a rozsdát a perl emlékeimről.

#!/usr/bin/env perl
while(<>){ $a{$2}=$1 if (/([^ ]+).* (.+)/ && $1>$a{$2}) }
for(keys %a) {print "UPDATE servers set backup='$_' WHERE hostname='$a{$_}';\n"}