SQL exclure une colonne à l'aide de SELECT * [sauf la colonneA] DE la tableA?

Nous savons tous que pour sélectionner toutes les colonnes d'une table, nous pouvons utiliser

SELECT * FROM tableA

Existe-t-il un moyen d'exclure des colonnes d'une table sans spécifier toutes les colonnes?

SELECT * [except columnA] FROM tableA

La seule façon que je sache est de spécifier manuellement toutes les colonnes et d'exclure la colonne indésirable. Cela prend vraiment beaucoup de temps, donc je cherche des moyens d'économiser du temps et des efforts à ce sujet, ainsi qu'une maintenance future si la table a plus / moins de colonnes.

Je suis d'accord avec tout le monde ... mais si j'allais faire quelque chose comme ça, je pourrais le faire de cette façon:

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

Non.

La meilleure pratique en matière de maintenance est de ne spécifier que les colonnes requises.

Au moins 2 raisons:

• Cela rend votre contrat entre le client et la base de données stable. Mêmes données, à chaque fois
• Performance, couvrant les indices

Edit (juillet 2011):

Si vous faites glisser depuis l'Explorateur d'objets le Columnsnœud d'une table, il place pour vous une liste CSV de colonnes dans la fenêtre de requête qui atteint l'un de vos objectifs

Si vous ne voulez pas écrire manuellement le nom de chaque colonne, vous pouvez utiliser Script Table Asen cliquant avec le bouton droit sur la table ou afficher dans SSMS comme ceci:

Ensuite, vous obtiendrez toute la requête de sélection dans la nouvelle fenêtre de l'éditeur de requête, puis supprimez la colonne indésirable comme ceci:

Terminé

La façon automatisée de le faire dans SQL (SQL Server) est:

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

Vous pouvez créer une vue qui a les colonnes que vous souhaitez sélectionner, puis vous pouvez simplement à select *partir de la vue ...

Oui c'est possible (mais non recommandé).

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

Explication du code :

1. Déclarez une variable pour stocker une liste de noms de colonnes séparés par des virgules. Cette valeur par défaut est NULL.
2. Utilisez une vue système pour déterminer les noms des colonnes de notre tableau.
3. Utilisez SELECT @variable = @variable + ... FROMpour concaténer les noms de colonne. Ce type de SELECTne renvoie pas de jeu de résultats. Il s'agit peut-être d'un comportement non documenté, mais qui fonctionne dans toutes les versions de SQL Server. Comme alternative, vous pouvez utiliser SET @variable = (SELECT ... FOR XML PATH(''))pour concaténer des chaînes.
4. Utilisez le ISNULL fonction pour ajouter une virgule uniquement si ce n'est pas le nom de la première colonne. Utilisez la QUOTENAMEfonction pour prendre en charge les espaces et la ponctuation dans les noms de colonne.
5. Utilisez la WHEREclause pour masquer les colonnes que nous ne voulons pas voir.
6. Utilisez EXEC (@variable), également appelé SQL dynamique , pour résoudre les noms de colonne lors de l'exécution. Cela est nécessaire car nous ne connaissons pas les noms des colonnes au moment de la compilation.

Comme les autres l'ont dit, il n'y a aucun moyen de le faire, mais si vous utilisez Sql Server, une astuce que j'utilise est de changer la sortie en virgule séparée, alors faites

select top 1 * from table

et couper toute la liste des colonnes de la fenêtre de sortie. Ensuite, vous pouvez choisir les colonnes que vous souhaitez sans avoir à les saisir toutes.

Fondamentalement, vous ne pouvez pas faire ce que vous souhaitez - mais vous pouvez obtenir les bons outils pour vous aider à rendre les choses un peu plus faciles.

Si vous regardez l' invite SQL de Red-Gate , vous pouvez taper "SELECT * FROM MyTable", puis déplacer le curseur en arrière après le "*", et appuyer sur <TAB> pour développer la liste des champs et supprimer ces quelques champs que vous pas besoin.

Ce n'est pas une solution parfaite - mais une sacrément bonne! :-) Dommage que Intellisense de MS SQL Server Management Studio ne soit toujours pas assez intelligent pour offrir cette fonctionnalité .......

Marc

