Mysql

Несколько значений where mysql: Как выполнить SELECT к MySQL по нескольким значениям с сохранением порядка? — Хабр Q&A

Команда WHERE — условие для выбора строк в базе данных

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

Данная команда может использоваться для выборки строк с помощью SELECT,
удаления строк с помощью DELETE, редактирования строк
с помощью UPDATE.

См. также команды
OR,
AND,
IN,
BETWEEN,
LIKE,
NOT,
IS NULL,
IS NOT NULL,
которые допустимо использовать в комбинации с командой WHERE.

Синтаксис

Примеры

Все примеры будут по этой таблице workers, если не сказано иное:

id
айди
name
имя
age
возраст
salary
зарплата
1 Дима 23 400
2 Петя 25 500
3 Вася 23 500
4 Коля 30 1000
5 Иван 27 500
6 Кирилл 28 1000

Пример

В данном примере выбираются записи, у которых поле id больше 2-х и меньше 4-х:

SELECT * FROM workers WHERE id>=2 AND id

SQL запрос выберет следующие строки:

id
айди
name
имя
age
возраст
salary
зарплата
2 Петя 25 500
3 Вася 23 500
4 Коля 30 1000

Пример

В данном примере выбираются записи,
у которых возраст равен 23 и одновременно зарплата равна 400:

SELECT * FROM workers WHERE age=23 AND salary=400

SQL запрос выберет следующие строки:

id
айди
name
имя
age
возраст
salary
зарплата
1 Дима 23 400

Пример

В данном примере из таблицы удаляются записи,
у которых поле id больше 2-х и меньше 4-х:

DELETE FROM workers WHERE id>=2 AND id

В таблице останутся следующие строки:

id
айди
name
имя
age
возраст
salary
зарплата
1 Дима 23 400
5 Иван 27 500
6 Кирилл 28 1000

MySQL. Выборка значений из нескольких таблиц.

Для примеров используем следующие таблицы:

Используемые таблицы

1. JOIN.
Полное объединение

Операторы JOIN, INNER JOIN и «,» (запятая) с указанием условий объединения дают пересечение для всех совпадающих значений из условия.

SELECT t1.*, t2.* FROM t1, t2 WHERE t1.i1 = t2.i2
#Аналоги:
SELECT t1.*, t2.* FROM t1 JOIN t2 ON t1.i1 = t2.i2
SELECT t1.*, t2.* FROM t1 INNER JOIN t2 ON t1.i1 = t2.i2



SELECT t1.*, t2.* FROM t1, t2 WHERE t1.i1 = t2.i2

#Аналоги:

SELECT t1.*, t2.* FROM t1 JOIN t2 ON t1.i1 = t2.i2

SELECT t1.*, t2.* FROM t1 INNER JOIN t2 ON t1.i1 = t2.i2

В результате получим:

При этом если не указать для оператора «,» (запятая) условие выборки WHERE, то получим полное декартово произведение (пересечение каждой строки из первой таблицы с каждой строкой из второй):

(аналогичный результат получается при использовании CROSS JOIN)
INNER JOIN можно представить как декартово произведение таблиц, из которого потом отобрали только те строки, которые удовлетворяют условию ON, хотя на практике, конечно, используются более совершенные алгоритмы, такие как Hash join и Self-merge join, поскольку алгоритм декартова произведения очень неэффективен.

LEFT JOIN, RIGHT JOIN

При использовании оператора LEFT JOIN выбираются все значения из левой таблицы, после чего к ним подбираются соответствующие значения из правой, если таких нет, то все значения для правой таблицы в этой строке равны NULL.
RIGHT JOIN противоположен LEFT JOIN: всё абсолютно так же, но выбираются все значения для правой таблицы из выражения.

SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 ON t1.i1 = t2.i2



SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 ON t1.i1 = t2.i2

В результате получим:

результаты LEFT JOIN

SELECT t1.*, t2.* FROM t1, t2 ON t1.i1 = t2.i2
#другая запись
SELECT t1.*, t2.* FROM t1 INNER JOIN t2 ON t1.i1 = t2.i2 WHERE
#аналогично по результату, хотя обычно медленнее
SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 ON t1.i1 = t2.i2 WHERE t2.i2 IS NOT NULL

При указании любого из операторов JOIN можно использовать ключевое слово USING() вместо ON, если названия столбцов в обеих таблицах одинаковы.

SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 ON t1.i = t2.i
#аналогично
SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 USING(i)



SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 ON t1.i = t2.i

