Seleccionar todas las columnas excepto una en MySQL?

¿Funcionaría mejor una vista en este caso?

CREATE VIEW vwTable
as  
SELECT  
    col1  
    , col2  
    , col3  
    , col..  
    , col53  
FROM table

En las definiciones de mysql (manual) no existe tal cosa. Pero si usted tiene un número realmente grande de columnas col1, ..., col100, lo siguiente puede ser útil:

mysql> CREATE TEMPORARY TABLE temp_tb SELECT * FROM orig_tb;
mysql> ALTER TABLE temp_tb DROP col_x;
mysql> SELECT * FROM temp_tb;

Puedes hacer:

SELECT column1, column2, column4 FROM table WHERE whatever

Sin obtener column3, aunque tal vez usted estaba buscando una solución más general?

Si está buscando excluir el valor de un campo, por ejemplo, para problemas de seguridad / información sensible, puede recuperar esa columna como null.

Por ejemplo

SELECT *, NULL AS salary FROM users

A mi leal saber y entender, no lo hay. Puedes hacer algo como:

SELECT col1, col2, col3, col4 FROM tbl

Y elija manualmente las columnas que desee. Sin embargo, si desea un montón de columnas, entonces es posible que solo desee hacer un:

SELECT * FROM tbl 

Y simplemente ignora lo que no quieres.

En su caso particular, yo sugeriría:

SELECT * FROM tbl

A menos que solo desee unas pocas columnas. Si solo desea cuatro columnas, entonces:

SELECT col3, col6, col45, col 52 FROM tbl

Estaría bien, pero si desea 50 columnas, entonces cualquier código que haga consulta se convertiría (demasiado?) difícil de leer.

Mientras probaba las soluciones de @Mahomedalid y @Junaid encontré un problema. Así que pensé en compartirlo. Si el nombre de la columna tiene espacios o guiones como check-in, la consulta fallará. La solución simple es usar un backtick alrededor de los nombres de las columnas. La consulta modificada se encuentra debajo de

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;

Si la columna que no desea seleccionar tenía una gran cantidad de datos en ella, y no quería incluirla debido a problemas de velocidad y selecciona las otras columnas a menudo, le sugeriría que cree una nueva tabla con el campo que normalmente no selecciona con una clave para la tabla original y elimine el campo de la tabla original. Unirse a las tablas cuando ese campo adicional es realmente necesario.

Podría usar DESCRIBE my_table y usar los resultados de eso para generar la instrucción SELECT dinámicamente.

Mi principal problema son las muchas columnas que obtengo al unir tablas. Si bien esta no es la respuesta a su pregunta (cómo seleccionar todas las columnas excepto ciertas de una tabla), creo que vale la pena mencionar que puede especificar table. para obtener todas las columnas de una tabla en particular, en lugar de solo especificar .

Aquí hay un ejemplo de cómo esto podría ser muy útil:

select users.*, phone.meta_value as phone, zipcode.meta_value as zipcode

from users

left join user_meta as phone
on ( (users.user_id = phone.user_id) AND (phone.meta_key = 'phone') )

left join user_meta as zipcode
on ( (users.user_id = zipcode.user_id) AND (zipcode.meta_key = 'zipcode') )

El resultado son todas las columnas de la tabla users, y dos columnas adicionales que fueron se unió desde la tabla meta.

Me gustó la respuesta de @Mahomedalid además de este hecho informado en comentario de @Bill Karwin. El posible problema planteado por @Jan Koritak es cierto que me enfrenté a eso, pero he encontrado un truco para eso y solo quiero compartirlo aquí para cualquiera que se enfrente al problema.

Podemos reemplazar la función REPLACE con la cláusula where en la sub-consulta de la instrucción Preparada como esta:

Usando mi nombre de tabla y columna

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;

Entonces, esto va a excluir solo el campo id pero no company_id

Esperanza esto ayudará a cualquiera que busque una solución.

