nutools/mysqlloadcsv

#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
source "$(dirname -- "$0")/lib/ulib/auto" || exit 1
urequire awk

function display_help() {
    uecho "$scriptname: Charger une table MySQL avec un fichier csv

USAGE
    $scriptname [db.]table [fields...] [-- mysql options]

db      est le nom de la base de données
table   est le nom de la table à charger
fields  est la liste des colonnes. Si cette valeur est spécifiée, il faudra
        peut-être utiliser l'option -s pour ignorer le cas échéant la ligne des
        en-têtes dans le fichier en entrée. Sinon, les colonnes à utiliser sont
        calculées à partir du fichier en entrée.

Dans les données en entrées, qui doivent être en UTF8, les conversions suivantes
sont effectuées par MySQL:

    \\0 --> <caractère NUL>
    \\b --> <backspace>
    \\n --> <newline>
    \\r --> <carriage return>
    \\t --> <tab>
    \\Z --> Ctrl+Z
    \\N --> NULL

OPTIONS
    -h, --host host
    -P, --port port
    -u, --user user
    -ppassword
        Informations de connexion à la base de données
    -C, --config CONFIG
        Prendre les informations de connexion depuis le fichier spécifié.
        Le fichier doit être de la forme
            host=HOST.TLD
            #post=3306
            user=USER
            password=PASS
            #dbtable=DB.TABLE
            #fields=(FIELDS...)
            # Il est possible aussi de spécifier DB et TABLE séparément:
            #database=DB
            #table=TABLE
        Les variables port, dbtable et fields sont facultatives.
        Les valeurs définies dans ce fichier sont prioritaires par rapport à
        celles qui auraient été spécifiées sur la ligne de commande.
        Utiliser password=--NOT-SET-- s'il faut se connecter sans mot de passe
        Cette option peut être utilisée plusieurs fois, auquel cas les fichiers
        sont chargés dans l'ordre.
    --profile PROFILE
        La variable \$PROFILE est définie avec la valeur spécifiée avant de
        sourcer les fichiers de configuration. Cela permet d'avoir des fichiers
        de configuration qui calculent dynamiquement les paramètres en fonction
        de la valeur du profil.
    -f, --input INPUT
        Fichier en entrée. Ne pas spécifier cette option ou utiliser '-' pour
        lire depuis l'entrée standard.
    -d, --auto-dbtable DB
        Spécifier la base de données avec laquelle se connecter. De plus, si le
        nom de la table n'est pas spécifié, prendre par défaut le nom de base du
        fichier spécifié avec l'option -f
    -s, --skip-lines NBLINES
        Nombre de lignes à sauter dans le fichier en entrée
    -n, --fake
        Ne pas effectuer l'opération. Afficher simplement la commande SQL.
    --prefix PREFIX
        Spécifier un ensemble de requêtes SQL à exécuter ou à afficher avant les
        requêtes générées automatiquement.
    --run
        Forcer le lancement de l'opération. Utiliser cette option avec -A pour
        créer la table avec les paramètres analysés.
    -T, --truncate
        Vider la table avant d'effectuer le chargement
    -L, --load-data
        Charger les données avec la commande 'load data local'. C'est l'option
        par défaut. Le fichier est transmis tel quel à MySQL.
    -I, --insert-data
        Charger les données en générant des commandes 'insert into'. L'effet est
        en principe le même avec l'option -L (sauf que certains formats de date
        exotiques seront correctement importés). Cette option peut aussi être
        utilisée avec l'option -n pour générer une liste de commande à corriger
        et/ou adapter.
    -U, -k, --update-data KEY
        Au lieu de charger de nouvelles données, essayer de mettre à jour la
        table. KEY est le nom de la colonne qui est utilisée comme clé. Toutes
        les autres colonnes sont les nouvelles données à mettre à jour. Si
        aucune ligne ne correspond à une clé donnée, la mise à jour pour cette
        ligne est ignorée.
        Note: utiliser les options -T et -U ensemble n'a pas de sens, mais -T
        est quand même honoré.
    -Z, --null-value VALUE
        Avec les options -I et -U, considérer que NULL est représenté par la
        chaine spécifiée. Par défaut, utiliser \N
    -z, --null-is-empty
        Avec les options -I et -U, considérer que NULL est représenté par la
        chaine vide. Cette option est équivalente à -Z ''
    -t, --types [DEFAULT_TYPE,]FIELD:TYPE,...
        Spécifier pour chaque champ mentionné le type de donnée à forcer. Le
        type 'auto' signifie que le type est autodétecté. C'est la valeur par
        défaut. Les autres types valides sont 'str', 'int' et 'date'
        Cette option est ignorée avec l'option -L
    -A, --analyse
        Analyser les données et afficher une requête pour créer une table qui
        pourrait contenir ces données.
        Cette option implique --fake et affiche simplement la commande SQL.
        Pour lancer la commande SQL générée, il faut ajouter l'option --run
        APRES cette option"
}

