mysql - Hoe kan ik MySQL-queryresultaten in CSV-indeling uitvoeren?

Is er een gemakkelijke manier om een MySQL-query uit te voeren vanaf de Linux-opdrachtregel en de resultaten uit te voeren in CSV-indeling?

Dit is wat ik nu doe:

mysql -u uid -ppwd -D dbname << EOQ | sed -e 's/        /,/g' | tee list.csv
select id, concat("\"",name,"\"") as name
from students
EOQ

Het wordt rommelig als er veel kolommen tussen aanhalingstekens moeten staan, of als er aanhalingstekens in de resultaten staan die moeten worden escaped.

Antwoord 1, autoriteit 100%

Van Sla MySQL-queryresultaten op in een tekst- of CSV-bestand:

SELECT order_id,product_name,qty
FROM orders
WHERE foo = 'bar'
INTO OUTFILE '/var/lib/mysql-files/orders.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';

Opmerking: die syntaxis moet mogelijk opnieuw worden geordend om

SELECT order_id,product_name,qty
INTO OUTFILE '/var/lib/mysql-files/orders.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM orders
WHERE foo = 'bar';

in recentere versies van MySQL.

Met deze opdracht worden kolomnamen niet geëxporteerd.

Houd er ook rekening mee dat /var/lib/mysql-files/orders.csvzich op de serverbevindt waarop MySQL draait. De gebruiker onder wie het MySQL-proces wordt uitgevoerd, moet machtigingen hebben om naar de gekozen map te schrijven, anders mislukt de opdracht.

Als u uitvoer naar uw lokale machine wilt schrijven van een externe server (vooral een gehoste of virtualiseerde machine zoals Heroku of Amazon rds ), is deze oplossing niet geschikt.

Antwoord 2, Autoriteit 27%

mysql your_database --password=foo < my_requests.sql > out.csv

die tab gescheiden is. Pijp het zo leuk om een echte CSV te krijgen (bedankt Gebruiker John Carter ):

... .sql | sed 's/\t/,/g' > out.csv

Antwoord 3, Autoriteit 12%

MySQL – –Batch, -B

Afdrukresultaten met behulp van het tabblad als kolomscheider, met elke rij op een
nieuwe lijn. Met deze optie gebruikt MySQL het geschiedenisbestand niet.
Batch-modus resulteert in niet-tabeluitgangsformaat en ontsnappen
Speciale tekens. Ontsnappen kan worden uitgeschakeld met behulp van de onbewerkte modus; zien
de beschrijving voor de –RAW-optie.

Hiermee geeft u een tabbladscheidend bestand. Omdat komma’s (of snaren die komma’s bevatten) niet zijn ontsnapt, is het niet eenvoudig om het scheidingsteken te veranderen in komma’s.

Antwoord 4, Autoriteit 9%

Hier is een vrij gnarly manier om het te doen ^{[1] :}

mysql --user=wibble --password wobble -B -e "select * from vehicle_categories;" | sed "s/'/'/;s/\t/","/g;s/^/"/;s/$/"/;s/\n//g" > vehicle_categories.csv

Het werkt redelijk goed. Nogmaals, hoewel, een reguliere uitdrukking bewijst alleen.

Regex Explanation:

s/// betekent vervangen wat tussen de eerste // staat door wat tussen de tweede staat //
de “g” aan het einde is een modifier die “alle instanties, niet alleen eerst” betekent
^ (in deze context) betekent begin van regel
$ (in deze context) betekent einde regel

Dus alles bij elkaar:

s/'/\'/          Replace ' with \'
s/\t/\",\"/g     Replace all \t (tab) with ","
s/^/\"/          at the beginning of the line place a "
s/$/\"/          At the end of the line, place a "
s/\n//g          Replace all \n (newline) with nothing

^{[1] Ik heb het ergens gevonden en kan geen krediet opeisen.}

Antwoord 5, autoriteit 6%

Leid het door ‘tr’ (alleen Unix/Cygwin):

mysql <database> -e "<query here>" | tr '\t' ',' > data.csv

