MySQLDUMP - Novos atributos / opções

Nova versão do mysqldump, possui alguns defaults que podem ocasionar erros na execução. Para contornar:

1) "mysqldump: Couldn't execute 'SELECT COLUMN_NAME,                       JSON_EXTRACT(HISTOGRAM, '$."number-of-buckets-specified"')                FROM information_schema.COLUMN_STATISTIC"

usar opção --column-statistics=0

2) "mysqldump: Error: 'Access denied; you need (at least one of) the PROCESS privilege(s) for this operation' when trying to dump tablespaces"

usar opção --no-tablespaces

MySQLDUMP - Remover DEFINER

 A partir da versão 5.7.8 do MySQL é possível no mysqldump remover o DEFINER usando o parâmetro --skip-definer. Porém antes desta versão, podemos usar o SED como abaixo:

sed -i 's/DEFINER=[^*]*\*/\*/g' mydump.sql

ou 

sed -i 's/\sDEFINER=`[^`]*`@`[^`]*`//g'

Dica retirada de: https://stackoverflow.com/questions/9446783/remove-definer-clause-from-mysql-dumps

MySQL - Saída de SELECT direto em Arquivo Delimitado

 Utilizar o mysql junto com o sed.

Sintaxe com Nome das Colunas:

mysql -A -u[user] -p[senha] [banco] -e "[mysql statement];" | sed 's/\t/;/g' > [arquivo.csv]

Sintaxe sem Nome das Colunas:

mysql -AN -u[user] -p[senha] [banco] -e "[mysql statement];" | sed 's/\t/;/g' > [arquivo.csv]

Exemplo 1 - Converte o separador de <tab> para ponto-e-vírgula:

mysql -A -ueu -psenha banco -e "CALL PR_SELECIONA('202009');" | sed 's/\t/;/g' > relatorio_mes_20200930.csv &

Exemplo 2 - Sem nome das colunas e converte o separador de <tab> para ponto-e-vírgula:

mysql -NA -ueu -psenha banco -e "CALL PR_SELECIONA('202009');" | sed 's/\t/;/g' > relatorio_mes_20200930.csv &

Exemplo 3 - Converte o separador de <tab> para ponto-e-vírgula, e coloca um delimitador de campo alfanumérico

mysql -A -ueu -psenha banco -e "select t1.nu_cpfcnpj, CONCAT('<#>', t1.nm_razao_social,'<#>') razao_social, t2.nu_asset_id, t2.nu_conta_faturamento from tb_crm_customer t1 inner join tb_crm_account t2 on t2.id_customer = t1.id_customer where isnull(t2.dt_desativacao);" | sed 's/\t/;/g' | sed s/"<#>"/\"/g

MySQL - Restore de Tabela Única

Para restaurar uma única tabela de um dump MYSQL contendo diversas tabelas, pode-se usar a seguinte estratégia:

- Quando utilizar o DROP/CREATE da tabela

gzip -dc <arquivo.sql.gz> | sed -n -e '/DROP TABLE.*`<tabela>`/,/UNLOCK TABLES/p' > mytable.sql

mysql -u root -p'password' mydatabase < mytable_restore.sql

- Quando for apenas INSERT da tabela

gzip -dc <arquivo.sql.gz> | sed -n -e '/LOCK TABLES `<tabela>`/,/UNLOCK TABLES/p' > mytable.sql

mysql -u root -p'password' mydatabase < mytable_restore.sql

MySQL - Processo lento - Creating Sort Index

Quando um processo no MySQL utiliza JOIN com várias tabelas e o mesmo começa a ficar lento - apesar de estar usando as devidas chaves e no explain aparecer algo como Using where; Using join buffer (Block Nested Loop), uma alternativa é desabilitar o parâmetro block_nested_loop na sessão.

Sintaxe:

SET SESSION optimizer_switch='block_nested_loop=off';

Referências: https://dev.mysql.com/doc/refman/5.6/en/switchable-optimizations.html e https://dev.mysql.com/doc/refman/5.7/en/bnl-bka-optimization.html

MYSQLDUMP - Exemplos

Alguns exemplos de uso do mysqldump - utilitário de exportação de dados do MySQL:

Para todos os exemplos:
-h [host] - hostname/IP do estância de banco
-P [porta] - porta da estância do banco (quando diferente de 3306)
-u [usuário] - usuário de conexão
-p [password] - senha do usuário
[banco] - banco (database)
[arquivo_dump.sql] - nome do arquivo com o dump (estrutura sql)

