7) Запрос

SELECT 'Id with Name: '|| StudentId || StudentName AS StudentIdWithName
FROM Students;

SQLite CAST оператор:

Оператор CAST используется для преобразования значения из типа данных в другой тип данных.

Например, если у вас есть числовое значение, хранящееся в виде строкового значения, такого как « 12 .5 », и вы хотите преобразовать его в числовое значение, вы можете использовать оператор CAST, чтобы сделать это как « CAST (’12 .5 ‘AS). НАСТОЯЩИЙ) «. Или, если у вас есть десятичное значение, например 12,5, и вам нужно получить только целую часть, вы можете привести его к целому числу, например, «CAST (12.5 AS INTEGER)».

пример

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

SELECT CAST('12.5' AS REAL) ToReal, CAST(12.5 AS INTEGER) AS ToInteger;

Это даст вам:

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

• CAST (’12 .5 ‘AS REAL) — значение ’12 .5’ является строковым значением, оно будет преобразовано в значение REAL.
• CAST (12.5 AS INTEGER) — значение 12.5 является десятичным значением, оно будет преобразовано в целочисленное значение. Десятичная часть будет усечена, и станет 12.

Арифметические операторы SQLite:

Возьмите два или более числовых литеральных значения или числовых столбца и верните одно числовое значение. Арифметические операторы, поддерживаемые в SQLite:

Пример:

В следующем примере мы попробуем пять арифметических операторов с буквенными числовыми значениями в одном и том же

выберите пункт:

SELECT 25+6, 25-6, 25*6, 25%6, 25/6;

Это даст вам:

Обратите внимание, как мы использовали оператор SELECT без предложения FROM. И это разрешено в SQLite, если мы выбираем литеральные значения.

Операторы сравнения SQLite

Сравните два операнда друг с другом и верните true или false следующим образом:

Обратите внимание, что SQLite выражает истинное значение с 1 и ложное значение с 0.

Пример:

SELECT 
  10<6 AS '<', 10<=6 AS '<=',
  10>6 AS '>', 10>=6 AS '>=',
  10=6 AS '=', 10==6 AS '==',
  10!=6 AS '!=', 10<>6 AS '<>';

Это даст что-то вроде этого:

Операторы соответствия шаблонов SQLite

« LIKE » — используется для сопоставления с образцом. Используя « Like », вы можете искать значения, которые соответствуют шаблону, указанному подстановочным знаком.

Операндом слева может быть либо строковое литеральное значение, либо строковый столбец. Шаблон может быть указан следующим образом:

• Содержит шаблон. Например, StudentName LIKE «% a%» — при этом будут выполняться поиск имен учащихся, содержащих букву «a», в любой позиции в столбце StudentName.
• Начинается с рисунка. Например, « StudentName LIKE ‘a%’ » — поиск имен учащихся, которые начинаются с буквы «a».
• Заканчивается с рисунком. Например, « StudentName LIKE ‘% a’ » — поиск имен учащихся, заканчивающихся буквой «a».
• Соответствие любому отдельному символу в строке с использованием буквы подчеркивания «_». Например, « StudentName LIKE ‘J___’ » — поиск имен учеников длиной 4 символа. Он должен начинаться с буквы «J» и может содержать любые другие три символа после буквы «J».

Примеры сопоставления с образцом:

1. Получите имена учеников, которые начинаются с буквы «j»:

   SELECT StudentName FROM Students WHERE StudentName LIKE 'j%';

   Результат:

   

2. Имена учеников заканчиваются буквой «у»:

   SELECT StudentName FROM Students WHERE StudentName LIKE '%y';				

   Результат:

   

3. Получите имена учеников, которые содержат букву «n»:

   SELECT StudentName FROM Students WHERE StudentName LIKE '%n%';

   Результат:

   

«GLOB» — эквивалент оператора LIKE, но GLOB чувствителен к регистру, в отличие от оператора LIKE. Например, следующие две команды будут возвращать разные результаты:

SELECT 'Jack' GLOB 'j%';
SELECT 'Jack' LIKE 'j%';

Это даст вам:

• Первый оператор возвращает 0 (ложь), потому что оператор GLOB чувствителен к регистру, поэтому ‘j’ не равно ‘J’. Тем не менее, второй оператор вернет 1 (true), потому что оператор LIKE нечувствителен к регистру, поэтому «j» равно «J».

Другие операторы:

SQLite И

Логический оператор, который объединяет одно или несколько выражений. Он вернет true, только если все выражения выдают «истинное» значение. Однако он вернет false только в том случае, если все выражения выдают «ложное» значение.

Пример:

Следующий запрос будет искать студентов, которые имеют StudentId> 5 и StudentName начинается с буквы N, возвращаемые студенты должны соответствовать двум условиям:

SELECT * 
FROM Students 
WHERE (StudentId > 5) AND (StudentName LIKE 'N%');

В качестве вывода на приведенном выше снимке экрана это даст вам только «Нэнси». Нэнси — единственная студентка, которая отвечает обоим условиям.

SQLite ИЛИ

Логический оператор, который объединяет одно или несколько выражений, так что если один из объединенных операторов выдает true, он вернет true. Однако, если все выражения выдают false, оно вернет false.

Пример:

Следующий запрос будет искать студентов, у которых StudentId> 5 или StudentName начинается с буквы N, возвращаемые студенты должны соответствовать хотя бы одному из условий:

SELECT * 
FROM Students 
WHERE (StudentId > 5) OR (StudentName LIKE 'N%');

Это даст вам:

В качестве вывода на приведенном выше снимке экрана это даст вам имя студента с буквой «n» в имени плюс идентификатор студента со значением> 5.

Как видите, результат отличается от запроса с оператором AND.

SQLite МЕЖДУ

МЕЖДУ используется для выбора тех значений, которые находятся в диапазоне двух значений. Например, « X МЕЖДУ Y И Z » вернет true (1), если значение X находится между двумя значениями Y и Z. В противном случае он вернет false (0). « X МЕЖДУ Y И Z » эквивалентно « X> = Y И X <= Z », X должно быть больше или равно Y, а X меньше или равно Z.

Пример:

В следующем примере запроса мы напишем запрос, чтобы получить студентов со значением Id от 5 до 8:

SELECT *
FROM Students
WHERE StudentId BETWEEN 5 AND 8;

Это даст только студентам с идентификаторами 5, 6, 7 и 8:

SQLite IN

Принимает один операнд и список операндов. Он вернет true, если значение первого операнда равно значению одного из операндов из списка. Оператор IN возвращает true (1), если список операндов содержит первое значение операнда в своих значениях. В противном случае он вернет false (0).

Примерно так: « col IN (x, y, z) ». Это эквивалентно » (col = x) или (col = y) или (col = z) «.

Пример:

Следующий запрос выберет студентов с идентификаторами 2, 4, 6, 8:

SELECT * 
FROM Students
WHERE StudentId IN(2, 4, 6, 8);

Нравится:

Предыдущий запрос даст точный результат как следующий запрос, потому что они эквивалентны:

SELECT * 
FROM Students
WHERE (StudentId = 2) OR (StudentId =  4) OR (StudentId =  6) OR (StudentId = 8);

Оба запроса дают точный результат. Однако разница между этими двумя запросами заключается в том, что в первом запросе мы использовали оператор «IN». Во втором запросе мы использовали несколько операторов «ИЛИ».

Оператор IN эквивалентен использованию нескольких операторов OR. « WHERE StudentId IN (2, 4, 6, 8) » эквивалентно « WHERE (StudentId = 2) ИЛИ (StudentId = 4) ИЛИ (StudentId = 6) ИЛИ (StudentId = 8); »

Нравится:

SQLite НЕ В

