← 정보처리기사 실기 개념정리 목차

SQL 완전 정리 ① 기초 — SELECT 구조·실행 순서·WHERE·정렬

이 시리즈는 기출 함정 요약(04편)과 달리 SQL 자체를 처음부터 쌓는다. 1편은 모든 쿼리의 뼈대인 SELECT … FROM … WHERE … ORDER BY 를 다룬다. 핵심은 하나 — SQL은 적힌 순서대로 실행되지 않는다. 논리적 처리 순서(FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY)를 몸에 붙이면 "왜 WHERE 에서 별칭을 못 쓰나", "왜 NULL 행이 사라졌나" 같은 질문이 전부 한 원리로 풀린다. 본문의 쿼리와 결과 표는 모두 SQLite 3.54 와 PostgreSQL 에서 실제로 실행해 맞췄고, 엔진마다 결과가 다른 곳은 따로 표로 적었다.


0. 이 편에서 쓰는 테이블

부서

dnodnameloc
10개발서울
20영업부산
30인사서울
40기획NULL

사원

enoenamednojobsalmgrhiredatebonus
1김하늘10팀장500NULL2019-03-01NULL
2이도윤10대리35012021-07-1530
3박서준10사원28022023-01-02NULL
4최지우20팀장450NULL2018-11-2050
5정민재20사원30042022-05-0920
6한유나20사원30042024-02-01NULL
7오세린NULL사원250NULL2025-01-06NULL

눈여겨볼 점: 오세린은 부서가 없다(dno NULL), 보너스는 2·4·5번만 있다. 이 NULL 들이 이 편 거의 모든 함정의 재료다.


1. SQL 의 분류 — 명령어를 네 갈래로

SQL 문장은 "무엇을 다루느냐"로 네 묶음이다. 실기에서는 명령어 → 분류를 묻는 빈칸이 자주 나온다.

분류풀이다루는 대상명령어
DDLData Definition Language (정의어)테이블·뷰·인덱스 같은 구조(스키마)CREATE, ALTER, DROP, TRUNCATE, RENAME
DMLData Manipulation Language (조작어)테이블 안의 데이터(행)SELECT, INSERT, UPDATE, DELETE (+ MERGE)
DCLData Control Language (제어어)권한GRANT, REVOKE
TCLTransaction Control Language트랜잭션 확정·취소COMMIT, ROLLBACK, SAVEPOINT
  • SELECT 의 소속: 표준·대부분의 교재는 DML 로 묶는다. 일부 자료는 SELECT 만 따로 떼어 DQL(Data Query Language)이라 부르기도 한다. 시험에서 "DML 4개"를 물으면 SELECT·INSERT·UPDATE·DELETE.
  • TCL 을 DCL 에 포함시키는 교재도 있다(COMMIT·ROLLBACK 을 "제어"로 봄). 정보처리기사 교재는 보통 DCL = GRANT·REVOKE·COMMIT·ROLLBACK 으로 넓게 잡으므로, 문제에 "TCL"이라는 칸이 따로 없으면 그쪽 분류를 따른다.
  • TRUNCATE 가 DDL 인 이유: 행을 하나씩 지우는 DELETE(DML)와 달리, 테이블 저장 공간을 통째로 초기화하는 구조 수준 작업이라서다. 그래서 Oracle·MySQL 에서는 묵시적 COMMIT 이 일어나 ROLLBACK 이 안 된다 (PostgreSQL 은 트랜잭션 안에서 TRUNCATE 도 롤백된다).

2. 관계형 모델 기본 용어

SQL 은 관계형 모델 위에서 동작한다. 용어 짝이 세 벌(이론 / SQL / 일상) 있어서 헷갈린다.

관계 이론SQL·실무일상사원 테이블에서
릴레이션(relation)테이블표사원 자체
튜플(tuple)행(row), 레코드가로줄(1, 김하늘, 10, …) 한 줄
속성(attribute)열(column), 필드세로줄ename, sal …
도메인(domain)데이터 타입 + 제약허용 값 범위sal 은 0 이상의 정수
차수(degree)열 개수—8
카디널리티(cardinality)행 개수—7
  • 차수 = 속성 수, 카디널리티 = 튜플 수. "카디널리티는 카운트(행 세기)"로 외우면 덜 헷갈린다. 행은 INSERT·DELETE 로 수시로 변하므로 카디널리티는 계속 바뀌고, 차수는 ALTER TABLE 로 열을 바꿀 때만 바뀐다.
  • 릴레이션 스키마(구조: 이름 + 속성 목록)와 릴레이션 인스턴스(어느 시점의 실제 행 집합)는 구분된다. 스키마는 거의 안 바뀌고 인스턴스는 INSERT 할 때마다 바뀐다.
  • 릴레이션의 특성 — ① 튜플은 모두 서로 다르다(중복 없음) ② 튜플 사이에 순서가 없다 ③ 속성 사이에도 순서가 없다 ④ 속성 값은 원자값(더 쪼갤 수 없는 값). ②가 실무에서 중요하다: ORDER BY 없이 나온 결과 순서는 아무것도 보장되지 않는다. (실제 SQL 테이블은 기본키가 없으면 중복 행도 허용한다는 점에서 이론 릴레이션과 살짝 다르다 — 그래서 DISTINCT 가 필요하다.)

3. SELECT 문의 6절과 논리적 처리 순서

3.1 문법 골격

