SQL SELECT * [columnA] hariç bir sütunu tableA?

Hepimiz biliyoruz ki bir tablodaki tüm sütunları seçmek için

SELECT * FROM tableA

Tüm sütunları belirtmeden sütunları tablodan hariç tutmanın bir yolu var mı?

SELECT * [except columnA] FROM tableA

Bildiğim tek yol, tüm sütunları elle belirtmek ve istenmeyen sütunu hariç tutmaktır. Bu gerçekten zaman alıcıdır, bu yüzden zamandan ve çabadan tasarruf etmenin yollarını arıyoruz, ayrıca tablonun daha fazla / daha az sütunu olması durumunda gelecekteki bakım.

Herkese katılıyorum ... ama böyle bir şey yapacak olsaydım şu şekilde yapabilirdim:

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

Hayır.

Bakım ışığı en iyi uygulaması, yalnızca gerekli sütunları belirtmektir.

En az 2 neden:

• Bu, istemci ve veritabanı arasındaki sözleşmenizi istikrarlı hale getirir. Her seferinde aynı veriler
• Performans, dizinleri kapsayan

Düzenle (Temmuz 2011):

ColumnsBir tablo için düğümü Nesne Gezgini'nden sürüklerseniz, sizin için Sorgu Penceresine bir CSV sütun listesi koyar ve bu da hedeflerinizden birini gerçekleştirir

Her sütun adını yazmak istemiyorsanız manuel kullanabileceğiniz Script Table Assağ tıklayarak tabloda veya görünümde yer SSMS böyle:

Daha sonra Yeni Sorgu Düzenleyici Penceresinde tüm seçme sorgusunu alırsınız ve ardından böyle istenmeyen sütunu kaldırırsınız:

Bitti

SQL'de (SQL Server) bunu yapmanın otomatik yolu:

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

Seçmek istediğiniz sütunlara sahip bir görünüm oluşturabilir, ardından yalnızca select *görünümden yapabilirsiniz ...

Evet mümkün (ancak önerilmez).

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

Kodun açıklaması :

1. Bir değişkenin virgülle ayrılmış sütun adları listesini saklayacağını bildirin. Varsayılan olarak NULL.
2. Tablonuzdaki sütunların adlarını belirlemek için bir sistem görünümü kullanın.
3. SELECT @variable = @variable + ... FROMSütun adlarını birleştirmek için kullanın . Bu tür SELECTbir sonuç kümesi döndürmez. Bu belki de belgelenmemiş davranıştır, ancak SQL Server'ın her sürümünde çalışır. Alternatif olarak, SET @variable = (SELECT ... FOR XML PATH(''))dizeleri birleştirmek için kullanabilirsiniz .
4. Bu ISNULLişlevi, yalnızca ilk sütun adı değilse virgül eklemek için kullanın . QUOTENAMESütun adlarındaki boşlukları ve noktalama işaretlerini desteklemek için işlevi kullanın .
5. WHEREGörmek istemediğimiz sütunları gizlemek için yan tümcesi kullanın .
6. Çalışma zamanında sütun adlarını çözümlemek için dinamik SQLEXEC (@variable) olarak da bilinir . Bu gereklidir çünkü derleme zamanında sütun adlarını bilmiyoruz.

Diğerleri söylediler gibi bunu yapmanın bir yolu yoktur, ancak Sql Server kullanıyorsanız, kullandığım bir hile çıkış virgül ayrılmış olarak değiştirmek için, sonra yapmak

select top 1 * from table

ve çıktı penceresinden tüm sütun listesini kesin. Ardından, hepsini yazmak zorunda kalmadan istediğiniz sütunları seçebilirsiniz.

Temel olarak, istediğinizi yapamazsınız - ancak işleri biraz daha kolay hale getirmenize yardımcı olacak doğru araçları alabilirsiniz.

Red-Gate'in SQL İstemine bakarsanız İstemine "SELECT * FROM MyTable" yazıp imleci "*" karakterinden sonra geri taşıyabilir ve alan listesini genişletmek ve bu birkaç alanı kaldırmak için <TAB> tuşuna basabilirsiniz. gerek yok.

Mükemmel bir çözüm değil - ama iyi bir çözüm! :-) Çok kötü MS SQL Server Management Studio'nun Intellisense hala bu özelliği sunacak kadar akıllı değil .......

üzüm posası

hayır bunu yapmanın bir yolu yok. durumunuzda uygunsa belki özel görünümler oluşturabilirsiniz