NB: dit behandelt geen ingesloten komma’s of ingesloten tabbladen.

Antwoord 6, autoriteit 4%

Dit heeft me een paar keer gered. Het is snel en het werkt!

–batch
Druk resultaten af met tabals kolomscheidingsteken, met elke rij op a
nieuwe regel.

–rawschakelt escape-tekens uit (\n, \t, \0 en \)

Voorbeeld:

mysql -udemo_user -p -h127.0.0.1 --port=3306 \
   --default-character-set=utf8mb4 --database=demo_database \
   --batch --raw < /tmp/demo_sql_query.sql > /tmp/demo_csv_export.tsv

Voor de volledigheid kunt u converteren naar CSV(maar wees voorzichtigomdat er tabbladen in veldwaarden – bijv. tekstvelden)

tr '\t' ',' < file.tsv > file.csv

Antwoord 7, autoriteit 2%

De OUTFILE-oplossing gegeven door Paul Tomblinzorgt ervoor dat een bestand op de MySQL-server zelf wordt geschreven, dus dit werkt alleen als je BESTAND-toegang, evenals inlogtoegang of andere middelen om het bestand uit die box op te halen.

Als u dergelijke toegang niet hebt en door tabs gescheiden uitvoer een redelijk alternatief is voor CSV (bijvoorbeeld als uw einddoel is om naar Excel te importeren), dan serbaut’s oplossing(met behulp van mysql --batchen optioneel is --raw) de juiste keuze.

Antwoord 8, autoriteit 2%

MySQL Workbenchkan recordsets exporteren naar CSV en lijkt komma’s in velden te verwerken erg goed. De CSV wordt geopend in OpenOffice Calcprima.

Antwoord 9, autoriteit 2%

Gebruik:

mysql your_database -p < my_requests.sql | awk '{print $1","$2}' > out.csv

Antwoord 10, autoriteit 2%

Alle oplossingen hier tot nu toe, behalve de MySQL Workbench-versie, zijn onjuist en mogelijk onveilig (dat wil zeggen beveiligingsproblemen) voor ten minste een deel van de mogelijke inhoud in de MySQL-database.

MySQL Workbench (en op dezelfde manier phpMyAdmin) bieden een formeel correcte oplossing, maar ze zijn ontworpen voor het downloaden van de uitvoer naar de locatie van een gebruiker. Ze zijn niet zo handig voor zaken als het automatiseren van gegevensexport.

Het is niet mogelijk om betrouwbaar correcte CSV-inhoud te genereren uit de uitvoer van mysql -B -e 'SELECT ...'omdat dat geen regelterugloop en witruimte in velden kan coderen. De ‘-s’ vlag naar mysqldoet backslash escapen, en kan leiden tot een correcte oplossing. Het is echter veel veiliger om een scripttaal te gebruiken (een met degelijke interne datastructuren, dus niet Bash), en bibliotheken waar de coderingsproblemen al zorgvuldig zijn uitgewerkt.

Ik dacht erover om hier een script voor te schrijven, maar zodra ik erover nadacht hoe ik het zou noemen, kwam het bij me op om te zoeken naar reeds bestaand werk met dezelfde naam. Hoewel ik het niet grondig heb doorgenomen, ziet mysql2csver veelbelovend uit. Afhankelijk van uw toepassing, kan de YAML-benadering voor het specificeren van de SQL-opdrachten wel of niet aantrekkelijk zijn. Ik ben ook niet enthousiast over de vereiste voor een recentere versie van Ruby dan standaard wordt geleverd met mijn Ubuntu 12.04(Precise Pangolin) laptop of Debian 6.0(Squeeze)-servers. Ja, ik weet dat ik RVM zou kunnen gebruiken, maar ik zou dat liever niet onderhouden voor zo’n eenvoudig doel.

Antwoord 11, autoriteit 2%

Veel van de antwoorden op deze pagina zijn zwak, omdat ze niet het algemene geval behandelen van wat er kan gebeuren in CSV-formaat. Bijvoorbeeld komma’s en aanhalingstekens die zijn ingesloten in velden en andere voorwaarden die uiteindelijk altijd naar voren komen. We hebben een algemene oplossing nodig die werkt voor alle geldige CSV-invoergegevens.

