SQL excluye una columna usando SELECT * [excepto columnA] FROM tableA?

Todos sabemos que para seleccionar todas las columnas de una tabla, podemos usar

SELECT * FROM tableA

¿Hay alguna manera de excluir columnas de una tabla sin especificar todas las columnas?

SELECT * [except columnA] FROM tableA

La única forma que sé es especificar manualmente todas las columnas y excluir la columna no deseada. Esto lleva mucho tiempo, por lo que estoy buscando formas de ahorrar tiempo y esfuerzo en esto, así como el mantenimiento futuro en caso de que la tabla tenga más / menos columnas.

Estoy de acuerdo con todos ... pero si fuera a hacer algo como esto, podría hacerlo de esta manera:

/* Get the data into a temp table */
SELECT * INTO #TempTable
FROM YourTable
/* Drop the columns that are not needed */
ALTER TABLE #TempTable
DROP COLUMN ColumnToDrop
/* Get results and drop temp table */
SELECT * FROM #TempTable
DROP TABLE #TempTable

No.

La mejor práctica de mantenimiento ligero es especificar solo las columnas requeridas.

Al menos 2 razones:

• Esto hace que su contrato entre el cliente y la base de datos sea estable. Misma información, siempre
• Rendimiento, cubriendo índices

Editar (julio de 2011):

Si arrastra desde el Explorador de objetos el Columnsnodo para una tabla, coloca una lista CSV de columnas en la Ventana de consulta para usted, lo que logra uno de sus objetivos

Si no desea escribir cada nombre de columna manualmente, puede usarlo Script Table Ashaciendo clic derecho en la tabla o ver en SSMS de esta manera:

Luego obtendrá una consulta de selección completa en la Nueva ventana del editor de consultas y luego eliminará la columna no deseada como esta:

Hecho

La forma automatizada de hacer esto en SQL (SQL Server) es:

declare @cols varchar(max), @query varchar(max);
SELECT  @cols = STUFF
    (
        ( 
            SELECT DISTINCT '], [' + name
            FROM sys.columns
            where object_id = (
                select top 1 object_id from sys.objects
                where name = 'MyTable'
            )
            and name not in ('ColumnIDontWant1', 'ColumnIDontWant2')
            FOR XML PATH('')
        ), 1, 2, ''
    ) + ']';

SELECT @query = 'select ' + @cols + ' from MyTable';  
EXEC (@query);

Puede crear una vista que tenga las columnas que desea seleccionar, luego puede simplemente select *desde la vista ...

Sí, es posible (pero no recomendado).

CREATE TABLE contact (contactid int, name varchar(100), dob datetime)
INSERT INTO contact SELECT 1, 'Joe', '1974-01-01'

DECLARE @columns varchar(8000)

SELECT @columns = ISNULL(@columns + ', ','') + QUOTENAME(column_name)
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME = 'contact' AND COLUMN_NAME <> 'dob'
ORDER BY ORDINAL_POSITION

EXEC ('SELECT ' + @columns + ' FROM contact')

Explicación del código :

1. Declare una variable para almacenar una lista separada por comas de nombres de columna. Esto predeterminado es NULL.
2. Use una vista del sistema para determinar los nombres de las columnas en nuestra tabla.
3. Use SELECT @variable = @variable + ... FROMpara concatenar los nombres de columna. Este tipo de SELECTno devuelve un conjunto de resultados. Este es quizás un comportamiento no documentado, pero funciona en todas las versiones de SQL Server. Como alternativa, puede usar SET @variable = (SELECT ... FOR XML PATH(''))para concatenar cadenas.
4. Use la ISNULLfunción para anteponer una coma solo si este no es el nombre de la primera columna. Use la QUOTENAMEfunción para admitir espacios y puntuación en los nombres de columna.
5. Use la WHEREcláusula para ocultar columnas que no queremos ver.
6. Use EXEC (@variable), también conocido como SQL dinámico , para resolver los nombres de columna en tiempo de ejecución. Esto es necesario porque no conocemos los nombres de las columnas en tiempo de compilación.

Como los otros han dicho, no hay forma de hacer esto, pero si está usando SQL Server, un truco que uso es cambiar la salida a coma separada, entonces haga

select top 1 * from table

y cortar la lista completa de columnas de la ventana de salida. Luego puede elegir qué columnas desea sin tener que escribirlas todas.

Básicamente, no puede hacer lo que le gustaría, pero puede obtener las herramientas adecuadas para ayudarlo a hacer las cosas un poco más fáciles.

Si observa la solicitud SQL de Red-Gate , puede escribir "SELECCIONAR * DE MyTable", y luego mover el cursor hacia atrás después de "*", y presionar <TAB> para expandir la lista de campos, y eliminar esos pocos campos que no necesito

No es una solución perfecta, ¡pero es una muy buena! :-) Lástima que Intellisense de MS SQL Server Management Studio todavía no sea lo suficientemente inteligente como para ofrecer esta característica .......

Bagazo

no, no hay forma de hacer esto. tal vez pueda crear vistas personalizadas si eso es factible en su situación

EDITAR Puede ser si su base de datos admite la ejecución de sql dinámico. Podría escribir un SP y pasar las columnas que no desea ver y dejar que cree la consulta dinámicamente y le devuelva el resultado. Creo que esto es factible en SQL Server al menos

Si está utilizando SQL Server Management Studio, haga lo siguiente:

1. Escriba el nombre de su tabla deseada y selecciónela
2. Presione Alt+F1
3. o / p muestra las columnas en la tabla.
4. Seleccione las columnas deseadas
5. Copie y pegue los de su consulta de selección
6. Dispara la consulta.

Disfrutar.

En SQL Management Studio puede expandir las columnas en el Explorador de objetos, luego arrastrar el Columnselemento del árbol a una ventana de consulta para obtener una lista de columnas separadas por comas.

En resumen, no puede hacerlo, pero no estoy de acuerdo con todos los comentarios anteriores, hay "escenarios" en los que puede usar legítimamente un * cuando crea una consulta anidada para seleccionar un rango específico de una lista completa (como paginación) ¿por qué en el mundo desearía especificar cada columna en la declaración de selección externa cuando lo ha hecho en la interna?

DECLARE @SQL VARCHAR(max), @TableName sysname = 'YourTableName'

SELECT @SQL = COALESCE(@SQL + ', ', '') + Name 
FROM sys.columns
WHERE OBJECT_ID = OBJECT_ID(@TableName)
AND name NOT IN ('Not This', 'Or that');

SELECT @SQL = 'SELECT ' + @SQL + ' FROM ' + @TableName

EXEC (@SQL)

ACTUALIZAR:

También puede crear un procedimiento almacenado para encargarse de esta tarea si la usa con más frecuencia. En este ejemplo, he usado el STRING_SPLIT () que está disponible en SQL Server 2016+, pero si lo necesita, hay muchos ejemplos de cómo crearlo manualmente en SO.

CREATE PROCEDURE [usp_select_without]
@schema_name sysname = N'dbo',
@table_name sysname,
@list_of_columns_excluded nvarchar(max),
@separator nchar(1) = N','
AS
BEGIN
 DECLARE 
 @SQL nvarchar(max),
 @full_table_name nvarchar(max) = CONCAT(@schema_name, N'.', @table_name);

 SELECT @SQL = COALESCE(@SQL + ', ', '') + QUOTENAME([Name])
 FROM sys.columns sc
 LEFT JOIN STRING_SPLIT(@list_of_columns_excluded, @separator) ss ON sc.[name] = ss.[value]
 WHERE sc.OBJECT_ID = OBJECT_ID(@full_table_name, N'u')
 AND ss.[value] IS NULL;

 SELECT @SQL = N'SELECT ' + @SQL + N' FROM ' + @full_table_name;
 EXEC(@SQL)
END

Y luego solo:

EXEC [usp_select_without] 
@table_name = N'Test_Table',
@list_of_columns_excluded = N'ID, Date, Name';

Si hablamos de procedimientos, funciona con este truco para generar una nueva consulta y EJECUTARLA INMEDIATA :

SELECT LISTAGG((column_name), ', ') WITHIN GROUP (ORDER BY column_id)
INTO var_list_of_columns
FROM ALL_TAB_COLUMNS
WHERE table_name = 'PUT_HERE_YOUR_TABLE'
AND column_name NOT IN ('dont_want_this_column','neither_this_one','etc_column');

¿Hay alguna manera de excluir columnas de una tabla sin especificar todas las columnas?

Usando SQL declarativo de la manera usual, no.

Creo que su sintaxis propuesta es digna y buena. De hecho, el lenguaje de base de datos relacional 'Tutorial D' tiene una sintaxis muy similar donde las palabras clave ALL BUTvan seguidas de un conjunto de atributos (columnas).

Sin embargo, el SQL SELECT *ya recibe muchas críticas (la respuesta de @ Guffa aquí es una objeción típica), por lo que no creo SELECT ALL BUTque llegue al Estándar SQL pronto.

Creo que el mejor 'trabajo' es crear una VIEWcon solo las columnas que desee en ese momento SELECT * FROM ThatView.

Un dialecto SQL moderno como BigQuery propone una excelente solución

SELECCIONAR * EXCEPTO (ColumnNameX, [ColumnNameY, ...])

Esta es una sintaxis SQL muy poderosa para evitar una larga lista de columnas que deben actualizarse todo el tiempo debido a cambios en el nombre de la columna de la tabla. Y esta funcionalidad falta en la implementación actual de SQL Server, lo cual es una pena. Con suerte, algún día, Microsoft Azure será más amigable con los científicos de datos.

A los científicos de datos les gusta poder tener una opción rápida para acortar una consulta y poder eliminar algunas columnas (debido a la duplicación o cualquier otra razón).

https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#select-modifiers

Postgres sql tiene una forma de hacerlo

consulte: http://www.postgresonline.com/journal/archives/41-How-to-SELECT-ALL-EXCEPT-some-columns-in-a-table.html

El esquema de información Hack Way

SELECT 'SELECT ' || array_to_string(ARRAY(SELECT 'o' || '.' || c.column_name
        FROM information_schema.columns As c
            WHERE table_name = 'officepark' 
            AND  c.column_name NOT IN('officeparkid', 'contractor')
    ), ',') || ' FROM officepark As o' As sqlstmt

Lo anterior para mi tabla de ejemplo particular: genera una instrucción sql que se ve así

SELECCIONE o.officepark, o.owner, o.squarefootage FROM officepark As o

No conozco ninguna base de datos que soporte esto (SQL Server, MySQL, Oracle, PostgreSQL). Definitivamente no es parte de los estándares SQL, así que creo que debe especificar solo las columnas que desea.

Por supuesto, podría construir su declaración SQL de forma dinámica y hacer que el servidor la ejecute. Pero esto abre la posibilidad de inyección SQL.

Sé que esto es un poco viejo, pero acababa de encontrarme con el mismo problema y estaba buscando una respuesta. Luego tuve un desarrollador senior que me mostró un truco muy simple.

Si está utilizando el editor de consultas de Management Studio, expanda la base de datos, luego expanda la tabla que está seleccionando para que pueda ver la carpeta de columnas.

En su declaración de selección, solo resalte la carpeta de columnas referenciadas arriba y arrástrela y suéltela en la ventana de consulta. Pegará todas las columnas de la tabla, luego simplemente eliminará la columna de identidad de la lista de columnas ...

La mejor manera de resolver esto es usando la vista, puede crear una vista con las columnas requeridas y recuperar datos de ella

example

mysql> SELECT * FROM calls;
+----+------------+---------+
| id | date       | user_id |
+----+------------+---------+
|  1 | 2016-06-22 |       1 |
|  2 | 2016-06-22 |    NULL |
|  3 | 2016-06-22 |    NULL |
|  4 | 2016-06-23 |       2 |
|  5 | 2016-06-23 |       1 |
|  6 | 2016-06-23 |       1 |
|  7 | 2016-06-23 |    NULL |
+----+------------+---------+
7 rows in set (0.06 sec)

mysql> CREATE VIEW C_VIEW AS
    ->     SELECT id,date from calls;
Query OK, 0 rows affected (0.20 sec)

mysql> select * from C_VIEW;
+----+------------+
| id | date       |
+----+------------+
|  1 | 2016-06-22 |
|  2 | 2016-06-22 |
|  3 | 2016-06-22 |
|  4 | 2016-06-23 |
|  5 | 2016-06-23 |
|  6 | 2016-06-23 |
|  7 | 2016-06-23 |
+----+------------+
7 rows in set (0.00 sec)

Si desea excluir una columna de mayúsculas y minúsculas como la contraseña, por ejemplo, hago esto para ocultar el valor:

SELECT * , "" as password FROM tableName;

Bueno, es una práctica recomendada común especificar qué columnas desea, en lugar de solo especificar *. Por lo tanto, debe indicar qué campos desea que devuelva su selección.

Un colegio aconseja una buena alternativa:

• SELECCIONE EN su consulta anterior (donde genera u obtiene los datos) en una tabla (que eliminará cuando termine). Esto creará la estructura para ti.
• Realice un script como CREAR en una nueva ventana de consulta.
• Eliminar las columnas no deseadas. Formatee las columnas restantes en un trazador de líneas 1 y péguelo como su lista de columnas.
• Elimina la tabla que creaste.

Hecho...

Esto nos ayudó mucho.

Haga clic con el botón derecho en la tabla en el Explorador de objetos, seleccione las 1000 filas superiores

Enumerará todas las columnas y no *. Luego, elimine las columnas no deseadas. Debería ser mucho más rápido que escribirlo usted mismo.

Luego, cuando sienta que esto es demasiado trabajo, obtenga el mensaje SQL de Red Gate y escriba ssf desde tbl, vaya a * y haga clic en la pestaña nuevamente.

Que lo uso a menudo para este caso:

declare @colnames varchar(max)=''

select @colnames=@colnames+','+name from syscolumns where object_id(tablename)=id and name not in (column3,column4)

SET @colnames=RIGHT(@colnames,LEN(@colnames)-1)

@colnames parece column1,column2,column5

A veces, el mismo programa debe manejar diferentes estructuras de bases de datos. Por lo tanto, no podría usar una lista de columnas en el programa para evitar errores en las selectdeclaraciones.

*me da todos los campos opcionales Compruebo si los campos existen en la tabla de datos antes de usarlos. Este es mi razón para usar *en select.

Así es como manejo los campos excluidos:

Dim da As New SqlDataAdapter("select * from table", cn)
da.FillSchema(dt, SchemaType.Source)
Dim fieldlist As String = ""
For Each DC As DataColumn In DT.Columns
   If DC.ColumnName.ToLower <> excludefield Then
    fieldlist = fieldlist &  DC.Columnname & ","
   End If
  Next

Sé que esta pregunta es antigua, pero espero que aún pueda ser útil. La respuesta está inspirada en un debate de los foros de SQL Server . Puede hacer de esto un procedimiento almacenado . También se puede modificar para agregar más de uno, excepto los campos.

DECLARE @SQL NVARCHAR(MAX)
SELECT @SQL = COALESCE(@SQL + ', ', ' ' ) + name from sys.columns where name not in ('colName1','colName2') and object_id = (Select id from sysobjects where name = 'tblName')
SELECT @SQL = 'SELECT ' + @SQL + ' FROM ' + 'tblName'
EXEC sp_executesql  @SQL

¿No sería más simple hacer esto?

sp_help <table_name>

-Haga clic en la columna 'Column_name'> Copiar> Pegar (crea una lista vertical) en una ventana Nueva consulta y simplemente escriba comas delante del valor de cada columna ... comente las columnas que no desea ... mucho menos escribiendo que cualquier código ofrecido aquí y aún manejable.

Puede obtener SQL Complete de devart.com, que no solo expande el comodín * al igual que lo hace SQL Prompt de Red Gate (como se describe en la respuesta de cairnz), sino que también proporciona un menú desplegable de selección de columnas con casillas de verificación en las que puede marcar todos los columnas que desee en la lista de selección y se insertarán automáticamente por usted (y si desmarca una columna, se eliminará automáticamente de la lista de selección).

En SSMS hay una manera más fácil con IntelliSense y Aliasing . Prueba esto

1. Haga clic derecho en el editor de texto y asegúrese de que IntelliSense esté habilitado.
2. Escriba la consulta con un alias [SELEC . T. * DESDE nombre de tabla t].
3. Ir al texto t. * Y elimine el * , y SSMS se auto-lista de las columnas de la f tabla de alias.