function norm_type() {
    case "$1" in
    string|str|s|varchar) echo varchar;;
    integer|int|i) echo integer;;
    #datetime|dt) echo datetime;;
    date|d) echo date;;
    auto|a) echo auto;;
    *) echo "$1";;
    esac
}

__AWK_MYSQLFUNCS='
function is_null(value) {
  return value == null_value
}
function is_integer(value) {
  return value ~ /^(0|[1-9][0-9]*)$/
}
function is_date_dmy(value) {
  return value ~ /^[0-9][0-9]\/[0-9][0-9]\/[0-9][0-9]$/
}
function is_date_dmY(value) {
  return value ~ /^[0-9][0-9]\/[0-9][0-9]\/[0-9][0-9][0-9][0-9]$/
}
function is_date_Ymd1(value) {
  return value ~ /^[0-9][0-9][0-9][0-9]\/[0-9][0-9]\/[0-9][0-9]$/
}
function is_date_Ymd2(value) {
  return value ~ /^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]$/
}
function is_date(value) {
  return is_date_dmy(value) || is_date_dmY(value) || is_date_Ymd1(value) || is_date_Ymd2(value)
}
#function is_datetime(value) {
#}
function format_string(value) {
  gsub(/'\''/, "'\'\''", value)
  value = "'\''" value "'\''"
  return value
}
function format_integer(value) {
  if (is_integer(value)) {
    if (value != "0") {
      gsub(/^0+/, "", value)
    }
  } else {
    value = format_string(value)
  }
  return value
}
function format_date(value) {
  if (is_date_dmy(value)) {
    value = "str_to_date('\''" value "'\'', '\''%d/%m/%y'\'')"
  } else if (is_date_dmY(value)) {
    value = "str_to_date('\''" value "'\'', '\''%d/%m/%Y'\'')"
  } else if (is_date_Ymd1(value)) {
    value = "str_to_date('\''" value "'\'', '\''%Y/%m/%d'\'')"
  } else if (is_date_Ymd2(value)) {
    value = "str_to_date('\''" value "'\'', '\''%Y-%m-%d'\'')"
  } else {
    value = format_string(value)
  }
  return value
}
function format_sqlvalue(value, type) {
  if (type == "varchar" || type == "string" || type == "str" || type == "s") {
    value = format_string(value)
  } else if (type == "integer" || type == "int" || type == "i") {
    value = format_integer(value)
  } else if (type == "date" || type == "d") {
    value = format_date(value)
  #} else if (type == "datetime" || type == "dt") {
  #  value = format_datetime(value)
  } else {
    # par defaut, autodétecter
    if (is_null(value)) {
      value = "NULL"
    } else if (is_integer(value)) {
      value = format_integer(value)
    } else if (is_date(value)) {
      value = format_date(value)
    } else {
      value = format_string(value)
    }
  }
  return value
}
'

host=
port=
user=
password=--NOT-SET--
configs=()
profile=
input=
auto_db=
skip_lines=
prefix=
truncate=
fake=
method=load
update_key=
null_value='\N'
fieldtypes=()
parse_opts "${PRETTYOPTS[@]}" \
    --help '$exit_with display_help' \
    -h:,-H:,--host: host= \
    -P:,--port: port= \
    -u:,--user: user= \
    -p::,--passwd:,--password: password= \
    -C:,--config: configs \
    -f:,--input: input= \
    -d:,--auto-dbtable: auto_db= \
    -s:,--skip-lines: skip_lines= \
    -n,--fake fake=1 \
    --run fake= \
    --prefix: prefix= \
    -T,--truncate truncate=1 \
    -L,--load-data method=load \
    -I,--insert-data method=insert \
    -U:,-k:,--update-data: '$method=update; set@ update_key' \
    -Z:,--null-value: null_value= \
    -z,--null-is-empty null_value= \
    -t:,--types: fieldtypes \
    -A,--analyse '$method=analyse; fake=1' \
    @ args -- "$@" && set -- "${args[@]}" || die "$args"

dbtable="$1"; shift
fields=()
while [ "$#" -gt 0 -a "$1" != "--" ]; do
    fields=("${fields[@]}" "$1")
    shift