Hier is een eenvoudige en sterke oplossing in Python:

#!/usr/bin/env python
import csv
import sys
tab_in = csv.reader(sys.stdin, dialect=csv.excel_tab)
comma_out = csv.writer(sys.stdout, dialect=csv.excel)
for row in tab_in:
    comma_out.writerow(row)

Noem dat bestand tab2csv, plaats het op je pad, geef het uitvoeringsrechten en gebruik het als volgt:

mysql OTHER_OPTIONS --batch --execute='select * from whatever;' | tab2csv > outfile.csv

De Python CSV-afhandelingsfuncties dekken hoekgevallen voor CSV-invoerformat(en).

Dit kan worden verbeterd om zeer grote bestanden te verwerken via een streamingbenadering.

Antwoord 12

Vanaf uw opdrachtregel kunt u dit doen:

mysql -h *hostname* -P *port number* --database=*database_name* -u *username* -p -e *your SQL query* | sed 's/\t/","/g;s/^/"/;s/$/"/;s/\n//g' > *output_file_name.csv*

Credits:Tabel exporteren van Amazon RDS naar een CSV-bestand

Antwoord 13

Logica:

CREATE TABLE () (SELECT data FROM other_table ) ENGINE=CSV  ;

Als u een CSV-tabel aanmaakt, maakt de server een bestand met tabelindeling in
de databasedirectory. Het bestand begint met de tabelnaam en heeft een
.frm-extensie. De opslagengine maakt ook een gegevensbestand aan. Zijn naam
begint met de tabelnaam en heeft de extensie .CSV. Het gegevensbestand is
een gewoon tekstbestand. Wanneer u gegevens in de tabel opslaat, wordt de opslag
engine slaat het op in het gegevensbestand in door komma’s gescheiden waarden.

Antwoord 14

Dit antwoord maakt gebruik van Python en een populaire bibliotheek van derden, pymysql . Ik voeg het toe omdat Python’s CSV bibliotheek is krachtig genoeg voor correct Verhaal veel verschillende smaken van .csven geen andere antwoorden gebruiken Python-code om met de database te communiceren.

import contextlib
import csv
import datetime
import os
# https://github.com/PyMySQL/PyMySQL
import pymysql
SQL_QUERY = """
SELECT * FROM my_table WHERE my_attribute = 'my_attribute';
"""
# embedding passwords in code gets nasty when you use version control
# the environment is not much better, but this is an example
# https://stackoverflow.com/questions/12461484
SQL_USER = os.environ['SQL_USER']
SQL_PASS = os.environ['SQL_PASS']
connection = pymysql.connect(host='localhost',
                             user=SQL_USER,
                             password=SQL_PASS,
                             db='dbname')
with contextlib.closing(connection):
    with connection.cursor() as cursor:
        cursor.execute(SQL_QUERY)
        # Hope you have enough memory :)
        results = cursor.fetchall()
output_file = 'my_query-{}.csv'.format(datetime.datetime.today().strftime('%Y-%m-%d'))
with open(output_file, 'w', newline='') as csvfile:
    # http://stackoverflow.com/a/17725590/2958070 about lineterminator
    csv_writer = csv.writer(csvfile, lineterminator='\n')
    csv_writer.writerows(results)

Antwoord 15

Dit is eenvoudig en het werkt aan alles zonder batchmodus of uitvoerbestanden te hebben:

select concat_ws(',',
    concat('"', replace(field1, '"', '""'), '"'),
    concat('"', replace(field2, '"', '""'), '"'),
    concat('"', replace(field3, '"', '""'), '"'))
from your_table where etc;

Uitleg:

Vervang "door ""in elk veld –> replace(field1, '"', '""')
Stuur elk resultaat tussen aanhalingstekens –> concat('"', result1, '"')
Plaats een komma tussen elk geciteerd resultaat –> concat_ws(',', quoted1, quoted2, ...)

Dat is het!

Antwoord 16

