Como a saída do MySQL resultados da consulta em formato CSV?

https://stackoverflow.com/questions/356578

21-08-2019
|

Pergunta

Existe uma maneira fácil de executar uma consulta MySQL a partir da linha de comando do Linux e saída dos resultados em formato CSV ?

Aqui está o que eu estou fazendo agora:

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

Ele fica confuso quando há um grande número de colunas que precisam estar entre aspas, ou se existem citações nos resultados que precisam ser escapado.

Solução

De http://www.tech-recipes.com/rx/1475/save-mysql-query-results-into-a-text-or-csv-file/

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';

Usando este colunas comando nomes não serão exportados.

Observe também que /var/lib/mysql-files/orders.csv estará no MySQL servidor que está sendo executado. O usuário que o processo de MySQL está sendo executado em deve ter permissões para escrever para o diretório escolhido, ou o comando falhará.

Se você quiser saída escrita para sua máquina local de um servidor remoto (especialmente uma máquina hospedado ou Virtualizar como Heroku ou Amazon RDS), esta solução não é adequada.

Outras dicas

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

O que é guia separada. Canalizá-lo como que para obter uma verdadeira CSV (graças @therefromhere):

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

mysql --batch, -B

Os resultados de impressão usando tab como o separador de colunas, com cada linha em um nova linha. Com esta opção, o MySQL não utiliza o arquivo de histórico. Resultados de modo descontínuo em formato de saída não tabulares e de escapar caracteres especiais. Escapar pode ser desactivado através da utilização modo bruto; Vejo a descrição para a opção --raw.

Isto lhe dará um arquivo guia separada. Desde vírgulas (ou strings contendo vírgula) não são escapou, não é simples para alterar o delimitador de vírgula.

Aqui está uma maneira bastante gnarly de fazê-lo. Encontrado em algum lugar, não pode tomar qualquer crédito

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

funciona muito bem. Mais uma vez, embora um regex prova escrita única.

Regex Explicação:

s /// meios substituto que está entre o primeiro // com o que está entre o segundo //
o "g" no final é um modificador que significa "todas as instâncias, não apenas em primeiro lugar"
^ (neste contexto) meios início da linha
$ (neste contexto) significa o fim da linha

Então, juntando tudo:

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

Unix / Cygwin somente, canalizá-lo através de 'tr':

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

NB .: Este alças nem vírgulas incorporadas, nem guias embutidos.

Esta me salvou um par de vezes. Rápido e funciona!

--batch Imprimir resultados usando como o separador de colunas, com cada linha em um nova linha.

--raw < em> caráter desativa escapar (\ n \ t, \ 0 e \)

Exemplo:

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

Para completar você poderia convertido ao csv (mas ter cuidado porque guias poderia estar dentro valores de campo - por exemplo, campos de texto)

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

A solução OUTFILE dado por Paul Tomblin faz com que um arquivo a ser gravado no servidor MySQL em si, de modo que este só funcionará se você tiver acesso ao arquivo , bem como o acesso de login ou outros meios para recuperar o arquivo de caixa.

Se você não tem esse acesso e saída delimitado por tabulações é um substituto razoável para CSV (por exemplo, se o seu objetivo final é a importação para o Excel), então a solução da Serbaut (usando mysql --batch e, opcionalmente, --raw) é o caminho para ir.

MySQL Workbench pode exportar registros para CSV, e parece para lidar com vírgulas em campos muito bem. O CSV abre em OpenOffice bem.

Como sobre: ??

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

Todas as soluções aqui, até à data, exceto o MySQL bancada, estão incorretas e possivelmente insegura (ou seja, as questões de segurança) para pelo menos algum conteúdo possível no db mysql.

MySQL Workbench (e da mesma forma PHPMyAdmin) fornecer uma solução formalmente correta, mas são projetados para transferir a saída para a localização de um usuário. Eles não são tão útil para coisas como automatizar a exportação de dados.

Não é possível gerar CSV confiável correta a partir da saída de mysql -B -e 'SELECT ...' porque isso não pode codificar retornos de carro e espaço em branco nos campos. A bandeira '-s' para mysql faz barra invertida escapar, e poderá conduzir a uma solução correta. No entanto, usando uma linguagem de script (um com estruturas decentes internas de dados que é, não bash), e bibliotecas, onde os problemas de codificação já foram cuidadosamente trabalhados é muito mais seguro.

Eu pensei em escrever um script para isso, mas assim que eu pensei sobre o que eu chamaria, ocorreu-me para procurar trabalho pré-existente com o mesmo nome. Embora eu não tenha ido mais-lo completamente, a solução em https://github.com/robmiller/mysql2csv parece promissor. Dependendo da sua aplicação, a abordagem yaml a especificar os comandos SQL pode ou não apelar embora. Eu também não estou emocionado com a exigência de uma versão mais recente de rubi que vem como padrão com o meu laptop Ubuntu 12.04 ou servidores Squeeze Debian. Sim, eu sei que eu poderia usar RVM, mas eu prefiro não manter isso para um propósito tão simples.

