##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 ## fonctions pour awk ##@cooked nocomments ##@require base uprovide awk urequire base __AWKDEF_HELP="\ Les variables données en arguments sont définies dans une section BEGIN{}. Si une valeur ne ressemble pas à une définition de variable, l'analyse des variables s'arrête et le reste des arguments est inséré tel quel. Normalement, les variables définies sont scalaires, avec une syntaxe de la forme name:str=value pour une chaine, name:int=value pour une valeur entière, ou name=value pour déterminer automatiquement le type: entier si la valeur ne contient que des chiffres, chaine sinon. Il est aussi possible d'utiliser la syntaxe awk_array[@]=bash_array pour initialiser le tableau awk_array, qui contiendra toute les valeurs du tableau nommé bash_array, avec les indices de 1 à N, N étant le nombre d'éléments du tableau bash_array. La variable awk_array_count est aussi initialisée, et contient le nombre d'éléments du tableau. La syntaxe simplifiée array[@] est équivalente à array[@]=array Il existe une autre syntaxe 'awk_array[@]=<' qui permet de spécifier les valeurs du tableau, une par ligne, e.g: $'values[@]=<\nvalue1\nvalue2' pour un tableau values qui contiendra deux valeurs: value1 et value2 Les fonctions suivantes sont définies: num(s) si s ne contient que des chiffres, retourner la valeur numérique associée, sinon retournée la valeur inchangée ord(s) retourner le code ASCII du premier caractère de la chaine s. seuls les codes de 32 à 127 sont supportés hex(i) retourner la représentation hexadécimale du nombre i qhtml(s) remplacer respectivement dans la chaine s les valeurs &, \", > et < par &, ", > et < L'alias quote_html(s) existe pour compatibilité unquote_html(s) faire le contraire de qhtml(s) qval(s) quoter une valeur pour le shell. la valeur est entourée de quotes, e.g: qval(\"here, \\\"there\\\" and 'everywhere'.\") --> 'here, \"there\" and '\\''everywhere'\\''.' L'alias quote_value(s) existe pour compatibilité sqval(s) comme qval() mais ajouter un espace avant la valeur quotée. ceci permet de construire facilement une ligne de commande, e.g.: print \"mycmd\" sqval(arg1) sqval(arg2) L'alias qsval(s) existe pour compatibilité qvals() quoter les valeurs \$1..\$NF pour les passer comme argument sur la ligne de commande avec eval. e.g.: print \"mycmd \" qvals() La ligne qui est affichée pourra être évaluée avec eval dans le shell. L'alias quoted_values(s) existe pour compatibilité sqvals(s) comme qvals() mais ajouter un espace avant la valeur quotée. ceci permet de construire facilement une ligne de commande, e.g.: print \"mycmd\" sqvals() L'alias qsvals(s) existe pour compatibilité qarr(vs[, prefix]) quoter les valeurs du tableau vs pour le shell, e.g: print \"values=(\" qarr(values) \")\" si prefix est spécifié, il est affiché suivi d'un espace, suivi des valeurs du tableau, ce qui permet de construire une ligne de commande, e.g.: print qarr(values, \"mycmd\") qsubrepl(s) quoter une valeur pour l'argument r des fonctions sub() et gsub(). Les caractères suivants sont mis en échappement: \\ & L'alias quote_subrepl(s) existe pour compatibilité qgrep(s) quoter une valeur pour un pattern *simple* de grep. Les caractères suivants sont mis en échappement: \\ . [ ^ \$ * L'alias quote_grep(s) existe pour compatibilité qegrep(s) quoter une valeur pour un pattern *étendu* de grep. Les caractères suivants sont mis en échappement: \\ . [ ^ \$ ? + * ( ) | { L'alias quote_egrep(s) existe pour compatibilité qsql(s, [suffix]) quoter une valeur pour un script sql. la valeur est entourée de quotes, e.g: qsql(\"hello'there\") --> 'hello''there' L'alias quote_sql(s) existe pour compatibilité Si suffix est spécifié, le rajouter après la valeur précédé d'un espace, e.g: qsql(\"value\", \"field\") --> 'value' field cqsql(s, [suffix]) comme qsql() mais ajouter une virgule avant la valeur quotée. ceci permet de construire facilement une requête SQL, e.g: print \"insert into t(a, b, c) values (\" qsql(a) cqsql(b) cqsql(c) \");\" --> insert into t(a, b, c) values ('a','b','c'); Si suffix est spécifié, le rajouter après la valeur précédé d'un espace, e.g: cqsql(\"value\", \"field\") --> ,'value' field unquote_mysqlcsv(s) Analyser une valeur exportée de MySQL avec mysqlcsv. Les transformations suivantes sont effectuées: \\n --> <newline> \\t --> <tab> \\0 --> <caractère NUL> \\\\ --> \\ sval(s) retourner la valeur s précédée d'un espace si elle est non vide, e.g: sval(\"\") --> \"\" sval(\"any\") --> \" any\" cval(s, [suffix]) retourner la valeur s précédée d'une virgule si elle est non vide, e.g: sval(\"\") --> \"\" sval(\"any\") --> \",any\" Si suffix est spécifié, le rajouter après la valeur précédé d'un espace, e.g: cval(\"\", \"field\") --> \"\" cval(\"value\", \"field\") --> \",value field\" mkindices(values, indices) créer le tableau indices qui contient les indices du tableau values, de 1 à N, et retourner la valeur N. Il faudra utiliser les valeurs de cette manière: count = mkindices(values, indices) for (i = 1; i <= count; i++) { value = values[indices[i]] ... } cette fonction nécessite gnuawk array_new(dest) créer un nouveau tableau vide dest array_newsize(dest, size) créer un nouveau tableau de taille size, rempli de chaines vides array_len(src) calculer la taille d'un tableau. length(array) a un bug sur GNUawk 3.1.5. cette fonction est plus lente, mais fonctionne sur toutes les versions de awk et GNUawk array_copy(dest, src) faire une copie d'un tableau. Cette fonction nécessite gnuawk, puisqu'elle utilise mkindices(). array_getlastindex(src) Retourner l'index du dernier élément du tableau src array_add(dest, value) Ajouter un élément dans dest, avec l'index array_getlastindex(dest)+1 array_deli(dest, i) Supprimer l'élément d'index i dans le tableau dest. Les index des éléments après i sont corrigés en conséquence. Cette fonction assume que les indices du tableau commencent à 1 et n'ont pas de \"trous\". Si i==0, cette fonction est un NOP. array_del(dest, value[, ignoreCase]) Supprimer *tous* les éléments du tableau dest dont la valeur est value. Les indexes des valeurs sont trouvées avec key_index(), puis les valeurs sont supprimées avec array_deli() ignoreCase permet de spécifier que la recherche de la valeur se fait en ignorant la casse. array_extend(dest, src) Ajouter les éléments de src dans dest, en commençant avec l'index array_getlastindex(dest)+1 array_fill(dest) remplir le tableau avec \$1..\$NF array_getline(src) avec le tableau array contenant N éléments, initialise \$1..\$N avec les valeurs du tableau array_appendline(src) avec le tableau array contenant N éléments, initialise \$(NF+1)..\$(NF+N) avec les valeurs du tableau in_array(value, values[, ignoreCase]) tester si le tableau values contient la valeur value, en ne tenant éventuellement pas compte de la casse. key_index(value, values[, ignoreCase]) trouver l'index de value dans le tableau values, en ne tenant éventuellement pas compte de la casse. Retourner 0 si la valeur n'a pas été trouvée array2s(values, prefix, sep, suffix, noindices) convertir un tableau en chaine pour affichage. attention! les valeurs sont affichés dans un ordre arbitraire. noindices, s'il vaut 1, supprime l'affichage des indices du tableau. prefix (qui vaut par défaut \"[\") est ajouté avant la chaine, suffix (qui vaut par défaut \"]\") après, et sep (qui vaut par défaut \",\") est utilisé pour séparer chaque valeur. array2so(values, prefix, sep, suffix, noindices) convertir un tableau en chaine pour affichage. Les valeurs sont affichés dans l'ordre du tableau. Cette fonction nécessite gnuawk, puisqu'elle utilise mkindices(). noindices, s'il vaut 1, supprime l'affichage des indices du tableau. prefix est ajouté avant la chaine, suffix après, et sep (qui vaut par défaut \",\") est utilisé pour séparer chaque valeur. array_join(values, sep, prefix, suffix) convertir un tableau en chaine pour affichage. Les valeurs sont affichés dans l'ordre du tableau. Cette fonction nécessite gnuawk, puisqu'elle utilise mkindices(). Il n'y a pas de valeur par défaut pour sep, prefix et suffix. printto(s, output) en fonction de la valeur de output, afficher la chaine s sur la destination spécifiée. output est de la forme... faire.... \"\" print s \"dest\" print s >\"dest\" \">dest\" print s >\"dest\" \">>dest\" print s >>\"dest\" XXX les formes suivantes sont désactivées pour le moment: \"|dest\" print s |\"dest\" \"|&dest\" print s |&\"dest\" find_line(input, field, value) retourner la première ligne du fichier input dont le champ \$field vaut value. Retourner une chaine vide si la ligne n'a pas été trouvée. merge_line(input, field, key) équivaut à: \$0 = \$0 FS find_line(input, field, \$key) La ligne courante n'est pas modifiée si la ligne correspondante dans input n'est pas trouvée. array_parsecsv2(fields, line, nbfields, colsep, qchar, echar) array_parsecsv(fields, line, nbfields[, colsep, qchar, echar]) analyser une ligne au format csv, et initialiser le tableau fields aux valeurs des champs trouvés. Si nbfields est spécifié, c'est le nombre de champs minimum que doit avoir le tableau résultat. Le tableau est complété avec des chaines vides au besoin. Le tableau commence à l'index 1. Consulter array_formatcsv2 pour la signification de colsep, qchar et echar. array_parsecsv(fields, line, nbfields) est équivalent à array_parsecsv2(fields, line, nbfields, ",", "\"", "") parsecsv(line) équivaut à: array_parsecsv(fields, line) array_getline(fields) getlinecsv(file) obtient une ligne par getline, l'analyse, puis initialise \$1..\$N avec les valeurs trouvées. equivaut à: getline parsecsv(\$0) Si file est spécifié, utiliser 'getline <file' au lieu de 'getline' array_formatcsv2(fields, colsep, mvsep, qchar, echar) construit une ligne au format csv avec les colonnes du tableau fields. - colsep est le séparateur des colonnes, e.g \",\" - mvsep est le séparateur des valeurs des colonnes (si une colonne contient plusieurs valeurs, par exemple si elle transporte la valeur d'un attribut multivalué). Cette information ne sert que pour décider s'il faut encadrer la colonne avec qchar. - qchar est le caractère à employer pour encadrer la valeur d'une colonne si elle contient l'un des caractères colsep ou mvsep - echar est le caractère à employer pour mettre en echappement le caractère qchar dans la valeur d'une colonne. Si echar est vide, le caractère qchar est doublé. array_formatcsv(fields, output) équivaut à array_formatcsv2(fields, \",\", \";\", \"\\\"\", \"\") array_printcsv(fields, output) équivaut à printto(array_formatcsv(fields), output) get_formatcsv() équivaut à array_fill(fields) return array_formatcsv(fields) formatcsv() équivaut à \$0 = get_formatcsv() printcsv(output) équivaut à array_fill(fields) array_printcsv(fields, output) array_findcsv(fields, input, field, value, nbfields) initialiser le tableau fields avec la première ligne au format csv du fichier input dont le champ \$field vaut value. Le tableau est toujours initialisé, même si la ligne correspondante n'a pas été trouvée. Retourner 1 si la ligne correspondante a été trouvée Si nbfields est spécifié, c'est le nombre de champs minimum que doit avoir le tableau résultat. Le tableau est complété avec des chaines vides au besoin. Le tableau commence à l'index 1." ################################################################################ __AWKCSV_HELP="\ Lancer un script awk pour traiter un flux csv Typiquement, l'option -e sera utilisée pour faire un traitement sur les données, e.g: awkcsv -e '{ \$2 = toupper(\$2) }' pour mettre en majuscule le deuxième champ. Analyse du flux en entrée: -s, -S, --skip-lines nblines Sauter nblines au début du flux -h, -H, --parse-headers Lire la liste des champs à partir de la première ligne non ignorée du flux. Si la liste des champs est vide, cette option est implicitement activée. Par contre, si une liste de champs est spécifiée et que le flux en entrée contient une ligne d'en-têtes, il *faut* spécifier explicitement cette option. --sepconf 'CQE' Spécifier en une seule option les caractères de séparation des colonnes (C), le caractère pour encadrer les chaines (Q) et le caractère d'échappement (E). Pour chacun des caractères, s'il n'est pas spécifié, la valeur par défaut est prise. CQE vaut par défaut ',\"' --colsep C --qchar Q --echar E Spécifier les caractères pour l'analyse du flux csv. Seul le premier caractère de respectivement C, Q et E est considéré. - C est le séparateur des colonnes, e.g \",\" - Q est le caractère employé pour encadrer la valeur d'une colonne si elle contient le caractère C - E est le caractère employé pour mettre en echappement le caractère Q dans la valeur d'une colonne. Si E est vide, le caractère Q doit être doublé. Flux en sortie: -n, --no-headers Ne pas afficher les en-têtes. Par défaut, les en-têtes sont affichés. -z, --reset-fields Commencer le script -e avec les champs vides. Il faut les copier individuellement avec copyfield(). Scripts: -v var=value Définir une variable pour le script awk -b before Instructions à exécuter avant le début de l'analyse. Utiliser la variante --rb pour remplacer les instructions par défaut, qui sont exécutées avant les instructions de -b Par défaut, il n'y a pas d'instructions -b et les instructions de --rb sont d'analyser les en-têtes si -h est spécifié. Le tableau ORIGHEADERS contient les en-têtes analysées en entrée. Le tableau HEADERS contient les en-têtes spécifiées par l'utilisateur (copie de ORIGHEADERS si l'utilisateur de spécifie pas d'en-têtes). Il est recommandé de ne pas modifier --rb -e script Instructions à exécuter pour chaque ligne en entrée. Utiliser la variante --re pour remplacer les instructions par défaut qui sont exécutées avant les instructions de -e Par défaut, il n'y a pas d'instructions -e et les instructions de --re sont d'analyser la ligne courante. Les champs sont disponibles dans \$1..\$NF et dans le tableau ORIGFIELDS. Il est recommandé de ne pas modifier --re -m, --map FIELDMAP Renommer les champs selon la liste FIELDMAP, qui contient des éléments de la forme dest:src et séparés par des virgules. Le champ src doit exister dans HEADERS, et dest ne doit pas exister dans HEADERS, sinon l'élément est ignoré. Un script équivalent au suivant est ajouté aux instructions par défaut --re: '{ if (do_once(\"mapfields\")) mapfields(FIELDMAP) }' Cette option annule l'option -z -c, --checkfields FIELDS S'assurer que toutes les en-têtes spécifiées dans la liste FIELDS sont présentes. Sinon, sortir du script avec le code de retour 1. Un script équivalent au suivant est rajouté aux instructions par défaut --re: '{ if (do_once(\"checkfields\") && !checkfields(FIELDS)) exit 1 }' Ce traitement est effectué le cas échéant après le traitement --map Cette option annule l'option -z --checkvalues FIELDS S'assurer que toutes les valeurs des en-têtes spécifiées dans la liste FIELDS sont non vides. Sinon, sortir du script avec le code de retour 1. Un script équivalent au suivant est rajouté aux instructions par défaut --re: '{ if (!checkvalues(FIELDS)) exit 1 }' Ce traitement est effectué le cas échéant après le traitement --checkfields Cette option annule l'option -z -k, --keep-fields KEEPFIELDS Garder les champs spécifiés. Les autres sont supprimés de la sortie. KEEPFIELDS est une liste de champs séparés par des virgules, ou '*' pour spécifier de garder tous les champs, ou '' pour ne garder aucun champ. Si un champ de KEEPFIELDS n'existe pas, il est créé. Cette option annule l'option -z --skip-fields SKIPFIELDS Exclure les champs spécifiés. SKIPFIELDS est une liste de champs séparés par des virgules. Pour les options --keep et --skip, un script équivalent au suivant est rajouté aux instructions par défaut --re: if (do_once(\"filterfields\")) { build_skipfs(KEEPFIELDS, SKIPFIELDS, SKIPFS, ADDFS) filterheaders(SKIPFS, ADDFS) } filterfields(SKIPFS, ADDFS) Ce traitement est effectué le cas échéant après le traitement --checkvalues -a after Instructions à exécuter après avoir traité la ligne en entrée. Utiliser la variante --ra pour remplacer les instructions par défaut qui sont exécutées avant les instructions de -a Par défaut, il n'y a pas d'instructions --ra et les instructions de -a sont d'afficher les en-têtes si -n n'est pas spécifié. Puis afficher les champs \$1..\$NF En fonctions des arguments, les variables skip_lines, parse_headers et show_headers sont définis. user_headers est un tableau contenant les champs spécifiés par l'utilisateur. Les fonctions suivantes sont disponibles: do_once(key) Retourner vrai s'il faut faire l'opération identifiées par key (qui vaut par défaut \"default\"), qui ne devrait être faite qu'une seule fois. Utiliser de cette manière: if (do_once(key)) { ... } ogeth(field) ogeti(num) oget(field) Gestion des valeurs originales. geth(field) sethi(num, value) seth(field, newfield) addh(field) delhi(num) delh(field) geti(num) get(field) seti(num, value) set(field, value) add(field, value) deli(num) del(field) Gestion des valeurs courantes. comparevic(field1, value1, field2, value2, icfields) ocompareic(field1, field2, icfields) compareic(field1, field2, icfields) infields(field, fields) parseheaders() printheaders() resetfields() copyfield(field) copyfields(fields) copyall() mapfields(fieldmap) checkfields(fields[, missings]) checkvalues(fields[, missings]) build_skipfs(keepfields, skipfields, skipfs, addfs) filterheaders(skipfs, addfs) filterfields(skipfs, addfs) Gestion avancée des valeurs. Pour les fonctions comparevic(), ocompareic(), compareic(), infields(), copyfields(), checkfields(), checkvalues(), mapfields(), build_skipfs(), les arguments sont une suite d'éléments séparés par des virgules." __AWKCSV_FUNCTIONS=' BEGIN { # Forcer ici le type tableau pour les variables ci-dessous. Sinon, leur # utilisation dans une section BEGIN{} provoque une erreur fatale, parce # qu"ils ne sont déclarés que dans des fonctions array_new(HEADERS) array_new(ORIGHEADERS) array_new(ORIGFIELDS) array_new(__DONE_ONCE) } function do_once(key) { if (!key) key = "default" if (__DONE_ONCE[key] != "") return 0 __DONE_ONCE[key] = 1 return 1 } function __geth(field, HEADERS, nbfields, i) { nbfields = array_len(HEADERS) if (int(field) == field) { field = int(field) if (field >= 1 && field <= nbfields) return field else return 0 } field = tolower(field) for (i = 1; i <= nbfields; i++) { if (field == tolower(HEADERS[i])) { return i } } return 0 } function __geti(num, HEADERS) { if (num != 0) return HEADERS[num] } function __get(field, HEADERS) { return __geti(__geth(field, HEADERS), HEADERS) } function ogeth(field, nbfields, i) { nbfields = array_len(ORIGHEADERS) if (int(field) == field) { field = int(field) if (field >= 1 && field <= nbfields) return field else return 0 } field = tolower(field) for (i = 1; i <= nbfields; i++) { if (field == tolower(ORIGHEADERS[i])) { return i } } return 0 } function ogeti(num) { if (num != 0) return ORIGFIELDS[num] } function oget(field) { return ogeti(ogeth(field)) } function geth(field, nbfields, i) { nbfields = array_len(HEADERS) if (int(field) == field) { field = int(field) if (field >= 1 && field <= nbfields) return field else return 0 } field = tolower(field) for (i = 1; i <= nbfields; i++) { if (field == tolower(HEADERS[i])) { return i } } return 0 } function sethi(num, value) { if (num != 0) HEADERS[num] = value } function seth(field, value) { sethi(geth(field), value) } function addh(field, num) { num = geth(field) if (num == 0) { num = array_len(HEADERS) + 1 HEADERS[num] = field } return num } function delhi(num, i, l) { if (num == 0) return array_deli(HEADERS, num) } function delh(field) { delhi(geth(field)) } function geti(num) { if (num != 0) return $num } function get(field) { return geti(geth(field)) } function seti(num, value) { if (num != 0) $num = value } function set(field, value) { seti(geth(field), value) } function add(field, value, num, i, max) { num = addh(field) i = NF max = array_len(HEADERS) if (i < max) { i = i + 1 while(i <= max) { $i = "" i = i + 1 } } if ($num == "") { $num = value } else { $num = $num ";" value } } function deli(num, i, j) { if (num == 0) return i = num while (i < NF) { j = i + 1 $i = $j i = i + 1 } NF = NF - 1 } function del(field) { deli(geth(field)) } function __starts_with(prefix, string) { return substr(string, 1, length(prefix)) == prefix } function __comparevic_truth(retval) { return substr(retval, 1, 1) == "1" } function __comparevic_suffix(retval) { return substr(retval, 2) } function comparevic(field1, value1, field2, value2, icfields, spfields, array, i, vs, f, prefix, suffix) { # tester si on est un champ spécial. prefix = "" split(spfields, array, /,/) for (i in array) { split(array[i], vs, /=/) f = tolower(vs[1]) if (f == tolower(field1) || f == tolower(field2)) { prefix = vs[2] break } } suffix = "" if (prefix != "") { # les valeurs ayant le préfixe spécifié sont ignorées split(value1, array, /;/) array_new(vs) for (i in array) { if (!__starts_with(prefix, array[i])) { array_add(vs, array[i]) } else { if (suffix != "") suffix = suffix ";" suffix = suffix array[i] } } value1 = array_join(vs, ";") split(value2, array, /;/) array_new(vs) for (i in array) { if (!__starts_with(prefix, array[i])) { array_add(vs, array[i]) } } value2 = array_join(vs, ";") } split(icfields, array, /,/) if (in_array(field1, array, 1) || in_array(field2, array, 1)) { i = tolower(value1) == tolower(value2)? "1": "0" } else { i = value1 == value2? "1": "0" } return i suffix } function ocompareic(field1, field2, icfields, spfields, v1, v2, array) { return comparevic(field1, oget(field1), field2, oget(field2), icfields, spfields) } function compareic(field1, field2, icfields, spfields, v1, v2, array) { return comparevic(field1, get(field1), field2, get(field2), icfields, spfields) } function infields(field, fields, array) { split(fields, array, /,/) return in_array(field, array, 1) } function parseheaders() { if (do_once("parse-headers")) { array_parsecsv(ORIGHEADERS, $0) if (!user_headers_count) array_copy(HEADERS, ORIGHEADERS) next } } function printheaders() { if (do_once("show-headers")) { array_printcsv(HEADERS) } } function resetheaders() { array_new(HEADERS) } function resetfields( nf) { $0 = "" nf = array_len(HEADERS) $nf = "" } function copyfield(field) { set(field, oget(field)) } function copyfields(fields, array) { split(fields, array, /,/) for (i = 1; i <= array_len(array); i++) { copyfield(array[i]) } } function copyall() { array_getline(ORIGFIELDS) } function checkfields(fields, missings, array, r, field) { array_new(missings) split(fields, array, /,/) r = 1 for (i = 1; i <= array_len(array); i++) { field = array[i] if (geth(field) == 0) { array_add(missings, field) r = 0 } } return r } function checkvalues(fields, missings, array, r, field) { array_new(missings) split(fields, array, /,/) r = 1 for (i = 1; i <= array_len(array); i++) { field = array[i] if (geth(field) == 0 || !get(field)) { array_add(missings, field) r = 0 } } return r } function mapfields(fieldmap, mapitems, parts) { split(fieldmap, mapitems, /,/) for (i = 1; i <= array_len(mapitems); i++) { split(mapitems[i], parts, /:/) if (array_len(parts) != 2) continue desti = geth(parts[1]) srci = geth(parts[2]) if (desti == 0 && srci != 0) { HEADERS[srci] = parts[1] } } } function build_skipfs(keepfields, skipfields, skipfs, addfs, keepfs, keepfs_count, tmpfields, headers_count, i, field, fieldi) { array_new(skipfs) array_new(addfs) if (skipfields == "*") { skipfields = ""; keepfields = "" } if (keepfields == "*" && skipfields == "") return 0 # construire la liste des champs à garder dans keepfs split(keepfields, keepfs, /,/) if (in_array("*", keepfs)) { array_del(keepfs, "*") array_extend(keepfs, HEADERS) } split(skipfields, tmpfields, /,/) for (i in tmpfields) { array_del(keepfs, tmpfields[i], 1) } keepfs_count = array_len(keepfs) # puis construire la liste des champs à supprimer dans skipfs headers_count = array_len(HEADERS) for (i = 1; i <= headers_count; i++) { field = HEADERS[i] if (!in_array(field, keepfs, 1)) { fieldi = geth(field) if (i != 0) array_add(skipfs, fieldi) } } asort(skipfs) # puis construire la liste des champs à ajouter dans addfs for (i = 1; i <= keepfs_count; i++) { field = keepfs[i] if (!in_array(field, HEADERS, 1)) { array_add(addfs, field) } } return array_len(skipfs) } function filterheaders(skipfs, addfs, skipfs_count, addfs_count) { skipfs_count = array_len(skipfs) for (i = skipfs_count; i >= 1; i--) { array_deli(HEADERS, skipfs[i]) } addfs_count = array_len(addfs) for (i = 1; i <= addfs_count; i++) { addh(addfs[i]) } } function filterfields(skipfs, addfs, skipfs_count) { skipfs_count = array_len(skipfs) for (i = skipfs_count; i >= 1; i--) { deli(skipfs[i]) } addfs_count = array_len(addfs) for (i = 1; i <= addfs_count; i++) { add(addfs[i], "") } } ' function lawkcsv() { local beforescript='{ if (user_headers_count && do_once("user-headers")) { if (!parse_headers) array_copy(ORIGHEADERS, user_headers) array_copy(HEADERS, user_headers) } if (parse_headers) parseheaders() }' local append_beforescript= local awkscript='{ array_parsecsv(ORIGFIELDS, $0, array_len(ORIGHEADERS)) if (reset_fields) { resetfields() } else { copyall() } }' local append_awkscript= local afterscript= local append_afterscript='{ if (show_headers) printheaders() printcsv() }' local -a args headers vars local skip=0 parse_headers= local autosep= local sepconf=',"' colsep=',' qchar='"' echar= local show_headers=1 reset_fields= local fieldmap checkfields checkvalues keepf skipf if parse_opts \ -s:,-S:,--skip-lines:,--skiplines: skip= \ -h,-H,--parse-headers parse_headers=1 \ --sepconf: '$autosep=sepconf; set@ sepconf' \ --colsep: '$autosep=indiv; set@ colsep' \ --qchar: '$autosep=indiv; set@ qchar' \ --echar: '$autosep=indiv; set@ echar' \ -n,--no-headers show_headers= \ --show-headers show_headers=1 \ -z,--reset-fields reset_fields=1 \ -v:,--var: vars \ --rb:,--rbe: '$set@ beforescript; append_beforescript=' \ -b:,--b:,--be:,--before-script: append_beforescript= \ --re: '$set@ awkscript; append_awkscript=' \ -e:,--e:,--awk-script:,--script: append_awkscript= \ -m:,--map:,--mapfields fieldmap= \ -c:,--check-fields:,--checkfields: checkfields= \ --check-values:,--checkvalues: checkvalues= \ -k:,--keep:,--keep-fields:,--keepfields: keepf= \ --skip:,--skip-fields:,--skipfields: skipf= \ --ra:,--rae: '$set@ afterscript; append_afterscript=' \ -a:,--a:,--ae:,--after-script: append_afterscript= \ @ args -- "$@"; then set -- "${args[@]}" else eerror "$args" return 1 fi if [ "$autosep" == sepconf ]; then colsep="${sepconf:0:1}" qchar="${sepconf:1:1}" echar="${sepconf:2:1}" autosep= if [ -n "$colsep" -o -n "$qchar" -o -n "$echar" ]; then [ -n "$colsep" ] || colsep=',' [ -n "$qchar" ] || qchar='"' # n'activer la configuration que si elle diffère de la configuration # par défaut [ "$colsep" != ',' -o "$qchar" != '"' -o -n "$echar" ] && autosep=1 fi elif [ "$autosep" == indiv ]; then autosep=1 fi colsep="${colsep:0:1}" qchar="${qchar:0:1}" echar="${echar:0:1}" headers=() while [ $# -gt 0 -a "$1" != "--" ]; do array_add headers "$1" shift done shift [ -n "${headers[*]}" ] || parse_headers=1 if [ -n "$fieldmap" ]; then awkscript="$awkscript"'{ if (do_once("mapfields")) { mapfields(fields2map) } }' reset_fields= fi if [ -n "$checkfields" ]; then awkscript="$awkscript"'{ if (do_once("checkfields")) { if (!checkfields(fields2check)) exit 1 } }' reset_fields= fi if [ -n "$checkvalues" ]; then awkscript="$awkscript"'{ if (!checkvalues(values2check)) exit 1 }' reset_fields= fi if [ -n "$skipf" ]; then [ -n "$keepf" ] || keepf="*" fi if [ -n "$keepf" ]; then awkscript="$awkscript"'{ if (do_once("filterfields")) { build_skipfs(fields2keep, fields2skip, SKIPFS, ADDFS) filterheaders(SKIPFS, ADDFS) } filterfields(SKIPFS, ADDFS) }' reset_fields= fi lawkrun -f \ skip_lines:int="$skip" parse_headers:int="$parse_headers" \ autosep:int="$autosep" colsep="$colsep" qchar="$qchar" echar="$echar" \ show_headers:int="$show_headers" reset_fields:int="$reset_fields" \ fields2map="$fieldmap" fields2check="$checkfields" values2check="$checkvalues" \ fields2keep="$keepf" fields2skip="$skipf" \ "user_headers[@]=headers" "${vars[@]}" \ "$__AWKCSV_FUNCTIONS"' BEGIN { if (autosep) { DEFAULT_COLSEP = colsep DEFAULT_QCHAR = qchar DEFAULT_ECHAR = echar } } NR <= skip_lines { next } '"$beforescript $append_beforescript $awkscript $append_awkscript $afterscript $append_afterscript " -- "$@" } function cawkcsv() { LANG=C lawkcsv "$@"; } function awkcsv() { LANG=C lawkcsv "$@"; } ################################################################################ __GREPCSV_HELP="\ Faire une recherche dans un flux csv, et afficher uniquement les lignes qui correspondent à l'expression. EXPR est une expression awk, e.g. 'field == \"value1\" || field == \"value2\"' Analyse du flux en entrée: -s, -S, --skip-lines nblines Sauter nblines au début du flux -h, -H, --parse-headers Lire la liste des champs à partir de la première ligne non ignorée du flux. Si la liste des champs est vide, cette option est implicitement activée. Par contre, si une liste de champs est spécifiée et que le flux en entrée contient un ligne d'en-têtes, il *faut* spécifier explicitement cette option. --sepconf 'CQE' Spécifier en une seule option les caractères de séparation des colonnes (C), le caractère pour encadrer les chaines (Q) et le caractère d'échappement (E). Pour chacun des caractères, s'il n'est pas spécifié, la valeur par défaut est prise. CQE vaut par défaut ',\"' --colsep C --qchar Q --echar E Spécifier les caractères pour l'analyse du flux csv. Seul le premier caractère de respectivement C, Q et E est considéré. - C est le séparateur des colonnes, e.g \",\" - Q est le caractère employé pour encadrer la valeur d'une colonne si elle contient le caractère C - E est le caractère employé pour mettre en echappement le caractère Q dans la valeur d'une colonne. Si E est vide, le caractère Q doit être doublé. Flux en sortie: -n, --no-headers Ne pas afficher les en-têtes. Par défaut, les en-têtes sont affichés. -q, --quiet Ne pas afficher les lignes. Indiquer seulement si des lignes ont été trouvées. Scripts: -v var=value Définir une variable pour le script awk -e script Instructions à exécuter pour chaque ligne en entrée. Utiliser la variante --re pour remplacer les instructions par défaut qui sont exécutées avant les instructions de -e Par défaut, il n'y a pas d'instructions -e et les instructions de --re sont de créer des variables nommées d'après les colonnes du flux csv. Il est recommandé de ne pas modifier --re Note d'implémentation: pour des raisons d'optimisation, le traitement effectué sur chaque ligne n'est pas aussi complet que celui de la fonction awkcsv(): Les tableaux ORIGFIELDS et ORIGHEADERS sont disponible; par contre, la ligne courante est au format csv non analysé. Utiliser la fonction copyall() pour être dans les mêmes conditions que le script awkcsv." function lgrepcsv() { local -a args vars local skip= parse_headers= local sepconf= colsep= qchar= echar= local no_headers= quiet= local awkscript=--use-default-- local append_awkscript= if parse_opts \ -s:,-S:,--skip:,--skip-lines:,--skiplines: skip= \ -h,-H,--parse-headers parse_headers=1 \ --sepconf: sepconf= \ --colsep: colsep= \ --qchar: qchar= \ --echar: echar= \ -n,--no-headers no_headers=1 \ --show-headers no_headers= \ -q,--quiet quiet=1 \ -v:,--var: vars \ --re: '$set@ awkscript; append_awkscript=' \ -e:,--e:,--awk-script:,--script: append_awkscript= \ @ args -- "$@"; then set -- "${args[@]}" else eerror "$args" return 1 fi local expr="$1"; shift local -a inputfiles tmpfiles local inputfile while [ $# -gt 0 -a "$1" != "--" ]; do if [ "$1" == "-" ]; then ac_set_tmpfile inputfile array_add tmpfiles "$inputfile" cat >"$inputfile" else inputfile="$1" fi array_add inputfiles "$inputfile" shift done shift if [ "${#inputfiles[*]}" -eq 0 ]; then ac_set_tmpfile inputfile array_add tmpfiles "$inputfile" cat >"$inputfile" array_add inputfiles "$inputfile" fi local -a headers headers=("$@") if [ -z "${headers[*]}" ]; then parse_headers=1 array_from_lines headers "$(lawkrun -f lskip:int="$skip" 'NR <= lskip { next } { count = array_parsecsv(__fields, $0) for (i = 1; i <= count; i++) { print __fields[i] } exit }' -- "${inputfiles[@]}")" fi if [ "$awkscript" == --use-default-- ]; then awkscript= for header in "${headers[@]}"; do awkscript="$awkscript $header = oget(\"$header\")" done fi local grepscript="\ BEGIN { ec = 1 } { $awkscript $append_awkscript if ($expr) { ec = 0 if (quiet) exit printheaders() print } } END { exit ec }" lawkcsv ${skip:+-s "$skip"} ${parse_headers:+-h} \ ${sepconf:+--sepconf "$sepconf"} ${colsep:+--colsep "$colsep"} ${qchar:+--qchar "$qchar"} ${echar:+--echar "$echar"} \ ${no_headers:+--no-headers} -v quiet:int=$quiet \ --re '{array_parsecsv(ORIGFIELDS, $0, array_len(ORIGHEADERS))}' -a "$grepscript" \ -- "${headers[@]}" -- "${inputfiles[@]}" local r=$? ac_clean "${tmpfiles[@]}" return $r } function cgrepcsv() { LANG=C lgrepcsv "$@"; } function grepcsv() { LANG=C lgrepcsv "$@"; } ################################################################################ __AWKFSV2CSV_HELP="\ Transformer un flux fsv (colonnes à largeurs fixes) en csv Chaque argument doit être de la forme [-]header:size. La colonne sera incluse dans le fichier en sortie, sauf si elle est précédée de - Analyse du flux en entrée: -s, -S, --skip-lines nblines Sauter nblines au début du flux -r, --no-trim Ne pas trimmer les valeurs à droite. Flux en sortie: -n, --no-headers Ne pas afficher les en-têtes. Par défaut, les en-têtes sont affichés." function lawkfsv2csv() { local -a args headersizes local skip=0 rtrim=1 show_headers=1 if parse_opts \ -s:,-S:,--skip:,--skip-lines:,--skiplines: skip= \ -r,--no-trim rtrim= \ -n,--no-headers show_headers= \ --show-headers show_headers=1 \ @ args -- "$@"; then set -- "${args[@]}" else eerror "$args" return 1 fi local -a headers starts sizes local headersize header i size i=1 while [ $# -gt 0 -a "$1" != "--" ]; do headersize="$1" shift splitpair "$headersize" header size [ -n "$header" ] || { eerror "header est requis" return 1 } [ -n "$size" ] || size=1 if [ "${header#-}" == "$header" ]; then array_add headers "$header" array_add starts "$i" array_add sizes "$size" fi i="$(($i + $size))" done shift lawkrun -f \ skip_lines:int="$skip" trim_values:int="$rtrim" show_headers:int="$show_headers" \ headers[@] starts[@] sizes[@] \ "$__AWKCSV_FUNCTIONS"' BEGIN { if (show_headers) { print array_formatcsv(headers) } } NR <= skip_lines { next } { line = $0 $0 = "" for (i = 1; i <= headers_count; i++) { value = substr(line, starts[i], sizes[i]) if (trim_values) { sub(/^ */, "", value) sub(/ *$/, "", value) } $i = value } formatcsv() print } ' -- "$@" } function cawkfsv2csv() { LANG=C lawkfsv2csv "$@"; } function awkfsv2csv() { LANG=C lawkfsv2csv "$@"; } ################################################################################ __AWKCSV2FSV_HELP="\ Transformer un flux csv en fsv (colonnes à largeurs fixes) Chaque argument doit être de la forme field:size" function lawkcsv2fsv() { local -a args fieldsizes if parse_opts @ args -- "$@"; then set -- "${args[@]}" else eerror "$args" return 1 fi local -a fields sizes local fieldsize field size while [ $# -gt 0 -a "$1" != "--" ]; do fieldsize="$1" shift splitpair "$fieldsize" field size [ -n "$field" ] || { eerror "field est requis" return 1 } [ -n "$size" ] || size=1 array_add fields "$field" array_add sizes "$size" done shift lawkcsv -v fields[@] -v sizes[@] -a '{ line = "" for (i = 1; i <= fields_count; i++) { size = sizes[i] + 0 value = get(fields[i]) "" while (length(value) < size) value = value " " if (length(value) > size) value = substr(value, 1, size) line = line value } print line }' -- "$@" } function cawkcsv2fsv() { LANG=C lawkcsv2fsv "$@"; } function awkcsv2fsv() { LANG=C lawkcsv2fsv "$@"; } ################################################################################ __MERGECSV_HELP="\ Fusionner deux fichiers csv en faisant la correspondance sur la valeur d'un champ, qui est la clé -h, -H, --parse-headers Lire la liste des champs à partir de la première ligne non ignorée des flux. Si cette option est spécifiée (ce qui est le cas par défaut), les champs spécifiés avec les options -k, --lk et --rk peuvent être les noms effectifs des champs. Sinon, les champs ne peuvent être que numériques. -n, -N, --numkeys Ne pas analyser la première ligne pour les noms des champs. Les champs spécifiés ne peuvent être que numériques. --lskip nblines --rskip nblines Sauter nblines au début du flux, respectivement pour left et pour right --lheaders FIELDS --rheaders FIELDS Spécifier les noms des champs à utiliser *en sortie*, respectivement pour left et pour right. Les champs doivent être séparés par des virgules. Si ces valeurs ne sont pas spécifiées, prendre les champs lus avec l'option --parse-headers. Sinon, ne pas afficher d'en-têtes en sortie. --lprefix prefix --rprefix prefix Spécifier un préfixe à rajouter automatiquement aux champs à utiliser *en sortie*. Le prefix est rajouté que les champs soient déterminés par --parse-headers ou spécifiés par --{l,r}headers. La correspondance des champs avec --lk et --rk est faite sur les noms des champs *avant* qu'ils soient modifiés par cette option. --lk, --lkey FIELD --rk, --rkey FIELD Spécifier le champ utilisé pour faire la correspondance entre les deux flux, respectivement pour left et pour right. Si --parse-headers n'est pas spécifié, ces valeurs doivent être numériques. La valeur par défaut est 1. -k, --key FIELD Spécifier le champ utilisé pour faire la correspondance sur les deux flux. Equivalent à '--lk FIELD --rk FIELD' La correspondance des champs avec --lk et --rk est faite sur les noms des champs *avant* qu'ils soient modifiés le cas échéant par --lprefix et/ou --rprefix -i Faire la correspondance de la valeur des champs sans tenir compte de la casse Après la fusion des deux fichiers csv, il est possible de faire une sélection des lignes selon certains critères: -s SELECT Spécifier un type de sélection à faire. SELECT peut valoir: none, n C'est l'action par défaut; toutes les lignes sont affichées inner-join, j N'inclure dans le résultat que les lignes pour lesquelles il y a une correspondance sur les clés. L'option -J est synonyme de '-s inner-join' left-join, l Inclure dans le résultat les lignes pour lesquelles il y a une correspondance sur les clés, et les lignes de left pour lesquelles il n'y a pas de correspondance. Les lignes de right sans correspondance ne sont pas affichées. L'option -L est synonyme de '-s left-join' right-join, r Inclure dans le résultat les lignes pour lesquelles il y a une correspondance sur les clés, et les lignes de right pour lesquelles il n'y a pas de correspondance. Les lignes de left sans correspondance ne sont pas affichées. L'option -R est synonyme de '-s right-join' left-only, lo N'inclure dans le résultat que les lignes de left pour lesquelles il n'y a pas de correspondance dans right. right-only, ro N'inclure dans le résultat que les lignes de right pour lesquelles il n'y a pas de correspondance dans left. Les options suivantes sont des actions qu'il est possible d'effectuer après la sélection des lignes. Les noms des champs spécifiés dans ces options sont les noms en sortie, en tenant compte de l'analyse et du traitement effectués par les options --parse-headers, --{l,r}headers et --{l,r}prefix. --copy, --lcopyf FIELDS Copier les champs spécifiés de right vers left. Les champs spécifiés sont séparés par des virgules et sont de la forme [dest:]src --rcopyf FIELDS Copier les champs spécifiés de left vers right. Les champs spécifiés sont séparés par des virgules et sont de la forme [dest:]src --lkeepf FIELDS Garder les champs de left spécifiés. Les autres sont supprimés de la sortie. FIELDS est une liste de champs séparés par des virgules, ou '*' pour spécifier de garder tous les champs ou '' pour ne garder aucun champ. Par défaut, avec '-s right-only', FIELDS vaut '', sinon FIELDS vaut '*' --keep, --rkeepf FIELDS Garder les champs de right spécifiés. Les autres sont supprimés de la sortie. FIELDS est une liste de champs séparés par des virgules, ou '*' pour spécifier de garder tous les champs, ou '' pour ne garder aucun champ. Par défaut, avec '-s left-only', FIELDS vaut '', sinon FIELDS vaut '*' --lskipf FIELDS --rskipf FIELDS Exclure les champs de left (resp. de right) spécifiés. FIELDS est une liste de champs séparés par des virgules." : "${__MERGECSV_DEBUG:=}" function lmergecsv() { # Fusionner sur la sortie standard les deux fichiers csv $1 et $2. La clé du # fichier $1 est spécifiée par l'option --lkey et vaut 1 par défaut. La clé # du fichier $2 est spécifiée par l'option --rkey et vaut 1 par défaut. Les # valeurs des clés ne doivent pas faire plus de 64 caractères de long. eval "$(utools_local)" local parse_headers=auto local ignore_case= local lskip=0 lkey=1 lheaders= lprefix= local rskip=0 rkey=1 rheaders= rprefix= local select=none local postproc=auto local lcopyf= rcopyf= local lkeepf=--NOT-SET-- rkeepf=--NOT-SET-- local lskipf= rskipf= parse_opts "${PRETTYOPTS[@]}" \ -h,-H,--parse-headers parse_headers=1 \ -n,-N,--numkeys parse_headers= \ --lskip: lskip= \ --lkey:,--lk: lkey= \ --lheaders:,--lh: lheaders= \ --lprefix:,--lp: lprefix= \ --rskip: rskip= \ --rkey:,--rk: rkey= \ --rheaders:,--rh: rheaders= \ --rprefix:,--rp: rprefix= \ -i,--ignore-case ignore_case=1 \ -k:,--key: '$set@ lkey; set@ rkey' \ -s:,--select: select= \ -J select=inner-join \ -L select=left-join \ -R select=right-join \ --lcopyf:,--copy: '$set@ lcopyf; postproc=1' \ --rcopyf: '$set@ rcopyf; postproc=1' \ --lkeepf: '$set@ lkeepf; postproc=1' \ --rkeepf:,--keep: '$set@ rkeepf; postproc=1' \ --lskipf: '$set@ lskipf; postproc=1' \ --rskipf: '$set@ rskipf; postproc=1' \ @ args -- "$@" && set -- "${args[@]}" || die "$args" local lfile="$1" local rfile="$2" [ -f "$lfile" -a -f "$rfile" ] || { [ -f "$lfile" ] || eerror "$lfile: fichier introuvable" [ -f "$rfile" ] || eerror "$rfile: fichier introuvable" return 1 } local padding="----------------------------------------------------------------" local padlen=${#padding} [ "$parse_headers" == "auto" ] && parse_headers=1 if [ -n "$parse_headers" ]; then [ -n "$lheaders" ] || lheaders="$(<"$lfile" lawkrun lskip:int="$lskip" 'NR <= lskip { next } { print; exit }')" [ -n "$rheaders" ] || rheaders="$(<"$rfile" lawkrun lskip:int="$lskip" 'NR <= lskip { next } { print; exit }')" fi # faire le fichier de travail pour lfile local tmpleft ac_set_tmpfile tmpleft "" __mergecsv_left "" __MERGECSV_DEBUG <"$lfile" lawkrun -f \ padding="$padding" padlen:int="$padlen" \ parse_headers:int="$parse_headers" ignore_case:int="$ignore_case" \ lskip:int="$lskip" lkey="$lkey" \ "$__AWKCSV_FUNCTIONS"' NR <= lskip { next } parse_headers && do_once("parse-headers") { array_parsecsv(HEADERS, $0) lkey = geth(lkey) if (!lkey) lkey = 1 next } { oline = $0 parsecsv($0) keyvalue = substr($lkey, 1, padlen) if (ignore_case) keyvalue = tolower(keyvalue) print keyvalue substr(padding, 1, padlen - length(keyvalue)) "1" oline } ' | csort -su >"$tmpleft" # faire le fichier de travail pour rfile local tmpright ac_set_tmpfile tmpright "" __mergecsv_right "" __MERGECSV_DEBUG <"$rfile" lawkrun -f \ padding="$padding" padlen:int="$padlen" \ parse_headers:int="$parse_headers" ignore_case:int="$ignore_case" \ rskip:int="$rskip" rkey="$rkey" \ "$__AWKCSV_FUNCTIONS"' NR <= rskip { next } parse_headers && do_once("parse-headers") { array_parsecsv(HEADERS, $0) rkey = geth(rkey) if (!rkey) rkey = 1 next } { oline = $0 parsecsv($0) keyvalue = substr($rkey, 1, padlen) if (ignore_case) keyvalue = tolower(keyvalue) print keyvalue substr(padding, 1, padlen - length(keyvalue)) "2" oline } ' | csort -su >"$tmpright" # calculer les options de post-traitement case "$select" in none|n|"") select=none;; inner-join|inner|join|j) select=inner-join;; left-join|left|l) select=left-join;; right-join|right|r) select=right-join;; left-only|lo) select=left-only;; right-only|ro) select=right-only;; *) ewarn "$select: valeur de --select invalide. Elle sera ignorée" select=none ;; esac if [ "$postproc" == "auto" ]; then case "$select" in left-only) lkeepf="*"; rkeepf=""; postproc=1;; right-only) lkeepf=""; rkeepf="*"; postproc=1;; *) lkeepf="*"; rkeepf="*"; postproc=;; esac fi if [ -n "$postproc" ]; then if [ "$lkeepf" == "--NOT-SET--" ]; then case "$select" in right-only) lkeepf=;; *) lkeepf="*";; esac fi if [ "$rkeepf" == "--NOT-SET--" ]; then case "$select" in left-only) rkeepf=;; *) rkeepf="*";; esac fi local -a tmpfields fields local field src dest if [ -n "$lcopyf" ]; then array_split tmpfields "$lcopyf" , fields=() for field in "${tmpfields[@]}"; do splitpair "$field" dest src [ -n "$src" ] || src="$dest" array_add fields "$dest:$src" done lcopyf="$(array_join fields ,)" fi if [ -n "$rcopyf" ]; then array_split tmpfields "$rcopyf" , fields=() for field in "${tmpfields[@]}"; do splitpair "$field" dest src [ -n "$src" ] || src="$dest" array_add fields "$dest:$src" done rcopyf="$(array_join fields ,)" fi if [ "$lskipf" == "*" ]; then lskipf= lkeepf= fi if [ -n "$lskipf" ]; then [ "$lkeepf" == "*" ] && lkeepf="$lheaders" array_split fields "$lkeepf" , array_split tmpfields "$lskipf" , for field in "${tmpfields[@]}"; do array_del fields "$field" done lkeepf="$(array_join fields ,)" fi if [ "$rskipf" == "*" ]; then rskipf= rkeepf= fi if [ -n "$rskipf" ]; then [ "$rkeepf" == "*" ] && rkeepf="$rheaders" array_split fields "$rkeepf" , array_split tmpfields "$rskipf" , for field in "${tmpfields[@]}"; do array_del fields "$field" done rkeepf="$(array_join fields ,)" fi fi local -a lcopyfs rcopyfs lkeepfs rkeepfs array_split lcopyfs "$lcopyf" , array_split rcopyfs "$rcopyf" , array_split lkeepfs "$lkeepf" , array_split rkeepfs "$rkeepf" , # fusionner les deux fichiers local tmpmerged ac_set_tmpfile tmpmerged "" __mergecsv_merged "" __MERGECSV_DEBUG csort -s -k 1,$(($padlen + 1)) "$tmpleft" "$tmpright" >"$tmpmerged" <"$tmpmerged" lawkrun -f \ padlen:int="$padlen" \ parse_headers:int="$parse_headers" ignore_case:int="$ignore_case" \ lheaderscsv="$lheaders" lkey="$lkey" lprefix="$lprefix" \ rheaderscsv="$rheaders" rkey="$rkey" rprefix="$rprefix" \ select="$select" postproc:int="$postproc" \ lcopyfs[@] rcopyfs[@] \ lkeepfs[@] rkeepfs[@] \ "$__AWKCSV_FUNCTIONS"' function lgeth(field, nbfields, i) { nbfields = array_len(lheaders) if (int(field) == field) { field = int(field) if (field >= 1 && field <= nbfields) return field else return 0 } field = tolower(field) for (i = 1; i <= nbfields; i++) { if (field == tolower(lheaders[i])) { return i } } return 0 } function rgeth(field, nbfields, i) { nbfields = array_len(rheaders) if (int(field) == field) { field = int(field) if (field >= 1 && field <= nbfields) return field else return 0 } field = tolower(field) for (i = 1; i <= nbfields; i++) { if (field == tolower(rheaders[i])) { return i } } return 0 } function copyf(lfields, rfields, i, fs, vs, l, r) { for (i = 1; i <= lcopyfs_count; i++) { fs = lcopyfs[i] match(fs, /(.*):(.*)/, vs) l = vs[1]; l = lgeth(l) r = vs[2]; r = rgeth(r) if (l && r) { lfields[l] = rfields[r] } } for (i = 1; i <= rcopyfs_count; i++) { fs = rcopyfs[i] match(fs, /(.*):(.*)/, vs) l = vs[2]; l = lgeth(l) r = vs[1]; r = rgeth(r) if (l && r) { rfields[r] = lfields[l] } } } function keepf(lfields, rfields, i) { for (i = lskipfs_count; i >= 1; i--) { array_deli(lfields, lskipfs[i]) } for (i = rskipfs_count; i >= 1; i--) { array_deli(rfields, rskipfs[i]) } } function printmerged(lline, rline, nocopy, linecsv, tmplinecsv) { if (lline != "") array_parsecsv(lfields, lline, array_len(lheaders)) else array_newsize(lfields, array_len(lheaders)) if (rline != "") array_parsecsv(rfields, rline, array_len(rheaders)) else array_newsize(rfields, array_len(rheaders)) if (postproc) { if (!nocopy) copyf(lfields, rfields) keepf(lfields, rfields) } linecsv = array_formatcsv(lfields) tmplinecsv = array_formatcsv(rfields) if (array_len(rfields) > 0) { if (array_len(lfields) > 0) linecsv = linecsv "," linecsv = linecsv tmplinecsv } print linecsv } BEGIN { if (parse_headers) { array_parsecsv(lheaders, lheaderscsv) lheaders_count = array_len(lheaders) if (lprefix != "") { for (i = 1; i <= lheaders_count; i++) { lheaders[i] = lprefix lheaders[i] } lheaderscsv = array_formatcsv(lheaders) } lkey = lgeth(lkey) if (!lkey) lkey = 1 array_parsecsv(rheaders, rheaderscsv) rheaders_count = array_len(rheaders) if (rprefix != "") { for (i = 1; i <= rheaders_count; i++) { rheaders[i] = rprefix rheaders[i] } rheaderscsv = array_formatcsv(rheaders) } rkey = rgeth(rkey) if (!rkey) rkey = 1 } LEFT = 1 RIGHT = 2 hasleft = 0 # quelle sélection effectuer? selectjoin = select ~ /none|inner-join|left-join|right-join/ selectleft = select ~ /none|left-join|left-only/ selectright = select ~ /none|right-join|right-only/ # liste des indexes de champs a supprimer array_new(lskipfs) if (!in_array("*", lkeepfs)) { for (i = 1; i <= lheaders_count; i++) { field = lheaders[i] if (!in_array(field, lkeepfs)) { fieldi = lgeth(field) if (i != 0) array_add(lskipfs, fieldi) } } asort(lskipfs) } lskipfs_count = array_len(lskipfs) array_new(rskipfs) if (!in_array("*", rkeepfs)) { for (i = 1; i <= rheaders_count; i++) { field = rheaders[i] if (!in_array(field, rkeepfs)) { fieldi = rgeth(field) if (i != 0) array_add(rskipfs, fieldi) } } asort(rskipfs) } rskipfs_count = array_len(rskipfs) if (parse_headers) { # afficher les en-têtes après traitement de lkeepfs et rkeepfs, parce que # printmerged() a besoin de lskipfs et rskipfs printmerged(lheaderscsv, rheaderscsv, 1) } } function readleft() { lprefix = substr($0, 1, padlen) lwhich = substr($0, padlen + 1, 1) if (lwhich == "1") lwhich = LEFT; else lwhich = RIGHT lline = substr($0, padlen + 2) hasleft = 1 } function readright() { rprefix = substr($0, 1, padlen) rwhich = substr($0, padlen + 1, 1) if (rwhich == "1") rwhich = LEFT; else rwhich = RIGHT rline = substr($0, padlen + 2) } function right2left() { lprefix = rprefix lwhich = rwhich lline = rline hasleft = 1 } !hasleft { readleft() next } { readright() if (lprefix == rprefix && lwhich == LEFT && rwhich == RIGHT) { if (selectjoin) printmerged(lline, rline) hasleft = 0 next } else { if (lwhich == LEFT && selectleft) { printmerged(lline, "") } else if (lwhich == RIGHT && selectright) { printmerged("", lline) } right2left() next } } END { if (hasleft) { if (lwhich == LEFT && selectleft) { printmerged(lline, "") } else if (lwhich == RIGHT && selectright) { printmerged("", lline) } } } ' ac_clean "$tmpleft" "$tmpright" "$tmpmerged" return 0 } function cmergecsv() { LANG=C lmergecsv "$@"; } function mergecsv() { LANG=C lmergecsv "$@"; } ################################################################################ __SORTCSV_HELP="\ Trier un fichier csv sur la valeur d'un champ -S, --skip-lines nblines Sauter nblines au début du flux -h, -H, --parse-headers Lire la liste des champs à partir de la première ligne non ignorée des flux. Si cette option est spécifiée (ce qui est le cas par défaut), le champ spécifié avec l'option -k peut être le nom effectif du champ. Sinon, le champ ne peut être que numérique. -N, --numkeys Ne pas analyser la première ligne pour les noms des champs. Les champs spécifiés ne peuvent être que numériques. -k, --key FIELD Spécifier le champ utilisé pour le tri. Si --parse-headers n'est pas spécifié, cette valeur doit être numérique. La valeur par défaut est 1. --no-headers Ne pas afficher les en-têtes en sortie. -n, --numeric-sort Comparer selon la valeur numérique du champ -i, -f, --ignore-case Comparer sans tenir compte de la casse -r, --reverse Inverser l'ordre de tri -s, --stable Stabiliser le tri en inhibant la comparaison de dernier recours -u, --unique Ne garder que la première occurence de plusieurs entrées identiques rencontrées. Note: la correspondance se fait sur toute l'entrée, pas uniquement sur la valeur de la clé. -o, --output OUTPUT Ecrire le résultat dans OUTPUT au lieu de la sortie standard" : "${__SORTCSV_DEBUG:=}" function lsortcsv() { # Trier le fichier csv $1. La clé du tri est spécifiée par l'option -k et # vaut 1 par défaut. Les valeurs des clés ne doivent pas faire plus de 64 # caractères de long. eval "$(utools_local)" local skip=0 parse_headers=auto key=1 show_headers=1 local numeric_sort= ignore_case= reverse_sort= stable_sort= unique_sort= output= parse_opts "${PRETTYOPTS[@]}" \ -S:,--skip:,--skip-lines:,--skiplines: skip= \ -h,-H,--parse-headers parse_headers=1 \ -N,--numkeys parse_headers= \ -k:,--key: key= \ --no-headers show_headers= \ --show-headers show_headers=1 \ -n,--numeric-sort numeric_sort=1 \ -i,-f,--ignore-case ignore_case=1 \ -r,--reverse reverse_sort=1 \ -s,--stable stable_sort=1 \ -u,--unique unique_sort=1 \ -o:,--output: output= \ @ args -- "$@" && set -- "${args[@]}" || die "$args" local input="$1" if [ -z "$input" -o "$input" == "-" ]; then input=/dev/stdin elif [ ! -f "$input" ]; then eerror "$input: fichier introuvable" return 1 fi local padding="----------------------------------------------------------------" local padlen=${#padding} local headers local -a tmpfiles [ "$parse_headers" == "auto" ] && parse_headers=1 if [ -n "$parse_headers" -a -z "$headers" ]; then if [ "$input" == /dev/stdin ]; then # Si on lit depuis stdin, il faut faire une copie du flux dans un # fichier temporaire pour calculer les en-têtes local tmpinput ac_set_tmpfile tmpinput "" __sortcsv_input0 "" __SORTCSV_DEBUG array_add tmpfiles "$tmpinput" cat >"$tmpinput" input="$tmpinput" fi headers="$(<"$input" lawkrun skip:int="$skip" 'NR <= skip { next } { print; exit }')" fi # faire le fichier de travail local tmpinput ac_set_tmpfile tmpinput "" __sortcsv_input "" __SORTCSV_DEBUG array_add tmpfiles "$tmpinput" <"$input" >"$tmpinput" lawkrun -f \ padding="$padding" padlen:int="$padlen" \ skip:int="$skip" parse_headers:int="$parse_headers" \ key="$key" \ "$__AWKCSV_FUNCTIONS"' NR <= skip { next } parse_headers && do_once("parse-headers") { array_parsecsv(HEADERS, $0) key = geth(key) if (!key) key = 1 next } { oline = $0 parsecsv($0) keyvalue = substr($key, 1, padlen) print keyvalue substr(padding, 1, padlen - length(keyvalue)) oline } ' # trier le fichier de travail local tmpsorted ac_set_tmpfile tmpsorted "" __sortcsv_sorted "" __SORTCSV_DEBUG array_add tmpfiles "$tmpsorted" args=(# arguments de sort ${numeric_sort:+-n} ${ignore_case:+-f} ${reverse_sort:+-r} ${stable_sort:+-s} ${unique_sort:+-u} ) csort -k 1,$(($padlen + 1)) "${args[@]}" <"$tmpinput" >"$tmpsorted" # résultat [ -n "$output" ] || output=/dev/stdout stdredir "$tmpsorted" "$output" "" lawkrun -f \ padlen:int="$padlen" \ headerscsv="$headers" show_headers:int="$show_headers" \ ' BEGIN { if (show_headers) print headerscsv } { print substr($0, padlen + 1) } ' ac_clean "${tmpfiles[@]}" return 0 } function csortcsv() { LANG=C lsortcsv "$@"; } function sortcsv() { LANG=C lsortcsv "$@"; } ################################################################################ __DUMPCSV_HELP="\ Afficher les champs spécifiés pour traitement par le shell ou par awk -S, --skip-lines nblines Sauter nblines au début du flux -H, --parse-headers Lire la liste des champs à partir de la première ligne non ignorée du flux. Si cette option est spécifiée (ce qui est le cas par défaut), les champs spécifiés peuvent être les noms effectifs des champs. Sinon, les champs ne peuvent être que numériques. -N, --numkeys Ne pas analyser la première ligne pour les noms des champs. Les champs spécifiés ne peuvent être que numériques. -k, --keep-fields KEEPFIELDS Garder les champs spécifiés. Les autres sont supprimés de la sortie. KEEPFIELDS est une liste de champs séparés par des virgules. -s, --skip-fields SKIPFIELDS Exclure les champs spécifiés. SKIPFIELDS est une liste de champs séparés par des virgules. -h, --dump-headers Inclure les en-têtes dans la sortie. Elles sont traitées exactement comme une ligne de données. --hname HNAME Spécifier le nom à utiliser pour afficher les en-têtes avec l'option -h -n, --name NAME Spécifier le nom à utiliser pour les options -f, -a, -b, -w -f, --function Afficher les champs comme l'appel d'une fonction, e.g: dump value00 value01... dump value10 value11... C'est la méthode d'affichage par défaut. L'option -n permet de spécifier le nom de la fonction, qui vaut 'dump' par défaut. Avec -h, le nom par défaut est 'dumph' -a, --array Afficher les champs comme les valeurs d'un tableau, e.g: values=() values=(value00 value01...) values=(value10 value11...) Bien entendu, cela n'a sens que si une seule ligne résultat est attendue. L'option -n permet de spécifier le nom du tableau, qui vaut 'values' par défaut. Avec -h, le nom par défaut est 'names' Cette méthode commence par afficher de quoi initialiser le tableau à une valeur vide. Ainsi, si aucune ligne n'est trouvée, le tableau est néanmoins initialisé. Si ce comportement n'est pas désiré, il est possible d'utiliser l'option --no-reset -b, --array-function Afficher les champs comme l'initialisation des valeurs d'un tableau suivi de l'appel d'une fonction, e.g: values=(value00 value01...) dump values=(value10 value11...) dump Le nom du tableau est fixé à 'values'. L'option -n permet de spécifier le nom de la fonction, qui vaut 'dump' par défaut. Avec -h le nom par défaut est 'dumph' -w, --awk-map Afficher les champs comme une fonction awk qui permet de rechercher une valeur et d'afficher la valeur correspondante. L'option -n permet de spécifier le nom de la fonction, qui vaut 'mapval' par défaut. --wtype TYPE Spécifier le type de fonction à générer avec l'option --awk-map. Le type par défaut est 'value' Avec le type 'value', la fonction générée est de la forme dump(inval). Cette fonction prend en argument la valeur de la colonne spécifiée avec --wscol, et si cette valeur est trouvée dans les données, retourner la valeur de la colonne spécifiée avec --wrcol Avec le type 'array', la fonction générée est de la forme dump(inval, outvs) Cette fonction prend en argument la valeur de la colonne spécifiée avec --wscol, et si cette valeur est trouvée dans les données, le tableau outvs est rempli avec les donnée de la ligne correspondante. --wscol SFIELD Nom du champ qui est cherché par la fonction générée avec l'option --awk-map La valeur par défaut est '1', c'est à dire le premier champ. --wrcol RFIELD Nom du champ dont la valeur est retournée par la fonction générée avec l'option '--awk-map --wtype value' en cas de correspondance. La valeur par défaut est '2', c'est à dire le deuxième champ. -v, --var Affiche les champ en initialisant des variables, e.g: names=(header0 header1) header0= header1= header0=value00 header1=value01 ... header0=value10 header1=value11 ... Bien entendu, cela n'a sens que si une seule ligne résultat est attendue. Cette option implique -h. Le nom par défaut du tableau qui liste les variables est names. Cette méthode commence par réinitialiser les variables à la valeur vide. Ainsi, si aucune ligne n'est trouvée, les variables sont vides. Si ce comportement n'est pas désiré, il est possible d'utiliser l'option --no-reset" function ldumpcsv() { eval "$(utools_local)" local skip= parse_headers=1 keepf skipf show_headers local dump=function reset=1 name hname local wtype wscol wrcol parse_opts "${PRETTYOPTS[@]}" \ -S:,--skip:,--skip-lines:,--skiplines: skip= \ -H,--parse-headers parse_headers=1 \ -N,--numkeys parse_headers= \ -k:,--keep:,--keep-fields:,--keepfields: keepf= \ -s:,--skip:,--skip-fields:,--skipfields: skipf= \ -h,--dump-headers show_headers=1 \ -n:,--name: name= \ --hname: hname= \ -f,--function dump=function \ -a,--array dump=array \ --reset reset=1 \ --no-reset reset= \ -b,--array-function dump=array-function \ -w,--awk-map dump=awk-map \ --wtype: wtype= \ --wscol: wscol= \ --wrcol: wrcol= \ -v,--var dump=var \ @ args -- "$@" && set -- "${args[@]}" || die "$args" args=( ${skip:+--skip-lines "$skip"} ${keepf:+--keep-fields "$keepf"} ${skipf:+--skip-fields "$skipf"} ) if [ -n "$parse_headers" ]; then array_add args -h else array_add args -n fi [ "$dump" == var ] && show_headers=1 if [ -z "$hname" ]; then case "$dump" in function|array-function) hname=dumph;; array|var) hname=names;; esac fi if [ -z "$name" ]; then case "$dump" in function|array-function) name=dump;; array) name=values;; awk-map) name=mapval;; esac fi case "${wtype:-value}" in array|a) wtype=array;; value|v) wtype=value;; esac [ -n "$wscol" ] || wscol=1 [ -n "$wrcol" ] || wrcol=2 local -a fields fields=("$@") awkcsv "${args[@]}" -v show_headers:int="$show_headers" \ -v hname="$hname" -v name="$name" -v dump="$dump" \ -v reset_values:int="$reset" -v fields[@] \ -v wtype="$wtype" -v wscol="$wscol" -v wrcol="$wrcol" \ -e ' function init_fields() { if (do_once("init_fields")) { if (fields_count == 0) { array_copy(fields, HEADERS) fields_count = array_len(fields) } } } function before_awkmap(name, wtype) { if (do_once("before_awkmap")) { if (wtype == "value") { print "function " name "(inval) {" } else if (wtype == "array") { print "function " name "(inval, outvs) {" } } } function awkmap(inval, outval, values, count, wtype, i) { if (wtype == "value") { print "if (inval == " qawk(inval) ") return " qawk(outval) } else if (wtype == "array") { print "if (inval == " qawk(inval) ") {" print "delete outvs" for (i = 1; i <= count; i++) { print "outvs[" i "] = " qawk(values[i]) } print "return 1" print "}" } } function after_awkmap() { if (do_once("after_awkmap")) { if (wtype == "value") { print "return \"\"" } else if (wtype == "array") { print "return 0" } print "}" } } function dump_values(name, values, dump) { if (dump == "function") { print qarr(values, name) } else if (dump == "array") { print name "=(" qarr(values) ")" } else if (dump == "array-function") { print "values=(" qarr(values) ")" print name } else if (dump == "var") { i = 1 while (i <= fields_count) { print fields[i] "=" qval(values[i]) i++ } } } function before_dump() { if (do_once("before_dump")) { if (show_headers) { dump_values(hname, fields, dump == "var"? "array": dump) } if ((dump == "array" || dump == "var") && reset_values) { array_new(reset) dump_values(name, reset, dump) } } } { init_fields() array_new(values) i = 1 while (i <= fields_count) { values[i] = get(fields[i]) i++ } if (dump == "awk-map") { before_awkmap(name, wtype) if (wscol ~ /^[0-9]+$/) inval = geti(wscol) else inval = get(wscol) if (wrcol ~ /^[0-9]+$/) outval = geti(wrcol) else outval = get(wrcol) awkmap(inval, outval, values, fields_count, wtype) } else { before_dump() dump_values(name, values, dump) } } END { if (dump == "awk-map") { before_awkmap(name, wtype) after_awkmap() } else { before_dump() } }' -a '' } function cdumpcsv() { LANG=C ldumpcsv "$@"; } function dumpcsv() { LANG=C ldumpcsv "$@"; } ################################################################################ __PRINTCSV_HELP="\ Afficher les valeurs spécifiées au format CSV -F, --fields FIELDS Spécifier les champs en sortie -o, --output OUTPUT Ajouter la ligne au fichier spécifié. Si le fichier n'existe pas ou est de taille vide, et que l'option -F est spécifiée, alors écrire les en-têtes dans le fichier avant d'écrire les valeurs. --show-headers -n, --no-headers Forcer l'affichage (resp. le non-affichage) des en-têtes" function lprintcsv() { eval "$(utools_local)" local fields output show_headers=auto parse_opts "${PRETTYOPTS[@]}" \ -F:,--fields: fields= \ -o:,--output: output= \ -n,--no-headers show_headers= \ --show-headers show_headers=1 \ @ args -- "$@" && set -- "${args[@]}" || die "$args" array_split fields "$fields" , [ "$output" == - ] && output= [ -n "$fields" ] || show_headers= if [ "$show_headers" == auto ]; then if [ -n "$output" ]; then [ -s "$output" ] || show_headers=1 else show_headers= fi fi [ -n "$output" ] || output=/dev/stdout values=("$@") stdredir "" ">>$output" "" lawkrun -f fields[@] show_headers:int="$show_headers" values[@] ' BEGIN { if (show_headers) array_printcsv(fields) if (fields_count > 0) count = fields_count else count = values_count array_new(output) for (i = 1; i <= count; i++) { if (i <= values_count) output[i] = values[i] else output[i] = "" } array_printcsv(output) }' } function cprintcsv() { LANG=C lprintcsv "$@"; } function printcsv() { LANG=C lprintcsv "$@"; }