Selecione todas as colunas, exceto uma no MySQL?

365

Estou tentando usar uma instrução select para obter todas as colunas de uma determinada tabela do MySQL, exceto uma. Existe uma maneira simples de fazer isso?

EDIT: existem 53 colunas nesta tabela (NÃO MEU DESIGN)

Tom Grochowicz
fonte
6
53 colunas? Eu ficaria com SELECT *, como Thomas sugere nesse caso ... a menos que essa coluna extra tenha uma quantidade enorme de dados que seria indesejável recuperar ...?
Mike Stone
Exceto uma coluna ... suponho que você saiba qual delas deve ser ignorada; portanto, o Information_SCHEMA.columns é o caminho.
Alfabravo 23/02
Confira esta resposta que faz o que você quer fazer!
donL
A coluna de big data é um problema real quando os dados geográficos são mantidos. As colunas podem ter muitos megabytes de tamanho. Eles funcionam bem nas cláusulas where para encontrar linhas, mas geralmente você não deseja esses dados nos resultados.
Jason
Um uso comum para isso é excluir a coluna ID de incremento automático. Por exemplo, para selecionar dados a serem inseridos em uma tabela diferente, que possui seu próprio ID.
ToolmakerSteve

Respostas:

222

Na verdade, existe uma maneira, você precisa ter permissões, é claro, para fazer isso ...

SET @sql = CONCAT('SELECT ', (SELECT REPLACE(GROUP_CONCAT(COLUMN_NAME), '<columns_to_omit>,', '') FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '<table>' AND TABLE_SCHEMA = '<database>'), ' FROM <table>');

PREPARE stmt1 FROM @sql;
EXECUTE stmt1;

Substituindo <table>, <database> and <columns_to_omit>

Mahomedalid
fonte
20
ressalva: as consultas do Information_SCHEMA têm desempenho muito ruim, portanto, tenha cuidado para que esse tipo de consulta não esteja no caminho crítico para nada.
Bill Karwin
9
Como @Jan Koritak disse abaixo, esta resposta não funciona se as colunas do título que você deseja remover também forem uma sub-string do título de todas as colunas que você deseja manter. Há uma resposta melhor que é semelhante a esta que pode ser encontrada aqui .
donL
8
Isso é muito pior do que apenas especificar as colunas, que é uma prática recomendada conhecida.
HLGEM
3
Isso não funciona se houver espaços nos nomes das colunas. Ele deve ser atualizado para sempre cercam os nomes em backticks<column_name>
adamF
3
Isso também não funcionará se a coluna a ser ignorada for a última listada na estrutura da tabela (porque a substituição não corresponderá ao coma à direita).
Vincent Pazeller
61

Nas definições do mysql (manual) não existe. Mas se você tiver um número realmente grande de colunas col1, ... col100, o seguinte poderá ser útil:

DROP TABLE IF EXISTS temp_tb;
CREATE TEMPORARY TABLE ENGINE=MEMORY temp_tb SELECT * FROM orig_tb;
ALTER TABLE temp_tb DROP col_x;
SELECT * FROM temp_tb;
ghionoiu
fonte
4
Me deu a mensagem de erro na 3ª etapa: "A contagem de colunas não corresponde à contagem de valores na linha 1". Então, mudei a etapa 2 para "UPDATE temp_tb SET id = NULL" e funcionou.
oyvey
11
Ok, isso funciona. Mas quando executo essa consulta novamente, ocorre um erro, já que temp_tb já existe. Por quanto tempo o temp_tb fica na memória? Desculpas se for uma pergunta estúpida. PS votou sua resposta.
Karan
2
@Karan Para executar esta consulta repetidamente, adicione outro comando ao início:DROP TABLE IF EXISTS temp_tb;
gregn3 11/11/19
11
@Karan Para especificar o mecanismo de memória, use o comando:, CREATE TEMPORARY TABLE temp_tb ENGINE=MEMORY (SELECT * FROM orig_tb); caso contrário, ele é salvo no disco por padrão e sobrevive à reinicialização do servidor. ( obrigado )
gregn3 11/07/19
Excelente resposta. Para eliminar várias colunas , consulte esta resposta .
S3DEV
45

