SQL исключает столбец, используя SELECT * [кроме columnA] FROM tableA?

Мы все знаем, что для выбора всех столбцов из таблицы мы можем использовать

SELECT * FROM tableA

Есть ли способ исключить столбцы из таблицы без указания всех столбцов?

SELECT * [except columnA] FROM tableA

Единственный известный мне способ - вручную указать все столбцы и исключить ненужные столбцы. Это действительно отнимает много времени, поэтому я ищу способы сэкономить время и усилия на этом, а также будущее обслуживание, если в таблице будет больше / меньше столбцов.

Я согласен со всеми ... но если бы я собирался сделать что-то подобное, я мог бы сделать это так:

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

Нет.

Лучшая практика обслуживания - указывать только необходимые столбцы.

Как минимум 2 причины:

• Это делает ваш контракт между клиентом и базой данных стабильным. Одни и те же данные, каждый раз
• Производительность, покрытие показателей

Изменить (июль 2011 г.):

Если вы перетаскиваете из Object Explorer Columnsузел таблицы, он помещает список CSV-столбцов в окно запроса для вас, что позволяет достичь одной из ваших целей.

Если вы не хотите писать каждое имя столбца вручную, вы можете использовать Script Table Asего, щелкнув правой кнопкой мыши по таблице или просмотрев в SSMS следующим образом:

Затем вы получите весь запрос select в окне New Query Editor, а затем удалите ненужный столбец, например:

Выполнено

Автоматический способ сделать это в 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);

Вы можете создать представление, в котором есть столбцы, которые вы хотите выбрать, тогда вы можете просто select *из представления ...

Да, это возможно (но не рекомендуется).

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

Пояснение к коду :

1. Объявите переменную для хранения списка имен столбцов через запятую. По умолчанию это NULL.
2. Используйте системное представление, чтобы определить имена столбцов в нашей таблице.
3. Используйте SELECT @variable = @variable + ... FROMдля объединения имен столбцов. Этот тип SELECTне возвращает набор результатов. Это, возможно, недокументированное поведение, но работает в каждой версии SQL Server. В качестве альтернативы вы можете использовать SET @variable = (SELECT ... FOR XML PATH(''))для объединения строк.
4. Используйте ISNULLфункцию для добавления запятой, только если это не имя первого столбца. Используйте QUOTENAMEфункцию для поддержки пробелов и знаков препинания в именах столбцов.
5. Используйте WHEREпредложение, чтобы скрыть столбцы, которые мы не хотим видеть.
6. Используйте EXEC (@variable), также известный как динамический SQL , для разрешения имен столбцов во время выполнения. Это необходимо, потому что мы не знаем имен столбцов во время компиляции.

Как и другие говорили, что сделать это невозможно, но если вы используете Sql Server, уловка, которую я использую, состоит в том, чтобы изменить вывод на запятую, а затем

select top 1 * from table

и вырезать весь список столбцов из окна вывода. Затем вы можете выбрать, какие столбцы вы хотите, не вводя их все.

По сути, вы не можете делать то, что хотели бы - но вы можете найти правильные инструменты, которые помогут вам сделать вещи немного проще.

Если вы посмотрите на SQL-запрос Red-Gate , вы можете набрать «SELECT * FROM MyTable», а затем переместить курсор назад после «*» и нажать <TAB>, чтобы развернуть список полей и удалить те несколько полей, которые вы не нужно

Это не идеальное решение - но чертовски хорошее! :-) Жаль, что Intellisense в MS SQL Server Management Studio все еще недостаточно интеллектуален, чтобы предлагать эту функцию .......

Марк

нет нет способа сделать это. может быть, вы можете создать собственные представления, если это возможно в вашей ситуации

РЕДАКТИРОВАТЬ Может быть, если ваша БД поддерживает выполнение динамического SQL, вы могли бы написать SP и передать столбцы, которые вы не хотите видеть, и позволить ему динамически создавать запрос и возвращать результат вам. Я думаю, что это выполнимо в SQL Server по крайней мере

Если вы используете SQL Server Management Studio, выполните следующие действия:

1. Введите желаемое имя таблицы и выберите его
2. Нажмите Alt+F1
3. o / p показывает столбцы в таблице.
4. Выберите нужные столбцы
5. Скопируйте и вставьте их в ваш запрос выбора
6. Запустите запрос.

Наслаждаться.

В SQL Management Studio вы можете развернуть столбцы в обозревателе объектов, а затем перетащить Columnsэлемент дерева в окно запроса, чтобы получить список столбцов через запятую.

Таким образом, вы не можете сделать это, но я не согласен со всеми комментариями, приведенными выше, существуют «сценарии», в которых вы можете законно использовать * при создании вложенного запроса для выбора определенного диапазона из целого списка (например, paging) почему в мире захочется указать каждый столбец во внешнем операторе select, когда вы сделали это во внутреннем?

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)

ОБНОВИТЬ:

Вы также можете создать хранимую процедуру для решения этой задачи, если будете использовать ее чаще. В этом примере я использовал встроенную функцию STRING_SPLIT (), которая доступна в SQL Server 2016+, но, если вам нужно, есть множество примеров того, как создать его вручную в 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

А потом просто:

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

Если мы говорим о процедурах, он работает с этим трюком, чтобы сгенерировать новый запрос и выполнить его немедленно :

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

Есть ли способ исключить столбцы из таблицы без указания всех столбцов?

Используя декларативный SQL обычным способом, нет.

Я думаю, что ваш предложенный синтаксис достоин и хорош. На самом деле язык реляционной базы данных «Учебник D» имеет очень похожий синтаксис, где за ключевыми словами ALL BUTследует набор атрибутов (столбцов).