SELECT   [DISTINCT | ALL] 열 | 식 [AS 별칭], ...   -- ⑤ 무엇을 보여 줄까
FROM     테이블 [AS 별칭], ...                      -- ① 어디서
[WHERE   행 조건]                                     -- ② 어떤 행만
[GROUP BY 열, ...]                                    -- ③ 어떻게 묶을까
[HAVING  그룹 조건]                                   -- ④ 어떤 그룹만
[ORDER BY 열 | 별칭 | 열 번호 [ASC | DESC], ...];     -- ⑥ 어떤 순서로

대괄호 [ ] 는 생략 가능. 꼭 있어야 하는 것은 SELECT 하나뿐이다(SELECT 1+1; 도 쿼리다. Oracle 만은 FROM 이 필수라 SELECT 1+1 FROM DUAL;). 적는 순서는 이 순서로 고정이다 — WHERE 를 GROUP BY 뒤에 쓰면 문법 오류.

3.2 논리적 처리 순서

DBMS 는 위 문장을 ①→⑥ 번호 순서로 처리한 것과 같은 결과를 낸다.

다이어그램 로딩 중…

"논리적"이라는 말이 중요하다. 실제 실행 계획(옵티마이저)은 인덱스를 쓰거나 조건을 먼저 밀어 넣는 등 순서를 마음대로 바꾼다. 다만 결과는 반드시 이 순서로 처리한 것과 같아야 한다. 그래서 문법 규칙 (어디서 무엇을 참조할 수 있나)은 이 순서를 기준으로 정해진다.

3.3 단계별로 펼쳐 보기

SELECT dno, COUNT(*) AS cnt, MAX(sal) AS 최고
FROM 사원
WHERE sal >= 280
GROUP BY dno
HAVING COUNT(*) >= 2
ORDER BY cnt DESC, dno;

① FROM — 사원 7행 전부가 작업대에 올라온다.

② WHERE sal >= 280 — 행 하나하나에 조건을 대 본다. 오세린(250)만 탈락.

enoenamednosal통과
1김하늘10500✓
2이도윤10350✓
3박서준10280✓ (280 ≥ 280)
4최지우20450✓
5정민재20300✓
6한유나20300✓
7오세린NULL250✗

③ GROUP BY dno — 남은 6행을 dno 값별로 묶는다. 이 순간부터 "행"이 아니라 "그룹"이 단위다.

dno그룹에 든 행행 수MAX(sal)
10김하늘, 이도윤, 박서준3500
20최지우, 정민재, 한유나3450

④ HAVING COUNT(*) >= 2 — 그룹 단위 조건. 두 그룹 모두 3 ≥ 2 라 통과.

⑤ SELECT — 그룹마다 한 행씩 dno, COUNT(*), MAX(sal) 를 계산하고, 이때 처음으로 별칭 cnt, 최고 가 생긴다.

⑥ ORDER BY cnt DESC, dno — 이미 만들어진 결과에 정렬. cnt 가 같으니 dno 오름차순.

dnocnt최고
103500
203450

3.4 순서가 낳는 규칙 — 별칭은 어디서 쓸 수 있나

별칭은 ⑤ SELECT 에서 태어난다. 그러니 그보다 먼저 처리되는 절에서는 아직 존재하지 않는다.

절처리 순서SELECT 별칭 사용 (표준)이유
WHERE②불가별칭이 만들어지기 전
GROUP BY③불가 (PG·MySQL 은 확장으로 허용, Oracle 은 불가)별칭이 만들어지기 전
HAVING④불가 (MySQL 은 확장으로 허용)별칭이 만들어지기 전
ORDER BY⑥가능SELECT 이후라 별칭이 있음
-- WHERE 에서 별칭 → 표준 위반
SELECT ename, sal * 12 AS 연봉 FROM 사원 WHERE 연봉 >= 4000;

PostgreSQL 실행 결과:

ERROR:  column "연봉" does not exist

SQLite 는 이 쿼리를 통과시킨다 (별칭 참조를 허용하는 SQLite 고유 확장). 실기는 표준 기준이므로 "WHERE 에서 별칭 사용 불가"가 정답이다. 연습을 SQLite 로 할 때 특히 속기 쉽다.

올바른 형태 — 조건에는 식을 그대로 다시 쓰고, 정렬에는 별칭을 쓴다.

SELECT ename, sal * 12 AS 연봉
FROM 사원
WHERE sal * 12 >= 4000
ORDER BY 연봉 DESC;
ename연봉
김하늘6000
최지우5400
이도윤4200

HAVING 도 같은 이유로 막힌다.

SELECT dno, COUNT(*) AS cnt FROM 사원 GROUP BY dno HAVING cnt >= 2;
-- PostgreSQL: ERROR: column "cnt" does not exist
-- 올바른 형태: HAVING COUNT(*) >= 2

WHERE 와 HAVING 의 차이를 순서로 설명하면 — WHERE 는 ②에서 개별 행을, HAVING 은 ④에서 그룹을 거른다. 그래서 WHERE 에는 집계 함수(COUNT, SUM …)를 쓸 수 없다(그룹이 아직 없다). WHERE COUNT(*) >= 2 는 오류. 집계 함수는 GROUP BY 이후 단계(HAVING·SELECT·ORDER BY)에서만 쓴다. GROUP BY 는 3편에서 자세히 다룬다.


4. SELECT 절 — 무엇을 보여 줄까

4.1 * 와 열 선택