DÜZENLEME DB dinamik sql yürütülmesini destekliyorsa u bir SP yazabilir ve u görmek istemiyorum sütunları geçmek olabilir ve dinamik olarak sorgu oluşturmak ve sonucu size dönmesine izin verebilir. Bu SQL Server en azından yapılabilir olduğunu düşünüyorum

SQL Server Management Studio kullanıyorsanız aşağıdakileri yapın:

1. İstediğiniz tabloların adını yazın ve seçin
2. Basın Alt+F1
3. o / p tablodaki sütunları gösterir.
4. İstediğiniz sütunları seçin
5. Bunları seçim sorgunuzda kopyalayıp yapıştırın
6. Sorguyu tetikleyin.

Zevk almak.

SQL Management Studio'da Nesne Gezgini'nde sütunları genişletebilir, ardından Columnsvirgülle ayrılmış sütun listesi almak için ağaç öğesini bir sorgu penceresine sürükleyebilirsiniz .

Özetle bunu yapamazsınız, ancak yukarıdaki tüm yorumlara katılmıyorum, meşru bir şekilde kullanabileceğiniz "senaryolar" var * Tüm listeden belirli bir aralığı seçmek için iç içe bir sorgu oluşturduğunuzda (örneğin sayfalama) neden dünyanın içinde, içte yaptığınız zaman dış seçim deyimindeki her bir sütunu belirtmek istersiniz?

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)

GÜNCELLEME:

Ayrıca, daha sık kullanıyorsanız bu görevi gerçekleştirmek için saklı bir yordam da oluşturabilirsiniz. Bu örnekte SQL Server 2016+ üzerinde bulunan yerleşik STRING_SPLIT () yöntemini kullandım, ancak ihtiyacınız varsa SO üzerinde manuel olarak nasıl oluşturulacağına dair çok sayıda örnek var.

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

Ve sonra sadece:

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

Yordamlardan bahsediyorsak, yeni bir sorgu oluşturmak ve HEMEN UYGULAMAK için bu hile ile çalışır :

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

Tüm sütunları belirtmeden sütunları tablodan hariç tutmanın bir yolu var mı?

Bildirici SQL'i her zamanki gibi kullanmak, hayır.

Önerilen sözdiziminizin değerli ve iyi olduğunu düşünüyorum. Aslında, ilişkisel veritabanı dili 'Tutorial D' çok benzer bir sözdizimine sahiptir, burada anahtar kelimelerin ALL BUTardından bir dizi özellik (sütun) gelir.

Ancak, SQL SELECT *zaten zaten bir plak (@ Guffa'nın cevabı burada tipik bir itiraz) alır, bu yüzden SELECT ALL BUTyakın zamanda SQL Standardına gireceğini sanmıyorum .

Bence en iyi 'geçici çözüm' VIEWsadece o zaman istediğiniz sütunlar ile bir oluşturmaktır SELECT * FROM ThatView.

BigQuery gibi modern bir SQL lehçesi mükemmel bir çözüm öneriyor

SEÇ * HARİÇ (ColumnNameX, [ColumnNameY, ...])

Bu, tablo sütun adı değişiklikleri nedeniyle sürekli güncellenmesi gereken sütunların uzun bir listesini önlemek için çok güçlü bir SQL sözdizimidir. Ve bu işlevsellik, yazık ki mevcut SQL Server uygulamasında eksik. Umarım, bir gün, Microsoft Azure daha fazla veri bilimci dostu olacaktır.

Veri bilimcileri, bir sorguyu kısaltmak ve bazı sütunları (çoğaltma veya başka bir nedenden dolayı) kaldırmak için hızlı bir seçeneğe sahip olmayı severler.

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

Postgres sql bunu yapmanın bir yolu var

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

Bilgi Şeması Hack Yolu

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

Benim özel örnek tablo için yukarıdaki - böyle bir sql deyimi oluşturur

OF.Picepark, o.owner, o. kare görüntülerini SEÇİM

Bunu destekleyen herhangi bir veritabanı bilmiyorum (SQL Server, MySQL, Oracle, PostgreSQL). Kesinlikle SQL standartlarının bir parçası değildir, bu yüzden sadece istediğiniz sütunları belirtmeniz gerektiğini düşünüyorum.

Elbette SQL ifadenizi dinamik olarak oluşturabilir ve sunucunun çalıştırmasını sağlayabilirsiniz. Ancak bu SQL enjeksiyonu olasılığını açar.

Bunun biraz eski olduğunu biliyorum, ama aynı sorunla karşılaştım ve bir cevap arıyordum. Sonra üst düzey bir geliştirici bana çok basit bir numara gösterdi.

Management studio sorgu düzenleyicisini kullanıyorsanız, veritabanını genişletin, ardından sütunlar klasörünü görebilmek için seçtiğiniz tabloyu genişletin.

Select deyiminizde, yukarıdaki başvurulan sütunlar klasörünü vurgulayın ve sorgu penceresine sürükleyip bırakın. Tablonun tüm sütunlarını yapıştırır, daha sonra kimlik sütununu sütun listesinden kaldırmanız yeterlidir ...

Bunu çözmenin en iyi yolu, gerekli sütunlarla görünüm oluşturabileceğiniz ve formdan veri alabileceğiniz görünümü kullanmaktır.

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)