1. Dump Completo de um banco
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] > [arquivo_dump.sql]
Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste > dump_banco_teste.sql

2. Dump de Algumas Tabelas 
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] > [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 > dump_banco_teste.sql

3. Dump sem Lock
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] --lock-tables=false --single-transaction > [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 --lock-tables=false --single-transaction > dump_banco_teste.sql

4. Dump apenas da Estrutura de Tabelas e Views - sem dados
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] --no-data > [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 --no-data > dump_banco_teste.sql

5. Dump apenas das Procedures/Functions
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] -d -t --routines > [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 -d -t --routines > dump_banco_teste.sql

6. Dump apenas da Estrutura de Tabelas e Views - sem dados e Procedures/Functions
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] --no-data > [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 --no-data --routines > dump_banco_teste.sql

7. Dump apenas dos Dados das Tabelas (Sem Informação de Create)
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] -t > [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 -t > dump_banco_teste.sql

8. Dump apenas dos Dados das Tabelas com WHERE
Sintaxe: mysqldump -h [host] -P [porta] -u [usuário] -p[password] [banco] [tabela1] [tabela2] -t --where="[condicao]"> [arquivo_dump.sql]
Onde:
[tabela1] [tabela2] - Nome das tabelas que serão extraídas

Exemplo: mysqldump -h 192.198.0.1 -P 3307 -u usuario -pminhasenha teste tab1 tab2 -t --where="valor BETWEEN 133007 AND 135167" > dump_banco_teste.sql

MySQL - Dump de Procedure e Functions Individuais

O MySQL infelizmente não permite que o dump das Procedures/Functions seja feito separado por objeto.

Para contornar isto, peguei uns scripts na Internet e acabei montando a minha versão.

Para executá-los:

./gera_dump_procedure [host/Ip] [Porta] [Usuário] [Senha] [Banco/Schema] [Procedure] [Diretório para Gravação]

./gera_dump_function [host/Ip] [Porta] [Usuário] [Senha] [Banco/Schema] [Function] [Diretório para Gravação]

Estes scripts são para rodar em ambiente bash (LINUX).

Para obter uma lista dos objetos, pode-se usar os SELECTS

SELECT CONCAT('./gera_dump_procedure.sh [host] [porta] [usuario] [senha] [banco]', ROUTINE_NAME, ' [diretorio]') exec

  FROM INFORMATION_SCHEMA.ROUTINES 

  WHERE ROUTINE_SCHEMA = '[banco]' 

   AND ROUTINE_TYPE = 'PROCEDURE'

;

SELECT CONCAT('./gera_dump_function.sh [host] [porta] [usuario] [senha] [banco]', ROUTINE_NAME, ' [diretorio]') exec

  FROM INFORMATION_SCHEMA.ROUTINES 

  WHERE ROUTINE_SCHEMA = '[banco]' 

   AND ROUTINE_TYPE = 'FUNCTION'

;

Nos SELECTs troque as informações [host] [porta] [usuario] [senha] [banco] e [diretorio] de acordo com a sua necessidade.

Script Gera_Dump_Procedure

#!/bin/bash

##---------------------------------------##

## Gera Arquivo SQL de Procedure MySQL   ##

## Parametros :                          ##

##  1 - Host (IP)                        ##

##  2 - Porta                            ##

##  3 - Usuário                          ##

##  4 - Senha                            ##

##  5 - Database/Schema                  ##

##  6 - Procedure                        ##

##  7 - Diretório                        ##

##---------------------------------------##

    if [ "$#" -ne 7 ];then

   echo "Sintaxe incorreta..."

   echo "Uso: $0 host(ip) porta usuario senha banco procedure diretorio"

   exit

    fi

HOST=${1}

PORTA=${2}

USUARIO=${3}

SENHA=${4}

BANCO=${5}

PROCEDURE=${6}

DIRETORIO=${7}

    ARQ_SAIDA="${DIRETORIO}/${PROCEDURE}.sql"

    

    echo "DROP PROCEDURE IF EXISTS ${PROCEDURE};" > ${ARQ_SAIDA}

    echo 'DELIMITER $$' >> ${ARQ_SAIDA}

    mysql -NB -h${HOST} -P${PORTA} -u ${USUARIO} -p${SENHA} ${BANCO} -e "show create procedure ${PROCEDURE}" |\

    xargs -n 1 -d '\t' echo |\

    egrep '^CREATE' |\

    xargs --null echo -e >> ${ARQ_SAIDA}

    echo '$$' >> ${ARQ_SAIDA}

    echo "DELIMITER ;" >> ${ARQ_SAIDA}

    

Script Gera_Dump_Function

#!/bin/bash

##---------------------------------------##

## Gera Arquivo SQL de Function MySQL    ##

## Parametros :                          ##

##  1 - Host (IP)                        ##

##  2 - Porta                            ##

##  3 - Usuário                          ##

##  4 - Senha                            ##

##  5 - Database/Schema                  ##

##  6 - Function                         ##

##  7 - Diretório                        ##

##---------------------------------------##

    if [ "$#" -ne 7 ];then

    echo "Sintaxe incorreta..."

    echo "Uso: $0 host(ip) porta usuario senha banco function diretorio"

    exit

    fi

HOST=${1}

PORTA=${2}

USUARIO=${3}

SENHA=${4}

BANCO=${5}

FUNCTION=${6}

DIRETORIO=${7}

    ARQ_SAIDA="${DIRETORIO}/${FUNCTION}.sql"

    

    echo "DROP FUNCTION IF EXISTS ${FUNCTION};" > ${ARQ_SAIDA}

    echo 'DELIMITER $$' >> ${ARQ_SAIDA}

    mysql -NB -h${HOST} -P${PORTA} -u ${USUARIO} -p${SENHA} ${BANCO} -e "show create function ${FUNCTION}" |\

    xargs -n 1 -d '\t' echo |\

    egrep '^CREATE' |\

    xargs --null echo -e >> ${ARQ_SAIDA}

    echo '$$' >> ${ARQ_SAIDA}

    echo "DELIMITER ;" >> ${ARQ_SAIDA}

MySQL - RowNum Number com GroupBy

SELECT  t1.id_ciclo_produto, t1.id_wf_produto_ciclo,
t1.cd_area_ddd, t1.cd_eot_owner, t1.cd_eot_relac,
t1.dt_cham, 
(CASE CONCAT(t1.id_ciclo_produto, t1.id_wf_produto_ciclo, t1.cd_area_ddd, t1.cd_eot_owner, t1.cd_eot_relac, t1.dt_cham) 
WHEN @cur_chave
THEN @curRow := @curRow + 1
ELSE @curRow := 0 END) + 1 AS id_tarifa,
@cur_chave := CONCAT(t1.id_ciclo_produto, t1.id_wf_produto_ciclo, t1.cd_area_ddd, 
t1.cd_eot_owner, t1.cd_eot_relac, t1.dt_cham)  AS cur_chave,
t1.vl_tarifa,
t1.nu_qtd_minutos, t1.vl_liquido,
t1.vl_pis_cofins, t1.vl_icms,
t1.vl_total
 FROM (SELECT t1.id_ciclo_produto, t1.id_wf_produto_ciclo,
t1.cd_area_ddd,
t1.cd_eot_owner, t1.cd_eot_relac,
DATE_FORMAT(t1.dt_chamada, '%Y%m') dt_cham, 
t1.vl_tarifa,
SUM(t1.nu_qtd_minutos) nu_qtd_minutos, SUM(t1.vl_liquido) vl_liquido,
SUM(t1.vl_pis_cofins) vl_pis_cofins, SUM(t1.vl_icms) vl_icms,
SUM(t1.vl_total) vl_total
 FROM tb_tmp_trafego_itx_expec_despesa_bk_smp_1 t1
GROUP BY 1,2,3,4,5,6,7) t1,
(SELECT @curRow := 0, @cur_crew_type := '') t2
;

MySQL - Information Schema - Referências

Para pesquisar informações sobre Tabelas, Colunas, Procedures, etc do MySQL pode-se usar as diversas tabelas do schema padrão INFORMATION_SCHEMA.

São elas:

• CHARACTER_SETS
• COLLATIONS
• COLLATION_CHARACTER_SET_APPLICABILITY
• COLUMNS
• COLUMN_PRIVILEGES
• ENGINES
• EVENTS
• FILES
• GLOBAL_STATUS
• GLOBAL_VARIABLES
• KEY_COLUMN_USAGE
• PARTITIONS
• PLUGINS
• PROCESSLIST
• PROFILING
• REFERENTIAL_CONSTRAINTS
• ROUTINES
• SCHEMATA
• SCHEMA_PRIVILEGES
• SESSION_STATUS
• SESSION_VARIABLES
• STATISTICS
• TABLES
• TABLE_CONSTRAINTS
• TABLE_PRIVILEGES
• TRIGGERS
• USER_PRIVILEGES
• VIEWS

Exemplos:

1) Para ver todas as tabelas de um determinado Schema:

SELECT t1.table_name
  FROM information_schema.tables t1

  WHERE lower(t1.table_schema) = 'information_schema';

2) Identificar quais tabelas referenciam uma determinada coluna:

SELECT t1.*
  FROM information_schema.columns t1
  WHERE upper(t1.table_schema) = 'information_schema'

    AND upper(t1.column_name) = 'COLUMN_NAME';

MySQL - Identificar quais Procedures usam uma Tabela

Para identificar qual(is) PROCEDURE(S)/FUNCTION(S) utilizam uma tabela, pode-se fazer uma pesquisa usando o INFORMATION_SCHEMA, conforme abaixo:

SELECT t1.routine_name, t1.routine_type, t1.definer
  FROM information_schema.routines t1 
  WHERE upper(t1.routine_schema) = <'schema|db'>
    AND upper(t1.routine_definition) like '%<'TABELA'>%';

Onde

<'schema|db'> - Schema/DB

<'TABELA'> - Tabela que será pesquisa. Deve estar em Maiúsculo para facilitar a pesquisa

Exemplo:

SELECT t1.routine_name, t1.routine_type, t1.DEFINER

  FROM information_schema.routines t1 

  WHERE upper(t1.routine_schema) = 'db'

    AND upper(t1.routine_definition) like '%ESTOQUE_PRODUTO%';