SELECT * FROM 사원;                         -- 모든 열, 테이블 정의 순서대로
SELECT ename, sal FROM 사원 WHERE dno = 10; -- 원하는 열만, 적은 순서대로
enamesal
김하늘500
이도윤350
박서준280
  • * 는 "모든 열"의 약칭. 실무에서는 테이블에 열이 추가되면 결과 모양이 바뀌므로 열을 명시하는 게 원칙이다.
  • 관계대수로 보면 열 고르기 = 프로젝션(π), 행 고르기(WHERE) = 셀렉션(σ). 이름이 SELECT 인데 하는 일은 프로젝션이라는 점이 시험용 함정.
  • 여러 테이블을 쓸 때는 사원.ename, e.ename 처럼 테이블명(또는 테이블 별칭).열 로 소속을 밝힌다.

4.2 별칭(AS)

SELECT ename AS "사원 이름", sal 월급 FROM 사원 WHERE eno <= 2;
사원 이름월급
김하늘500
이도윤350
  • AS 는 생략할 수 있다(sal 월급). 단 Oracle 은 테이블 별칭에 AS 를 쓰면 오류(FROM 사원 AS e ✗, FROM 사원 e ○). 열 별칭에는 Oracle 도 AS 를 허용한다.
  • 공백·특수문자가 들어가거나 대소문자를 살리려면 큰따옴표 "…". 작은따옴표 '…' 는 문자열 값이다. (MySQL 은 별칭에 작은따옴표·백틱도 받아 주지만 표준은 큰따옴표.)

4.3 산술 연산과 NULL

SELECT 절에는 열뿐 아니라 식을 쓸 수 있다. + - * / 와 괄호, 우선순위는 수학과 같다(* / 가 먼저).

SELECT ename, sal, sal * 12 AS 연봉, sal + bonus AS 합계
FROM 사원 WHERE dno = 20;
enamesal연봉합계
최지우4505400500
정민재3003600320
한유나3003600NULL

NULL 은 산술에서 전염된다. 300 + NULL 은 0을 더한 300이 아니라 NULL. NULL 은 "0"이 아니라 "모르는 값"이므로, 모르는 값에 무엇을 더해도 모른다. 0으로 바꿔 계산하려면 COALESCE(bonus, 0) (2편)을 쓴다. 정수끼리 나눗셈(7/2)의 결과가 엔진마다 다른 문제도 2편에서 다룬다.

4.4 문자열 연결 — || vs CONCAT vs +

열을 이어 붙여 한 문자열로 만드는 방법이 엔진마다 다르다.

SELECT ename || '(' || job || ')' AS 표시, '부서:' || dno AS 부서
FROM 사원 WHERE eno IN (1, 7);

SQLite·PostgreSQL 결과:

표시부서
김하늘(팀장)부서:10
오세린(사원)NULL

'부서:' || NULL 은 표준에서 NULL — 산술과 같은 전염 규칙이다. 그런데 엔진마다 다르다.

엔진연결 연산자'부서:' || NULLCONCAT('부서:', NULL)
표준 SQL||NULL(표준에 없음)
PostgreSQL||, CONCAT(…)NULL'부서:' (NULL 무시)
SQLite||, CONCAT(…) (3.44+)NULL'부서:' (NULL 무시)
Oracle||, CONCAT(a, b) (인자 2개만)'부서:' (NULL 을 빈 문자열로 취급)'부서:'
MySQLCONCAT(…) — || 는 기본이 논리 OR(OR 로 해석됨)NULL (하나라도 NULL 이면 NULL)
SQL Server+, CONCAT(…)'부서:' + NULL → NULL'부서:'

실측(SQLite·PG):

SELECT CONCAT('부서:', dno) AS c FROM 사원 WHERE eno IN (1, 7);
c
부서:10
부서:

정리 — 시험에서 연결 연산자를 물으면 ||(Oracle·표준). MySQL 에서 || 를 쓰면 문자열 연결이 아니라 OR 이 되어 0/1 이 나온다(PIPES_AS_CONCAT 모드를 켜야 연결). + 는 SQL Server 전용이며 다른 엔진에서 'a' + 'b' 는 숫자 변환을 시도한다.

4.5 DISTINCT 와 ALL

SELECT DISTINCT 는 ⑤ 단계에서 결과 행 전체가 똑같은 것을 하나로 접는다. 기본값은 ALL(중복 유지)이라 보통 생략한다.

SELECT DISTINCT job FROM 사원 ORDER BY job;
job
대리
사원
팀장

NULL 도 하나의 값처럼 접힌다. 비교(=)에서는 NULL 끼리 같다고 하지 않지만, DISTINCT·GROUP BY 에서는 "NULL 은 NULL 끼리 한 묶음"으로 취급한다.

SELECT DISTINCT dno FROM 사원 ORDER BY dno;
SQLite (NULL 이 작다)PostgreSQL (NULL 이 크다)
NULL10
1020
20NULL

→ 3행. 정렬 위치만 다르고 행 수는 같다(§8.4).

DISTINCT 는 열 하나가 아니라 SELECT 목록 전체에 걸린다.

SELECT DISTINCT dno, job FROM 사원 ORDER BY dno, job;   -- PostgreSQL 결과
dnojob
10대리
10사원
10팀장
20사원
20팀장
NULL사원

7행 중 (20, 사원) 이 정민재·한유나 두 번 → 하나로 접혀 6행. SELECT DISTINCT dno, DISTINCT job 같은 문법은 없다.

COUNT 와 함께 쓰면 세는 대상이 달라진다.

SELECT COUNT(job) AS a, COUNT(DISTINCT job) AS b,
       COUNT(DISTINCT dno) AS c, COUNT(*) AS d