done
[ "$1" == "--" ] && shift

splitfsep2 "$dbtable" . database table
if [ -z "$database" -a -n "$auto_db" ]; then
    database="$auto_db"
    if [ -z "$table" -a -n "$input" -a "$input" != "-" ]; then
        table="$(basename -- "$input")"
        table="${table%.*}"
    fi
fi

if [ -n "${configs[*]}" ]; then
    PROFILE="$profile"
    array_fix_paths configs
    for config in "${configs[@]}"; do
        [ -f "$config" ] || die "Fichier introuvable: $config"
        source "$(abspath "$config")"
    done
fi
[ -n "$table" ] || die "Vous devez spécifier la table dans laquelle se fera l'importation"

if [ -n "$input" -a "$input" != "-" ]; then
    [ -f "$input" ] || die "$input: fichier introuvable"
fi

isnum "$skip_lines" || skip_lines=0

if [ -n "${fields[*]}" ]; then
    # nous savons quels champs utiliser
    cfields="$(array_join fields ,)"
    if [ -z "$input" -o "$input" == "-" ]; then
        ac_set_tmpfile input
        awkcsv -s "$skip_lines" -k "$cfields" >"$input"
    else
        ac_set_tmpfile tmpinput
        <"$input" awkcsv -s "$skip_lines" -k "$cfields" >"$tmpinput"
        input="$tmpinput"
    fi
else
    # les champs seront calculés à partir de l'entrée
    if [ -z "$input" -o "$input" == "-" ]; then
        ac_set_tmpfile input
        cat >"$input"
    fi
    array_split fields "$(awkcsv -s "$skip_lines" -e '{ print array_join(HEADERS, ","); exit }' <"$input")" ","
    cfields="$(array_join fields ,)"
fi

# calculer les types à utiliser pour chaque champ
types=()
for field in "${fields[@]}"; do
    array_add types ""
done
default_type=auto
array_fix_paths fieldtypes ,
for ft in "${fieldtypes[@]}"; do
    splitpair "$ft" f t
    if [ -n "$t" ]; then
        let i=0
        for field in "${fields[@]}"; do
            if [ "$field" == "$f" ]; then
                types[$i]="$(norm_type "$t")"
                break
            fi
            let i=$i+1
        done
    else
        default_type="$(norm_type "$f")"
    fi
done
let i=0
for type in "${types[@]}"; do
    [ -n "$type" ] || types[$i]="$default_type"
    let i=$i+1
done

mysqlargs=(
    ${host:+-h "$host"} ${port:+-P "$port"}
    ${user:+-u "$user"} ${database:+-D "$database"}
)
[ "$password" != "--NOT-SET--" ] && mysqlargs=("${mysqlargs[@]}" -p"$password")

[ -n "$truncate" ] && truncate="truncate table \`$table\`;"

if [ "$method" == load ]; then
    skip_lines=$(($skip_lines + 1))
    loadcsv="load data local infile '$input' into table \`$table\` character set 'utf8' fields terminated by ',' optionally enclosed by '\\\"' escaped by '\\\\' lines terminated by '\\n' starting by '' ignore $skip_lines lines ($cfields);"
    mysqlargs=("${mysqlargs[@]}"
        "\
$prefix
$truncate
$loadcsv"
        --
        --local-infile=1
    )
    cmd=("$scriptdir/mysqlcsv" "${mysqlargs[@]}" "$@")

    r=0
    if [ -n "$fake" ]; then
        echo "-- Requêtes SQL:"
        [ -n "$prefix" ] && echo "$prefix"
        [ -n "$truncate" ] && echo "$truncate"
        echo "$loadcsv"
        echo "-- Commande à lancer pour importer la table dans MySQL:"
        echo "--     $(qvals "${cmd[@]}")"
    else
        "${cmd[@]}"; r=$?
    fi

    exit $r

elif [ "$method" == insert ]; then
    ac_set_tmpfile inserts
    [ -n "$prefix" ] && echo "$prefix" >>"$inserts"
    [ -n "$truncate" ] && echo "$truncate" >>"$inserts"
    awkcsv <"$input" >>"$inserts" -s "$skip_lines" -v table="$table" \
        -v null_value="$null_value" -v types[@] -a "$__AWK_MYSQLFUNCS"'