#аналогично

SELECT t1.*, t2.* FROM t1 LEFT JOIN t2 USING(i)

JOIN‘ы можно комбинировать:

SELECT t1.*, t2.*
FROM t1, t2
LEFT JOIN t3
ON t1.i = t3.i1 AND t2.i = t3.i2
WHERE t3.i2 IS NOT NULL



SELECT t1.*, t2.*

FROM t1, t2

LEFT JOIN t3

ON t1.i = t3.i1 AND t2.i = t3.i2

WHERE t3.i2 IS NOT NULL

Self-join

Self-join объединяет таблицу саму с собой. Проще показать на примере.
Допустим есть таблица

Таблица Employee

И допустим, что нужно получить пары сотрудников, которые работают в одной стране. Результата можно добиться и уже описанными join’ами, но эффективнее будет следующий запрос:

SELECT F.EmployeeID, F.LastName, S.EmployeeID, S.LastName, F.Country
FROM Employee F, Employee S
WHERE F.Country = S.Country
AND F.EmployeeID < S.EmployeeID
ORDER BY F.EmployeeID, S.EmployeeID;



SELECT F.EmployeeID, F.LastName, S.EmployeeID, S.LastName, F.Country

FROM Employee F, Employee S

WHERE F.Country = S.Country

AND F.EmployeeID < S.EmployeeID

ORDER BY F.EmployeeID, S.EmployeeID;

В результате получим:

Результат self-join таблицы Employee

В данном случае:
F и S — алиасы таблицы Employee
условие F.Country = S.Country исключает из результата пары, для которых страны не совпадают
условие F.EmployeeID исключает пары с одинаковыми EmployeeID, а также дублирование ранее выведенных пар (т.е. сотрудник с EmployeeID=145 не выведется слева).

INNER JOIN в некоторых случаях значительно быстрее, чем OUTER JOIN (LEFT JOIN или RIGHT JOIN), поэтому лучше по возможности использовать INNER JOIN. Пример сравнения производительности с объяснением.
Виды JOIN’ов

2. Подзапросы.

Подзапросы организуются в виде вложенных SELECT‘ов.
В принципе, в подзапросах можно использовать и другие операторы, но модифицирующие INSERT, REPLACE, DELETE, UPDATE при этом не могут модифицировать таблицу из основного запроса.

SELECT t1.*FROM t1 WHERE t1.i1 IN (SELECT i2 FROM t2 WHERE c2 = ‘a’)



SELECT t1.*FROM t1 WHERE t1.i1 IN (SELECT i2 FROM t2 WHERE c2 = ‘a’)


Подзапрос может возвращать одно значение (скалярный подзапрос), несколько значений одного столбца, несколько значений нескольких столбцов (фактически, таблицу).
Со скалярным подзапросом можно использовать операторы сравнение («=», «>», «<«, «<>» и т.д.).
Приэтом важно, чтобы подзапрос возвращал только одно значение.
Это очень удобно в запросах типа

#так писать нельзя, т.к. значение MIN(i) неизвестно
#до того момента, как произойдёт выборка
#т.е. уже после того, как понадобится «WHERE»
SELECT * FROM t1 WHERE i = MIN(i)
#а вот так писать можно
SELECT * FROM t1 WHERE i = (SELECT MIN(i) FROM t1)



#так писать нельзя, т.к. значение MIN(i) неизвестно

#до того момента, как произойдёт выборка

#т.е. уже после того, как понадобится «WHERE»

SELECT * FROM t1 WHERE i = MIN(i)

#а вот так писать можно

SELECT * FROM t1 WHERE i = (SELECT MIN(i) FROM t1)


Если подзапрос возвращает одну строку, то можно использовать кортеж (набор значений для сравнения):
Это очень удобно в запросах типа

SELECT t1.* FROM t1
WHERE (i, c) = (SELECT i, c FROM t2 WHERE i = 2 LIMIT 1)



SELECT t1.* FROM t1

WHERE (i, c) = (SELECT i, c FROM t2 WHERE i = 2 LIMIT 1)


Если подзапрос может вернуть несколько значений, то лучше ипользовать операторы IN и NOT IN вместо = и <> соответственно.

SELECT t1.* FROM t1
WHERE (i, c) IN (SELECT i, c FROM t2)



SELECT t1.* FROM t1

WHERE (i, c) IN (SELECT i, c FROM t2)


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

SELECT * FROM t1
WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE i > 10000)



SELECT * FROM t1

WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE i > 10000)


Коррелированные подзапросы

содержат ссылки на значения внешнего запроса.

SELECT i FROM t1 WHERE j IN (SELECT k FROM t2 WHERE k = i)



SELECT i FROM t1 WHERE j IN (SELECT k FROM t2 WHERE k = i)


Пример несколько странный получился.
Более реалистичный:

SELECT i FROM t1
WHERE EXISTS (SELECT 1 FROM t2 WHERE t2.i1 = t1.i)



SELECT i FROM t1

WHERE EXISTS (SELECT 1 FROM t2 WHERE t2.i1 = t1.i)


Подзапросы можно переписывать через операторы JOIN (в некоторых случаях может работать быстрее).

SELECT * FROM t1
WHERE i IN (SELECT i1 FROM t2 WHERE t2.i = 15)
#аналогично
SELECT t1.* FROM t1, t2
WHERE t1.i = t2.i1 AND t2.i = 15



SELECT * FROM t1

WHERE i IN (SELECT i1 FROM t2 WHERE t2.i = 15)

#аналогично

SELECT t1.* FROM t1, t2

WHERE t1.i = t2.i1 AND t2.i = 15


* При этом могут возвращаться несколько разные результаты, если в t2.i1 содержатся неуникальные значения. В таком случае подзапрос выдаст только уникальные значения, а JOIN выдаст все. Чтобы этого избежать, нужно во втором запросе использовать оператор SELECT DISTINCT (выбрать только уникальные значения).

SELECT * FROM t1
WHERE i NOT IN (SELECT i1 FROM t2)
#аналогично
SELECT t1.*
FROM t1 LEFT JOIN t2 ON t2.i1 = t1.i
WHERE t2.i1 IS NULL



SELECT * FROM t1

WHERE i NOT IN (SELECT i1 FROM t2)

#аналогично

SELECT t1.*

FROM t1 LEFT JOIN t2 ON t2.i1 = t1.i

WHERE t2.i1 IS NULL


(при этом в подзапросе можно заметить отсутствие условия выборки;))

3. UNION

Выборка из нескольких таблиц последовательно.
UNION действует как SELECT DISTINCT, т.е. отбрасывает повторяющиеся значения. чтобы этого избежать, нужно использовать оператор UNION ALL

(SELECT i, c FROM t1 ORDER BY i DESC)
UNION
(SELECT i, d FROM t2 ORDER BY i)



(SELECT i, c FROM t1 ORDER BY i DESC)

UNION

(SELECT i, d FROM t2 ORDER BY i)


SQL-запрос на выборку из нескольких таблиц

Я уже писал о самых различных SQL-запросах, но пришло время поговорить и о более сложных вещах, например, SQL-запрос на выборку записей из нескольких таблиц.

Когда мы с Вами делали выборку из одной таблицы, то всё было очень просто:


SELECT названия_нужных_полей FROM название_таблицы WHERE условие_выборки

Всё очень просто и тривиально, но при выборке сразу из нескольких таблиц становится всё несколько сложнее. Одна из трудностей — это совпадение имён полей. Например, в каждой таблице есть поле id.

Давайте рассмотрим такой запрос:


SELECT * FROM table_1, table_2 WHERE table_1.id > table_2.user_id

Многим, кто не занимался подобными запросами, покажется, что всё очень просто, подумав, что здесь добавились только названия таблиц перед названиями полей. Фактически, это позволяет избежать противоречий между одинаковыми именами полей. Однако, сложность не в этом, а в алгоритме работы подобного SQL-запроса.

Перед тем как читать дальше, попробуйте самостоятельно сообразить, как будет работать подобный SQL-запрос. Что он должен вывести?

Алгоритм работы следующий: берётся первая запись из table_1. Берётся id этой записи из table_1. Дальше полностью смотрится таблица table_2. И добавляются все записи, где значение поля user_id меньше id выбранной записи в table_1. Таким образом, после первой итерации может появиться от 0 до бесконечного количества результирующих записей. На следующей итерации берётся следующая запись таблицы table_1. Снова просматривается вся таблица table_2, и вновь срабатывает условие выборки table_1.id > table_2.user_id. Все записи, удовлетворившие этому условию, добавляются в результат. На выходе может получиться огромное количество записей, во много раз превышающих суммарный размер обеих таблиц.

Если Вы поняли, как это работает после первого раза, то очень здорово, а если нет, то читайте до тех пор, пока не вникните окончательно. Если Вы это поймёте, то дальше будет проще.