FROM 사원;
abcd
7327

함정 — SELECT DISTINCT dno 는 NULL 을 포함해 3행인데 COUNT(DISTINCT dno) 는 2. 집계 함수는 NULL 을 세지 않기 때문이다(COUNT(*) 만 예외). 3편에서 다시 다룬다.

  • DISTINCT + ORDER BY 제약: SELECT DISTINCT job FROM 사원 ORDER BY sal; 은 표준·PostgreSQL 에서 오류(for SELECT DISTINCT, ORDER BY expressions must appear in select list). 같은 job 에 sal 이 여러 개라 어느 sal 로 정렬할지 정할 수 없기 때문이다. SQLite 는 통과시키지만 결과는 의미가 없다.

5. WHERE 절 — 어떤 행만 남길까

WHERE 는 행마다 조건식을 평가해서 결과가 TRUE 인 행만 남긴다. FALSE 는 물론이고 UNKNOWN 도 탈락한다 — 이 한 문장이 NULL 함정의 전부다(§6).

5.1 비교 연산자

연산자뜻비고
=같다대입이 아니라 비교. == 는 표준 아님(SQLite 만 허용)
<>다르다표준. != 도 대부분 엔진에서 허용
> >= < <=크기 비교문자열은 사전순, 날짜는 시간순
  • 문자열·날짜 값은 작은따옴표 '서울', '2021-07-15'. 숫자는 따옴표 없이 10.
  • 문자열 비교는 기본적으로 대소문자를 구분한다(Oracle·PG). MySQL 기본 콜레이션은 구분하지 않는다.

5.2 논리 연산자와 우선순위 — NOT > AND > OR

SELECT ename, dno, sal FROM 사원
WHERE dno = 10 OR dno = 20 AND sal >= 400
ORDER BY eno;

괄호가 없으면 AND 가 먼저 묶인다 → dno = 10 OR (dno = 20 AND sal >= 400).

enamednosal
김하늘10500
이도윤10350
박서준10280
최지우20450

10번 부서는 급여와 상관없이 전원, 20번은 400 이상만. "10·20번 부서 중 400 이상"을 원했다면 괄호가 필요하다.

SELECT ename, dno, sal FROM 사원
WHERE (dno = 10 OR dno = 20) AND sal >= 400
ORDER BY eno;
enamednosal
김하늘10500
최지우20450

NOT 은 바로 뒤의 조건 하나에만 붙는다.

SELECT ename FROM 사원 WHERE NOT dno = 10 AND sal >= 300 ORDER BY eno;
-- = (NOT dno = 10) AND sal >= 300
ename
최지우
정민재
한유나

오세린은 dno = 10 이 UNKNOWN → NOT UNKNOWN 도 UNKNOWN → 탈락(게다가 sal 250).

전체 우선순위(높은 것부터, Oracle 문서 기준 요약):

순위연산자
1* /
2+ - ||
3= <> < > <= >=
4IS [NOT] NULL, LIKE, [NOT] BETWEEN, [NOT] IN
5NOT
6AND
7OR

실무 원칙: AND 와 OR 를 섞으면 무조건 괄호. 시험은 괄호를 일부러 빼고 결과를 묻는다.

5.3 BETWEEN — 양 끝 포함 범위

열 [NOT] BETWEEN 하한 AND 상한     -- = 열 >= 하한 AND 열 <= 상한
SELECT ename, sal FROM 사원 WHERE sal BETWEEN 300 AND 450 ORDER BY eno;
enamesal
이도윤350
최지우450
정민재300
한유나300
  • 양 끝을 포함한다(300, 450 모두 포함).
  • 작은 값을 먼저 써야 한다. BETWEEN 450 AND 300 은 sal >= 450 AND sal <= 300 이 되어 항상 거짓 → 결과 0행 (오류가 아니라 빈 결과라 더 위험하다).
  • NOT BETWEEN a AND b = 열 < a OR 열 > b.
  • 날짜에도 쓴다.
SELECT ename, hiredate FROM 사원
WHERE hiredate BETWEEN '2021-01-01' AND '2023-12-31' ORDER BY hiredate;
enamehiredate
이도윤2021-07-15
정민재2022-05-09
박서준2023-01-02

날짜+시각 타입(TIMESTAMP, Oracle DATE)이라면 '2023-12-31' 은 그날 0시 0분이므로 12월 31일 낮에 들어온 행이 빠진다. 그래서 실무에서는 >= '2021-01-01' AND < '2024-01-01' 처럼 반열린 구간을 쓴다.

5.4 IN — 목록 중 하나

열 [NOT] IN (값1, 값2, ...)    -- = 열 = 값1 OR 열 = 값2 OR ...
SELECT ename, dno FROM 사원 WHERE dno IN (10, 30) ORDER BY eno;
enamedno
김하늘10
이도윤10
박서준10

30번 부서 사원은 없으니 10번만. NOT IN (10) 은 20번 세 명만 나오고 오세린(NULL)은 안 나온다 (NULL <> 10 이 UNKNOWN).

NOT IN 목록에 NULL 이 섞이면 결과가 전멸한다.

SELECT COUNT(*) FROM 사원 WHERE dno NOT IN (10, NULL);   -- 0

펼치면 dno <> 10 AND dno <> NULL. 뒤쪽 dno <> NULL 은 어떤 행이든 UNKNOWN 이고, TRUE AND UNKNOWN = UNKNOWN 이라 어떤 행도 TRUE 가 될 수 없다.