Um View funcionaria melhor nesse caso?

CREATE VIEW vwTable
as  
SELECT  
    col1  
    , col2  
    , col3  
    , col..  
    , col53  
FROM table
Brian Childress
fonte
15
HAHA! Sim claro. Agora, como você constrói a exibição para incluir todas, exceto uma das colunas. Eu acho que você vê como isso implora a pergunta original. Na verdade, eu encontrei esse segmento especificamente porque queria criar uma exibição que excluísse determinadas colunas sem ser forçada a listar todas as colunas restantes explicitamente na definição da exibição.
Chris Nadovich
31

Você pode fazer:

SELECT column1, column2, column4 FROM table WHERE whatever

sem obter a coluna3, embora talvez você estivesse procurando uma solução mais geral?

Mike Stone
fonte
3
A maioria das respostas notação superior são na sua maioria apenas encontrar formas de gerar essa consulta exata sem digitar com a mão
mehtunguh
5
Na verdade, por motivos de manutenção, é útil ter um tipo de consulta "tudo, exceto". Caso contrário, as listas de campos explícitas deverão ser atualizadas se novos campos forem adicionados posteriormente.
Leiavoia
11
@ Lev, isso é correto e eles deveriam ser !!! BE, caso você não saiba se deseja ter colunas futuras (elas podem ser colunas de metadados ou que não se aplicam a uma tela específica). Você não; deseja prejudicar o desempenho retornando mais do que você precisa (o que é verdade 100% do tempo em que você tem uma associação interna).
HLGEM
26
O PO afirma que existem> 50 colunas, portanto isso é bastante impraticável.
augurar
11
@HLGEM Na verdade, eu queria selecionar todas as colunas sem manter a consulta sempre que adiciono uma nova coluna, exceto uma delas, e isso simplesmente não funcionaria no meu caso. Mas de qualquer maneira eu apliquei solução de Sean O para mim
OverCoder
26

Se você deseja excluir o valor de um campo, por exemplo, por questões de segurança / informações confidenciais, é possível recuperar essa coluna como nula.

por exemplo

SELECT *, NULL AS salary FROM users
Sean O
fonte
13
Por quê? Isso não funciona. Se você tiver um salário de coluna, essa consulta acabará com os resultados com duas colunas denominadas salário, uma cheia de valores nulos e outra com os salários reais.
Myforwik
4
@ Myforwik Esta consulta realmente adiciona uma segunda salarycoluna. Mas, como é recuperado após o *, ele substitui o original. Não é bonito, mas funciona.
Sean O
68
O SQL sempre permitiu nomes de colunas duplicados em um conjunto de resultados. Se você deseja que isso funcione, é necessário executá-lo com um aplicativo cliente que não oferece suporte a dupes e dá prioridade ao último dupe. O cliente de linha de comando oficial oferece suporte a dupes. O HeidiSQL também os suporta. O SQL Fiddle não, mas exibe o primeiro engano, não o último. Resumindo: isso não funciona .
Álvaro González
9
Claro que não funciona. Este é um ótimo exemplo de por que você deve testar suas respostas no próprio mysql, em vez de através de bibliotecas que falam com o mysql.
Myforwik
8
@SeanO, @ Alastair, @ Todo mundo, não substitui. O servidor ainda retorna dados confidenciais.
Pacerier
22

Que eu saiba, não existe. Você pode fazer algo como:

SELECT col1, col2, col3, col4 FROM tbl

e escolha manualmente as colunas que deseja. No entanto, se você quiser muitas colunas, poderá fazer:

SELECT * FROM tbl 

e apenas ignore o que você não quer.

No seu caso particular, eu sugeriria:

SELECT * FROM tbl

a menos que você queira apenas algumas colunas. Se você deseja apenas quatro colunas, então:

SELECT col3, col6, col45, col 52 FROM tbl

seria bom, mas se você quiser 50 colunas, qualquer código que faça a consulta se tornará (também?) difícil de ler.

Thomas Owens
fonte
3
Selecionar * é uma má escolha sempre. Não recomendo. Leia porque é um Antipattern SQl.
HLGEM
18

Ao tentar as soluções de @Mahomedalid e @Junaid, encontrei um problema. Então, pensei em compartilhá-lo. Se o nome da coluna tiver espaços ou hífens, como o check-in, a consulta falhará. A solução simples é usar backtick em torno dos nomes das colunas. A consulta modificada está abaixo

SET @SQL = CONCAT('SELECT ', (SELECT GROUP_CONCAT(CONCAT("`", COLUMN_NAME, "`")) FROM
INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'users' AND COLUMN_NAME NOT IN ('id')), ' FROM users');
PREPARE stmt1 FROM @SQL;
EXECUTE stmt1;
Suraj
fonte
11

Se a coluna que você não deseja selecionar continha uma grande quantidade de dados e não os incluía devido a problemas de velocidade e você seleciona as outras colunas frequentemente, sugiro que você crie uma nova tabela com o campo que você normalmente não seleciona com uma chave para a tabela original e remova o campo da tabela original. Junte-se às tabelas quando esse campo extra for realmente necessário.

Stacey Richards
fonte
8

Meu principal problema são as muitas colunas que recebo ao ingressar nas tabelas. Embora essa não seja a resposta para sua pergunta (como selecionar todas as colunas, exceto algumas de uma tabela), acho que vale a pena mencionar que você pode especificar para obter todas as colunas de uma tabela específica, em vez de apenas especificar .table.

Aqui está um exemplo de como isso pode ser muito útil:

selecione users. *, phone.meta_value como phone, zipcode.meta_value como zipcode

dos usuários

deixou juntar user_meta como telefone
on ((users.user_id = phone.user_id) AND (phone.meta_key = 'phone'))

deixou unir user_meta como CEP
on ((users.user_id = zipcode.user_id) AND (zipcode.meta_key = 'zipcode'))

O resultado são todas as colunas da tabela de usuários e duas colunas adicionais que foram unidas a partir da meta-tabela.

cwd
fonte
2
obrigado, preciso selecionar todas as colunas da primeira tabela e apenas um campo da segunda tabela na associação e sua resposta me ajudou.
Mohammad Falahat
5

Eu gostei da resposta de @Mahomedalidalém deste fato informado no comentário de @Bill Karwin. O possível problema levantado por @Jan Koritaké verdade. Enfrentei isso, mas encontrei um truque para isso e só quero compartilhá-lo aqui para qualquer um que esteja enfrentando o problema.

podemos substituir a função REPLACE pela cláusula where na subconsulta da instrução Prepared como esta:

Usando meu nome de tabela e coluna

SET @SQL = CONCAT('SELECT ', (SELECT GROUP_CONCAT(COLUMN_NAME) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'users' AND COLUMN_NAME NOT IN ('id')), ' FROM users');
PREPARE stmt1 FROM @SQL;
EXECUTE stmt1;

Então, isso vai excluir apenas o campo, idmas nãocompany_id

Junaid
fonte
4

É uma boa prática especificar as colunas que você está consultando, mesmo se você consultar todas as colunas.

Então, eu sugiro que você escreva o nome de cada coluna na declaração (excluindo a que você não deseja).

SELECT
    col1
    , col2
    , col3
    , col..
    , col53

FROM table
mbillard
fonte
Ele age como um contrato com o código e, ao examinar a consulta, você sabe exatamente quais dados podem ser extraídos sem consultar o esquema da tabela.
23411 mbillard
6
@kodecraft: É uma boa prática pelo mesmo motivo que sempre retorne o mesmo tipo de uma função (mesmo se você trabalhar em um idioma em que não seja imposto). Basicamente, apenas o princípio da menor surpresa.
Daniel Pryden
4