Esperemos que alguém irá apontar uma ferramenta adequada, que teve um pouco de testes. Caso contrário, eu provavelmente vou atualizar isso quando eu encontrar ou uma gravação.

A partir da sua linha de comando, você pode fazer isso:

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*

Créditos: Exportando da Amazon RDS para um arquivo CSV

Muitas das respostas nesta página são fracos porque eles não lidar com o caso geral do que pode ocorrer no formato CSV. por exemplo. vírgulas e aspas embutido em campos e outras condições que sempre surgem eventualmente. Precisamos de uma solução geral que funciona para todos os dados de entrada CSV válido.

Aqui está uma solução simples e forte em 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)

Nome que tab2csv arquivo, colocá-lo em seu caminho, dar-lhe permissões de execução, em seguida, usá-lo como este:

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

As funções Python CSV-manuseamento cobrir casos de canto para formato CSV de entrada (s).

Esta poderia ser melhorado para lidar com arquivos muito grandes através de uma abordagem de streaming.

lógica:

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

Quando você cria uma tabela CSV, o servidor cria um arquivo de formato de tabela em o diretório de banco de dados. O arquivo começa com o nome da tabela e tem um extensão .frm. O mecanismo de armazenamento também cria um arquivo de dados. seu nome começa com o nome da tabela e tem uma extensão .csv. O arquivo de dados é um arquivo de texto simples. Quando você armazena dados na tabela, o armazenamento motor de poupa-lo para o arquivo de dados em formato de valores separados por vírgulas.

Esta é simples, e funciona em qualquer coisa sem a necessidade de arquivos de modo de lote ou de saída:

select concat_ws(',',
    concat('"', replace(field1, '"', '""'), '"'),
    concat('"', replace(field2, '"', '""'), '"'),
    concat('"', replace(field3, '"', '""'), '"'))

from your_table where etc;

Explicação:

Substitua " com "" em cada campo -> replace(field1, '"', '""')
Surround cada resultado entre aspas -> concat('"', result1, '"')
Coloque uma vírgula entre cada resultado citado -> concat_ws(',', quoted1, quoted2, ...)

É isso aí!

Esta resposta usa Python e uma biblioteca de terceiros popular, PyMySQL . Eu estou adicionando-o porque csv biblioteca do Python é poderoso o suficiente para corretamente lidar com muitos sabores diferentes de .csv e há outras respostas estão usando o código Python para interagir com o banco de dados.

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)

Como alternativa para a resposta acima, você pode ter uma tabela MySQL que usa o motor CSV.

Em seguida, você terá um arquivo no seu disco rígido que estará sempre em um formato CSV que você pode simplesmente copiar sem processá-lo.

Para expandir em respostas anteriores, as exportações one-liner após uma única tabela como um arquivo separado por tabulações. É adequado para automação, exportando a base de dados todos os dias ou assim.

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

Convenientemente, podemos usar a mesma técnica para listar tabelas do MySQL, e para descrever os campos em uma única tabela:

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

Além disso, se você está executando a consulta na linha de comando Bash, acredito que o comando tr pode ser usado para substituir as guias padrão para delimitadores arbitrários.

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

Com base user7610, aqui é a melhor maneira de fazê-lo. Com mysql outfile havia 60 minutos de propriedade do arquivo e problemas de substituição.

Não é legal, mas funcionou em 5 minutos.

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);

?>

Aqui está o que eu faço:

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

O script perl (sniped de outros lugares) faz um bom trabalho de converter os campos da guia espaçados para CSV.

Não é exatamente como um formato CSV, mas o comando tee da MySQL cliente pode ser usado para salvar a saída em um Local arquivo:

tee foobar.txt
SELECT foo FROM bar;

Você pode desativá-lo usando notee.

O problema com SELECT … INTO OUTFILE …; é que ele requer permissão para arquivos de gravação no servidor.

Usando a solução postado por Tim, eu criei este script bash para facilitar o processo (senha de root é solicitada, mas você pode modificar o script facilmente para pedir qualquer outro usuário):

#!/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

Ele vai criar um arquivo chamado: database.table.csv

Se você tem PHP configurado no servidor, você pode usar mysql2csv para exportar um (na verdade, válido) arquivo CSV para uma consulta de mysql abitrary. Consulte minha resposta no MySQL -?. SELECT * INTO OUTFILE LOCAL para um pouco mais de contexto / info