반면 IN 에 NULL 이 섞이는 것은 무해하다. dno IN (10, NULL) = dno = 10 OR dno = NULL 이고 TRUE OR UNKNOWN = TRUE 라 10번 세 명은 그대로 나온다. 이 비대칭이 서브쿼리(NOT IN (SELECT …))에서 실전 버그가 된다(4편).

5.5 LIKE — 패턴 매칭

열 [NOT] LIKE '패턴' [ESCAPE '이스케이프문자']
와일드카드뜻예맞는 값
%0개 이상의 아무 문자'이%'이, 이도윤, 이순신
_정확히 1개의 아무 문자'_세%'오세린 (둘째 글자가 세)
SELECT ename FROM 사원 WHERE ename LIKE '이%';                          -- 이도윤
SELECT ename FROM 사원 WHERE ename LIKE '%윤' OR ename LIKE '_세%' ORDER BY eno;
ename
이도윤
오세린
SELECT ename FROM 사원 WHERE ename LIKE '%하%' ORDER BY eno;   -- 김하늘 (어디든 '하' 포함)
SELECT COUNT(*) FROM 사원 WHERE ename NOT LIKE '%하%';          -- 6
  • '%' 는 빈 문자열도 맞는다. '이%' 는 '이' 한 글자짜리 값도 잡는다.
  • 와일드카드가 없으면 LIKE '이도윤' 은 = '이도윤' 과 같다.
  • LIKE '%' 는 모든 값과 맞지만 NULL 은 제외(NULL LIKE … 는 UNKNOWN).
  • 앞이 % 로 시작하는 패턴('%윤')은 일반 인덱스를 못 탄다 — 성능 함정.

ESCAPE — % _ 자체를 찾고 싶을 때. 쿠폰 이름 테이블로 실험한다.

name
10%할인
100원할인
A_B
AXB
SELECT name FROM 쿠폰 WHERE name LIKE '%\%%' ESCAPE '\';   -- 10%할인
SELECT name FROM 쿠폰 WHERE name LIKE 'A\_B' ESCAPE '\';   -- A_B
SELECT name FROM 쿠폰 WHERE name LIKE 'A_B';               -- A_B, AXB

ESCAPE '\' 는 "\ 바로 뒤 한 글자는 와일드카드가 아니라 글자 그대로"라는 선언이다. '%\%%' 를 쪼개면 %(아무거나) + \%(진짜 %) + %(아무거나) → "% 를 포함". 이스케이프 문자는 \ 말고 '#' 등 아무 글자나 지정할 수 있다. 마지막 줄처럼 ESCAPE 없이 _ 를 쓰면 AXB 까지 잡힌다.

대소문자 구분은 엔진마다 다르다.

엔진'abc' LIKE 'A%'대소문자 무시 매칭
Oracle거짓UPPER(col) LIKE 'A%'
PostgreSQL거짓 (실측 f)ILIKE 연산자
MySQL참 (기본 콜레이션이 대소문자 무시)—
SQLite참 (실측 1, ASCII 한정 무시)—

5.6 IS NULL — NULL 은 = 로 찾을 수 없다

SELECT ename, bonus FROM 사원 WHERE bonus IS NULL ORDER BY eno;
enamebonus
김하늘NULL
박서준NULL
한유나NULL
오세린NULL
SELECT COUNT(*) FROM 사원 WHERE bonus = NULL;        -- 0  (오류도 아니고 그냥 0행)
SELECT COUNT(*) FROM 사원 WHERE dno IS NOT NULL;     -- 6

bonus = NULL 은 모든 행에서 UNKNOWN 이라 아무 행도 안 나온다. 문법 오류가 아니라서 더 위험하다.

부정 조건이 NULL 행을 몰래 버린다.

SELECT ename, bonus FROM 사원 WHERE bonus <> 30 ORDER BY eno;
enamebonus
최지우50
정민재20

"보너스가 30이 아닌 사람"을 원했는데 보너스가 없는(NULL) 4명이 사라졌다. NULL 행까지 원하면 WHERE bonus <> 30 OR bonus IS NULL 로 명시해야 한다.

UPDATE·DELETE 에서도 같다. UPDATE … SET … WHERE x = NULL 은 0행을 바꾼다. 대입(SET x = NULL)은 등호가 맞지만 비교는 IS NULL.


6. 3값 논리 — TRUE · FALSE · UNKNOWN

SQL 의 조건식은 참·거짓 두 값이 아니라 세 값을 가진다. NULL 이 끼어든 비교는 전부 UNKNOWN 이다.

식결과왜
NULL = NULLUNKNOWN모르는 값 둘이 같은지 모른다
NULL <> 1UNKNOWN모르는 값이 1인지 모른다
NULL > 0UNKNOWN
NULL + 1NULL(산술은 값 NULL, 비교는 진리값 UNKNOWN)

6.1 진리표

AND — 하나라도 FALSE 면 FALSE (UNKNOWN 이 무엇이든 결과가 정해짐)

ANDTRUEFALSEUNKNOWN
TRUETRUEFALSEUNKNOWN
FALSEFALSEFALSEFALSE
UNKNOWNUNKNOWNFALSEUNKNOWN

OR — 하나라도 TRUE 면 TRUE

ORTRUEFALSEUNKNOWN
TRUETRUETRUETRUE
FALSETRUEFALSEUNKNOWN
UNKNOWNTRUEUNKNOWNUNKNOWN

NOT

xNOT x
TRUEFALSE
FALSETRUE
UNKNOWNUNKNOWN