Apenas faça

SELECT * FROM table WHERE whatever

Em seguida, solte a coluna na sua linguagem de programação favorita: php

while (($data = mysql_fetch_array($result, MYSQL_ASSOC)) !== FALSE) {
   unset($data["id"]);
   foreach ($data as $k => $v) { 
      echo"$v,";
   }      
}
Soth
fonte
6
A menos que a coluna que você deseja excluir seja um BLOB enorme ou algo assim.
Bill Karwin
11
Isso é ruim se você está tentando evitar os dados desperdiçados.
Kristopher Ives
1 coluna de 53 não deve fazer nenhuma diferença. Se isso acontecer, provavelmente é um design ruim.
precisa
11
SElect * é um antipadrão SQL e nunca deve ser usado no código de produção.
HLGEM
11
Não concordo que SELECT * seja algum tipo de antipadrão que "nunca" deve ser usado no código de produção. É muito mais claro que você recuperou todas as suas colunas - em comparação à referência cruzada de uma longa lista de colunas que podem ou não ser, de fato, todos os campos. É também, obviamente, mais rápido de codificar, de longe. E há muitos casos em que os campos da tabela corresponderão exatamente aos campos em uma exibição ou formulário.
Geoff Kendall
4

Concordo com a solução "simples" de listar todas as colunas, mas isso pode ser oneroso e erros de digitação podem causar muito tempo perdido. Eu uso a função "getTableColumns" para recuperar os nomes de minhas colunas adequadas para colar em uma consulta. Então, tudo o que preciso fazer é excluir aqueles que não quero.

CREATE FUNCTION `getTableColumns`(tablename varchar(100)) 
          RETURNS varchar(5000) CHARSET latin1
BEGIN
  DECLARE done INT DEFAULT 0;
  DECLARE res  VARCHAR(5000) DEFAULT "";

  DECLARE col  VARCHAR(200);
  DECLARE cur1 CURSOR FOR 
    select COLUMN_NAME from information_schema.columns 
    where TABLE_NAME=@table AND TABLE_SCHEMA="yourdatabase" ORDER BY ORDINAL_POSITION;
  DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;
  OPEN cur1;
  REPEAT
       FETCH cur1 INTO col;
       IF NOT done THEN 
          set res = CONCAT(res,IF(LENGTH(res)>0,",",""),col);
       END IF;
    UNTIL done END REPEAT;
  CLOSE cur1;
  RETURN res;

Seu resultado retorna uma string delimitada por vírgula, por exemplo ...

col1, col2, col3, col4, ... col53

David Poor
fonte
4

Sim, embora possa ser alta E / S, dependendo da tabela, aqui está uma solução alternativa encontrada.

SELECT *
INTO #temp
FROM table

ALTER TABLE #temp DROP COlUMN column_name

SELECT *
FROM #temp
Nathan A
fonte
Isso será muito lento para qualquer mesa de tamanho médio.
Joel
3

Concordo que não é suficiente Select *, se aquele de que você não precisa, como mencionado em outro lugar, é um BLOB, você não quer que essa sobrecarga ocorra.

Eu criaria uma visualização com os dados necessários, para que você possa Select *com conforto - se o software do banco de dados os suportar. Senão, coloque os enormes dados em outra tabela.

nlucaroni
fonte
3

No começo eu pensei que você poderia usar expressões regulares, mas como eu tenho lido os documentos do MYSQL , parece que você não pode. Se eu fosse você, usaria outra linguagem (como PHP) para gerar uma lista de colunas que deseja obter, armazene-a como uma string e use-a para gerar o SQL.

icco
fonte
3

Eu também queria isso, então criei uma função.