non, il n'y a aucun moyen de le faire. vous pouvez peut-être créer des vues personnalisées si cela est possible dans votre situation

EDIT Peut-être si votre base de données prend en charge l'exécution de sql dynamique u pourrait écrire un SP et passer les colonnes que vous ne voulez pas voir et le laisser créer la requête dynamiquement et vous renvoyer le résultat. Je pense que c'est faisable dans SQL Server atleast

Si vous utilisez SQL Server Management Studio, procédez comme suit:

1. Tapez le nom de votre table souhaité et sélectionnez-le
2. Appuyez sur Alt+F1
3. o / p affiche les colonnes du tableau.
4. Sélectionnez les colonnes souhaitées
5. Copiez et collez ceux dans votre requête de sélection
6. Déclenchez la requête.

Prendre plaisir.

Dans SQL Management Studio, vous pouvez développer les colonnes dans l'Explorateur d'objets, puis faire glisser l' Columnsélément d'arborescence dans une fenêtre de requête pour obtenir une liste de colonnes séparées par des virgules.

En résumé, vous ne pouvez pas le faire, mais je ne suis pas d'accord avec tous les commentaires ci-dessus, il existe des scénarios dans lesquels vous pouvez légitimement utiliser un * Lorsque vous créez une requête imbriquée afin de sélectionner une plage spécifique dans une liste entière (telle que paging) pourquoi diable voudrait spécifier chaque colonne sur l'instruction select externe quand vous l'avez fait dans l'interne?

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)

MISE À JOUR:

Vous pouvez également créer une procédure stockée pour effectuer cette tâche si vous l'utilisez plus souvent. Dans cet exemple, j'ai utilisé le STRING_SPLIT () intégré qui est disponible sur SQL Server 2016+, mais si vous en avez besoin, il existe de nombreux exemples de la façon de le créer manuellement sur 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

Et puis juste:

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

Si nous parlons de procédures, cela fonctionne avec cette astuce pour générer une nouvelle requête et EXÉCUTER IMMÉDIATEMENT :

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

Existe-t-il un moyen d'exclure des colonnes d'une table sans spécifier toutes les colonnes?

Utiliser SQL déclaratif de la manière habituelle, non.

Je pense que la syntaxe que vous proposez est digne et bonne. En fait, le langage de base de données relationnelle «Tutorial D» a une syntaxe très similaire où les mots ALL BUT- clés sont suivis d'un ensemble d'attributs (colonnes).

Cependant, SQL SELECT *reçoit déjà beaucoup de critiques (la réponse de @ Guffa ici est une objection typique), donc je ne pense pas que j'entrerai SELECT ALL BUTbientôt dans la norme SQL.

Je pense que le meilleur «contourner» est de créer un VIEWavec uniquement les colonnes que vous désirez alors SELECT * FROM ThatView.

Un dialecte SQL moderne comme BigQuery propose une excellente solution

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

Il s'agit d'une syntaxe SQL très puissante pour éviter une longue liste de colonnes qui doivent être mises à jour tout le temps en raison des changements de nom de colonne de table. Et cette fonctionnalité manque dans l'implémentation actuelle de SQL Server, ce qui est dommage. Espérons qu'un jour, Microsoft Azure sera plus convivial pour les scientifiques des données.

Les scientifiques des données aiment pouvoir avoir une option rapide pour raccourcir une requête et pouvoir supprimer certaines colonnes (en raison de la duplication ou pour toute autre raison).

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

Postgres sql a un moyen de le faire

les pls se réfèrent: http://www.postgresonline.com/journal/archives/41-How-to-SELECT-ALL-EXCEPT-some-columns-in-a-table.html

Le schéma d'information 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

Ce qui précède pour mon exemple de tableau particulier - génère une instruction sql qui ressemble à ceci

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

Je ne connais aucune base de données qui supporte cela (SQL Server, MySQL, Oracle, PostgreSQL). Il ne fait définitivement pas partie des normes SQL, donc je pense que vous devez spécifier uniquement les colonnes que vous souhaitez.

Vous pouvez bien sûr créer dynamiquement votre instruction SQL et demander au serveur de l'exécuter. Mais cela ouvre la possibilité d'une injection SQL ..