외우는 요령: UNKNOWN 을 "TRUE 일 수도 FALSE 일 수도 있는 값"으로 놓고 두 경우 모두 같은 답이 나오면 그 답, 갈리면 UNKNOWN. UNKNOWN AND FALSE 는 어느 쪽이든 FALSE → FALSE. UNKNOWN OR FALSE 는 갈림 → UNKNOWN.

실측 (PostgreSQL — SQLite 는 TRUE/FALSE 를 1/0 으로 표시):

SELECT (NULL = NULL) AS a, (NULL <> 1) AS b, (NULL AND FALSE) AS c,
       (NULL OR TRUE) AS d, (NOT NULL) AS e, (NULL AND TRUE) AS f;
abcdef
NULLNULLftNULLNULL

(UNKNOWN 은 화면에 NULL 로 표시된다. PostgreSQL 의 boolean 에서 UNKNOWN 과 NULL 은 같은 것이다.)

6.2 WHERE · HAVING · CHECK 의 차이

위치통과 기준UNKNOWN 은
WHERE, HAVING, JOIN ONTRUE 만 통과탈락
CHECK 제약FALSE 만 거부통과

CHECK (sal > 0) 이 걸린 열에 NULL 을 넣으면 NULL > 0 이 UNKNOWN 이라 들어간다. NULL 을 막으려면 NOT NULL 제약이 따로 필요하다. "조회는 보수적으로(확실한 것만), 제약은 관대하게(확실히 틀린 것만 거부)"로 기억.

6.3 예제로 확인

SELECT COUNT(*) FROM 사원 WHERE NOT (bonus > 25);
enobonusbonus > 25NOT (…)통과
1NULLUNKNOWNUNKNOWN✗
230TRUEFALSE✗
3NULLUNKNOWNUNKNOWN✗
450TRUEFALSE✗
520FALSETRUE✓
6NULLUNKNOWNUNKNOWN✗
7NULLUNKNOWNUNKNOWN✗

→ 1. "25 초과가 아닌 사람 = 7 − 2 = 5" 라고 셈하면 틀린다. WHERE 조건 과 WHERE NOT 조건 의 결과를 합쳐도 전체가 되지 않는다 — 둘 다에서 UNKNOWN 행이 빠지기 때문이다.


7. ORDER BY — 정렬

7.1 문법과 동작

ORDER BY 정렬키1 [ASC | DESC] [NULLS FIRST | NULLS LAST],
         정렬키2 [ASC | DESC] ...
  • ASC(오름차순)가 기본값이라 생략 가능. DESC 는 키마다 따로 적는다 — ORDER BY sal, ename DESC 는 sal 오름차순·ename 내림차순이지 둘 다 내림차순이 아니다.
  • 다중 키: 첫 키로 정렬하고, 첫 키가 같은 행들끼리만 둘째 키로 정렬한다.
  • 정렬은 ⑥ 단계, SELECT 다음이다. 그래서 SELECT 별칭을 쓸 수 있다.
  • ORDER BY 가 없으면 결과 순서는 보장되지 않는다(릴레이션에는 순서가 없다). 오늘 eno 순으로 나왔어도 내일 인덱스가 바뀌면 달라질 수 있다.
SELECT ename, sal, hiredate FROM 사원 ORDER BY sal DESC, hiredate ASC;
enamesalhiredate
김하늘5002019-03-01
최지우4502018-11-20
이도윤3502021-07-15
정민재3002022-05-09
한유나3002024-02-01
박서준2802023-01-02
오세린2502025-01-06

sal 300 동점인 정민재·한유나는 둘째 키(입사일 빠른 순)로 순서가 정해진다.

7.2 정렬 키로 쓸 수 있는 것

정렬 키예비고
열 이름ORDER BY salSELECT 에 없는 열도 가능 (DISTINCT·GROUP BY 가 없을 때)
SELECT 별칭ORDER BY 연봉⑥ 단계라 가능
열 번호ORDER BY 3 DESCSELECT 목록의 n번째 항목(1부터). 테이블의 n번째 열이 아님
식ORDER BY sal * 12
SELECT ename, dno, sal FROM 사원 WHERE dno = 20 ORDER BY 3 DESC, 1;
enamednosal
최지우20450
정민재20300
한유나20300

3 = sal, 1 = ename. 열 번호는 SELECT 목록을 고치면 뜻이 바뀌므로 실무에서는 피한다.

SELECT 에 없는 열로 정렬하기:

SELECT ename FROM 사원 WHERE dno = 10 ORDER BY sal;
ename
박서준
이도윤
김하늘

7.3 NULL 은 어디에 정렬되나 — 엔진마다 다르다

표준은 "NULL 을 모든 값보다 크게 볼지 작게 볼지는 구현 정의"라고만 정한다. 그래서 갈린다.

SELECT ename, bonus FROM 사원 ORDER BY bonus, eno;
SQLite·MySQL (NULL 이 가장 작다)PostgreSQL·Oracle (NULL 이 가장 크다)
김하늘 NULL정민재 20
박서준 NULL이도윤 30
한유나 NULL최지우 50
오세린 NULL김하늘 NULL
정민재 20박서준 NULL
이도윤 30한유나 NULL
최지우 50오세린 NULL

DESC 로 바꾸면 위치가 그대로 뒤집힌다 — PostgreSQL 에서 ORDER BY bonus DESC 는 NULL 4행이 맨 위에 온다 ("보너스 많은 순 1등"을 뽑으려다 NULL 을 뽑는 실무 버그).