Als je de query uitvoert op de Bash-opdrachtregel, geloof ik dat de opdracht trkan worden gebruikt om de standaardtabs te vervangen door willekeurige scheidingstekens.

$ echo "SELECT * FROM Table123" | mysql Database456 | tr "\t" ,

Antwoord 17

U kunt een MySQL-tabel hebben die de CSV-engine gebruikt.

Dan heb je een bestand op je harde schijf dat altijd in CSV-indeling is en dat je gewoon kunt kopiëren zonder het te verwerken.

Antwoord 18

Ik kwam hetzelfde probleem tegen en Paul’s Answerwas geen optie omdat het Amazon RDS. Het vervangen van het tabblad door de komma’s werkte niet omdat de gegevens ingesloten komma’s en tabbladen hadden. Ik ontdekte dat mycli, een drop-in alternatief voor de mysql-client, CSV-uitvoer ondersteunt vanuit het vak met de vlag --csv:

mycli db_name --csv -e "select * from flowers" > flowers.csv

Antwoord 19

Om uit te breiden op eerdere antwoorden, exporteert de volgende one-liner een enkele tabel als een tabbladeerd bestand. Het is geschikt voor automatisering, het exporteren van de database elke dag of zo.

mysql -B -D mydatabase -e 'select * from mytable'

Handig, we kunnen dezelfde techniek gebruiken om de tabellen van MySQL te vermelden en om de velden op een enkele tabel te beschrijven:

mysql -B -D mydatabase -e 'show tables'
mysql -B -D mydatabase -e 'desc users'
Field   Type    Null    Key Default Extra
id  int(11) NO  PRI NULL    auto_increment
email   varchar(128)    NO  UNI NULL    
lastName    varchar(100)    YES     NULL    
title   varchar(128)    YES UNI NULL    
userName    varchar(128)    YES UNI NULL    
firstName   varchar(100)    YES     NULL

Antwoord 20

Hier is wat ik doe:

echo $QUERY | \
  mysql -B  $MYSQL_OPTS | \
  perl -F"\t" -lane 'print join ",", map {s/"/""/g; /^[\d.]+$/ ? $_ : qq("$_")} @F ' | \
  mail -s 'report' person@address

Het PERL-script (geknipt van elders) doet een mooie taak om het tabblad op afstand van elkaar te converteren naar CSV.

Antwoord 21

Gebouw op User7610, hier is de beste manier om het te doen. Met mysql outfileEr waren 60 minuten bestanden eigendom en het overschrijven van problemen.

Het is niet cool, maar het werkte in 5 minuten.

php csvdump.php localhost root password database tablename > whatever-you-like.csv

<?php
$server = $argv[1];
$user = $argv[2];
$password = $argv[3];
$db = $argv[4];
$table = $argv[5];
mysql_connect($server, $user, $password) or die(mysql_error());
mysql_select_db($db) or die(mysql_error());
// fetch the data
$rows = mysql_query('SELECT * FROM ' . $table);
$rows || die(mysql_error());
// create a file pointer connected to the output stream
$output = fopen('php://output', 'w');
// output the column headings
$fields = [];
for($i = 0; $i < mysql_num_fields($rows); $i++) {
    $field_info = mysql_fetch_field($rows, $i);
    $fields[] = $field_info->name;
}
fputcsv($output, $fields);
// loop over the rows, outputting them
while ($row = mysql_fetch_assoc($rows)) fputcsv($output, $row);
?>

Antwoord 22

Niet precies als een CSV-indeling, maar de teecommandovan de MySQL clientkan worden gebruikt om de uitvoer op te slaan in een lokaalbestand:

tee foobar.txt
SELECT foo FROM bar;

Je kunt het uitschakelen met notee.

Het probleem met SELECT … INTO OUTFILE …;is dat er toestemming nodig is om bestanden op de server te schrijven.

Antwoord 23

Wat voor mij werkte:

SELECT *
FROM students
WHERE foo = 'bar'
LIMIT 0,1200000
INTO OUTFILE './students-1200000.csv'
FIELDS TERMINATED BY ',' ESCAPED BY '"'
ENCLOSED BY '"'
LINES TERMINATED BY '\r\n';