Saludos

Es una buena práctica especificar las columnas que está consultando incluso si consulta todas las columnas.

Así que le sugeriría que escriba el nombre de cada columna en la declaración (excluyendo la que no desea).

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

FROM table

Estoy de acuerdo con la solución "simple" de enumerar todas las columnas, pero esto puede ser engorroso, y los errores tipográficos pueden causar una gran pérdida de tiempo. Utilizo una función "getTableColumns" para recuperar los nombres de mis columnas adecuadas para pegar en una consulta. Entonces todo lo que tengo que hacer es eliminar los que no quiero.

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;

El resultado devuelve una cadena delimitada por comas, por ejemplo...

Col1,col2,col3,col4,...col53

Estoy de acuerdo en que no es suficiente con Select *, si ese que no necesitas, como se mencionó en otro lugar, es un BLOB, no quieres tener ese arrastre de arriba.

Crearía una vista con los datos requeridos, entonces puede Select * cómodamente if si el software de la base de datos los admite. De lo contrario, ponga los datos enormes en otra tabla.

Al principio pensé que podría usar expresiones regulares, pero como he estado leyendo MYSQL docs parece que no puede. Si fuera usted, usaría otro lenguaje (como PHP) para generar una lista de columnas que desea obtener, almacenarla como una cadena y luego usarla para generar el SQL.

Solo hazlo

SELECT * FROM table WHERE whatever

Luego suelta la columna en tu lenguaje de programación favorito: php

while (($data = mysql_fetch_array($result, MYSQL_ASSOC)) !== FALSE) {
   unset($data["id"]);
   foreach ($data as $k => $v) { 
      echo"$v,";
   }      
}

Yo también quería esto, así que creé una función en su lugar.

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)."`";
    }
}

Entonces, cómo funciona es que ingresa la tabla, luego una columna que no desea o como en un array: array("id","name","whatevercolumn")

Así que en select puedes usarlo así:

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

O

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

Si bien estoy de acuerdo con la respuesta de Thomas (+1 ;)), me gustaría agregar la advertencia de que asumiré que la columna que no desea apenas contiene datos. Si contiene enormes cantidades de texto, xml o blobs binarios, tómese el tiempo para seleccionar cada columna individualmente. Su rendimiento se verá afectado de lo contrario. ¡Salud!

Sí, aunque puede ser alta E/S dependiendo de la tabla aquí es una solución que encontré para ello.

Select *
into #temp
from table

alter table #temp drop column column_name

Select *
from #temp

La respuesta publicada por Mahomedalid tiene un pequeño problema:

Dentro del código de la función reemplazar estaba reemplazando "<columns_to_delete>," por "", este reemplazo tiene un problema si el campo a reemplazar es el último en la cadena concat debido a que el último no tiene la coma char "," y no se elimina de la cadena.

Mi propuesta:

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

Sustitución <table>, <database> y "

La columna eliminada se reemplaza por la cadena "FIELD_REMOVED" en mi caso esto funciona porque estaba tratando de memoria segura. (El campo que estaba eliminando es una GOTA de alrededor de 1MB)

Basado en la respuesta de @Mahomedalid, he hecho algunas mejoras para soportar "seleccionar todas las columnas excepto algunas en 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;

Si tiene muchos cols, use este sql para cambiar group_concat_max_len

SET @@group_concat_max_len = 2048;

Puede ser que tenga una solución a Jan Koritak señaló discrepancia

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

Cuadro:

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 de la consulta:

'SELECT name_eid,sal FROM employee'

Estoy de acuerdo con la respuesta de @Mahomedalid. Pero no quería hacer algo como declaración preparada y no quería escribir todos los campos. Así que lo que tenía era una solución tonta. Vaya a la tabla en phpmyadmin - > sql - > select, vuelca la consulta copy replace y listo! :)

Si siempre es la misma columna, entonces puede crear una vista que no la tenga en ella.

