Що швидше / краще? SELECT * або SELECT стовпчик1, colum2, стовпець3 тощо

Я чув, що SELECT *це взагалі погана практика використання під час написання команд SQL, оскільки це більш ефективно для SELECTстовпців, які вам спеціально потрібні.

Якщо мені потрібно до SELECTкожного стовпця таблиці, чи повинен я використовувати

SELECT * FROM TABLE

або

SELECT column1, colum2, column3, etc. FROM TABLE

Чи справді ефективність в цьому випадку має значення? Я думаю, SELECT *було б більш оптимальним внутрішньо, якщо вам справді потрібні всі дані, але я говорю це, не маючи реального розуміння бази даних.

Мені цікаво дізнатися, яка найкраща практика в цьому випадку.

ОНОВЛЕННЯ: Напевно, я повинен зазначити, що єдиною ситуацією, коли я дійсно хотів би зробити це, SELECT *є коли я вибираю дані з однієї таблиці, де я знаю, що всі стовпці завжди потрібно буде отримати, навіть коли нові стовпці додаються.

З огляду на відповіді, які я бачив, однак це все ще здається поганою ідеєю, і SELECT *його ніколи не слід використовувати з набагато більше технічних причин, з яких я коли-небудь хотів.

Однією з причин того, що вибір конкретних стовпців краще, є те, що це підвищує ймовірність того, що SQL Server може отримати доступ до даних з індексів, а не запитувати дані таблиці.

Ось пост, про який я писав: Я справжню причину вибору запитів - це погане покриття індексу

Це також менш крихке для зміни, оскільки будь-який код, який споживає дані, отримає ту саму структуру даних незалежно від змін, які ви внесете в схему таблиці в майбутньому.

З огляду на ваші специфікації , що ви є вибором всіх стовпців, є невелика різниця в цей час . Зрозумійте, проте, що схеми бази даних змінюються. Якщо ви користуєтеся, SELECT *ви отримаєте нові таблиці, додані до таблиці, хоча, швидше за все, ваш код не готовий використовувати ці нові дані. Це означає, що ви піддаєте свою систему несподіваним змінам продуктивності та функціональності.

Можливо, ви хочете відхилити це як незначну вартість, але розумійте, що стовпці, які вам ще не потрібні, повинні бути:

1. Читати з бази даних
2. Надіслано по всій мережі
3. Марширували у вашому процесі
4. (для технологій типу ADO) Збережено в пам'яті таблиці даних
5. Ігнорується та викидається / збирається сміття

Пункт №1 має багато прихованих витрат, включаючи усунення деякого потенційного індексу покриття, спричинення завантаження сторінок даних (та обробка кешу сервера), виникнення блокувань рядків / сторінок / таблиць, яких можна уникнути інакше.

Збалансуйте це за рахунок потенційної економії, вказавши стовпці проти *та єдину потенційну економію:

1. Програмісту не потрібно переглядати SQL для додавання стовпців
2. Мережевий транспорт SQL менший / швидший
3. Час розбору / перевірки запитів SQL Server
4. Кеш плану запитів SQL Server

Для пункту 1 реальність полягає в тому, що ви збираєтесь додати / змінити код, щоб використовувати будь-який новий стовпець, який ви могли б додати в будь-якому випадку, тож це миття.

Для пункту 2 різниці достатньо рідко, щоб підштовхнути вас до іншого розміру або кількості мережевих пакетів. Якщо ви перейдете до того, що час передачі операторів SQL є переважаючим питанням, вам, ймовірно, потрібно спочатку зменшити швидкість операторів.

Для пункту 3 економії немає, оскільки розширення *має відбутися в будь-якому випадку, що означає, будь-ласка, звернутися до схеми (таблиць). Реально, перерахування стовпців буде мати таку саму вартість, оскільки вони повинні бути затверджені відповідно до схеми. Іншими словами, це повне миття.

Для пункту 4, коли ви вказуєте конкретні стовпці, кеш плану ваших запитів може збільшитися, але лише якщо ви маєте справу з різними наборами стовпців (це не те, що ви вказали). У цьому випадку ви хочете різних записів кешу, тому що вам потрібно різні плани за потребою.

Отже, все це зводиться через те, як ви вказали питання, до стійкості випуску в умовах можливих модифікацій схеми. Якщо ви записуєте цю схему в ROM (це трапляється), тоді *цілком прийнятний.

Однак, моє загальне керівництво полягає в тому, що ви повинні вибирати лише потрібні вам стовпці, це означає, що іноді це буде виглядати так, що ви просите їх усіх, але DBA і еволюція схеми означають, що можуть з’являтися нові колонки, які можуть сильно вплинути на запит .

Моя порада полягає в тому, що ВЖЕ ВИБІРИТЕ конкретні стовпці . Пам’ятайте, що ви добре розумієтеся, чим займаєтеся знову і знову, тому просто ввійдіть у звичку робити це правильно.

Якщо вам цікаво, чому схема може змінюватися без зміни коду, подумайте з точки зору журналу аудиту, термінів набуття чинності / терміну придатності та інших подібних речей, які додаються DBA для системного вирішення питань відповідності. Іншим джерелом незмінних змін є денормалізація для продуктивності в інших місцях системи або визначених користувачем полів.

Вам слід вибрати лише потрібні стовпці. Навіть якщо вам потрібні всі стовпці, все ж краще перелічити назви стовпців, щоб серверу sql не потрібно було запитувати системну таблицю для стовпців.

Також ваша програма може зламатися, якщо хтось додасть стовпці до таблиці. Ваша програма отримає стовпці, яких вона теж не очікувала, і вона може не знати, як їх обробити.

Крім цього, якщо в таблиці є двійковий стовпець, то запит буде набагато повільніше і використовувати більше мережевих ресурсів.

Існує чотири великі причини, що select *погано:

1. Найважливіша практична причина полягає в тому, що вона змушує користувача магічно пізнати порядок повернення стовпців. Краще бути явним, що також захищає вас від зміни таблиці, яка чудово перетворюється на ...

2. Якщо ім’я стовпця, яке ви використовуєте, зміни, краще зафіксувати його рано (в точці виклику SQL), а не тоді, коли ви намагаєтесь використовувати стовпець, якого більше немає (або змінилася його назва тощо). )

3. Перерахування імен стовпців робить ваш код набагато більш задокументованим та таким, ймовірно, більш читабельним.

4. Якщо ви переносите по мережі (або навіть якщо ви цього не зробите), стовпці, які вам не потрібні, - це лише відходи.

Визначення списку стовпців зазвичай є найкращим варіантом, оскільки ваша програма не вплине, якщо хтось додасть / вставить стовпець у таблицю.

Вказання назв стовпців, безумовно, швидше - для сервера. Але якщо

1. продуктивність не є великою проблемою (наприклад, це база даних із вмістом веб-сайтів із сотнями, може, тисячами, але не мільйонами - рядків у кожній таблиці); І
2. ваше завдання - створити багато невеликих подібних додатків (наприклад, веб-сайти, що керують вмістом), використовуючи загальну основу, а не створювати складні разові програми; І
3. важлива гнучкість (велике налаштування схеми db для кожного сайту);

тоді вам краще не дотримуватися SELECT *. У нашій рамках велике використання SELECT * дозволяє нам ввести нове поле вмісту, кероване веб-сайтом, до таблиці, надаючи йому всі переваги CMS (версія, робочий процес / затвердження тощо), при цьому лише торкаючись коду на пару балів, замість пари десятків балів.

Я знаю, що гуру БД будуть ненавидіти мене за це - продовжуйте, голосуйте мене - але в моєму світі час розробників обмежений, а цикли процесора - в достатку, тому я відповідно коригую те, що я заощаджую і на що трачу.

SELECT * є поганою практикою, навіть якщо запит не надсилається через мережу.

1. Вибір більшої кількості потрібних даних робить запит менш ефективним - сервер повинен читати та передавати зайві дані, тому це потребує часу і створює зайве навантаження на систему (не тільки мережу, як згадували інші, але й диск, процесор тощо). ). Крім того, сервер не в змозі настільки добре оптимізувати запит (наприклад, використовувати індекс покриття для запиту).
2. Через деякий час структура таблиці може змінитися, тому SELECT * поверне інший набір стовпців. Отже, ваша програма може отримати набір даних про несподівану структуру і зламатися десь за течією. Явне зазначення стовпців гарантує, що ви отримаєте набір даних відомої структури, або отримаєте явну помилку на рівні бази даних (наприклад, "стовпець не знайдено").

Звичайно, для маленької та простої системи все це не має великого значення.

Вибір продуктивності, SELECT з певними стовпцями може бути швидшим (не потрібно читати у всіх даних). Якщо ваш запит дійсно використовує ВСІ стовпці, SELECT з явними параметрами все ж є кращим. Будь-яка різниця швидкостей буде в основному непомітною і майже постійною. Одного разу ваша схема зміниться, і це хороша страховка для запобігання проблем через це.

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

Явне називання стовпців допоможе вам у догляді за дорогою. У якийсь момент ви збираєтеся вносити зміни або вирішувати проблеми, і опиняєтесь, "запитаючи, де використовується цей стовпець".

Якщо ви чітко вказані імена, то знайти кожне посилання на цей стовпець - через усі ваші збережені процедури, представлення даних тощо - просто. Просто скиньте CREATE-скрипт для вашої схеми БД і виконайте пошук тексту за допомогою нього.

безумовно, визначаючи стовпці, оскільки SQL Server не повинен буде робити пошук на стовпцях, щоб витягнути їх. Якщо ви визначаєте стовпці, то SQL може пропустити цей крок.

Завжди краще вказувати потрібні стовпці, якщо ви думаєте про це один раз, SQL не повинен думати "wtf є *" щоразу, коли ви запитуєте. Крім того, хтось пізніше може додати стовпці до таблиці, які вам фактично не потрібні у вашому запиті, і вам буде краще в цьому випадку, вказавши всі ваші стовпці.

Проблема "select *" - це можливість передачі даних, які вам насправді не потрібні. Під час фактичного запиту до бази даних вибрані стовпці насправді не додають до обчислення. Насправді "важким" є перевезення даних до вашого клієнта, і будь-який стовпець, який вам насправді не потрібен, - це просто витрачати пропускну спроможність мережі та додати час, який ви очікуєте, щоб повернути запит.

Навіть якщо ви використовуєте всі стовпці, приведені з пункту "select * ...", це лише наразі. Якщо в майбутньому ви зміните макет таблиці / перегляду та додасте більше стовпців, ви почнете приносити ті, що є у вибраному, навіть якщо вони вам не потрібні.

Ще один момент, у якому заява "select *" погана - це створення перегляду. Якщо ви створили подання за допомогою "select *" і пізніше додасте стовпці до таблиці, визначення перегляду та повернуті дані не збігаються, і вам потрібно буде перекомпілювати свої представлення для того, щоб вони знову працювали.

Я знаю, що написання "select *" є заманливим, тому що я дійсно не люблю вручну вказувати всі поля моїх запитів, але коли ваша система почне розвиватися, ви побачите, що варто витратити цей додатковий час / зусиль у визначенні полів, а не витрачати набагато більше часу та зусиль на видалення помилок у ваших переглядах чи оптимізацію програми.

Хоча явний перелік стовпців є хорошим для продуктивності, не збожеволійте.

Отже, якщо ви використовуєте всі дані, спробуйте SELECT * для простоти (уявіть, що у вас є багато стовпців і робити СПОЛУЧЕННЯ ... запит може стати жахливим). Потім - міра. Порівняйте запит із чітко вказаними назвами стовпців.

Не спекулюйте на ефективності, вимірюйте це!

Явний перелік найбільше допомагає, коли у вас є стовпець із великими даними (наприклад, частина публікації чи статті), і він не потребує цього в заданому запиті. Тоді, не повертаючи його у відповідь, сервер DB може заощадити час, пропускну здатність та пропускну здатність диска. Результат запиту також буде меншим, що добре підходить для будь-якого кешу запитів.

Ви дійсно повинні вибирати лише потрібні вам поля, і лише необхідну кількість, тобто

SELECT Field1, Field2 FROM SomeTable WHERE --(constraints)

Поза межами бази даних динамічні запити ризикують нападів ін'єкцій та неправильних даних. Зазвичай ви долаєте це за допомогою збережених процедур або параметризованих запитів. Також (хоча це не дуже велика проблема) сервер повинен генерувати план виконання щоразу, коли виконується динамічний запит.

Вибір не менш ефективний (з точки зору швидкості), якщо ви використовуєте * або стовпці.

Різниця стосується пам’яті, а не швидкості. При виборі декількох стовпців SQL Server повинен виділити простір пам’яті для обслуговування запиту, включаючи всі дані для всіх запитуваних стовпців, навіть якщо ви використовуєте лише один із них.

Що стосується продуктивності, важливим є план виплат, який, в свою чергу, сильно залежить від вашого пункту WHERE та кількості ПРИЄДНАЙТЕСЬ, ЗОВНІШНІЙ ПРИЄДНАЙТЕСЬ тощо.

Для свого питання просто використовуйте SELECT *. Якщо вам потрібні всі стовпці, різниці в продуктивності немає.

НЕ швидше використовувати явні імена полів проти *, якщо і лише якщо вам потрібно отримати дані для всіх полів.

Програмне забезпечення вашого клієнта не повинно залежати від порядку повернених полів, тому це теж нісенітниця.

І можливо (хоча й малоймовірно), що вам потрібно отримати всі поля за допомогою *, оскільки ви ще не знаєте, які поля існують (думаю, дуже динамічна структура бази даних).

Ще одним недоліком використання явних імен полів є те, що якщо їх багато і вони довгі, це ускладнює читання коду та / або журналу запитів.

Отже, правило повинно бути: якщо вам потрібні всі поля, використовуйте *, якщо вам потрібна лише підмножина, назвіть їх явно.

Результат занадто величезний. Генерувати та відправляти результат із двигуна SQL клієнту повільно.

Клієнтська сторона, будучи загальним середовищем програмування, не має і не повинна розроблятися для фільтрації та обробки результатів (наприклад, пункт WHERE, пункт ORDER), оскільки кількість рядків може бути величезною (наприклад, десятки мільйонів рядків).

Іменування кожного стовпця, який ви очікуєте отримати у вашій заявці, також гарантує, що ваша програма не порушиться, якщо хтось змінить таблицю, якщо ваші стовпці все ще присутні (у будь-якому порядку).

Це залежить від версії вашого сервера БД, але сучасні версії SQL можуть кешувати план будь-яким способом. Я б сказав, що за допомогою коду доступу до даних можна отримати все, що найрентабельніше.

Однією з причин є краща практика чітко визначити, які саме стовпці ви хочете, через можливі майбутні зміни структури таблиці.

Якщо ви читаєте дані вручну, використовуючи підхід на основі індексу, щоб заповнити структуру даних результатами вашого запиту, то в майбутньому, коли ви додасте / видалятимете стовпець, у вас будуть головні болі, намагаючись з’ясувати, що пішло не так.

Що стосується того, що швидше, я віддам іншим їх досвід.

Як і у більшості проблем, це залежить від того, чого ви хочете досягти. Якщо ви хочете створити сітку db, яка дозволить усім стовпцям у будь-якій таблиці, то відповідь "Вибрати *". Однак якщо вам знадобляться лише певні стовпці, а додавання або видалення стовпців із запиту робиться нечасто, то вкажіть їх окремо.

Це також залежить від кількості даних, які ви хочете передати з сервера. Якщо один із стовпців визначений як пам'ятка, графіка, крапка тощо, і вам не потрібен цей стовпець, вам краще не використовувати "Select *", або ви отримаєте цілу купу даних, яких ви не хочете хочете, і ваша ефективність може постраждати.

Щоб додати до сказаного всі інші, якщо всі ваші стовпці, які ви вибираєте, включені до індексу, ваш набір результатів буде витягнутий з індексу замість пошуку додаткових даних з SQL.

SELECT * необхідний, якщо потрібно отримати метадані, такі як кількість стовпців.

Що сказали всі вище, плюс:

Якщо ви прагнете дочитаного коду, який можна читати, виконайте щось на кшталт:

SELECT foo, bar ВІДЖЕТИ;

легко читається і виявляє наміри. Якщо ви зробите цей дзвінок, ви знаєте, що повертаєтеся. Якщо у віджетах є лише колонки foo та bar, тоді вибір * означає, що вам все одно доведеться думати про те, що ви повертаєтесь, підтвердити, що замовлення відображено правильно тощо. Однак якщо у віджетах є більше стовпців, але вас цікавить лише foo і бар, тоді ваш код стає безладним, коли ви запитуєте на підстановку, а потім використовуєте лише частину повернутого.

І пам’ятайте, якщо у вас є внутрішнє з'єднання за визначенням, вам не потрібні всі стовпці, оскільки дані в стовпцях приєднання повторюються.

Це не так, як перерахування стовпців на сервері SQl є важким або навіть трудомістким. Ви просто перетягніть їх із браузера об'єктів (ви можете отримати все за один раз, перетягнувши з стовпців слова). Поставити постійне звернення до продуктивності у вашій системі (тому що це може зменшити використання індексів і, таким чином, надсилання зайвих даних по мережі дорого коштує) та зробить більш імовірним виникнення несподіваних проблем під час зміни бази даних (іноді додаються стовпці, що ви не хочете, щоб користувач бачив, наприклад) лише для того, щоб заощадити менше хвилини часу на розробку, є недалекоглядним та непрофесійним.

Якість бачення Я бачив коментарі, що обидва рівні. але аспект юзабіліті є деякі + і

Якщо ви використовуєте (виберіть *) у запиті, і якщо хтось із них змінює таблицю та додає нові поля, які не потрібні попередньому запиту, це непотрібна накладні витрати. А що робити, якщо щойно додане поле - це крапка або поле зображення ??? тоді ваш час відповіді на запит буде дуже повільним.

З іншого боку, якщо ви використовуєте (виберіть col1, col2, ..) і якщо таблиця буде змінена і додано нові поля, і якщо ці поля потрібні у наборі результатів, вам завжди потрібно буде редагувати обраний запит після зміни таблиці.

Але я пропоную завжди використовувати у своїх запитах Select col1, col2, ... та змінювати запит, якщо таблиця буде змінена пізніше ...

Абсолютно визначайте стовпці, які ви бажаєте вибирати кожен раз. Причин цього не робити, а покращення продуктивності варто того.

Вони ніколи не повинні давати можливість "SELECT *"

Якщо вам потрібен кожен стовпець, просто використовуйте SELECT *, але пам’ятайте, що порядок потенційно може змінюватися, тому коли ви споживаєте результати, отримуйте доступ до них за назвою, а не за індексом.

Я б ігнорував коментарі про те, як * потрібно пройти отримати список - шанси на аналіз і перевірку названих стовпців дорівнює часу обробки, якщо не більше. Не передчасно оптимізуйте ;-)

Щодо ефективності виконання, я не знаю жодної суттєвої різниці. Але для ефективності програмістів я б написав назви полів, оскільки

• Ви знаєте порядок, якщо вам потрібно індексувати за номером, або якщо ваш драйвер веде себе смішно на значення blob, і вам потрібно певне замовлення
• Ви читаєте лише потрібні поля, якщо ви коли-небудь повинні додавати більше полів
• Ви отримуєте sql-помилку, якщо неправильно написали або перейменували поле, а не порожнє значення із набору записів / рядків
• Ви можете краще прочитати, що відбувається.

ей, будь практичним. використовувати select * при прототипуванні та вибирати конкретні стовпці при впровадженні та розгортанні. З точки зору плану виконання, обидва відносно однакові в сучасних системах. однак, вибір конкретних стовпців обмежує кількість даних, які потрібно отримати з диска, зберегти в пам'яті та надіслати по мережі.

Зрештою, найкращим планом є вибір конкретних стовпців.