MySQL - ìndices

O uso de índices no MySQL é fantástico, mas vale aqui algumas observações. 

Tab_1
cpo_a varchar(20) default null,
cpo_b int default 0,
cpo_c datetime default null,
cpo_d char(5) default null

Index indx01 (cpo_a, cpo_b, cpo_c);

Para esta tabela, usando o índice são válidas as seguintes pesquisas, para utilização do índice:

• cpo_a, cpo_b, cpo_c
• cpo_a, cpo_b
• cpo_a

Caso o cpo_a NÃO seja utilizado em uma pesquisa, o índice NÃO será usado, como nos exemplos abaixo:

• cpo_b, cpo_c
• cpo_b
• cpo_c

Outros exemplos de pesquisa, aonde o índice não será usado:

• cpo_a, cpo_c (falta o cpo_b)
• cpo_c, cpo_a (falta o cpo_b)

mysql> EXPLAIN SELECT * from tabela_a WHERE cd_reg = 1;
+----+-------------+----------+-------+---------------+---------+---------+-------+------+-------+
| id | select_type | table    | type  | possible_keys | key     | key_len | ref   | rows | Extra |
+----+-------------+----------+-------+---------------+---------+---------+-------+------+-------+
|  1 | SIMPLE      | tabela_a | const | PRIMARY       | PRIMARY | 4       | const |    1 |       |
+----+-------------+----------+-------+---------------+---------+---------+-------+------+-------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_a = 'a';
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
| id | select_type | table    | type | possible_keys | key    | key_len | ref   | rows | Extra       |
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
|  1 | SIMPLE      | tabela_a | ref  | indx01        | indx01 | 10      | const |    1 | Using where |
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_a = 'd';
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
| id | select_type | table    | type | possible_keys | key    | key_len | ref   | rows | Extra       |
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
|  1 | SIMPLE      | tabela_a | ref  | indx01        | indx01 | 10      | const |    1 | Using where |
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_a = 'd' and cpo_b = '2016-03-10' and cpo_c = 3;
+----+-------------+----------+------+---------------+--------+---------+-------------------+------+-------------+
| id | select_type | table    | type | possible_keys | key    | key_len | ref               | rows | Extra       |
+----+-------------+----------+------+---------------+--------+---------+-------------------+------+-------------+
|  1 | SIMPLE      | tabela_a | ref  | indx01        | indx01 | 24      | const,const,const |    1 | Using where |
+----+-------------+----------+------+---------------+--------+---------+-------------------+------+-------------+
1 row in set, 2 warnings (0.01 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_a = 'd' and cpo_b = '2016-03-10';
+----+-------------+----------+------+---------------+--------+---------+-------------+------+-------------+
| id | select_type | table    | type | possible_keys | key    | key_len | ref         | rows | Extra       |
+----+-------------+----------+------+---------------+--------+---------+-------------+------+-------------+
|  1 | SIMPLE      | tabela_a | ref  | indx01        | indx01 | 15      | const,const |    1 | Using where |
+----+-------------+----------+------+---------------+--------+---------+-------------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_a = 'd';
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
| id | select_type | table    | type | possible_keys | key    | key_len | ref   | rows | Extra       |
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
|  1 | SIMPLE      | tabela_a | ref  | indx01        | indx01 | 10      | const |    1 | Using where |
+----+-------------+----------+------+---------------+--------+---------+-------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_a = 'd' and cpo_c = '2016-03-10' and cpo_b = 3;
+----+-------------+----------+------+---------------+--------+---------+-------------------+------+-------------+
| id | select_type | table    | type | possible_keys | key    | key_len | ref               | rows | Extra       |
+----+-------------+----------+------+---------------+--------+---------+-------------------+------+-------------+
|  1 | SIMPLE      | tabela_a | ref  | indx01        | indx01 | 24      | const,const,const |    1 | Using where |
+----+-------------+----------+------+---------------+--------+---------+-------------------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_c = '2016-03-10' and cpo_b = 3;
+----+-------------+----------+------+---------------+------+---------+------+------+-------------+
| id | select_type | table    | type | possible_keys | key  | key_len | ref  | rows | Extra       |
+----+-------------+----------+------+---------------+------+---------+------+------+-------------+
|  1 | SIMPLE      | tabela_a | ALL  | NULL          | NULL | NULL    | NULL |    2 | Using where |
+----+-------------+----------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * from tabela_a WHERE cpo_b = 3;
+----+-------------+----------+------+---------------+------+---------+------+------+-------------+
| id | select_type | table    | type | possible_keys | key  | key_len | ref  | rows | Extra       |
+----+-------------+----------+------+---------------+------+---------+------+------+-------------+
|  1 | SIMPLE      | tabela_a | ALL  | NULL          | NULL | NULL    | NULL |    2 | Using where |
+----+-------------+----------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)