Операнд NOT IN является противоположностью оператора IN. Но с тем же синтаксисом; требуется один операнд и список операндов. Он вернет true, если значение первого операнда не равно значению одного из операндов из списка. т.е. он вернет true (0), если список операндов не содержит первый операнд. Примерно так: « col NOT IN (x, y, z) ». Это эквивалентно » (col <> x) AND (col <> y) AND (col <> z) «.

Пример:

Следующий запрос выберет студентов с идентификаторами, не равными одному из этих идентификаторов 2, 4, 6, 8:

SELECT * 
FROM Students
WHERE StudentId NOT IN(2, 4, 6, 8);

Нравится

Предыдущий запрос мы даем точный результат как следующий запрос, потому что они эквивалентны:

SELECT * 
FROM Students
WHERE (StudentId <> 2) AND (StudentId <> 4) AND (StudentId <> 6) AND (StudentId <> 8);

Нравится:

На скриншоте выше,

Мы использовали несколько неравных операторов «<>», чтобы получить список студентов, которые не равны ни одному из следующих идентификаторов 2, 4, 6 или 8. Этот запрос вернет всех других студентов, кроме этого списка идентификаторов.

SQLite СУЩЕСТВУЕТ

Операторы EXISTS не принимают никаких операндов; после него требуется только предложение SELECT. Оператор EXISTS вернет true (1), если есть какие-либо строки, возвращенные из предложения SELECT, и вернет false (0), если вообще нет строк, возвращенных из предложения SELECT.

Пример:

В следующем примере мы выберем название отдела, если идентификатор отдела существует в таблице студентов:

SELECT DepartmentName
FROM Departments AS d
WHERE EXISTS (SELECT DepartmentId FROM Students AS s WHERE d.DepartmentId = s.DepartmentId);

Это даст вам:

Только три отдела » IT, физика и искусство » будут возвращены. И название кафедры « Математика » не будет возвращено, потому что на этом факультете нет ученика, поэтому идентификатор кафедры не существует в таблице учеников. Вот почему оператор EXISTS проигнорировал отдел « Математика ».

SQLite НЕ

Обращает результат предшествующего оператора, который идет после него. Например:

• NOT BETWEEN — Возвращает true, если BETWEEN возвращает false и наоборот.
• NOT LIKE — он вернет true, если LIKE вернет false, и наоборот.
• NOT GLOB — Возвращает true, если GLOB возвращает false и наоборот.
• NOT EXISTS — он вернет true, если EXISTS вернет false и наоборот.

Пример:

В следующем примере мы будем использовать оператор NOT с оператором EXISTS, чтобы получить имена отделов, которых нет в таблице Students, что является обратным результатом оператора EXISTS. Таким образом, поиск будет осуществляться через DepartmentId, которого нет в таблице отдела.

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId 
                  FROM Students AS s 
                  WHERE d.DepartmentId = s.DepartmentId);

Выход :

Только отдел » Математика » будет возвращен. Потому что « математический » отдел — единственный отдел, которого нет в таблице учеников.

Ограничение и порядок

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
ORDER BY d.DepartmentName ASC , s.StudentName DESC;

• SQLite сначала упорядочит всех студентов по названию отделения в порядке возрастания
• Затем для каждого названия отделения все студенты под этим названием будут отображаться в порядке убывания их имен.

SQLite Limit:

Вы можете ограничить количество строк, возвращаемых вашим SQL-запросом, используя предложение LIMIT. Например, LIMIT 10 даст вам только 10 строк и проигнорирует все остальные строки.

В предложении LIMIT вы можете выбрать определенное количество строк, начиная с определенной позиции, используя предложение OFFSET. Например, « LIMIT 4 OFFSET 4 » будет игнорировать первые 4 строки и вернет 4 строки, начиная с пятых, так что вы получите строки 5,6,7 и 8.

Обратите внимание, что предложение OFFSET является необязательным, вы можете написать его как « LIMIT 4, 4 », и оно даст вам точные результаты.

Пример :

В следующем примере мы вернем только 3 ученика, начиная с идентификатора ученика 5, используя запрос:

SELECT * FROM Students LIMIT 4,3;

