SQL schließt eine Spalte mit SELECT aus * [außer SpalteA] FROM TabelleA?

Wir alle wissen, dass wir alle Spalten aus einer Tabelle auswählen können

SELECT * FROM tableA

Gibt es eine Möglichkeit, Spalten aus einer Tabelle auszuschließen, ohne alle Spalten anzugeben?

SELECT * [except columnA] FROM tableA

Die einzige Möglichkeit, die ich kenne, besteht darin, alle Spalten manuell anzugeben und die unerwünschte Spalte auszuschließen. Dies ist sehr zeitaufwändig, daher suche ich nach Möglichkeiten, um Zeit und Mühe zu sparen, sowie nach zukünftigen Wartungsarbeiten, falls die Tabelle mehr / weniger Spalten enthält.

Ich stimme allen zu ... aber wenn ich so etwas machen würde, könnte ich es so machen:

/* 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

Nein.

Die bewährte Methode für Wartungslicht besteht darin, nur die erforderlichen Spalten anzugeben.

Mindestens 2 Gründe:

• Dies macht Ihren Vertrag zwischen Client und Datenbank stabil. Jedes Mal die gleichen Daten
• Performance, die Indizes abdeckt

Bearbeiten (Juli 2011):

Wenn Sie den ColumnsKnoten für eine Tabelle aus dem Objekt-Explorer ziehen , wird eine CSV-Liste mit Spalten im Abfragefenster für Sie eingefügt, mit der eines Ihrer Ziele erreicht wird

Wenn Sie nicht jeden Spaltennamen manuell schreiben möchten, können Sie ihn verwenden, Script Table Asindem Sie mit der rechten Maustaste auf eine Tabelle oder Ansicht in SSMS klicken :

Anschließend erhalten Sie im Fenster "Neuer Abfrage-Editor" eine vollständige Auswahlabfrage. Entfernen Sie dann unerwünschte Spalten wie folgt :

Erledigt

Der automatisierte Weg, dies in SQL (SQL Server) zu tun, ist:

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

Sie können eine Ansicht mit den Spalten erstellen, die Sie auswählen möchten, und dann einfach select *aus der Ansicht ...

Ja, es ist möglich (aber nicht empfohlen).

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

Erläuterung des Codes :

1. Deklarieren Sie eine Variable, um eine durch Kommas getrennte Liste von Spaltennamen zu speichern. Dies ist standardmäßig NULL.
2. Verwenden Sie eine Systemansicht, um die Namen der Spalten in unserer Tabelle zu ermitteln.
3. Verwenden Sie SELECT @variable = @variable + ... FROMdiese Option, um die Spaltennamen zu verketten. Diese Art von SELECTgibt keine Ergebnismenge zurück. Dies ist möglicherweise ein undokumentiertes Verhalten, funktioniert jedoch in jeder Version von SQL Server. Alternativ können Sie SET @variable = (SELECT ... FOR XML PATH(''))Zeichenfolgen verketten.
4. Verwenden Sie die ISNULLFunktion, um ein Komma nur voranzustellen, wenn dies nicht der erste Spaltenname ist. Verwenden Sie die QUOTENAMEFunktion, um Leerzeichen und Interpunktion in Spaltennamen zu unterstützen.
5. Verwenden Sie die WHEREKlausel, um Spalten auszublenden, die wir nicht sehen möchten.
6. Verwenden Sie diese Option EXEC (@variable), auch als dynamisches SQL bezeichnet , um die Spaltennamen zur Laufzeit aufzulösen. Dies ist erforderlich, da wir die Spaltennamen zur Kompilierungszeit nicht kennen.

Wie die anderen gesagt haben, gibt es keine Möglichkeit, dies zu tun, aber wenn Sie SQL Server verwenden, besteht ein Trick, den ich verwende, darin, die Ausgabe in durch Kommas getrennte zu ändern

select top 1 * from table

und schneiden Sie die gesamte Liste der Spalten aus dem Ausgabefenster. Dann können Sie auswählen, welche Spalten Sie möchten, ohne sie alle eingeben zu müssen.

Grundsätzlich können Sie nicht tun, was Sie möchten - aber Sie können die richtigen Tools erhalten, die Ihnen dabei helfen, die Dinge ein bisschen einfacher zu machen.

Wenn Sie sich die SQL-Eingabeaufforderung von Red-Gate ansehen , können Sie "SELECT * FROM MyTable" eingeben, den Cursor nach "*" zurückbewegen und <TAB> drücken, um die Liste der Felder zu erweitern und die wenigen Felder zu entfernen, die Sie haben brauche nicht.

Es ist keine perfekte Lösung - aber eine verdammt gute! :-) Schade, dass Intellisense von MS SQL Server Management Studio immer noch nicht intelligent genug ist, um diese Funktion anzubieten .......

Marc

Nein, dazu gibt es keine Möglichkeit. Vielleicht können Sie benutzerdefinierte Ansichten erstellen, wenn dies in Ihrer Situation möglich ist

EDIT Kann sein , wenn Ihre DB Ausführung von dynamischen unterstützt SQL u einen SP schreiben könnte und übergeben Sie die Spalten u will nicht , es zu sehen und lassen Sie es die Abfrage dynamisch erzeugen und liefert das Ergebnis für Sie. Ich denke, dass dies zumindest in SQL Server möglich ist

Wenn Sie SQL Server Management Studio verwenden, gehen Sie wie folgt vor:

1. Geben Sie den gewünschten Tabellennamen ein und wählen Sie ihn aus
2. Drücken Sie Alt+F1
3. o / p zeigt die Spalten in der Tabelle.
4. Wählen Sie die gewünschten Spalten aus
5. Kopieren Sie diese und fügen Sie sie in Ihre ausgewählte Abfrage ein
6. Feuern Sie die Abfrage ab.

Genießen.

In SQL Management Studio können Sie die Spalten im Objekt-Explorer erweitern und dann das ColumnsBaumelement in ein Abfragefenster ziehen, um eine durch Kommas getrennte Liste von Spalten zu erhalten.

Zusammenfassend können Sie dies nicht tun, aber ich bin mit allen obigen Kommentaren nicht einverstanden. Es gibt "Szenarien", in denen Sie ein * legitim verwenden können, wenn Sie eine verschachtelte Abfrage erstellen, um einen bestimmten Bereich aus einer ganzen Liste auszuwählen (z Paging) Warum in aller Welt möchten Sie jede Spalte in der äußeren select-Anweisung angeben, wenn Sie dies in der inneren getan haben?

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)

AKTUALISIEREN:

Sie können auch eine gespeicherte Prozedur erstellen, um diese Aufgabe zu erledigen, wenn Sie sie häufiger verwenden. In diesem Beispiel habe ich das integrierte STRING_SPLIT () verwendet, das unter SQL Server 2016+ verfügbar ist. Bei Bedarf gibt es jedoch zahlreiche Beispiele für die manuelle Erstellung in 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

Und dann einfach:

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

Wenn es sich um Prozeduren handelt, funktioniert es mit diesem Trick, eine neue Abfrage zu generieren und sie SOFORT AUSZUFÜHREN :

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

Gibt es eine Möglichkeit, Spalten aus einer Tabelle auszuschließen, ohne alle Spalten anzugeben?

Verwenden von deklarativem SQL auf die übliche Weise, nein.

Ich denke, Ihre vorgeschlagene Syntax ist würdig und gut. Tatsächlich hat die relationale Datenbanksprache 'Tutorial D' eine sehr ähnliche Syntax, bei der auf die Schlüsselwörter ALL BUTeine Reihe von Attributen (Spalten) folgt.

Allerdings SELECT *bekommt SQL bereits viel Flak (@ Guffas Antwort hier ist ein typischer Einwand), daher denke ich nicht, dass SELECT ALL BUTes bald in den SQL-Standard kommen wird.

Ich denke, die beste "Umgehung" besteht darin, eine VIEWmit nur den Spalten zu erstellen, die Sie dann wünschen SELECT * FROM ThatView.

Ein moderner SQL-Dialekt wie BigQuery bietet eine hervorragende Lösung

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

Dies ist eine sehr leistungsfähige SQL-Syntax, um eine lange Liste von Spalten zu vermeiden, die aufgrund von Änderungen des Tabellenspaltennamens ständig aktualisiert werden müssen. Und diese Funktionalität fehlt in der aktuellen SQL Server-Implementierung, was schade ist. Hoffentlich wird Microsoft Azure eines Tages datenwissenschaftlerfreundlicher sein.

Datenwissenschaftler möchten eine schnelle Möglichkeit haben, eine Abfrage zu verkürzen und einige Spalten zu entfernen (aufgrund von Duplikaten oder aus anderen Gründen).

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

Postgres SQL hat eine Möglichkeit, dies zu tun

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

Der Informationsschema-Hack-Weg

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

Das Obige für meine spezielle Beispieltabelle - generiert eine SQL-Anweisung, die so aussieht

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

Ich kenne keine Datenbank, die dies unterstützt (SQL Server, MySQL, Oracle, PostgreSQL). Es ist definitiv nicht Teil der SQL-Standards, daher müssen Sie meiner Meinung nach nur die gewünschten Spalten angeben.

Sie können Ihre SQL-Anweisung natürlich dynamisch erstellen und vom Server ausführen lassen. Dies eröffnet jedoch die Möglichkeit einer SQL-Injection.

Ich weiß, dass dies ein bisschen alt ist, aber ich war gerade auf dasselbe Problem gestoßen und suchte nach einer Antwort. Dann ließ ich mir von einem erfahrenen Entwickler einen sehr einfachen Trick zeigen.

Wenn Sie den Management Studio-Abfrageeditor verwenden, erweitern Sie die Datenbank und anschließend die Tabelle, aus der Sie auswählen, damit Sie den Spaltenordner sehen können.

Markieren Sie in Ihrer select-Anweisung einfach den Ordner mit den referenzierten Spalten oben und ziehen Sie ihn per Drag & Drop in das Abfragefenster. Es werden alle Spalten der Tabelle eingefügt und dann einfach die Identitätsspalte aus der Liste der Spalten entfernt ...

Der beste Weg, dies zu lösen, ist die Verwendung der Ansicht. Sie können eine Ansicht mit den erforderlichen Spalten erstellen und Daten daraus abrufen

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)

Wenn Sie eine Spalte mit sensiblen Groß- und Kleinschreibung wie beispielsweise das Kennwort ausschließen möchten, gehe ich folgendermaßen vor, um den Wert auszublenden:

SELECT * , "" as password FROM tableName;

Nun, es ist eine gängige bewährte Methode, anzugeben, welche Spalten Sie möchten, anstatt nur * anzugeben. Sie sollten also nur angeben, welche Felder Ihre Auswahl zurückgeben soll.

Ein Kollege riet zu einer guten Alternative:

• SELECT INTO in Ihrer vorherigen Abfrage (wo Sie die Daten generieren oder abrufen) in eine Tabelle (die Sie löschen, wenn Sie fertig sind). Dadurch wird die Struktur für Sie erstellt.
• Führen Sie ein Skript als CREATE to new query window aus.
• Entfernen Sie die unerwünschten Spalten. Formatieren Sie die verbleibenden Spalten in einen 1-Liner und fügen Sie sie als Spaltenliste ein.
• Löschen Sie die von Ihnen erstellte Tabelle.

Erledigt...

Das hat uns sehr geholfen.

Klicken Sie im Objekt-Explorer mit der rechten Maustaste auf die Tabelle. Wählen Sie die obersten 1000 Zeilen aus

Es werden alle Spalten aufgelistet und nicht *. Entfernen Sie dann die unerwünschten Spalten. Sollte viel schneller sein als selbst zu tippen.

Wenn Sie der Meinung sind, dass dies etwas zu viel Arbeit ist, rufen Sie die SQL-Eingabeaufforderung von Red Gate auf und geben Sie ssf von tbl ein. Gehen Sie zum * und klicken Sie erneut auf die Registerkarte.

Das, was ich für diesen Fall oft benutze:

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 sieht aus wie column1,column2,column5

Manchmal muss dasselbe Programm unterschiedliche Datenbankstrukturen verarbeiten. Daher konnte ich keine Spaltenliste im Programm verwenden, um Fehler in selectAnweisungen zu vermeiden .

*gibt mir alle optionalen Felder. Ich überprüfe vor der Verwendung, ob die Felder in der Datentabelle vorhanden sind. Dies ist mein Grund für die Verwendung *in select.

So gehe ich mit ausgeschlossenen Feldern um:

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

Ich weiß, dass diese Frage alt ist, aber ich hoffe, dass dies dennoch hilfreich sein kann. Die Antwort wurde von einer Diskussion in den SQL Server-Foren inspiriert . Sie können dies zu einer gespeicherten Prozedur machen . Es kann auch geändert werden, um mehr als ein Ausnahmefeld hinzuzufügen.

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

Wäre es nicht einfacher, dies zu tun:

sp_help <table_name>

- Klicken Sie auf die Spalte 'Spaltenname'> Kopieren> Einfügen (erstellt eine vertikale Liste) in ein Fenster für neue Abfragen und geben Sie vor jedem Spaltenwert Kommas ein ... kommentieren Sie die nicht gewünschten Spalten aus ... weit weniger Eingabe als jeder hier angebotene Code und immer noch überschaubar.

Sie können SQL Complete von devart.com herunterladen, wodurch nicht nur der Platzhalter * wie bei SQL Prompt von Red Gate erweitert wird (wie in der Antwort von cairnz beschrieben), sondern auch eine Dropdown-Liste mit Spaltenauswahlfeldern bereitgestellt wird, in der Sie alle Kontrollkästchen aktivieren können Spalten, die Sie in die Auswahlliste aufnehmen möchten, werden automatisch für Sie eingefügt (und wenn Sie dann eine Spalte deaktivieren, wird sie automatisch aus der Auswahlliste entfernt).

In SSMS gibt es mit IntelliSense und Aliasing einen einfacheren Weg . Versuche dies

1. Klicken Sie mit der rechten Maustaste in den Texteditor und stellen Sie sicher IntelliSense aktiviert ist.
2. Geben Sie die Abfrage mit einem Alias ​​ein [SELECT t. *Geben Sie FROM tablename t].
3. Gehen Sie zum Text t. * Und löschen Sie das * , und SSMS listet die Spalten des f automatisch auf aliased Tabelle.