Je sais que c'est un peu vieux, mais je venais de rencontrer le même problème et je cherchais une réponse. Ensuite, un développeur senior m'a montré une astuce très simple.

Si vous utilisez l'éditeur de requêtes de Management Studio, développez la base de données, puis développez la table dans laquelle vous sélectionnez afin de voir le dossier des colonnes.

Dans votre instruction select, sélectionnez simplement le dossier des colonnes référencées ci-dessus et faites-le glisser dans la fenêtre de requête. Il collera toutes les colonnes du tableau, puis supprimera simplement la colonne d'identité de la liste des colonnes ...

La meilleure façon de résoudre ce problème est d'utiliser la vue, vous pouvez créer une vue avec les colonnes requises et récupérer les données sous forme

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 vous souhaitez exclure une colonne de cas sensible comme le mot de passe par exemple, je fais cela pour masquer la valeur:

SELECT * , "" as password FROM tableName;

Eh bien, il est recommandé de spécifier les colonnes que vous souhaitez au lieu de simplement spécifier *. Vous devez donc simplement indiquer les champs que vous souhaitez que votre sélection renvoie.

Un collègue a conseillé une bonne alternative:

• Sélectionnez SELECT INTO dans votre requête précédente (où vous générez ou récupérez les données) dans une table (que vous supprimerez une fois terminé). Cela créera la structure pour vous.
• Faites un script comme CRÉER dans une nouvelle fenêtre de requête.
• Supprimez les colonnes indésirables. Formatez les colonnes restantes dans une ligne 1 et collez-les comme liste de colonnes.
• Supprimez le tableau que vous avez créé.

Terminé...

Cela nous a beaucoup aidés.

Cliquez avec le bouton droit sur la table dans l'Explorateur d'objets, sélectionnez les 1000 premières lignes

Il listera toutes les colonnes et non *. Supprimez ensuite la ou les colonnes indésirables. Cela devrait être beaucoup plus rapide que de le taper vous-même.

Ensuite, lorsque vous sentez que c'est un peu trop de travail, obtenez l'invite SQL de Red Gate et tapez ssf à partir de tbl, accédez à * et cliquez à nouveau sur l'onglet.

C'est ce que j'utilise souvent pour ce cas:

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 ressemble à column1,column2,column5

Parfois, le même programme doit gérer différentes structures de base de données. Je n'ai donc pas pu utiliser une liste de colonnes dans le programme pour éviter les erreurs dans les selectinstructions.

*me donne tous les champs facultatifs. Je vérifie si les champs existent dans la table de données avant utilisation. Ceci est ma raison d'utiliser *en select.

Voici comment je gère les champs exclus:

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

Je sais que cette question est ancienne, mais j'espère que cela peut toujours être utile.La réponse est inspirée d'une discussion sur les forums SQL Server . Vous pouvez en faire une procédure stockée . Il peut également être modifié pour ajouter plusieurs champs à l'exception de.

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

Ne serait-ce pas plus simple de faire ça:

sp_help <table_name>

-Cliquez sur la colonne 'Column_name'> Copier> Coller (crée une liste verticale) dans une nouvelle fenêtre de requête et tapez simplement des virgules devant chaque valeur de colonne ... commentez les colonnes que vous ne voulez pas ... beaucoup moins en tapant que tout code proposé ici et toujours gérable.

Vous pouvez obtenir SQL Complete sur devart.com, qui étend non seulement le caractère générique * comme le fait SQL Prompt de Red Gate (comme décrit dans la réponse de cairnz), mais fournit également un sélecteur de colonne déroulant avec des cases à cocher dans lesquelles vous pouvez cocher toutes les colonnes que vous souhaitez dans la liste de sélection et elles seront insérées automatiquement pour vous (et si vous décochez ensuite une colonne, elle sera automatiquement supprimée de la liste de sélection).

Dans SSMS, il existe un moyen plus simple avec IntelliSense et l' alias . Essaye ça

1. Cliquez avec le bouton droit dans l'éditeur de texte et assurez-vous que IntelliSense est activé.
2. Tapez la requête avec un alias [SELECT t. * FROM tablename t].
3. Allez dans le texte t. * Et supprimez le * , et SSMS listera automatiquement les colonnes du f tableau aliasé.