SQL esclude una colonna usando SELECT * [tranne la colonnaA] FROM tableA?

Sappiamo tutti che per selezionare tutte le colonne da una tabella, possiamo usare

SELECT * FROM tableA

C'è un modo per escludere le colonne da una tabella senza specificare tutte le colonne?

SELECT * [except columnA] FROM tableA

L'unico modo che conosco è specificare manualmente tutte le colonne ed escludere la colonna indesiderata. Ciò richiede molto tempo, quindi sto cercando modi per risparmiare tempo e fatica, oltre alla manutenzione futura nel caso in cui la tabella abbia più / meno colonne.

Sono d'accordo con tutti ... ma se avessi fatto qualcosa del genere avrei potuto farlo in questo modo:

/* 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 procedura consigliata per la manutenzione è specificare solo le colonne richieste.

Almeno 2 motivi:

• Ciò rende stabile il contratto tra client e database. Stessi dati, ogni volta
• Performance, che copre gli indici

Modifica (luglio 2011):

Se trascini da Esplora oggetti il Columnsnodo per una tabella, inserisce un elenco CSV di colonne nella finestra delle query per te che raggiunge uno dei tuoi obiettivi

Se non si desidera scrivere manualmente il nome di ogni colonna, è possibile utilizzare Script Table Asfacendo clic con il tasto destro sulla tabella o visualizzare in SSMS in questo modo:

Quindi otterrai un'intera query di selezione nella nuova finestra dell'editor di query, quindi rimuovi la colonna indesiderata in questo modo:

Fatto

Il modo automatico per farlo in SQL (SQL Server) è:

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

Puoi creare una vista con le colonne che desideri selezionare, quindi puoi semplicemente select *dalla vista ...

Sì è possibile (ma non raccomandato).

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

Spiegazione del codice :

1. Dichiarare una variabile per memorizzare un elenco separato da virgole di nomi di colonna. L'impostazione predefinita è NULL.
2. Utilizzare una vista di sistema per determinare i nomi delle colonne nella nostra tabella.
3. Utilizzare SELECT @variable = @variable + ... FROMper concatenare i nomi delle colonne. Questo tipo di SELECTnon restituisce un set di risultati. Questo è forse un comportamento non documentato ma funziona in ogni versione di SQL Server. In alternativa, è possibile utilizzare SET @variable = (SELECT ... FOR XML PATH(''))per concatenare le stringhe.
4. Utilizzare la ISNULLfunzione per anteporre una virgola solo se questo non è il nome della prima colonna. Utilizzare la QUOTENAMEfunzione per supportare spazi e punteggiatura nei nomi di colonna.
5. Usa la WHEREclausola per nascondere le colonne che non vogliamo vedere.
6. Utilizzare EXEC (@variable), noto anche come SQL dinamico , per risolvere i nomi delle colonne in fase di esecuzione. Questo è necessario perché non conosciamo i nomi delle colonne al momento della compilazione.

Come altri hanno già detto, non c'è modo di farlo, ma se si utilizza Sql Server un trucco che uso è quello di modificare l'output in virgola separata, quindi fare

select top 1 * from table

e tagliare l'intero elenco di colonne dalla finestra di output. Quindi puoi scegliere quali colonne vuoi senza doverle digitare tutte.

Fondamentalmente, non puoi fare quello che vorresti, ma puoi ottenere gli strumenti giusti per aiutarti a rendere le cose un po 'più facili.

Se dai un'occhiata al prompt SQL di Red-Gate , puoi digitare "SELECT * FROM MyTable", quindi spostare il cursore indietro dopo "*" e premere <TAB> per espandere l'elenco dei campi e rimuovere quei pochi campi che non ho bisogno.

Non è una soluzione perfetta, ma dannatamente buona! :-) Peccato che Intellisense di MS SQL Server Management Studio non sia ancora abbastanza intelligente da offrire questa funzionalità .......

Marc

no non c'è modo di farlo. forse puoi creare viste personalizzate se è possibile nella tua situazione

EDIT Può essere se il tuo DB supporta l'esecuzione di sql dinamico, potresti scrivere un SP e passare le colonne che non vuoi vedere e lasciargli creare la query in modo dinamico e restituirti il ​​risultato. Penso che questo sia fattibile in almeno SQL Server

Se si utilizza SQL Server Management Studio, procedere come segue:

1. Digita il nome desiderato per le tabelle e selezionalo
2. Premi Alt+F1
3. o / p mostra le colonne nella tabella.
4. Seleziona le colonne desiderate
5. Copia e incolla quelli nella tua query selezionata
6. Lancia la query.

Godere.

In SQL Management Studio è possibile espandere le colonne in Esplora oggetti, quindi trascinare l' Columnselemento dell'albero in una finestra di query per ottenere un elenco di colonne separato da virgole.

In sintesi non puoi farlo, ma non sono d'accordo con tutti i commenti sopra, ci sono "scenari" in cui puoi legittimamente usare un * Quando crei una query nidificata per selezionare un intervallo specifico da un intero elenco (come paging) perché nel mondo vorrebbe specificare ogni colonna sull'istruzione select esterna quando l'hai eseguita all'interno?

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)

AGGIORNARE:

È inoltre possibile creare una procedura memorizzata per occuparsi di questa attività se la si utilizza più spesso. In questo esempio ho usato il STRING_SPLIT () incorporato che è disponibile su SQL Server 2016+, ma se hai bisogno ci sono molti esempi di come crearlo manualmente su 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

E poi solo:

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

Se stiamo parlando di procedure, funziona con questo trucco per generare una nuova query ed eseguirla IMMEDIATA :

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

C'è un modo per escludere le colonne da una tabella senza specificare tutte le colonne?

Utilizzando SQL dichiarativo nel solito modo, no.

Penso che la tua sintassi proposta sia degna e buona. In effetti, il linguaggio del database relazionale 'Tutorial D' ha una sintassi molto simile in cui le parole chiave ALL BUTsono seguite da una serie di attributi (colonne).

Tuttavia, SQL ha SELECT *già molti difetti (la risposta di @ Guffa qui è un'obiezione tipica), quindi non credo che SELECT ALL BUTentrerà presto nello Standard SQL.

Penso che il miglior 'aggirare' sia quello di creare un VIEWcon solo le colonne che desideri allora SELECT * FROM ThatView.

Un moderno dialetto SQL come BigQuery propone una soluzione eccellente

SELECT * EXCEPT (ColumnNameX, [ColumnNameY, ...])

Questa è una sintassi SQL molto potente per evitare un lungo elenco di colonne che devono essere aggiornate continuamente a causa delle modifiche al nome della colonna della tabella. E questa funzionalità manca nell'attuale implementazione di SQL Server, il che è un peccato. Eventualmente, un giorno, Microsoft Azure sarà più amichevole per i data scientist.

Ai data scientist piace poter disporre di un'opzione rapida per abbreviare una query ed essere in grado di rimuovere alcune colonne (a causa della duplicazione o di qualsiasi altro motivo).

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

Postgres sql ha un modo di farlo

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

Lo schema informatico 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

Quanto sopra per la mia tabella di esempio particolare - genera un'istruzione sql simile a questa

SELEZIONA o.officepark, o.owner, o.squarefootage FROM officepark Come o

Non conosco nessun database che supporti questo (SQL Server, MySQL, Oracle, PostgreSQL). Non fa sicuramente parte degli standard SQL, quindi penso che devi specificare solo le colonne che desideri.

Ovviamente potresti creare la tua istruzione SQL in modo dinamico e farla eseguire dal server. Ma questo apre la possibilità per l'iniezione di SQL ..

So che questo è un po 'vecchio, ma avevo appena incontrato lo stesso problema e stavo cercando una risposta. Poi ho avuto uno sviluppatore senior che mi ha mostrato un trucco molto semplice.

Se si utilizza l'editor di query di Management Studio, espandere il database, quindi espandere la tabella da cui si sta selezionando in modo da poter visualizzare la cartella delle colonne.

Nell'istruzione select, evidenzia la cartella delle colonne di riferimento sopra e trascinala nella finestra della query. Incollerà tutte le colonne della tabella, quindi rimuoverà semplicemente la colonna identità dall'elenco delle colonne ...

Il modo migliore per risolvere questo problema è utilizzare la vista che è possibile creare vista con le colonne richieste e recuperare i dati da esso

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)

Se si desidera escludere una colonna di maiuscole / minuscole come la password, ad esempio, lo faccio per nascondere il valore:

SELECT * , "" as password FROM tableName;

Bene, è una buona pratica comune specificare quali colonne vuoi, invece di specificare *. Quindi dovresti semplicemente indicare quali campi vuoi che la tua selezione restituisca.

Un collega ha consigliato una buona alternativa:

• SELEZIONA INTO nella query precedente (da dove generi o ottieni i dati) in una tabella (che eliminerai al termine). Questo creerà la struttura per te.
• Esegui uno script come CREATE nella nuova finestra della query.
• Rimuovi le colonne indesiderate. Formatta le colonne rimanenti in una riga e incollale come elenco di colonne.
• Elimina la tabella che hai creato.

Fatto...

Questo ci ha aiutato molto.

Fare clic con il tasto destro del mouse in Esplora oggetti, selezionare le prime 1000 righe

Elencherà tutte le colonne e non *. Quindi rimuovere le colonne indesiderate. Dovrebbe essere molto più veloce che digitarlo da soli.

Quindi quando ritieni che sia un po 'troppo lavoro, ottieni il prompt SQL di Red Gate e digita ssf da tbl, vai al * e fai nuovamente clic sulla scheda.

Che cosa uso spesso per questo 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 sembra column1,column2,column5

A volte lo stesso programma deve gestire diverse strutture di database. Quindi non ho potuto usare un elenco di colonne nel programma per evitare errori nelle selectdichiarazioni.

*mi dà tutti i campi opzionali. Controllo se i campi esistono nella tabella dei dati prima dell'uso. Questa è la mia ragione per usare *in select.

Ecco come gestisco i campi esclusi:

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

So che questa domanda è vecchia, ma spero che possa ancora essere utile. La risposta è ispirata da una discussione dei forum di SQL Server . Puoi rendere questa una procedura memorizzata . Può anche essere modificato per aggiungere più di uno tranne i campi.

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

Non sarebbe più semplice farlo:

sp_help <table_name>

-Fai clic sulla colonna "Nome_colonna"> Copia> Incolla (crea un elenco verticale) in una finestra Nuova query e digita le virgole davanti al valore di ogni colonna ... commenta le colonne che non vuoi ... molto meno digitando rispetto a qualsiasi codice offerto qui e ancora gestibile.

È possibile ottenere SQL Complete da devart.com, che non solo espande il carattere jolly * proprio come fa il prompt SQL di Red Gate (come descritto nella risposta di cairnz), ma fornisce anche un selettore di colonne a discesa con caselle in cui è possibile selezionare tutti i colonne che desideri nell'elenco di selezione e verranno inserite automaticamente per te (e se deselezioni una colonna verrà automaticamente rimosso dall'elenco di selezione).

In SSMS c'è un modo più semplice con IntelliSense e Aliasing . Prova questo

1. Fare clic con il tasto destro nell'editor di testo e assicurarsi che IntelliSense sia abilitato.
2. Digita la query con un alias [SELEZIONA t. * FROM tablename t].
3. Vai al testo t. * Ed eliminare il * , e SSMS volontà auto-list le colonne della f tavolo alias.