Eu tentei manter os nomes das opções de mysql por isso deve ser suficiente para fornecer as opções --file e --query:

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

"Instalar" mysql2csv via

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 de conteúdo da essência, soma de verificação e torná-lo executável).

O que funcionou para mim:

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';

Nenhuma das soluções sobre esta discussão trabalhou para o meu caso particular, eu tinha de dados bonitas JSON dentro de uma das colunas, que iria ficar confuso na minha saída CSV. Para aqueles com um problema semelhante, tentar linhas terminadas por \ r \ n vez.

Também outro problema para aqueles que tentam abrir o CSV com o Microsoft Excel, tenha em mente que há um limite de 32.767 caracteres que uma única célula pode conter, acima, que transborda para as linhas abaixo. Para identificar quais registros em uma coluna tem o problema, use a consulta abaixo. Você pode, em seguida, truncar os registros ou tratá-los como você gostaria.

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

script bash minúsculo para fazer consulta simples para CSV lixeiras, inspirado por https://stackoverflow.com/a/5395421/2841607 .

#!/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"

Tente este código:

SELECT 'Column1', 'Column2', 'Column3', 'Column4', 'Column5'
UNION ALL
SELECT column1, column2,
column3 , column4, column5 FROM demo
INTO OUTFILE '/tmp/demo.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';

Para mais informações: http: //dev.mysql .com / doc / refman / 5.1 / en / select-into.html

O seguinte script bash funciona para mim. É opcionalmente também recebe o esquema para as tabelas solicitadas.

#!/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 stderr and exit
#
#   params:
#     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 "ouput csv directory not set"
fi
if [ "$database" == "" ]
then
  error "mysql database not set"
fi
if [ "$user" == "" ]
then
  error "mysql user not set"
fi
if [ "$password" == "" ]
then
  error "mysql password 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

Se houver PHP instalado na máquina que você está usando, você pode escrever um script PHP para fazer isso. Ela exige a instalação PHP tem a extensão MySQL instalado.

Você pode chamar o intérprete PHP na linha de comando da seguinte forma:

php --php-ini path/to/php.ini your-script.php

Estou incluindo o interruptor --php-ini, porque você pode precisar usar sua própria configuração do PHP, que permite a extensão MySQL. No PHP 5.3.0+ essa extensão é ativado por padrão, de modo que não é mais necessário usar a configuração para permitir que seja.

Em seguida, você pode escrever seu script de exportação como qualquer script PHP normal:

<?php
    #mysql_connect("localhost", "username", "password") or die(mysql_error());
    mysql_select_db("mydb") or die(mysql_error());

    $result = mysql_query("SELECT * FROM table_with_the_data p WHERE p.type = $typeiwant");

    $result || die(mysql_error());

    while($row = mysql_fetch_row($result)) {
      $comma = false;
      foreach ($row as $item) {

        # Make it comma separated
        if ($comma) {
          echo ',';
        } else {
          $comma = true;
        }

        # Quote the quotes
        $quoted = str_replace("\"", "\"\"", $item);

        # Quote the string
        echo "\"$quoted\"";
      }
        echo "\n";
    }
?>

A vantagem deste método é que ele não tem problemas com varchar e texto campos, que têm de texto contendo novas linhas. Esses campos estão corretamente citado e essas novas linhas neles será interpretada pelo leitor CSV como uma parte do texto, não separadores de registro. Isso é algo que é difícil de corrigir posteriormente com sed ou assim.

A seguir produz delimitado por tabulação e válido saída CSV. Ao contrário da maioria das outras respostas, esta técnica maneja bem escapar de guias, vírgulas, citações e novas linhas sem qualquer filtro de fluxo como sed, awk, ou tr. O exemplo mostra como a tubulação de uma tabela mysql remoto diretamente em um banco de dados SQLite local usando correntes. Isso funciona sem permissão de arquivo ou permissão SELECT INTO OUTFILE. Eu adicionei novas linhas para facilitar a leitura.

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'

O 2>/dev/null é necessária para suprimir o aviso sobre a senha na linha de comando.

Se os dados tem nulos, você pode usar a função IFNULL () na consulta.

Você pode usar o comando abaixo do seu editor SQL / Terminal:

" mysql -h (hostname / IP>) -u (username) -p (password) databasename <(query.sql)> outputfile (.txt / .xls) "

por exemplo hostname -x.x.x.x

uname - nome de usuário

password - senha

DBName - employeeDB

queryfile - employee.sql

outputFile - outputFile.xls

mysql -hx.x.x.x -uusername -ppassword employeeDB outputFile.xls

Certifique-se de que você está executando o comando a partir do diretório onde consulta SQL está localizado ou mencionar o caminho completo do local de consulta SQL no comando acima.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow