Есть ли различие между Выбором *, и Выбор [перечисляют каждое седло] [дубликат]
Исключение нулевого указателя - это индикатор того, что вы используете объект, не инициализируя его.
Например, ниже - класс ученика, который будет использовать его в нашем коде.
public class Student {
private int id;
public int getId() {
return this.id;
}
public setId(int newId) {
this.id = newId;
}
}
Приведенный ниже код дает вам исключение с нулевым указателем.
public class School {
Student obj_Student;
public School() {
try {
obj_Student.getId();
}
catch(Exception e) {
System.out.println("Null Pointer ");
}
}
}
Поскольку вы используете Obj_Student, но вы забыли инициализировать его, как в правильном коде, показанном ниже:
public class School {
Student obj_Student;
public School() {
try {
obj_Student = new Student();
obj_Student.setId(12);
obj_Student.getId();
}
catch(Exception e) {
System.out.println("Null Pointer ");
}
}
}
18 ответов
Обычно лучше быть явным, таким образом Select col1, col2 from Table лучше. Причина, являющаяся этим в какой-то момент, дополнительный столбец может быть добавлен к той таблице и заставил бы ненужные данные быть возвращенными из запроса.
Это не жесткое правило все же.
Используя "ВЫБОР *" оптимизирует для программиста, вводящего.Вот именно. Это - единственное преимущество.
Пример относительно того, почему никогда (по моему скромному мнению), необходимо использовать ВЫБОР *. Это не касается MSSQL, а скорее MySQL. Версии до 5.0.12 возвращенных столбцов от определенных типов не участвуют ни в одном - стандартный способ. Конечно, если Ваши запросы определяют, какие столбцы Вы хотите и в котором порядке у Вас нет проблемы. Вообразите забаву, если они не делают.
(Одно возможное исключение: Ваш запрос ВЫБИРАЕТ всего из одной таблицы и , Вы определяете столбцы на своем предпочтительном языке программирования по имени, а не положении.)
выбор каждого столбца лучше, чем просто *, потому что в случае, если Вы добавляете или удаляете новую строку, необходимо посмотреть на код и смотреть, что Вы делали с полученными данными.
кроме того, это помогает Вам понять свой код лучше и позволяет Вам использовать псевдонимы в качестве имен столбцов (в случае, если Вы выполняете соединение таблиц со столбцом, совместно использующим имя)
Беглый взгляд на план выполнения запросов показывает, что запросы являются тем же.
общее правило ползунка состоит в том, что Вы захотите ограничить свои запросы только полями, в которых Вы нуждаетесь, возвратился.
SELECT * FROM MyTable
выбор * зависит от порядка столбцов в схеме поэтому, если Вы обратитесь к набору результатов индексом # набора, то Вы будете смотреть на неправильный столбец.
SELECT Col1,Col2,Col3 FROM MyTable
этот запрос даст Вам набор, который остается таким же со временем, но как часто Вы изменяете порядок столбцов так или иначе?
Это зависит от того, что Вы подразумеваете под "различием". Существует очевидное различие в синтаксисе, но реальной разницей является одна из производительности.
, Когда Вы говорите SELECT * FROM MyTable, Вы говорите механизму SQL-запроса возвращать набор данных с весь из столбцов от той таблицы, в то время как SELECT ColA, ColB, ColC FROM MyTable говорит механизму запроса возвращать набор данных с [только 119] ColA, ColB и ColC от таблицы.
Говорят, что у Вас есть таблица с 100 столбцами, определенными как CHAR[10]. SELECT * возвратит 100 столбцов * 10-байтовая ценность данных, в то время как SELECT ColA, ColB, ColC возвратит 3 столбца * 10-байтовая ценность данных. Это - огромное различие в размере в сумме данных, которые пасуются назад через провод.
Определение списка столбцов также делает его намного более ясным, какими столбцами Вы интересуетесь. Недостаток состоит в том, что, если Вы добавляете/удаляете столбец от таблицы, необходимо удостовериться, что список столбцов обновляется также, но я думаю, что это - маленькая цена по сравнению с увеличением производительности.
Для LinqToSql, если Вы планируете изменить те записи позже, необходимо вытянуть целую запись в память.
Его польза для вперед-compatiblity.
, Когда Вы используете
SELECT * FROM myTable
и в "myTable", 3 столбца. Вы получаете те же результаты как
SELECT Column1, Column2, Column3 FROM myTable
, Но если Вы добавляете новый столбец в будущем, Вы получаете различные результаты.
, Конечно, если Вы меняете имя один из существующего столбца в первом случае, Вы получаете результаты, и во втором случае Вы получаете ошибку (я думаю, это - корректное поведение приложения).
Если Ваш код полагается на определенные столбцы, находящиеся в определенном порядке, необходимо перечислить столбцы. В противном случае это действительно не имеет значения, если Вы используете "*" или выписываете имена столбцов в избранном операторе.
пример - то, при вставке столбца в таблицу.
Берут эту таблицу: 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, запрос не возвратил бы то, что Вы ищете.
ВЫБЕРИТЕ *, плохая практика в большинстве мест.
- , Что, если кто-то добавляет столбец BLOB на 2 ГБ к той таблице?
- то, Кто такой кто-то, добавляет действительно какой-либо столбец к той таблице?
Это - неизбежная ошибка.
При выборе каждого поля индивидуально это более ясно, какие поля на самом деле выбираются.
Некоторые причины для не использования первый оператор (выбор *):
- , Если бы Вы добавляете некоторые большие поля (столбец BLOB был бы очень плох) позже к той таблице, Вы могли пострадать проблемы производительности в приложении
- , Если бы запрос был запросом СОЕДИНЕНИЯ с двумя или больше таблицами, некоторые поля могли бы иметь то же имя . Было бы лучше гарантировать, что Ваши имена полей отличаются.
- цель из запроса более ясна со вторым оператором с точки зрения эстетики программирования
Необходимо определить явный список столбцов. ВЫБЕРИТЕ *, возвратит больше столбцов, чем Вам нужно создание большего количества IO и сетевого трафика, но что еще более важно это могло бы потребовать дополнительных поисков даже при том, что некластеризованный закрывающий индекс существует (На SQL Server).
Две стороны проблемы - это: Явная спецификация столбца дает лучшую производительность, поскольку новые столбцы добавляются, но * спецификация не требует никакого обслуживания, поскольку добавляются новые столбцы.
то, Чтобы использовать, зависит от того, какие столбцы Вы ожидаете добавлять к таблице, и какова точка запроса.
, Если Вы используете свою таблицу в качестве запоминающего устройства для объекта (который кажется вероятным в случае LINQ к SQL), Вы, вероятно, хотите, чтобы любые новые столбцы, добавленные к этой таблице, были включены в Ваш объект, и наоборот. Вы поддерживаете их параллельно. Поэтому для этого случая, * спецификация в ИЗБРАННОМ пункте является правильной. Явная спецификация дала бы Вам дополнительный бит обслуживания каждый раз, когда что-то изменилось, и ошибка, если Вы не обновили cписок полей правильно.
, Если запрос собирается возвратить много записей, Вы, вероятно, более обеспечены с явной спецификацией по причинам производительности.
, Если обе вещи верны, рассмотрите наличие двух различных запросов.
Я собираюсь получить много людей нарушение со мной, но особенно если я добавляю столбцы позже, мне обычно нравится использовать ВЫБОР * таблица FROM. Меня назвали ленивым поэтому, потому что, если бы я делаю какие-либо модификации к своим таблицам, я хотел бы не разыскать все сохраненные procs, которые используют ту таблицу, и просто изменяют ее в классах уровня доступа к данным в моем приложении. Существуют случаи, в которых я определю столбцы, но в случае, где я пытаюсь получить полный "объект" от базы данных, я просто использовал бы "*". И, да, я знаю, что люди будут ненавидеть меня за это, но это позволило мне быть более быстрым и меньше ошибки, свободной при добавлении полей к моим приложениям.
1) второй является более явным, о котором возвращаются столбцы. Значение 2-го тогда - то, насколько Вы оцениваете явно знание, какие столбцы возвращаются.
2) Это включает потенциально меньше данных, возвращаемых, когда существует больше столбцов, чем те явно используемые также.
3), Если Вы изменяете таблицу путем добавления нового столбца, первых изменений запроса и второго, не делает. Если у Вас есть код как "для всех возвращенных столбцов, делают..." тогда изменение результатов, если Вы используете первое, но не 2-е.
Пара вещей:
- большое количество А людей отправили сюда рекомендацию против использования * и привели несколько серьезных причин для тех ответов. Из 10 других ответов до сих пор только один не рекомендует перечислить столбцы.
- Люди часто делают исключения к тому правилу при размещении для помощи сайтам как StackOverflow, потому что они часто не знают, какие столбцы находятся в таблице или важны для запроса. По этой причине Вы будете видеть много кода здесь и в другом месте в сети, которая использует * синтаксис, даже при том, что плакат имел бы тенденцию избегать его в его собственном коде.