public function getColsExcept($table,$remove){
    $res =mysql_query("SHOW COLUMNS FROM $table");

    while($arr = mysql_fetch_assoc($res)){
        $cols[] = $arr['Field'];
    }
    if(is_array($remove)){
        $newCols = array_diff($cols,$remove);
        return "`".implode("`,`",$newCols)."`";
    }else{
        $length = count($cols);
        for($i=0;$i<$length;$i++){
            if($cols[$i] == $remove)
                unset($cols[$i]);
        }
        return "`".implode("`,`",$cols)."`";
    }
}

Então, como ele funciona é que você insere a tabela e, em seguida, uma coluna que não deseja ou como em uma matriz: array ("id", "name", "Whatevercolumn")

Então, em select, você pode usá-lo assim:

mysql_query("SELECT ".$db->getColsExcept('table',array('id','bigtextcolumn'))." FROM table");

ou

mysql_query("SELECT ".$db->getColsExcept('table','bigtextcolumn')." FROM table");
Kilise
fonte
3

Concordo com a resposta de @ Mahomedalid, mas não queria fazer algo como uma declaração preparada e não queria digitar todos os campos, então o que tinha era uma solução boba.

Vá para a tabela em phpmyadmin-> sql-> select, despeja a consulta: copie, substitua e pronto! :)

neelabh
fonte
2

Embora eu concorde com a resposta de Thomas (+1;)), gostaria de adicionar a ressalva de que assumirei que a coluna que você não deseja contém quase nenhum dado. Se ele contiver enormes quantidades de texto, xml ou blobs binários, reserve um tempo para selecionar cada coluna individualmente. Seu desempenho sofrerá de outra forma. Felicidades!

JO.
fonte
2

A resposta postada por Mahomedalid tem um pequeno problema:

O código da função de substituição interna estava substituindo " <columns_to_delete>," por "", esta substituição tem um problema se o campo a substituir for o último na sequência de concat, pois o último não possui a vírgula de caractere "," e não é removido de a corda.

Minha proposta:

SET @sql = CONCAT('SELECT ', (SELECT REPLACE(GROUP_CONCAT(COLUMN_NAME),
                  '<columns_to_delete>', '\'FIELD_REMOVED\'')
           FROM INFORMATION_SCHEMA.COLUMNS
           WHERE TABLE_NAME = '<table>'
             AND TABLE_SCHEMA = '<database>'), ' FROM <table>');