엔진ASC 에서 NULLDESC 에서 NULLNULLS FIRST/LAST
Oracle마지막처음지원
PostgreSQL마지막처음지원
MySQL처음마지막미지원 (ORDER BY bonus IS NULL, bonus 로 흉내)
SQLite처음마지막지원 (3.30+)
SQL Server처음마지막미지원

NULLS FIRST / NULLS LAST 로 엔진에 상관없이 위치를 고정할 수 있다.

SELECT ename, bonus FROM 사원 ORDER BY bonus ASC NULLS LAST, eno;
enamebonus
정민재20
이도윤30
최지우50
김하늘NULL
박서준NULL
한유나NULL
오세린NULL

(SQLite·PG 모두 이 결과.)


8. 결과 행 수 제한 — LIMIT · FETCH · ROWNUM · TOP

"급여 상위 3명" 처럼 정렬한 뒤 앞의 몇 행만 원할 때. 논리 순서상 ORDER BY 다음(⑦)에 적용된다. 표준이 늦게(SQL:2008) 생겨서 엔진마다 문법이 제각각이다.

문법엔진예
LIMIT n [OFFSET m]MySQL, PostgreSQL, SQLiteLIMIT 3
OFFSET m ROWS FETCH FIRST n ROWS ONLY표준, Oracle 12c+, PostgreSQL, SQL Server 2012+
FETCH FIRST n ROWS WITH TIES표준, Oracle 12c+, PostgreSQL 13+동점 포함
WHERE ROWNUM <= nOracle (전통 방식)아래 함정 참고
SELECT TOP n …SQL Server, MS AccessSELECT TOP 3 ename …

8.1 LIMIT / OFFSET

SELECT ename, sal FROM 사원 ORDER BY sal DESC, eno LIMIT 3;
enamesal
김하늘500
최지우450
이도윤350

OFFSET m 은 앞의 m행을 건너뛰고 그다음부터. 페이지 나누기(한 페이지 2행, 2페이지)에 쓴다.

SELECT ename, sal FROM 사원 ORDER BY sal DESC, eno LIMIT 2 OFFSET 2;
enamesal
이도윤350
정민재300
  • OFFSET 은 0부터 센다. OFFSET 2 = 3번째 행부터.
  • MySQL 은 LIMIT 2, 2(= OFFSET 2 LIMIT 2, 건너뛸 수가 앞)도 허용한다 — 순서가 헷갈리는 표기.
  • ORDER BY 없는 LIMIT 은 "아무 3행"이다. 정렬 키에 동점이 있으면 경계 행이 실행마다 바뀔 수 있으니 eno 같은 고유 키를 마지막 정렬 키로 덧붙인다.

8.2 FETCH FIRST (표준)

SELECT ename, sal FROM 사원 ORDER BY sal DESC
OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY;          -- PostgreSQL 실행
enamesal
이도윤350
정민재300

WITH TIES 는 마지막 행과 정렬 키 값이 같은 행까지 함께 가져온다.

SELECT ename, sal FROM 사원 ORDER BY sal DESC FETCH FIRST 4 ROWS WITH TIES;
enamesal
김하늘500
최지우450
이도윤350
정민재300
한유나300

4행을 요청했지만 4번째(300)와 동점인 한유나까지 5행. (SQLite 는 FETCH 문법 자체를 지원하지 않는다.)

8.3 Oracle ROWNUM 함정 (소개)

Oracle 의 ROWNUM 은 행이 WHERE 를 통과할 때 붙는 번호(1, 2, 3 …)다. ORDER BY 보다 먼저 붙는다.

-- Oracle: 의도와 다르게 동작
SELECT ename, sal FROM 사원 WHERE ROWNUM <= 3 ORDER BY sal DESC;
-- → 아무 3행을 먼저 뽑고 그 3행만 정렬. "상위 3명"이 아니다.

-- 올바른 형태: 인라인 뷰에서 먼저 정렬
SELECT * FROM (SELECT ename, sal FROM 사원 ORDER BY sal DESC) WHERE ROWNUM <= 3;
  • WHERE ROWNUM = 2 나 ROWNUM > 1 은 항상 0행: 첫 행이 ROWNUM 1 을 받아 조건에서 탈락하면 다음 행이 다시 1 을 받고 또 탈락하기 때문이다.
  • 12c 이후로는 FETCH FIRST n ROWS ONLY 를 쓰는 것이 정석.

8.4 엔진 차이가 결과를 바꾸는 예

SELECT ename FROM 사원 ORDER BY dno DESC, sal LIMIT 3;
SQLite·MySQL (DESC 에서 NULL 마지막)PostgreSQL (DESC 에서 NULL 처음)
정민재오세린
한유나정민재
최지우한유나

정렬의 NULL 위치(§7.3)와 행 제한이 합쳐지면 결과 집합 자체가 달라진다. 같은 쿼리를 엔진만 바꿔 돌렸을 때 결과가 다르면 제일 먼저 의심할 곳.


9. 정리 — 한 쿼리에 모두 넣어 읽기

SELECT ename, sal * 12 AS 연봉            -- ⑤
FROM 사원                                  -- ①
WHERE job IN ('사원', '대리')              -- ②  NULL job 은 없음
  AND (bonus IS NULL OR bonus < 30)        -- ②  괄호 필수 (AND > OR)