Это даст вам только трех студентов, начиная со строки 5. Таким образом, это даст вам строки с StudentId 5, 6 и 7:

Удаление дубликатов

SELECT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Обратите внимание, как существуют дублирующиеся значения для названия отдела. Теперь мы будем использовать ключевое слово DISTINCT с тем же запросом, чтобы удалить эти дубликаты и получить только уникальные значения. Нравится:

SELECT DISTINCT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Это даст вам только три уникальных значения для столбца названия отдела:

заполнитель

SELECT AVG(Mark) FROM Marks;

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

COUNT () — COUNT (X) или COUNT (*)

Возвращает общее количество раз, когда появилось значение x. И вот несколько вариантов, которые вы можете использовать с COUNT:

• COUNT (x): считает только значения x, где x — имя столбца. Он будет игнорировать значения NULL.
• COUNT (*): Подсчитать все строки из всех столбцов.
• COUNT (DISTINCT x): Вы можете указать ключевое слово DISTINCT перед x, чтобы получить количество различных значений x.

пример

В следующем примере мы получим общее количество отделов с COUNT (DepartmentId), COUNT (*) и COUNT (DISTINCT DepartmentId) и их различия:

SELECT COUNT(DepartmentId), COUNT(DISTINCT DepartmentId), COUNT(*) FROM Students;

Это даст вам:

Следующим образом:

• COUNT (DepartmentId) подсчитает все идентификаторы отдела и проигнорирует нулевые значения.
• COUNT (DISTINCT DepartmentId) дает вам различные значения DepartmentId, которые равны только 3. Это три разных значения названия отдела. Обратите внимание, что в имени студента есть 8 значений названия отдела. Но только три различных значения: математика, информационные технологии и физика.
• COUNT (*) подсчитывает количество строк в таблице студентов, которые составляют 10 строк для 10 студентов.

GROUP_CONCAT () — GROUP_CONCAT (X) или GROUP_CONCAT (X, Y)

Агрегатная функция GROUP_CONCAT объединяет кратные значения в одно значение с запятой для их разделения. Он имеет следующие параметры:

• GROUP_CONCAT (X): это объединит все значения x в одну строку с запятой «,», используемой в качестве разделителя между значениями. Значения NULL будут игнорироваться.
• GROUP_CONCAT (X, Y): это объединит значения x в одну строку со значением y, используемым в качестве разделителя между каждым значением вместо разделителя по умолчанию ‘,’. Значения NULL также будут игнорироваться.
• GROUP_CONCAT (DISTINCT X): это объединит все различные значения x в одну строку с запятой «,», используемой в качестве разделителя между значениями. Значения NULL будут игнорироваться.

Пример GROUP_CONCAT (DepartmentName)

Следующий запрос объединит все значения названий отделов из таблицы студентов и отделов в одну строку через запятую. Таким образом, вместо того, чтобы возвращать список значений, по одному значению в каждой строке. Он вернет только одно значение в одной строке со всеми значениями, разделенными запятой:

SELECT GROUP_CONCAT(d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Это даст вам:

Это даст вам список значений из 8 названий отделов, объединенных в одну строку через запятую.

Пример GROUP_CONCAT (DISTINCT DepartmentName)

Следующий запрос объединит отдельные значения названия отдела из таблицы студентов и отделов в одну строку через запятую:

SELECT GROUP_CONCAT(DISTINCT d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Это даст вам:

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

Пример GROUP_CONCAT (DepartmentName, ‘&’)

Следующий запрос объединит все значения столбца имени отдела из таблицы студентов и отделов в одну строку, но с символом «&» вместо запятой в качестве разделителя:

SELECT GROUP_CONCAT(d.DepartmentName, '&')
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Это даст вам:

Обратите внимание, как символ «&» используется вместо символа по умолчанию «,» для разделения значений.

SQLite MAX () и MIN ()

MAX (X) возвращает вам самое высокое значение из значений X. MAX вернет значение NULL, если все значения x равны нулю. Принимая во внимание, что MIN (X) возвращает вам наименьшее значение из значений X. MIN вернет значение NULL, если все значения X равны нулю.

пример

В следующем запросе мы будем использовать функции MIN и MAX, чтобы получить самую высокую оценку и самую низкую оценку из таблицы « Marks »:

SELECT MAX(Mark), MIN(Mark) FROM Marks;

Это даст вам:

SQLite SUM (x), Всего (x)

Они оба вернут сумму всех значений x. Но они отличаются в следующем:

• SUM вернет ноль, если все значения равны нулю, а Total вернет 0.
• ВСЕГО всегда возвращает значения с плавающей запятой. SUM возвращает целочисленное значение, если все значения x являются целыми числами. Однако, если значения не являются целыми числами, он вернет значение с плавающей запятой.

пример

В следующем запросе мы будем использовать SUM и total для получения суммы всех отметок в таблицах « Marks »:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks;

Это даст вам:

Как видите, TOTAL всегда возвращает число с плавающей запятой. Но SUM возвращает целочисленное значение, потому что значения в столбце «Марк» могут быть целыми числами.

Разница между суммой и итоговым примером:

В следующем запросе мы покажем разницу между SUM и TOTAL, когда они получат SUM из значений NULL:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks WHERE TestId = 4;

Это даст вам:

Обратите внимание, что для TestId = 4 нет отметок, поэтому для этого теста есть нулевые значения. SUM возвращает нулевое значение как пустое, тогда как TOTAL возвращает 0.

Группа по

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s 
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName;

Предложение GROUPBY DepartmentName объединит всех студентов в группы по одному для каждого названия отделения. Для каждой группы «отдела» он будет рассчитывать на студентов.

HAVING пункт

Если вы хотите отфильтровать группы, возвращаемые предложением GROUP BY, вы можете указать предложение «HAVING» с выражением после GROUP BY. Выражение будет использоваться для фильтрации этих групп.

пример

В следующем запросе мы выберем те отделы, в которых работают только два студента:

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s 
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName
HAVING COUNT(s.StudentId) = 2;

Это даст вам:

Предложение HAVING COUNT (S.StudentId) = 2 отфильтровывает возвращаемые группы и возвращает только те группы, которые содержат ровно двух студентов. В нашем случае на факультете искусств обучаются 2 студента, поэтому он отображается в выводе.

SQLite Query & Subquery

SELECT
  s.StudentName, t.Mark
FROM Students AS s 
INNER JOIN
(
   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId
)  ON s.StudentId = t.StudentId;

   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId

Так что в нашем случае

• s.StudentName выбирается из основного запроса, который дает имя студентов и
• t.Mark выбран из подзапроса; что дает оценки, полученные каждым из этих студентов

Использование подзапроса в примере предложения WHERE

В следующем запросе мы включим подзапрос в предложение WHERE:

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId 
                  FROM Students AS s 
                  WHERE d.DepartmentId = s.DepartmentId);

Запрос:

SELECT DepartmentId 
FROM Students AS s 
WHERE d.DepartmentId = s.DepartmentId

Приведенный выше запрос называется здесь подзапросом, потому что он вложен в предложение WHERE. Подзапрос вернет значения DepartmentId, которые будут использоваться оператором NOT EXISTS.

Этот запрос даст вам:

В вышеприведенном запросе мы выбрали отдел, в котором нет студентов. Какой отдел «Математика» здесь.

Операции над множествами — UNION, Intersect

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION
SELECT DepartmentId FROM Departments;

Запрос возвращает только 5 строк, которые являются различными значениями идентификатора отдела. Обратите внимание на первое значение, которое является нулевым значением.

Пример SQLite UNION ALL

В следующем примере мы получим список DepartmentId из таблицы студентов и список DepartmentId из таблицы кафедры в том же столбце:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION ALL
SELECT DepartmentId FROM Departments;

Это даст вам:

Запрос вернет 14 строк, 10 строк из таблицы студентов и 4 из таблицы отделов. Обратите внимание, что в возвращаемых значениях есть дубликаты. Также обратите внимание, что имя столбца было указано в первом операторе SELECT.

Теперь давайте посмотрим, как UNION all даст разные результаты, если мы заменим UNION ALL на UNION:

SQLite INTERSECT

Возвращает значения, существующие в обоих наборах результатов. Значения, которые существуют в одном из комбинированных результатов, будут игнорироваться.

пример

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

SELECT DepartmentId FROM Students
Intersect
SELECT DepartmentId FROM Departments;

Это даст вам:

Запрос возвращает только три значения 1, 2 и 3. Какие значения существуют в обеих таблицах.

Однако значения NULL и 4 не были включены, поскольку значение NULL существует только в таблице студентов, а не в таблице отделов. И значение 4 существует в таблице отделов, а не в таблице студентов.

Вот почему оба значения NULL и 4 были проигнорированы и не включены в возвращаемые значения.

КРОМЕ

Предположим, если у вас есть два списка строк, list1 и list2, и вы хотите, чтобы строки только из list1, которого нет в list2, вы можете использовать предложение «EXCEPT». Предложение EXCEPT сравнивает два списка и возвращает те строки, которые существуют в list1 и не существуют в list2.

пример

В следующем запросе мы выберем значения DepartmentId, которые существуют в таблице департаментов, но не существуют в таблице студентов:

SELECT DepartmentId FROM Departments
EXCEPT
SELECT DepartmentId FROM Students;

Это даст вам:

Запрос возвращает только значение 4. Это единственное значение, которое существует в таблице отделов и не существует в таблице студентов.

Обработка NULL

SELECT * FROM Students WHERE DepartmentId = NULL;

Поскольку значение NULL не равно никакому другому значению, включает само нулевое значение, поэтому оно не вернуло никакого результата.

• Однако, чтобы запрос работал, вы должны использовать оператор «IS NULL» для поиска нулевых значений следующим образом:

SELECT * FROM Students WHERE DepartmentId IS NULL;

Это даст вам:

Запрос вернет тех студентов, которые имеют нулевое значение DepartmentId.

• Если вы хотите получить те значения, которые не равны NULL, вы должны использовать оператор « IS NOT NULL », например:

SELECT * FROM Students WHERE DepartmentId IS NOT NULL;

Это даст вам:

Запрос вернет тех студентов, которые не имеют значения NULL DepartmentId.

Условные результаты

CASE 
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  WHEN condition3 THEN result3
  …
  ELSE resultn
END

CASE expression
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  WHEN value3 THEN result3
  …
  ELSE restuln 
END

SELECT 
  StudentName,
  CASE 
    WHEN DepartmentId IS NULL THEN 'No Department'
    ELSE DepartmentId 
  END AS DepartmentId
FROM Students;

Общее табличное выражение

WITH CTEname
AS
(
   SELECT statement
)
SELECT, UPDATE, INSERT, or update statement here FROM CTE

WITH AllDepartments
AS
(
  SELECT DepartmentId, DepartmentName
  FROM Departments
)
SELECT 
  s.StudentId,
  s.StudentName,
  a.DepartmentName
FROM Students AS s
INNER JOIN AllDepartments AS a ON s.DepartmentId = a.DepartmentId;

  SELECT DepartmentId, DepartmentName
  FROM Departments

Расширенные запросы

SELECT 
  d.DepartmentName,
  COUNT(s.StudentId) StudentsCount,
  GROUP_CONCAT(StudentName) AS Students
FROM Departments AS d 
INNER JOIN Students AS s ON s.DepartmentId = d.DepartmentId
GROUP BY d.DepartmentName
HAVING COUNT(s.StudentId) >= 3;

Резюме:

Это было введение в написание запросов SQLite и основы запросов к базе данных, а также о том, как можно фильтровать возвращаемые данные. Теперь вы можете написать свои собственные запросы SQLite.