Substituindo <table>, <database>e `

A coluna removida é substituída pela string "FIELD_REMOVED". No meu caso, isso funciona porque eu estava tentando economizar memória. (O campo que eu estava removendo é um BLOB de cerca de 1 MB)

neurotico79
fonte
2

Com base na resposta @Mahomedalid, fiz algumas melhorias para suportar "selecione todas as colunas, exceto algumas no mysql"

SET @database    = 'database_name';
SET @tablename   = 'table_name';
SET @cols2delete = 'col1,col2,col3';

SET @sql = CONCAT(
'SELECT ', 
(
    SELECT GROUP_CONCAT( IF(FIND_IN_SET(COLUMN_NAME, @cols2delete), NULL, COLUMN_NAME ) )
    FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @tablename AND TABLE_SCHEMA = @database
), 
' FROM ',
@tablename);

SELECT @sql;

Se você possui muitas colunas, use este sql para alterar group_concat_max_len

SET @@group_concat_max_len = 2048;
hahakubile
fonte
2

Pode ser que eu tenha uma solução para a discrepância apontada por Jan Koritak

SELECT CONCAT('SELECT ',
( SELECT GROUP_CONCAT(t.col)
FROM
(
    SELECT CASE
    WHEN COLUMN_NAME = 'eid' THEN NULL
    ELSE COLUMN_NAME
    END AS col 
    FROM INFORMATION_SCHEMA.COLUMNS 
    WHERE TABLE_NAME = 'employee' AND TABLE_SCHEMA = 'test'
) t
WHERE t.col IS NOT NULL) ,
' FROM employee' );

Mesa :

SELECT table_name,column_name 
FROM INFORMATION_SCHEMA.COLUMNS 
WHERE TABLE_NAME = 'employee' AND TABLE_SCHEMA = 'test'

================================

table_name  column_name
employee    eid
employee    name_eid
employee    sal

================================

Resultado da consulta:

'SELECT name_eid,sal FROM employee'
Bhavik Shah
fonte
1

Se for sempre a mesma coluna, você poderá criar uma exibição que não a contém.

Caso contrário, não, acho que não.

Gareth Simpson
fonte
1

Você pode usar o SQL para gerar o SQL, se desejar e avaliar o SQL que ele produz. Essa é uma solução geral, pois extrai os nomes das colunas do esquema de informações. Aqui está um exemplo da linha de comando do Unix.

Substituindo

  • MYSQL com seu comando mysql
  • TABLE com o nome da tabela
  • EXCLUDEDFIELD com nome de campo excluído
echo $(echo 'select concat("select ", group_concat(column_name) , " from TABLE") from information_schema.columns where table_name="TABLE" and column_name != "EXCLUDEDFIELD" group by "t"' | MYSQL | tail -n 1) | MYSQL

Você realmente precisará extrair os nomes das colunas dessa maneira apenas uma vez para construir a lista de colunas excluídas dessa coluna e, em seguida, basta usar a consulta que você construiu.

Então, algo como:

column_list=$(echo 'select group_concat(column_name) from information_schema.columns where table_name="TABLE" and column_name != "EXCLUDEDFIELD" group by "t"' | MYSQL | tail -n 1)

Agora você pode reutilizar a $column_liststring nas consultas que você constrói.

rplevy
fonte
1

Gostaria de adicionar outro ponto de vista para resolver esse problema, especialmente se você tiver um pequeno número de colunas para remover.

Você pode usar uma ferramenta de banco de dados como o MySQL Workbench para gerar a instrução select para você; basta remover manualmente essas colunas da instrução gerada e copiá-la para o script SQL.

No MySQL Workbench, o caminho para gerá-lo é:

Clique com o botão direito do mouse na tabela -> enviar para o Sql Editor -> Selecionar todas as instruções.

Paúl Cervera García
fonte
1

A resposta aceita tem várias falhas.

  • Ele falha quando os nomes de tabela ou coluna requerem reticências
  • Falha se a coluna que você deseja omitir for a última da lista
  • Requer listar o nome da tabela duas vezes (uma vez para o texto selecionado e outro para o texto da consulta), o que é redundante e desnecessário
  • Pode potencialmente retornar nomes de colunas na ordem errada

Todos esses problemas podem ser superados com a simples inclusão de backticks no SEPARATORfor your GROUP_CONCATe usando uma WHEREcondição em vez de REPLACE(). Para meus propósitos (e imagino muitos outros), queria que os nomes das colunas retornassem na mesma ordem em que aparecem na própria tabela. Para conseguir isso, aqui usamos uma ORDER BYcláusula explícita dentro da GROUP_CONCAT()função:

SELECT CONCAT(
    'SELECT `',
    GROUP_CONCAT(COLUMN_NAME ORDER BY `ORDINAL_POSITION` SEPARATOR '`,`'),
    '` FROM `',
    `TABLE_SCHEMA`,
    '`.`',
    TABLE_NAME,
    '`;'
)
FROM INFORMATION_SCHEMA.COLUMNS
WHERE `TABLE_SCHEMA` = 'my_database'
    AND `TABLE_NAME` = 'my_table'
    AND `COLUMN_NAME` != 'column_to_omit';
billynoah
fonte
0

Eu tenho uma sugestão, mas não uma solução. Se algumas de suas colunas tiverem conjuntos de dados maiores, tente seguir os seguintes

SELECT *, LEFT(col1, 0) AS col1, LEFT(col2, 0) as col2 FROM table
MR_AMDEV
fonte
-1