Örneğin parola gibi hassas bir büyük / küçük harf sütununu hariç tutmak istiyorsanız, değeri gizlemek için bunu yaparım:

SELECT * , "" as password FROM tableName;

Sadece * belirtmek yerine, hangi sütunları istediğinizi belirtmek yaygın olarak kullanılan en iyi uygulamadır. Bu nedenle, yalnızca seçtiğiniz alanların geri dönmesini istediğinizi belirtmeniz gerekir.

Bir meslektaşım iyi bir alternatif önerdi:

• Önceki sorgunuzda (verileri oluşturduğunuz veya veri aldığınız yer) INTO SELECT komutunu bir tabloya (tamamlandığında sildiğiniz) yapın. Bu sizin için bir yapı yaratacaktır.
• Bir komut dosyasını yeni sorgu penceresine OLUŞTURUN.
• İstenmeyen sütunları kaldırın. Kalan sütunları 1 astar olarak biçimlendirin ve sütun listeniz olarak yapıştırın.
• Oluşturduğunuz tabloyu silin.

Bitti ...

Bu bize çok yardımcı oldu.

Nesne Gezgini'nde sağ tıklama tablosu, İlk 1000 satırı seç

* Değil tüm sütunları listeler. Ardından istenmeyen sütunları kaldırın. Kendiniz yazmaktan çok daha hızlı olmalı.

Daha sonra bunun biraz fazla iş olduğunu düşündüğünüzde, Red Gate'in SQL İstemini alın ve tbl'den ssf yazın, * öğesine gidin ve sekmeyi tekrar tıklayın.

Bu durum için sık kullandığım şey:

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

Bazen aynı program farklı veritabanı yapılarını işlemelidir. Bu yüzden, selectifadelerde hataları önlemek için programda bir sütun listesi kullanamadım .

*tüm isteğe bağlı alanları verir. Kullanmadan önce alanların veri tablosunda olup olmadığını kontrol ediyorum. Bu kullandığım için nedenidir *içindeselect .

Dışlanan alanları şu şekilde işleyebilirim:

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

Bu sorunun eski olduğunu biliyorum, ama umarım bu hala yardımcı olabilir. Cevap SQL Server Forumlarından bir tartışma esinlenmiştir . Bunu saklı yordam yapabilirsiniz . Alanlar dışında birden fazla eklenecek şekilde de değiştirilebilir.

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

Bunu yapmak daha kolay olmaz mıydı:

sp_help <table_name>

- 'Sütun_adı' sütunu> Kopyala> Yeni bir Sorgu penceresine yapıştır (dikey bir liste oluşturur) üzerine tıklayın ve her sütun değerinin önüne virgül yazın ... istemediğiniz sütunlara yorum yapın ... çok daha az burada sunulan ve hala yönetilebilir herhangi bir kod daha yazmak.

SQL Complete'i devart.com'dan alabilirsiniz; bu sadece Red Gate'ten SQL İstemi gibi * joker karakterini genişletmez (cairnz'ın cevabında açıklandığı gibi), aynı zamanda tüm onay kutularını işaretleyebileceğiniz onay kutuları içeren bir sütun seçici açılır seçim listesinde olmasını istediğiniz sütunları seçin ve bunlar sizin için otomatik olarak eklenir (ve daha sonra bir sütunun işaretini kaldırırsanız, seçim listesinden otomatik olarak kaldırılır).

SSMS'de IntelliSense ve Aliasing ile daha kolay bir yol var . Bunu dene

1. Metin düzenleyiciyi sağ tıklayın ve IntelliSense'ten emin olun etkinleştirildiğinden .
2. Sorguyu bir takma adla yazın [SELECT t. * FROM tablename t].
3. Metin git *. T ve silme * sütunlar ve ssms irade otomatik liste f Aliased masaya.