BEGIN {
  print "start transaction;"
}
{
  count = length(ORIGHEADERS)
  fields = ""
  for (i = 1; i <= count; i++) {
    if (i > 1) fields = fields ", "
    fields = fields "`" ORIGHEADERS[i] "`"
  }
  values = ""
  for (i = 1; i <= count; i++) {
    if (i > 1) values = values ", "
    values = values format_sqlvalue($i, types[i])
  }
  print "insert into `" table "` (" fields ") values (" values ");"
}
END {
  print "commit;"
}'
    r=0
    if [ -n "$fake" ]; then
        cat "$inserts"
    else
        cat "$inserts" | "$scriptdir/mysqlcsv" "${mysqlargs[@]}" -f -; r=$?
    fi

    ac_clean "$inserts"
    exit $r

elif [ "$method" == update ]; then
    array_contains fields "$update_key" || die "$update_key: ce champ n'existe pas dans la source"

    ac_set_tmpfile updates
    [ -n "$prefix" ] && echo "$prefix" >>"$updates"
    [ -n "$truncate" ] && echo "$truncate" >>"$updates"
    awkcsv <"$input" >>"$updates" -s "$skip_lines" \
        -v table="$table" -v update_key="$update_key" \
        -v null_value="$null_value" -v types[@] -a "$__AWK_MYSQLFUNCS"'{
  set_values = ""
  cond = ""
  count = length(ORIGHEADERS)
  for (i = 1; i <= count; i++) {
    field = ORIGHEADERS[i]
    value = format_sqlvalue($i, types[i])
    if (field == update_key) {
      cond = "`" field "`=" value
    } else {
      if (set_values) set_values = set_values ", "
      set_values = set_values "`" field "`=" value
    }
  }
  print "update `" table "` set " set_values " where " cond ";"
}
END {
  print "commit;"
}'
    r=0
    if [ -n "$fake" ]; then
        cat "$updates"
    else
        cat "$updates" | "$scriptdir/mysqlcsv" "${mysqlargs[@]}" -f -; r=$?
    fi

    ac_clean "$updates"
    exit $r

elif [ "$method" == analyse ]; then
    ac_set_tmpfile create
    [ -n "$prefix" ] && echo "$prefix" >>"$create"
    awkcsv <"$input" >>"$create" -s "$skip_lines" -v table="$table" \
        -v null_value="$null_value" -v types[@] -a "$__AWK_MYSQLFUNCS"'
function set_integer(i) {
  if (COL_TYPES[i] == "" || COL_TYPES[i] == "integer") {
    COL_TYPES[i] = "integer"
    return 1
  }
  return 0
}
function set_datetime(i) {
  if (COL_TYPES[i] == "" || COL_TYPES[i] == "datetime") {
    COL_TYPES[i] = "datetime"
    return 1
  }
  return 0
}
function set_date(i) {
  if (COL_TYPES[i] == "" || COL_TYPES[i] == "date") {
    COL_TYPES[i] = "date"
    return 1
  }
  return 0
}
function set_varchar(i, col_size) {
  COL_TYPES[i] = "varchar"
  if (COL_SIZES[i] == "") {
    COL_SIZES[i] = col_size
  } else if (col_size > COL_SIZES[i]) {
    COL_SIZES[i] = col_size
  }
    return 1
}
{
  if (do_once("init")) {
    count = length(ORIGHEADERS)
    array_newsize(COL_TYPES, count)
    array_newsize(COL_SIZES, count)
    for (i = 1; i <= count; i++) {
      if (types[i] != "auto") {
        COL_TYPES[i] = types[i]
      }
    }
  }
  for (i = 1; i <= count; i++) {
    if (is_null($i)) continue
    if (is_integer($i) && set_integer(i)) continue
#    if (is_datetime($i) && set_datetime(i)) continue
    if (is_date($i) && set_date(i)) continue
    set_varchar(i, length($i))
  }
}
END {
  print "drop table if exists `" table "`;"
  print "create table `" table "` ("
  for (i = 1; i <= count; i++) {
    line = ""
    if (i == 1) line = line " "
    else line = line ","
    line = line "`" ORIGHEADERS[i] "` "
    col_type = COL_TYPES[i]
    if (col_type == "") col_type = "varchar"
    if (col_type == "integer") {
      line = line col_type
    } else if (col_type == "datetime" || col_type == "date") {
      line = line col_type
    } else if (col_type == "varchar") {
      col_size = COL_SIZES[i]
      if (col_size == "") col_size = "80"
      line = line col_type "(" col_size ")"
    }
    print line
  }
  print ");"
}'
    r=0
    if [ -n "$fake" ]; then
        cat "$create"
    else
        cat "$create" | "$scriptdir/mysqlcsv" "${mysqlargs[@]}" -f -; r=$?
    fi

    ac_clean "$create"
    exit $r

else
    die "BUG: $method: method non implémentée"
fi