Geen van de oplossingen in deze thread werkte voor mijn specifieke geval. Ik had mooie JSON-gegevens in een van de kolommen, die in mijn CSV-uitvoer in de war zouden raken. Voor degenen met een soortgelijk probleem, probeer in plaats daarvan regels die eindigen op \r\n.

Ook een ander probleem voor degenen die de CSV proberen te openen met Microsoft Excel, houd er rekening mee dat er een limiet is van 32.767 tekens die een enkele cel kan bevatten, daarboven loopt het over naar de onderstaande rijen. Gebruik de onderstaande query om te bepalen welke records in een kolom het probleem hebben. U kunt die records vervolgens afkappen of ze behandelen zoals u wilt.

SELECT id,name,CHAR_LENGTH(json_student_description) AS 'character length'
FROM students
WHERE CHAR_LENGTH(json_student_description)>32767;

Antwoord 24

Met behulp van de oplossing gepost door Tim Harding, ik heb dit Bash-script gemaakt om het proces te vergemakkelijken (root-wachtwoord wordt gevraagd, maar je kunt het script eenvoudig aanpassen om naar een andere gebruiker te vragen):

#!/bin/bash
if [ "$1" == "" ];then
    echo "Usage: $0 DATABASE TABLE [MYSQL EXTRA COMMANDS]"
    exit
fi
DBNAME=$1
TABLE=$2
FNAME=$1.$2.csv
MCOMM=$3
echo "MySQL password: "
stty -echo
read PASS
stty echo
mysql -uroot -p$PASS $MCOMM $DBNAME -B -e "SELECT * FROM $TABLE;" | sed "s/'/\'/;s/\t/\",\"/g;s/^/\"/;s/$/\"/;s/\n//g" > $FNAME

Het maakt een bestand aan met de naam: database.table.csv

Antwoord 25

Als je PHP op de server hebt ingesteld, kun je mysql2csvgebruiken om een (eigenlijk geldig) CSV-bestand voor een willekeurige MySQL-query. Zie mijn antwoord op MySQL – SELECT * INTO OUTFILE LOCAL?voor wat meer context/info.

Ik heb geprobeerd de optienamen van mysqlte behouden, dus het zou voldoende moeten zijn om de opties --fileen --queryte geven:

./mysql2csv --file="/tmp/result.csv" --query='SELECT 1 as foo, 2 as bar;' --user="username" --password="password"

“Installeer” mysql2csvvia

wget https://gist.githubusercontent.com/paslandau/37bf787eab1b84fc7ae679d1823cf401/raw/29a48bb0a43f6750858e1ddec054d3552f3cbc45/mysql2csv -O mysql2csv -q && (sha256sum mysql2csv | cmp <(echo "b109535b29733bd596ecc8608e008732e617e97906f119c66dd7cf6ab2865a65  mysql2csv") || (echo "ERROR comparing hash, Found:" ;sha256sum mysql2csv) ) && chmod +x mysql2csv

(Download inhoud van de essentie, controleer de checksum en maak deze uitvoerbaar.)

Antwoord 26

Het volgende levert door tabs gescheiden en geldigeCSV-uitvoer op. In tegenstelling tot de meeste andere antwoorden, behandelt deze techniek het ontsnappen van tabs, komma’s, aanhalingstekens en nieuwe regels correct zonder een streamfilter zoals sed, AWKof tr.

Het voorbeeld laat zien hoe u een externe MySQL-tabel rechtstreeks in een lokale SQLite-database kunt pipen stromen. Dit werkt zonder FILE-toestemming of SELECT INTO OUTFILE-toestemming. Ik heb nieuwe regels toegevoegd voor de leesbaarheid.

mysql -B -C --raw -u 'username' --password='password' --host='hostname' 'databasename'
-e 'SELECT
    CONCAT('\''"'\'',REPLACE(`id`,'\''"'\'', '\''""'\''),'\''"'\'') AS '\''id'\'',
    CONCAT('\''"'\'',REPLACE(`value`,'\''"'\'', '\''""'\''),'\''"'\'') AS '\''value'\''
    FROM sampledata'