De lo contrario, no, no lo creo.

Puede usar SQL para generar SQL si lo desea y evaluar el SQL que produce. Esta es una solución general, ya que extrae los nombres de las columnas del esquema de información. Aquí hay un ejemplo de la línea de comandos de Unix.

Sustituyendo

• MYSQL con su comando mysql
• TABLA con el nombre de la tabla
• EXCLUIDEDFIELD con nombre de campo excluido

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

Realmente solo necesitará extraer los nombres de las columnas de esta manera solo una vez para construir el la lista de columnas excluyó esa columna, y luego simplemente use la consulta que ha construido.

Así que 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)

Ahora puede reutilizar la cadena $column_list en las consultas que construya.

Me gustaría agregar otro punto de vista para resolver este problema, especialmente si tiene un pequeño número de columnas para eliminar.

Puede usar una herramienta de base de datos como MySQL Workbench para generar la instrucción select por usted, por lo que solo tiene que eliminar manualmente esas columnas para la instrucción generada y copiarla a su script SQL.

En MySQL Workbench la forma de generarlo es:

Haga clic derecho en la tabla - > enviar al Editor Sql - > Seleccionar todo Instrucción.

Soy bastante tarde en la agonía de una respuesta para esto, puesto que esta es la forma en que siempre lo he hecho y, francamente, es 100 veces mejor y más limpio que la mejor respuesta, solo espero que alguien lo vea. Y lo encuentra ú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]);

Select * es un antipatrón SQL. No debe usarse en código de producción por muchas razones, incluyendo:

Tarda un poco más en procesarse. Cuando las cosas se ejecutan millones de veces, esos pequeños bits pueden importar. Una base de datos lenta donde la lentitud es causada por este tipo de codificación descuidada en todo es el tipo más difícil para la melodía de rendimiento.

Significa que probablemente está enviando más datos de los que necesita, lo que causa cuellos de botella tanto en el servidor como en la red. Si tienes una unión interior, las posibilidades de enviar más datos de los que necesita son del 100%.

Causa problemas de mantenimiento, especialmente cuando ha agregado nuevas columnas que no desea que se vean en todas partes. Además, si tiene una columna nueva, es posible que deba hacer algo en la interfaz para determinar qué hacer con esa columna.

Puede romper las vistas (sé que esto es cierto en SQl server, puede o no ser cierto en mysql).

Si alguien es lo suficientemente tonto como para reconstruir las tablas con las columnas en un diferente orden (que no debe hacer, pero sucede todo el tiempo), todo tipo de código puede romperse. Especialmente código para una inserción por ejemplo, donde de repente está poniendo la ciudad en el campo address_3 porque sin especificar, la base de datos solo puede ir en el orden de las columnas. Esto es suficientemente malo cuando los tipos de datos cambian, pero peor cuando las columnas intercambiadas tienen el mismo tipo de datos, ya que puede insertar datos defectuosos en algún momento que es un desastre para limpiar. Necesita preocuparse por los datos integridad.

Si se usa en un inserto, se romperá el inserto si se agrega una nueva columna en una tabla pero no en la otra.

Podría romper los disparadores. Los problemas desencadenantes pueden ser difíciles de diagnosticar.

Suma todo esto con el tiempo que se tarda en agregar los nombres de las columnas (diablos, incluso puedes tener una interfaz que te permita arrastrar sobre los nombres de las columnas (sé que lo hago en SQL Server, apuesto a que hay alguna manera de hacer esto es alguna herramienta que usas para escribir consultas mysql.) Let's vea, " Puedo causar problemas de mantenimiento, puedo causar problemas de rendimiento y puedo causar problemas de integridad de datos, pero bueno, ahorré cinco minutos de tiempo de desarrollo."Simplemente pon las columnas específicas que quieras.

También te sugiero que leas este libro: 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&keywords=sql+antipatterns