Предыдущий SQL-запрос, как таковой, редко используется. Он был просто дан для объяснения алгоритма выборки из нескольких таблиц. А теперь же разберём более приземистый SQL-запрос. Допустим, у нас есть две таблицы: с товарами (есть поле owner_id, отвечающего за id владельца товара) и с пользователями (есть поле id). Мы хотим одним SQL-запросом получить все записи, причём чтобы в каждой была информация о пользователе и его одном товаре. В следующей записи была информация о том же пользователе и следущем его товаре. Когда товары этого пользователя кончатся, то переходить к следующему пользователю. Таким образом, мы должны соединить две таблицы и получить результат, в котором каждая запись содержит информацию о пользователе и об одном его товаре.

Подобный запрос заменит 2 SQL-запроса: на выборку отдельно из таблицы с товарами и из таблицы с пользователями. Вдобавок, такой запрос сразу поставит в соответствие пользователя и его товар.

Сам же запрос очень простой (если Вы поняли предыдущий):


SELECT * FROM users, products WHERE users.id = products.owner_id

Алгоритм здесь уже несложный: берётся первая запись из таблицы users. Далее берётся её id и анализируются все записи из таблицы products, добавляя в результат те, у которых owner_id равен id из таблицы users. Таким образом, на первой итерации собираются все товары у первого пользователя. На второй итерации собираются все товары у второго пользователя и так далее.

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

Полный курс по PHP и MySQL: http://srs.myrusakov.ru/php


  • Создано 18.07.2011 16:37:33



  • Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Как использовать WHERE в MYSQL?

Если вы задавались вопросом, как пользоваться оператором WHERE в MYSQL, то вы попали туда, куда нужно. Множество новичков не понимают зачем он нужен, и когда его можно применять. Это очень полезный навык, который очень сильно поможет вам в будущем использовании запросов.

Определение

Where используется в качестве фильтрации для результатов в SELECT, UPDATE, INSERT, DELETE.

То есть, он выбирает ту информацию, которая будет выполнять определенные действия.

Далее вы можете увидеть синтаксис:

WHERE conditions;

Conditions — условия.

Примеры

Давайте рассмотрим некоторые примеры с использованием данного оператора.

У where MYSQL несколько значений, и применяться они могут в разных ситуациях.

К примеру, у нас существует таблица с пользователями. Нам нужно изъять пользователя по имени.

SELECT * 
FROM users //выбираем таблицу users
WHERE name = "Иван" AND lastname = "Максимов"; //Выбираем всех пользователей с именем Иван и Фамилией Максимов

На этом примере мы четко видели, что используется условие AND, это значит, что WHERE служит для объединения двух условий.

Подобным же образом пишется условие OR:

SELECT * 
FROM users //выбираем таблицу users
WHERE name = "Иван" OR lastname = "Максимов"; //Выбираем всех пользователей с именем Иван или Фамилией Максимов

Данный оператор, как уже понятно возвращает результат с именем Иван или фамилией Максимов.

Так же два последних оператора возможно объединить сделать это не так сложно. Выполняем код ниже:

SELECT * 
FROM users //выбираем таблицу users
WHERE name = ("Иван" AND lastname = "Максимов";)
OR (patronymic = "Александров")

Как мы видим, у нас объединены два условия — OR и AND.

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

Существует множество значений where и использовать их можно и важно, а также очень практично.

Заключение

WHERE — один из самых важнейший в языке структурированных запросов и встречается практически во всех проектах. Он имеет еще и операторы AND и OR, объединяющие несколько условий в один запрос, что очень сильно помогает не переписывать один и тот же запрос по нескольку раз и выполнять сложные и интересные задачки.

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

Команда IN — выборка по конкретным значениям

Команда IN выбирает записи из базы данных
по определенным значениям поля.

К примеру, можно выбрать записи,
у которых id имеет значение 1, 3, 7, 14, 28.
Это будет выглядеть так: WHERE id IN (1, 3, 7, 14, 28).

Или же
все записи, у которых поле name имеет значение ‘Дима’, ‘Вася’ или ‘Коля’.
Это будет выглядеть так: WHERE id IN (‘Дима’, ‘Вася’, ‘Коля’).

В принципе, для таких вещей можно пользоваться и командой OR,
тогда первый пример будет выглядеть так: WHERE id=1 OR id=3 OR id=7 OR id=14 OR id=28.
Вариант с IN все-таки выглядит проще и изящнее.

См. также команду NOT,
которая делает отрицание (к примеру, так: NOT IN).

См. также команду BETWEEN,
которая выбирает записи по диапазону значений.

Синтаксис

SELECT * FROM имя_таблицы WHERE поле IN (значение1, значение2...)

Примеры

Все примеры будут по этой таблице workers, если не сказано иное:

id
айди
name
имя
age
возраст
salary
зарплата
1 Дима 23 400
2 Петя 25 500
3 Вася 23 500
4 Коля 30 1000
5 Иван 27 500
6 Кирилл 28 1000

Пример

Давайте выберем записи с id, равным 1, 3 и 5:

SELECT * FROM workers WHERE id IN (1, 3, 5)

SQL запрос выберет следующие строки:

id
айди
name
имя
age
возраст
salary
зарплата
1 Дима 23 400
3 Вася 23 500
5 Иван 27 500

Пример

Давайте выберем записи с именами ‘Дима’, ‘Коля’, ‘Кирилл’:

SELECT * FROM workers WHERE id IN ('Дима', 'Коля', 'Кирилл')

SQL запрос выберет следующие строки:

id
айди
name
имя
age
возраст
salary
зарплата
1 Дима 23 400
4 Коля 30 1000
6 Кирилл 28 1000

Несколько SELECT COUNT в одном запросе MySQL « Блог вебмастера Романа Чернышова

В данной небольшой статье речь пойдет о базах данных в частности MySQL, выборке и подсчете. Работая с базами данных, часто требуется совершить подсчет количества строк COUNT() с определенным условием или без, это сделать крайне просто следующим запросом

Запрос вернет значение, с количеством строк в таблице.

Подсчет с условием

Запрос вернет значение, с количеством строк в таблице удовлетворяющих данному условию: var = 1

Для получения нескольких значений подсчета строк с разными условиями, можно поочередно выполнить несколько запросов, например

Но в ряде случаев, такой подход не практичен и не оптимален. По этому актуальным становится организация запроса, с несколькими подзапросами, для получения в одном запросе сразу несколько результатов. Например

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

c1|c2|c3
--------
1 |5 |8

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

Следующий пример запроса, содержащего несколько COUNT в одном запросе MySQL, построен несколько иначе, в нем используются конструкции IF(условие, значение1, значение2), а также суммирование SUM(). Позволяющие произвести отбор данных по заданным критериям в рамках одного запроса, затем суммировать их, и вывести несколько значений в качестве результата.

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

total|c1|c2|c3
--------------
14   |1 |5 |8

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

Скорость выполнения
Три отдельных запроса: 0.9 сек
Один запрос с подзапросами: 0.95 сек
Один запрос с конструкцией IF и SUM: 1.5 сек

Вывод. И так, мы имеет несколько вариантов построения запросов к базе данных MySQL с несколькими COUNT(), первый вариант с отдельными запросами не очень удобен, но имеет наилучший результат по скорости. Второй вариант с подзапросами несколько удобнее, но при этом скорость его выполнение немного ниже. И наконец третий лаконичный вариант запроса с конструкциями IF и SUM, кажущийся самым удобным, имеет самую низкую скорость выполнения, которая почти в два раза ниже первых двух вариантов. По этому, при задаче оптимизации работы БД, я рекомендую использовать второй вариант запроса содержащий подзапросы с COUNT(), во первых его скорость выполнения близка к самому быстрому результату, во вторых такая организация внутри одного запроса достаточно удобна.

Похожие записи

PHP MYSQL Выберите, где несколько переменных

Переполнение стека

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

  2. Переполнение стека для команд
    Где разработчики и технологи делятся частными знаниями с коллегами

  3. Вакансии
    Программирование и связанные с ним технические возможности карьерного роста

  4. Талант
    Нанимайте технических специалистов и создавайте свой бренд работодателя

  5. Реклама
    Обратитесь к разработчикам и технологам со всего мира

  6. О компании

.

php — MySQL, где предложение равно чему угодно (SELECT * WHERE col = ANY_VALUE)

Переполнение стека

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

  2. Переполнение стека для команд
    Где разработчики и технологи делятся частными знаниями с коллегами

  3. Вакансии
    Программирование и связанные с ним технические возможности карьерного роста

  4. Талант
    Нанимайте технических специалистов и создавайте свой бренд работодателя

  5. Реклама
    Обратитесь к разработчикам и технологам со всего мира

  6. О компании

.

Добавить комментарий

Ваш адрес email не будет опубликован.