2>/dev/null | sqlite3 -csv -separator $'\t' mydb.db '.import /dev/stdin mycsvtable'

De 2>/dev/nullis nodig om de waarschuwing over het wachtwoord op de opdrachtregel te onderdrukken.

Als uw gegevens NULL’s hebben, kunt u de functie IFNULL() in de query gebruiken.

Antwoord 27

Als u een foutmelding krijgt van secure-file-priv, ook nadat u de locatie van uw bestemmingsbestand hebt verplaatst naar de C:\ProgramData\MySQL\MySQL Server 8.0\Uploadsen ook daarna de vraag –

SELECT * FROM attendance INTO OUTFILE 'C:\ProgramData\MySQL\MySQL Server 8.0\Uploads\FileName.csv' FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '\n';

werkt niet, je moet gewoon \(backsplash) van de zoekopdracht wijzigen in /(forwardsplash)

En dat werkt!!

Voorbeeld:

SELECTEER * VAN aanwezigheid IN OUTFILE ‘C:/ProgramData/MySQL/MySQL Server 8.0/Uploads/FileName.csv’ VELDEN BEINDIGD DOOR ‘,’ INGESLOTEN DOOR ”’ REGELS BEINDIGD DOOR ‘\n’;

Elke keer dat u de succesvolle query uitvoert, wordt elke keer het nieuwe CSV-bestand gegenereerd!
Cool, toch?

Antwoord 28

In mijn geval geeft from table_name ..... voordat INTO OUTFILE ..... een foutmelding:

Onverwachte volgorde van clausules. (bij “FROM” op positie 10)

Wat voor mij werkt:

SELECT *
INTO OUTFILE '/Volumes/Development/sql/sql/enabled_contacts.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM table_name
WHERE column_name = 'value'

Antwoord 29

Tiny Bash-script voor eenvoudige vraag naar CSV Dumps, geïnspireerd door Het antwoord van Tim Harding .

#!/bin/bash
# $1 = query to execute
# $2 = outfile
# $3 = mysql database name
# $4 = mysql username
if [ -z "$1" ]; then
    echo "Query not given"
    exit 1
fi
if [ -z "$2" ]; then
    echo "Outfile not given"
    exit 1
fi
MYSQL_DB=""
MYSQL_USER="root"
if [ ! -z "$3" ]; then
    MYSQL_DB=$3
fi
if [ ! -z "$4" ]; then
    MYSQL_USER=$4
fi
if [ -z "$MYSQL_DB" ]; then
    echo "Database name not given"
    exit 1
fi
if [ -z "$MYSQL_USER" ]; then
    echo "Database user not given"
    exit 1
fi
mysql -u $MYSQL_USER -p -D $MYSQL_DB -B -s -e "$1" | sed "s/'/\'/;s/\t/\",\"/g;s/^/\"/;s/$/\"/;s/\n//g" > $2
echo "Written to $2"

ANTWOORD 30

Het volgende bash-script werkt voor mij. Het krijgt eventueel ook het schema voor de gevraagde tabellen.

