Есть ли разница между Select * и Select [перечислить каждый столбец]

Когда вы выбираете каждое поле по отдельности, становится более ясно, какие именно поля выбираются.

Как правило, лучше быть явным, поэтому Select col1, col2 from Table лучше. Причина в том, что в какой-то момент в эту таблицу может быть добавлен дополнительный столбец, что приведет к возврату ненужных данных из запроса.

Однако это не жесткое правило.

1) Второй вариант более четко определяет, какие столбцы возвращаются. Тогда значение второго - это то, насколько вы цените, зная, какие столбцы возвращаются.

2) Это подразумевает, что возвращается потенциально меньше данных, когда столбцов больше, чем явно используемых.

3) Если вы измените таблицу, добавив новый столбец, первый запрос изменится, а второй - нет. Если у вас есть код типа «для всех возвращаемых столбцов сделать ...», то результаты изменятся, если вы используете первый, но не второй.

Некоторые причины не использовать первого оператора (выберите *):

1. Если вы добавите несколько больших полей (столбец BLOB будет очень плохим) позже в эту таблицу, вы можете столкнуться с проблемы с производительностью в приложении
2. Если запрос был запросом JOIN с двумя или более таблицами, некоторые поля могли иметь то же имя. Лучше заверить, что имена ваших полей разные.
3. цель запроса более понятен со вторым утверждением с точки зрения эстетики программирования.

Вы должны указать явный список столбцов. SELECT * вернет больше столбцов, чем вам нужно, для создания большего количества операций ввода-вывода и сетевого трафика, но, что более важно, может потребоваться дополнительный поиск, даже если существует некластеризованный покрывающий индекс (на SQL Server).

Беглый взгляд на план выполнения запроса показывает, что запросы совпадают.

Общее практическое правило состоит в том, что вы захотите ограничить свои запросы только теми полями, которые вам нужно вернуть.

Это хорошо для прямой совместимости.

Когда вы используете

SELECT * FROM myTable

а в «myTable» 3 столбца. Вы получите те же результаты, что и

SELECT Column1, Column2, Column3 FROM myTable

Но если вы добавите новый столбец в будущем, вы получите другие результаты.

Конечно, если вы измените имя одного из существующих столбцов, в первом случае вы получите результат, а во втором случае вы получите ошибку (я думаю, это правильное поведение приложения).

Для LinqToSql, если вы планируете изменить эти записи позже, вы должны вытащить всю запись в память.

SELECT * - это плохая практика в большинстве случаев.

• Что, если кто-то добавит в эту таблицу столбец BLOB размером 2 ГБ?
• Что кто-то действительно добавляет в эту таблицу какой-нибудь столбец?

Это ошибка, которая ждет своего часа.

Это зависит от того, что вы подразумеваете под «различием». Существует очевидная разница в синтаксисе, но реальная разница заключается в производительности.

Когда вы говорите SELECT * FROM MyTable, вы указываете механизму запросов SQL вернуть набор данных с все столбцов из этой таблицы, в то время как SELECT ColA, ColB, ColC FROM MyTable сообщает механизму запросов вернуть набор данных с Только ColA, ColB и ColC из таблицы.

Допустим, у вас есть таблица со 100 столбцами, определенная как CHAR [10]. SELECT * вернет 100 столбцов * 10 байтов данных, а SELECT ColA, ColB, ColC вернет 3 столбца * 10 байтов данных. Это огромная разница в размере данных, передаваемых по сети.

Указание списка столбцов также делает более понятным, какие столбцы вас интересуют. Недостатком является то, что если вы добавляете / удаляете столбец из таблицы, вам необходимо убедиться, что список столбцов также обновляется, но я думаю, что это небольшая цена. по сравнению с приростом производительности.

выбор каждого столбца лучше, чем просто *, потому что в случае добавления или удаления новой строки вы ДОЛЖНЫ взглянуть на код и посмотреть, что вы делали с полученными данными. Кроме того, это помогает вам лучше понять ваш код и позволяет использовать псевдонимы в качестве имен столбцов (в случае, если вы выполняете соединение таблиц с столбцом, имеющим имя).

Я собираюсь расстроить многих людей из-за меня, но особенно если я добавляю столбцы позже, я обычно предпочитаю использовать таблицу SELECT * FROM. По этой причине меня назвали ленивым, потому что, если я внесу какие-либо изменения в свои таблицы, я бы не хотел отслеживать все сохраненные процессы, которые используют эту таблицу, а просто изменить их в классах уровня доступа к данным в моем приложении. . Бывают случаи, когда я указываю столбцы, но в случае, когда я пытаюсь получить полный «объект» из базы данных, я бы предпочел просто использовать «*». И, да, я знаю, что люди будут меня ненавидеть за это, но это позволило мне быстрее и меньше избавляться от ошибок при добавлении полей в мои приложения.

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

Например, если вы вставляете столбец в таблицу.

Возьмите эту таблицу: ColA ColB ColC

У вас может быть запрос:

SELECT *
FROM myTable

Тогда код может быть таким:

rs = executeSql("SELECT * FROM myTable")
while (rs.read())
    Print "Col A" + rs[0]
    Print "Col B" + rs[1]
    Print "Col C" + rs[2]

Если вы добавите столбец между ColB и ColC, запрос не вернет то, что вы ищете.

SELECT * FROM MyTable

select * зависит от порядка столбцов в схеме, поэтому, если вы ссылаетесь на результат, установленный по индексу # коллекции, вы будете смотреть не на тот столбец.

SELECT Col1,Col2,Col3 FROM MyTable

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

Пара вещей:

• Большое количество людей написали здесь, что рекомендуют не использовать *, и привели несколько веских причин для этих ответов. На данный момент из 10 других ответов только один не рекомендует перечислять столбцы.
• Люди часто делают исключения из этого правила при публикации сообщений на таких сайтах, как StackOverflow, потому что они часто не знают, какие столбцы находятся в вашей таблице или важны для вашего запроса. По этой причине вы увидите много кода здесь и в других местах в Интернете, который использует синтаксис *, даже если автор сообщения старается избегать его в своем собственном коде.

У проблемы есть две стороны: явная спецификация столбца дает лучшую производительность при добавлении новых столбцов, но * спецификация не требует обслуживания при добавлении новых столбцов.

Что использовать, зависит от того, какие столбцы вы ожидаете добавить в таблицу и в чем суть запроса.

Если вы используете свою таблицу в качестве резервного хранилища для объекта (что кажется вероятным в случае LINQ-to-SQL), вы, вероятно, захотите, чтобы любые новые столбцы, добавленные в эту таблицу, были включены в ваш объект, и наоборот. Вы поддерживаете их параллельно. По этой причине для этого случая правильная спецификация * в предложении SELECT. Явная спецификация предоставит вам дополнительную поддержку каждый раз, когда что-то изменится, и ошибку, если вы не обновите список полей правильно.

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

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

Пример того, почему вы никогда (imho) не должны использовать SELECT *. Это не относится к MSSQL, а скорее к MySQL. Версии до 5.0.12 возвращали столбцы из определенных типов объединений нестандартным образом. Конечно, если ваши запросы определяют, какие столбцы вам нужны и в каком порядке, у вас нет проблем. Представьте себе удовольствие, если они этого не сделают.

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

Использование "SELECT *" оптимизирует набор текста программистом. Вот и все. Это единственное преимущество.