Estou bem atrasado em encontrar uma resposta para isso, coloque desta maneira que sempre fiz e, francamente, é 100 vezes melhor e mais organizado do que a melhor resposta, só espero que alguém o veja. E achar útil

    //create an array, we will call it here. 
    $here = array();
    //create an SQL query in order to get all of the column names
    $SQL = "SHOW COLUMNS FROM Table";
        //put all of the column names in the array
        foreach($conn->query($SQL) as $row) {
            $here[] = $row[0];
        }
    //now search through the array containing the column names for the name of the column, in this case i used the common ID field as an example
    $key = array_search('ID', $here);
    //now delete the entry
    unset($here[$key]);
usuario
fonte
Talvez seja legal, mas não responde à pergunta: ele não perguntou sobre php, e você não fornece uma instrução select ou um resultado do que ele deseja, mas apenas um array php contendo as colunas que ele deseja.
Gou1 15/05
2
-1. Este não é um código SQL e não há nenhuma SELECTdeclaração aqui - a palavra nem ocorre uma vez.
Frungi 23/07/2013
Isso é apenas mais claro na medida em que (a) você se sente mais à vontade com PHP que SQL, ou (b) gosta de espalhar seu código por várias linhas para facilitar a leitura. Eu admitiria o ponto (b). Sua abordagem também teria menos desempenho, embora a diferença fosse menor em muitos casos de uso. Veja também outros comentários sobre sua pergunta. Não vale a pena gritar, por isso sugira que você remova seu comentário inadequado da pergunta original.
Mc0e
-5

Selecione * é um antipadrão SQL. Não deve ser usado no código de produção por vários motivos, incluindo:

Demora um pouco mais para processar. Quando as coisas acontecem milhões de vezes, esses pequenos pedaços podem ter importância. Um banco de dados lento em que a lentidão é causada por esse tipo de codificação superficial é o tipo mais difícil de ajustar o desempenho.

Isso significa que você provavelmente está enviando mais dados do que o necessário, o que causa gargalos no servidor e na rede. Se você tiver uma associação interna, as chances de enviar mais dados do que você precisa são de 100%.

Isso causa problemas de manutenção, especialmente quando você adiciona novas colunas que não deseja que sejam vistas em todos os lugares. Além disso, se você tiver uma nova coluna, pode ser necessário fazer algo na interface para determinar o que fazer com essa coluna.

Ele pode interromper as visualizações (eu sei que isso é verdade no servidor SQl, pode ou não ser verdade no mysql).

Se alguém for tolo o suficiente para reconstruir as tabelas com as colunas em uma ordem diferente (o que você não deve fazer, mas acontece o tempo todo), todo tipo de código pode ser quebrado. Codifique especialmente para uma inserção, por exemplo, onde de repente você está colocando a cidade no campo address_3, porque sem especificar, o banco de dados só pode seguir a ordem das colunas. Isso é ruim o suficiente quando os tipos de dados são alterados, mas pior quando as colunas trocadas têm o mesmo tipo de dados, pois você pode, por algum tempo, inserir dados ruins que são uma bagunça para limpar. Você precisa se preocupar com a integridade dos dados.

Se for usado em uma inserção, ele será interrompido se uma nova coluna for adicionada em uma tabela, mas não na outra.

Pode quebrar gatilhos. Problemas de gatilho podem ser difíceis de diagnosticar.

Adicione tudo isso contra o tempo que leva para adicionar os nomes das colunas (diabos você pode até ter uma interface que permita arrastar os nomes das colunas (eu sei que sim no SQL Server, aposto que há alguma maneira de faça isso é uma ferramenta que você usa para escrever consultas mysql.) Vamos ver: "Eu posso causar problemas de manutenção, posso causar problemas de desempenho e problemas de integridade de dados, mas ei, salvei cinco minutos de tempo de desenvolvimento." nas colunas específicas que você deseja.

Também sugiro que você leia este livro: http://www.amazon.com/SQL-Antipatterns-Programming-Pragmatic-Programmers-ebook/dp/B00A376BB2/ref=sr_1_1?s=digital-text&ie=UTF8&qid=1389896688&sr=1- 1 & palavras-chave = sql + antipatterns

HLGEM
fonte