ORDER BY 연봉 DESC, ename                  -- ⑥  별칭 OK
LIMIT 3;                                   -- ⑦
단계남은 행
② job 조건이도윤(대리), 박서준, 정민재, 한유나, 오세린 (5행)
② bonus 조건이도윤(30)은 30 < 30 거짓 → 탈락. 박서준·정민재(20)·한유나·오세린 (4행)
⑥ 연봉 내림차순, 동점은 이름순정민재 3600, 한유나 3600, 박서준 3360, 오세린 3000
⑦ LIMIT 3정민재, 한유나, 박서준
ename연봉
정민재3600
한유나3600
박서준3360

확인 문제

1. (결과 쓰기) 다음 쿼리의 결과 ename 을 순서대로 쓰시오.

SELECT ename FROM 사원
WHERE job = '사원' AND sal >= 300 OR dno IS NULL
ORDER BY eno;

2. (결과 쓰기) 결과 값은?

SELECT COUNT(*) FROM 사원 WHERE NOT (bonus > 25);

3. (OX) SELECT sal * 12 AS 연봉 FROM 사원 WHERE 연봉 > 4000; 은 표준 SQL 에서 정상 실행된다.

4. (빈칸) 이름의 둘째 글자가 '도' 인 사원을 찾는 조건을 완성하시오. WHERE ename LIKE '( ① )'

5. (결과 쓰기) 다음 두 쿼리의 결과 행 수 / 값을 각각 쓰시오.

SELECT DISTINCT dno FROM 사원;          -- (가) 결과 행 수
SELECT COUNT(DISTINCT dno) FROM 사원;   -- (나) 결과 값

6. (결과 쓰기) 결과 값은?

SELECT COUNT(*) FROM 사원 WHERE dno NOT IN (20, NULL);

7. (결과 쓰기) PostgreSQL 에서 실행한 결과 ename 3개를 순서대로 쓰시오.

SELECT ename FROM 사원 ORDER BY dno DESC, sal LIMIT 3;

8. (빈칸) SELECT 문의 논리적 처리 순서를 채우시오. FROM → ( ① ) → GROUP BY → ( ② ) → SELECT → ( ③ )

정답과 풀이

#정답풀이
1정민재, 한유나, 오세린(job='사원' AND sal>=300) OR dno IS NULL. 사원 직급 중 300 이상은 정민재·한유나, 박서준(280) 탈락, 오세린은 250이지만 OR 뒤쪽(dno NULL)으로 통과
21NULL 보너스 4행은 NOT UNKNOWN = UNKNOWN 으로 탈락, 30·50은 FALSE. 20(정민재)만 TRUE
3X별칭은 ⑤ SELECT 에서 생기고 WHERE 는 ② 라서 참조 불가. WHERE sal * 12 > 4000 으로 써야 한다 (SQLite 는 확장으로 허용하지만 표준은 오류)
4_도%_ 가 첫 글자 하나, 이어서 '도', 그 뒤 %. 결과: 이도윤
5(가) 3 / (나) 2DISTINCT 는 NULL 도 하나의 행으로 남기지만(10, 20, NULL), COUNT 는 NULL 을 세지 않는다
60dno <> 20 AND dno <> NULL — 뒤쪽이 항상 UNKNOWN 이라 어떤 행도 TRUE 가 안 된다
7오세린, 정민재, 한유나PostgreSQL 은 NULL 을 가장 큰 값으로 봐서 DESC 에서 맨 앞. 그다음 dno 20 중 sal 오름차순(300, 300, 450)의 앞 둘. MySQL·SQLite 라면 정민재, 한유나, 최지우
8① WHERE ② HAVING ③ ORDER BY적는 순서와 같아 보이지만 SELECT 만 5번째로 밀린다는 게 핵심

한 줄 요약

주제한 줄
SQL 분류구조 = DDL(CREATE·ALTER·DROP·TRUNCATE), 데이터 = DML(SELECT·INSERT·UPDATE·DELETE), 권한 = DCL(GRANT·REVOKE), 트랜잭션 = TCL(COMMIT·ROLLBACK·SAVEPOINT)
용어릴레이션=테이블, 튜플=행, 속성=열, 차수=열 수, 카디널리티=행 수
처리 순서FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY (→ LIMIT)
별칭SELECT 에서 태어나므로 표준에서는 ORDER BY 에서만 사용 가능
WHERE vs HAVINGWHERE 는 행을(집계 함수 불가), HAVING 은 그룹을 거른다
연결표준·Oracle ||, MySQL CONCAT, SQL Server +. Oracle 만 NULL 을 빈 문자열로 연결
DISTINCTSELECT 목록 전체에 걸리고, NULL 도 한 행으로 남긴다
우선순위NOT > AND > OR — 섞으면 괄호
BETWEEN양 끝 포함, 작은 값이 먼저 (BETWEEN 큰 AND 작은 = 0행)
NOT IN목록에 NULL 이 하나라도 있으면 결과 0행
LIKE% 0개 이상, _ 정확히 1개, 와일드카드 자체는 ESCAPE
NULL 비교= NULL 은 항상 UNKNOWN → IS NULL
3값 논리WHERE 는 TRUE 만 통과, CHECK 는 FALSE 만 거부
NULL 정렬Oracle·PG 는 NULL 이 최대(ASC 마지막), MySQL·SQLite 는 최소 → NULLS FIRST/LAST 로 고정
행 제한표준 FETCH FIRST n ROWS ONLY, MySQL·PG LIMIT, Oracle 구식 ROWNUM(정렬 전 번호), SQL Server TOP
← Python — 슬라이스·가변 객체SQL ② 함수·NULL·CASE →