Тем не менее, SQL SELECT *уже имеет много шансов (ответ @ Guffa здесь является типичным возражением), поэтому я не думаю, что в SELECT ALL BUTближайшее время попадет в стандарт SQL.

Я думаю, что лучший способ обойти это создать VIEWтолько те столбцы, которые вы хотите SELECT * FROM ThatView.

Современный диалект SQL, такой как BigQuery, предлагает отличное решение

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

Это очень мощный синтаксис SQL, позволяющий избежать длинного списка столбцов, которые необходимо постоянно обновлять из-за изменения имени столбца таблицы. И эта функциональность отсутствует в текущей реализации SQL Server, что очень жаль. Надеемся, что однажды Microsoft Azure станет более дружественным к ученым.

Специалистам по данным нравится иметь возможность быстро сократить запрос и удалить некоторые столбцы (из-за дублирования или по любой другой причине).

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

Postgres SQL имеет способ сделать это

Пожалуйста, обратитесь: http://www.postgresonline.com/journal/archives/41-How-to-SELECT-ALL-EXCEPT-some-columns-in-a-table.html

Информационная схема 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

Выше для моего конкретного примера таблицы - генерирует SQL-оператор, который выглядит следующим образом

ВЫБЕРИТЕ o.officepark, o.owner, o.squarefootage ОТ офисного парка As o

Я не знаю ни одной базы данных, которая бы поддерживала это (SQL Server, MySQL, Oracle, PostgreSQL). Это определенно не является частью стандартов SQL, поэтому я думаю, что вы должны указывать только те столбцы, которые вам нужны.

Конечно, вы можете динамически построить оператор SQL и выполнить его на сервере. Но это открывает возможность для инъекций SQL.

Я знаю, что это немного старо, но я только столкнулся с той же самой проблемой и искал ответ. Затем старший разработчик показал мне очень простой трюк.

Если вы используете редактор запросов Management Studio, разверните базу данных, затем разверните таблицу, из которой вы выбираете, чтобы увидеть папку столбцов.

В вашем операторе select просто выделите указанную выше папку столбцов и перетащите ее в окно запроса. Он вставит все столбцы таблицы, а затем просто удалит идентификационный столбец из списка столбцов ...

Лучший способ решить эту проблему - использовать представление, вы можете создать представление с необходимыми столбцами и извлечь из него данные.

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)

Если вы хотите исключить конфиденциальный столбец, например, пароль, я делаю это, чтобы скрыть значение:

SELECT * , "" as password FROM tableName;

Что ж, это обычная лучшая практика - указывать, какие столбцы вы хотите, вместо того, чтобы просто указывать *. Таким образом, вы должны просто указать, какие поля вы хотите, чтобы ваш выбор возвращал.

Колледж посоветовал хорошую альтернативу:

• Сделайте SELECT INTO в предыдущем запросе (где вы генерируете или получаете данные) в таблицу (которую вы удалите, когда закончите). Это создаст структуру для вас.
• Сделайте скрипт как CREATE для нового окна запроса.
• Удалите ненужные столбцы. Отформатируйте оставшиеся столбцы в 1 строку и вставьте в качестве списка столбцов.
• Удалить таблицу, которую вы создали.

Выполнено...

Это нам очень помогло.

Щелкните правой кнопкой мыши таблицу в проводнике объектов, выберите 1000 лучших строк

В нем будут перечислены все столбцы, а не *. Затем удалите ненужные столбцы. Должно быть намного быстрее, чем печатать самостоятельно.

Затем, когда вы почувствуете, что это слишком сложная работа, получите SQL-запрос от Red Gate и введите ssf из tbl, перейдите к * и снова нажмите вкладку.

Вот что я часто использую для этого случая:

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 похоже column1,column2,column5

Иногда одна и та же программа должна обрабатывать разные структуры базы данных. Поэтому я не мог использовать список столбцов в программе, чтобы избежать ошибок в selectвыражениях.

*дает мне все дополнительные поля. Я проверяю, существуют ли поля в таблице данных перед использованием. Это моя причина для использования *в select.

Вот как я обрабатываю исключенные поля:

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

Я знаю, что этот вопрос старый, но я надеюсь, что он все еще может быть полезным. Ответ вдохновлен обсуждением на форумах по SQL Server . Вы можете сделать это хранимой процедурой . Он также может быть изменен, чтобы добавить более одного, кроме полей.

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

Не было бы проще сделать это:

sp_help <table_name>

-Щелкните по столбцу Column_name> Copy> Paste (создает вертикальный список) в окне New Query и просто введите запятые перед каждым значением столбца ... закомментируйте столбцы, которые вам не нужны ... намного меньше набрав, чем любой код, предлагаемый здесь и по-прежнему управляемым.

Вы можете получить SQL Complete с devart.com, который не только расширяет подстановочный знак *, как это делает SQL Prompt от Red Gate (как описано в ответе cairnz), но также предоставляет выпадающий список столбцов с флажками, в которых вы можете проверить все столбцы, которые вы хотите в списке выбора, и они будут вставлены автоматически для вас (и если вы затем снимите флажок столбец, он будет автоматически удален из списка выбора).

В SSMS есть более простой способ с IntelliSense и Aliasing . Попробуй это

1. Щелкните правой кнопкой мыши в текстовом редакторе и убедитесь, что IntelliSense включен.
2. Введите запрос с псевдонимом [SELECT t. * FROM tablename t].
3. Перейти текст т. * И удалить * , и SSMS будет автоматически список столбцы ф псевдонимами таблицы.