MySQL - Função para Contar ocorrências de um caracter/string em uma string

Para contar a quantidade de ocorrências de um caracter ou string em uma string pode-se usar esta função:

round((length(<string>) - length(replace(<string>,<caracter/string pesquisada>,''))) / length(<caracter/string pesquisada>))

Exemplo:

round((length(dna_ppg) - length(replace(dna_ppg,'#',''))) / length('#'))

Procura no campo 'dna_ppg' a quantidade de ocorrências do caracter '#'

Fonte (http://gilbertoalbino.com/como-contar-numero-de-ocorrencias-de-string-num-campo-do-mysql/)

Instalação do MySQL - CentOS

Para instalar o MySQL no CentOS e NÃO utilizar os diretórios padrão de dados, deve-se desabilitar o SELinux, como pode ser visto neste artigo - SELinux and MySQL .

Para desabilitar o SELinux de maneira temporária:
setenforce 0
getenforce

Vide mais em : Desabilitar SELinux neste blog !

MySQL - Loader de Arquivo com Tamanho Fixo (posicional)

Para efetuar o loader de um arquivo fixo (ou posicional), ou seja, um arquivo que não possui delimitadores, existem duas maneiras:

Método 1 - Usar uma tabela de destino com TODOS os campos do arquivo, com tamanho fixo.
Para este método, a tabela de destino deverá possuir, OBRIGATORIAMENTE, a estrutura igual ao do arquivo de origem. No momento do LOADER, utilizar os parâmetros FIELD TERMINATED BY e ENCLOSED BY sem conteúdo ('').

Exemplo:
Arquivo
00101022014FULANO DE TAL  M
00201032014FULANA DO TAL  F

-- Tabela
CREATE TABLE tabela(
  codigo char(3) default null,
  data   char(3) default null,
  nome   char(15) default null,
  sexo   char(1) default null
) engine=MyIsam DEFAULT CHARSET=latin1;

-- Loader
LOAD DATA LOCAL INFILE '/Arquivo'
INTO TABLE tabela
FIELDS TERMINATED BY ''
ENCLOSED BY ''
LINES TERMINATED BY '\n';

-- Verificando se houve erro
show warnings;

Método 2 - Efetuar o LOADER em uma váriável auxiliar (@linha) e depois fazer o set para cada uma das linhas, usando a função SUBSTRING.

Exemplo:
Arquivo
00101022014FULANO DE TAL  M
00201032014FULANA DO TAL  F

-- Tabela
CREATE TABLE tabela(
  codigo int default null,
  nome   varchar(15) default null,
  data   date default null,
  sexo   char(1) default null
) engine=MyIsam DEFAULT CHARSET=latin1;

-- Loader
LOAD DATA LOCAL INFILE '/Arquivo'
INTO TABLE tabela
FIELDS TERMINATED BY ''
ENCLOSED BY ''
LINES TERMINATED BY '\n'
(@linha)
SET codigo = substr(@linha, 1, 3),
    nome = trim(upper(substr(@linha, 12, 15))),
    date = str_to_date(substr(@linha, 4, 8), '%Y%m%d'),
    sexo = substr(@linha, 27, 1)
;

-- Verificando se houve erro
show warnings;

MySQL - Backup apenas da estrutura (create table) e procedures/functions

Para efetuar o backup apenas da estutura das tabelas e procedures/functions - ou gerar na verdade um script de criação da estrutura - pode-se usar o utilitário MYSQLDUMP (que faz parte da própria instalação padrão do MySQL) com os seguintes parâmetros:

--no-data -> Indica que deve ser feita apenas o script de criação das tabelas - sem os inserts
--routine -> Indica que as procedures/fucntions deve ser exportadas

Sintaxe:
mysqldump.exe -u<usuario> -p<password> --no-data --routines --databases <banco> --quick --result-file=<arquivo>

onde:
<usuario> - usuário com permissão de acesso ao banco
<password> - senha do usuário
<banco> - banco que será exportado
<arquivo> - caminho e nome do arquivo onde os dados deverão ser exportados

Exemplo:
mysqldump.exe -uroot -p --no-data --routines --databases mysql --quick --result-file=c:\ESTRUTURA_MYSQL.sql

No exemplo acima, a senha será solicitada pelo utilitário no momento da execução

Bash (For) + Gzip + Loader Mysql

Problema: Efetuar o LOADER em banco de dados MySQL de arquivos compactados em inúmeros subdiretórios de um diretório pai.

Sugestão de solução: Fazer um (bash) FOR primeiro para a leitura dos subdiretórios, seguido do (bash) FOR para a obtenção dos arquivos, descompactar o arquivo, efetuar o loader e compactar o arquivo.

Sintaxe:

for j in $(ls -d <diretório_pai>*); do for i in $(ls $j/*gz); do tam=${#i}; arq=${i:0:tam-3}; dir=${j:33}; gzip -d $i ; echo 'LOAD DATA LOCAL INFILE "'$arq'" INTO TABLE <tabela> FIELDS TERMINATED BY "'''\''" LINES TERMINATED BY "\n" set filename="'$arq'", directory="'$dir'";' | mysql -u<user> -p<password> -qs; gzip $arq; done; done 

onde:
<diretório_pai> - caminho completo do diretório pai
<tabela> - tabela MySQL aonde os dados serão carregados
<user> - usuário MySQL
<password> - password do <user> MySQL

Opção mais completa - Tratar antes o arquivo (com um script perl, por exemplo) e verificar se houve erros na carga dos arquivos gerando um log

Sintaxe:


for j in $(ls -d <diretório_pai>*); do for i in $(ls $j/*gz); do tam=${#i}; arq=${i:0:tam-3}; arq_novo=$arq.new; dir=${j:33}; gzip -d $i ; <script> $arq > $arq_novo ; echo 'LOAD DATA LOCAL INFILE "'$arq_novo'" INTO TABLE <tabela> FIELDS TERMINATED BY "'''\''" LINES TERMINATED BY "\n" (<col1>, <col2>,..,<col3>) set filename="'$arq'", directory="'$dir'"; show warnings;' | mysql -u<user> -p<password> -qs; gzip $arq; rm -fr $arq_novo; done; done > <arquivo_log> &

onde:
<diretório_pai> - caminho completo do diretório pai
<script> - script a ser executado
<tabela> - tabela MySQL aonde os dados serão carregados
<col1>, <col2>, .., <coln> - colunas da <tabela>
<user> - usuário MySQL
<password> - password do <user> MySQL

<arquivo_log> - nome do arquivo log

MySQl - Sessões

Para visualizar as sessões no MySQL, usar o comando SHOW PROCESSLIST

Sintaxe;

SHOW [FULL] PROCESSLIST

Para deletar algum processo, usar o comando KILL

Sintaxe:

kill <nro_processo>;

Exemplo:

kill 1;

"C" - Conexão MySQL

Pré-requisitos
mysql (client)
mysql-devel

A compilação de programas com acesso a bibliotecas do MySQL necessitam de alguns parâmetros especiais. Estes parâmetros podem ser obtidos através da execução do script 'mysql_config' que faz parte do pacote mysql-devel. Para compilar o programa, usar a seguinte sintaxe:
gcc -o <output> $(mysql_config --cflags) <fonte.c> $(mysql_config --libs)

exemplo:
gcc -o consulta_mysql $(mysql_config --cflags) consulta_mysql.c $(mysql_config --libs)

Exemplo de programa para conexão ao MySQL

#include <mysql/mysql.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
   MYSQL *conexao;
   MYSQL_RES *res;
   MYSQL_ROW linhas;
   MYSQL_FIELD *campos;
   char query[]="select * from <tabela>;";
   int i;

   char *server = "<servidor>";
   char *user = "<usuario>";
   char *password = "<senha>";
   char *database = "<banco>";
   unsigned int port = <porta>;

   conexao = mysql_init(NULL);

   /* Connect to database */
   if (!mysql_real_connect(conexao, server,
         user, password, database, port, NULL, 0)) {
      fprintf(stderr, "%s\n", mysql_error(conexao));
      exit(EXIT_FAILURE);
   }

   /* send SQL query */
   if (mysql_query(conexao, query)) {
      fprintf(stderr, "%s\n", mysql_error(conexao));
      exit(EXIT_FAILURE);
   }

   res = mysql_store_result(conexao);
   
   if (res)
   {
     campos = mysql_fetch_fields(res);
     for (i=0; i < mysql_num_fields(res); i++)
     {
       printf("%s", (campos[i]).name);
       if (mysql_num_fields(res) > 1)
          printf("\t");
     }
     
     printf("\n");
     
     while ((linhas = mysql_fetch_row(res)) != NULL)
     {
       for (i=0; i < mysql_num_fields(res); i++)
         printf("%s\t", linhas[i]);
       printf("\n");
     }
   }

   /* close connection */
   mysql_free_result(res);
   mysql_close(conexao);
}

Uso de Funções UDF no MySQL

Arquivos ou bibliotecas UDF - DLL em ambiente Windows e SO em ambiente Unix/Linux - contém funções, normalmente escritas em linguagem 'C' e que podem ser usadas em queries no MySQL.

O link http://dev.mysql.com/doc/refman/5.0/en/adding-functions.html fala a respeito das UDFs e o link  http://dev.mysql.com/doc/refman/5.1/en/udf-compiling.html explica como compilar uma biblioteca UDF nos ambientes Unix/Linux e Windows usando usando o make/cmake.

Para criar estes arquivos no Windows usando o Visual Studio, cabem algumas dicas:
1) Pré-requisitos:

• Source do Mysql (diretório include);
• SDK do Microsoft

2) Criar uma nova solução/projeto vazia (empty projetct)
3) Em propriedades do projeto (verificar se a configuração está habilitada em 'all configurations'):

•  Project Defaults/Configuration type - Dynamic Library (.dll)
• C/C++/General/Aditional Include Directories - Incluir os diretórios do include do MySQL e do include do Microsoft SDK
• C/C++/Preprocessor/Preprocessor Definitions - Incluir a diretiva HAVE_DLOPEN
• Linker/General/Additional library Directories - Incluir o diretório lib do Microsoft SDK
• Linker/Input/Module Definition File - Referenciar o arquivo com as definições da biblioteca (arquivo .def)

Ao instalar a biblioteca criada em um servidor Windows não esquecer:
1) Colocar a DLL no diretório indicado pelo parâmetro plugin_dir (comando show variables like 'plug%')
2) Instalar o runtime do Visual C/C++ referente a versão em que foi compilado o arquivo DLL

Algumas dicas podem ser vistas - http://rpbouman.blogspot.com.br/2007/09/creating-mysql-udfs-with-microsoft.html