#!/bin/bash
#
# Export MySQL data to CSV
#https://stackoverflow.com/questions/356578/how-to-output-mysql-query-results-in-csv-format
#
# ANSI colors
#http://www.csc.uvic.ca/~sae/seng265/fall04/tips/s265s047-tips/bash-using-colors.html
blue='\033[0;34m'
red='\033[0;31m'
green='\033[0;32m' # '\e[1;32m' is too bright for white bg.
endColor='\033[0m'
#
# A colored message
#   params:
#     1: l_color - the color of the message
#     2: l_msg - the message to display
#
color_msg() {
  local l_color="$1"
  local l_msg="$2"
  echo -e "${l_color}$l_msg${endColor}"
}
#
# Error
#
# Show the given error message on standard error and exit
#
#   Parameters:
#     1: l_msg - the error message to display
#
error() {
  local l_msg="$1"
  # Use ANSI red for error
  color_msg $red "Error:" 1>&2
  color_msg $red "\t$l_msg" 1>&2
  usage
}
#
# Display usage
#
usage() {
  echo "usage: $0 [-h|--help]" 1>&2
  echo "               -o  | --output      csvdirectory"    1>&2
  echo "               -d  | --database    database"   1>&2
  echo "               -t  | --tables      tables"     1>&2
  echo "               -p  | --password    password"   1>&2
  echo "               -u  | --user        user"       1>&2
  echo "               -hs | --host        host"       1>&2
  echo "               -gs | --get-schema"             1>&2
  echo "" 1>&2
  echo "     output: output CSV directory to export MySQL data into" 1>&2
  echo "" 1>&2
  echo "         user: MySQL user" 1>&2
  echo "     password: MySQL password" 1>&2
  echo "" 1>&2
  echo "     database: target database" 1>&2
  echo "       tables: tables to export" 1>&2
  echo "         host: host of target database" 1>&2
  echo "" 1>&2
  echo "  -h|--help: show help" 1>&2
  exit 1
}
#
# show help
#
help() {
  echo "$0 Help" 1>&2
  echo "===========" 1>&2
  echo "$0 exports a CSV file from a MySQL database optionally limiting to a list of tables" 1>&2
  echo "   example: $0 --database=cms --user=scott --password=tiger  --tables=person --output person.csv" 1>&2
  echo "" 1>&2
  usage
}
domysql() {
  mysql --host $host -u$user --password=$password $database
}
getcolumns() {
  local l_table="$1"
  echo "describe $l_table" | domysql | cut -f1 | grep -v "Field" | grep -v "Warning" | paste -sd "," - 2>/dev/null
}
host="localhost"
mysqlfiles="/var/lib/mysql-files/"
# Parse command line options
while true; do
  #echo "option $1"
  case "$1" in
    # Options without arguments
    -h|--help) usage;;
    -d|--database)     database="$2" ; shift ;;
    -t|--tables)       tables="$2" ; shift ;;
    -o|--output)       csvoutput="$2" ; shift ;;
    -u|--user)         user="$2" ; shift ;;
    -hs|--host)        host="$2" ; shift ;;
    -p|--password)     password="$2" ; shift ;;
    -gs|--get-schema)  option="getschema";;
    (--) shift; break;;
    (-*) echo "$0: error - unrecognized option $1" 1>&2; usage;;
    (*) break;;
  esac
  shift
done
# Checks
if [ "$csvoutput" == "" ]
then
  error "output CSV directory is not set"
fi
if [ "$database" == "" ]
then
  error "MySQL database is not set"
fi
if [ "$user" == "" ]
then
  error "MySQL user is not set"
fi
if [ "$password" == "" ]
then
  error "MySQL password is not set"
fi
color_msg $blue "exporting tables of database $database"
if [ "$tables" = "" ]
then
tables=$(echo "show tables" | domysql)
fi
case $option in
  getschema)
   rm $csvoutput$database.schema
   for table in $tables
   do
     color_msg $blue "getting schema for $table"
     echo -n "$table:" >> $csvoutput$database.schema
     getcolumns $table >> $csvoutput$database.schema
   done
   ;;
  *)
for table in $tables
do
  color_msg $blue "exporting table $table"
  cols=$(grep "$table:" $csvoutput$database.schema | cut -f2 -d:)
  if [  "$cols" = "" ]
  then
    cols=$(getcolumns $table)
  fi
  ssh $host rm $mysqlfiles/$table.csv
cat <<EOF | mysql --host $host -u$user --password=$password $database
SELECT $cols FROM $table INTO OUTFILE '$mysqlfiles$table.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';
EOF
  scp $host:$mysqlfiles/$table.csv $csvoutput$table.csv.raw
  (echo "$cols"; cat $csvoutput$table.csv.raw) > $csvoutput$table.csv
  rm $csvoutput$table.csv.raw
done
  ;;
esac

Hoe kan ik MySQL-queryresultaten in CSV-indeling uitvoeren?