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. 이 편에서 쓰는 테이블
부서
| dno | dname | loc |
|---|---|---|
| 10 | 개발 | 서울 |
| 20 | 영업 | 부산 |
| 30 | 인사 | 서울 |
| 40 | 기획 | NULL |
사원
| eno | ename | dno | job | sal | mgr | hiredate | bonus |
|---|---|---|---|---|---|---|---|
| 1 | 김하늘 | 10 | 팀장 | 500 | NULL | 2019-03-01 | NULL |
| 2 | 이도윤 | 10 | 대리 | 350 | 1 | 2021-07-15 | 30 |
| 3 | 박서준 | 10 | 사원 | 280 | 2 | 2023-01-02 | NULL |
| 4 | 최지우 | 20 | 팀장 | 450 | NULL | 2018-11-20 | 50 |
| 5 | 정민재 | 20 | 사원 | 300 | 4 | 2022-05-09 | 20 |
| 6 | 한유나 | 20 | 사원 | 300 | 4 | 2024-02-01 | NULL |
| 7 | 오세린 | NULL | 사원 | 250 | NULL | 2025-01-06 | NULL |
눈여겨볼 점: 오세린은 부서가 없다(dno NULL), 보너스는 2·4·5번만 있다. 이 NULL 들이 이 편 거의 모든 함정의 재료다.
1. SQL 의 분류 — 명령어를 네 갈래로
SQL 문장은 "무엇을 다루느냐"로 네 묶음이다. 실기에서는 명령어 → 분류를 묻는 빈칸이 자주 나온다.
| 분류 | 풀이 | 다루는 대상 | 명령어 |
|---|---|---|---|
| DDL | Data Definition Language (정의어) | 테이블·뷰·인덱스 같은 구조(스키마) | CREATE, ALTER, DROP, TRUNCATE, RENAME |
| DML | Data Manipulation Language (조작어) | 테이블 안의 데이터(행) | SELECT, INSERT, UPDATE, DELETE (+ MERGE) |
| DCL | Data Control Language (제어어) | 권한 | GRANT, REVOKE |
| TCL | Transaction 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)만 탈락.
| eno | ename | dno | sal | 통과 |
|---|---|---|---|---|
| 1 | 김하늘 | 10 | 500 | ✓ |
| 2 | 이도윤 | 10 | 350 | ✓ |
| 3 | 박서준 | 10 | 280 | ✓ (280 ≥ 280) |
| 4 | 최지우 | 20 | 450 | ✓ |
| 5 | 정민재 | 20 | 300 | ✓ |
| 6 | 한유나 | 20 | 300 | ✓ |
| 7 | 오세린 | NULL | 250 | ✗ |
③ GROUP BY dno — 남은 6행을 dno 값별로 묶는다. 이 순간부터 "행"이 아니라 "그룹"이 단위다.
| dno | 그룹에 든 행 | 행 수 | MAX(sal) |
|---|---|---|---|
| 10 | 김하늘, 이도윤, 박서준 | 3 | 500 |
| 20 | 최지우, 정민재, 한유나 | 3 | 450 |
④ HAVING COUNT(*) >= 2 — 그룹 단위 조건. 두 그룹 모두 3 ≥ 2 라 통과.
⑤ SELECT — 그룹마다 한 행씩 dno, COUNT(*), MAX(sal) 를 계산하고, 이때 처음으로 별칭
cnt, 최고 가 생긴다.
⑥ ORDER BY cnt DESC, dno — 이미 만들어진 결과에 정렬. cnt 가 같으니 dno 오름차순.
| dno | cnt | 최고 |
|---|---|---|
| 10 | 3 | 500 |
| 20 | 3 | 450 |
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; -- 원하는 열만, 적은 순서대로
| ename | sal |
|---|---|
| 김하늘 | 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;
| ename | sal | 연봉 | 합계 |
|---|---|---|---|
| 최지우 | 450 | 5400 | 500 |
| 정민재 | 300 | 3600 | 320 |
| 한유나 | 300 | 3600 | NULL |
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 — 산술과 같은 전염 규칙이다. 그런데 엔진마다 다르다.
| 엔진 | 연결 연산자 | '부서:' || NULL | CONCAT('부서:', NULL) |
|---|---|---|---|
| 표준 SQL | || | NULL | (표준에 없음) |
| PostgreSQL | ||, CONCAT(…) | NULL | '부서:' (NULL 무시) |
| SQLite | ||, CONCAT(…) (3.44+) | NULL | '부서:' (NULL 무시) |
| Oracle | ||, CONCAT(a, b) (인자 2개만) | '부서:' (NULL 을 빈 문자열로 취급) | '부서:' |
| MySQL | CONCAT(…) — || 는 기본이 논리 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 이 크다) |
|---|---|
| NULL | 10 |
| 10 | 20 |
| 20 | NULL |
→ 3행. 정렬 위치만 다르고 행 수는 같다(§8.4).
DISTINCT 는 열 하나가 아니라 SELECT 목록 전체에 걸린다.
SELECT DISTINCT dno, job FROM 사원 ORDER BY dno, job; -- PostgreSQL 결과
| dno | job |
|---|---|
| 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 사원;
| a | b | c | d |
|---|---|---|---|
| 7 | 3 | 2 | 7 |
함정 —
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).
| ename | dno | sal |
|---|---|---|
| 김하늘 | 10 | 500 |
| 이도윤 | 10 | 350 |
| 박서준 | 10 | 280 |
| 최지우 | 20 | 450 |
10번 부서는 급여와 상관없이 전원, 20번은 400 이상만. "10·20번 부서 중 400 이상"을 원했다면 괄호가 필요하다.
SELECT ename, dno, sal FROM 사원
WHERE (dno = 10 OR dno = 20) AND sal >= 400
ORDER BY eno;
| ename | dno | sal |
|---|---|---|
| 김하늘 | 10 | 500 |
| 최지우 | 20 | 450 |
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 | = <> < > <= >= |
| 4 | IS [NOT] NULL, LIKE, [NOT] BETWEEN, [NOT] IN |
| 5 | NOT |
| 6 | AND |
| 7 | OR |
실무 원칙: AND 와 OR 를 섞으면 무조건 괄호. 시험은 괄호를 일부러 빼고 결과를 묻는다.
5.3 BETWEEN — 양 끝 포함 범위
열 [NOT] BETWEEN 하한 AND 상한 -- = 열 >= 하한 AND 열 <= 상한
SELECT ename, sal FROM 사원 WHERE sal BETWEEN 300 AND 450 ORDER BY eno;
| ename | sal |
|---|---|
| 이도윤 | 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;
| ename | hiredate |
|---|---|
| 이도윤 | 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;
| ename | dno |
|---|---|
| 김하늘 | 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;
| ename | bonus |
|---|---|
| 김하늘 | 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;
| ename | bonus |
|---|---|
| 최지우 | 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 = NULL | UNKNOWN | 모르는 값 둘이 같은지 모른다 |
NULL <> 1 | UNKNOWN | 모르는 값이 1인지 모른다 |
NULL > 0 | UNKNOWN | |
NULL + 1 | NULL | (산술은 값 NULL, 비교는 진리값 UNKNOWN) |
6.1 진리표
AND — 하나라도 FALSE 면 FALSE (UNKNOWN 이 무엇이든 결과가 정해짐)
| AND | TRUE | FALSE | UNKNOWN |
|---|---|---|---|
| TRUE | TRUE | FALSE | UNKNOWN |
| FALSE | FALSE | FALSE | FALSE |
| UNKNOWN | UNKNOWN | FALSE | UNKNOWN |
OR — 하나라도 TRUE 면 TRUE
| OR | TRUE | FALSE | UNKNOWN |
|---|---|---|---|
| TRUE | TRUE | TRUE | TRUE |
| FALSE | TRUE | FALSE | UNKNOWN |
| UNKNOWN | TRUE | UNKNOWN | UNKNOWN |
NOT
| x | NOT x |
|---|---|
| TRUE | FALSE |
| FALSE | TRUE |
| UNKNOWN | UNKNOWN |
외우는 요령: 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;
| a | b | c | d | e | f |
|---|---|---|---|---|---|
| NULL | NULL | f | t | NULL | NULL |
(UNKNOWN 은 화면에 NULL 로 표시된다. PostgreSQL 의 boolean 에서 UNKNOWN 과 NULL 은 같은 것이다.)
6.2 WHERE · HAVING · CHECK 의 차이
| 위치 | 통과 기준 | UNKNOWN 은 |
|---|---|---|
| WHERE, HAVING, JOIN ON | TRUE 만 통과 | 탈락 |
| CHECK 제약 | FALSE 만 거부 | 통과 |
CHECK (sal > 0) 이 걸린 열에 NULL 을 넣으면 NULL > 0 이 UNKNOWN 이라 들어간다. NULL 을 막으려면
NOT NULL 제약이 따로 필요하다. "조회는 보수적으로(확실한 것만), 제약은 관대하게(확실히 틀린 것만 거부)"로 기억.
6.3 예제로 확인
SELECT COUNT(*) FROM 사원 WHERE NOT (bonus > 25);
| eno | bonus | bonus > 25 | NOT (…) | 통과 |
|---|---|---|---|---|
| 1 | NULL | UNKNOWN | UNKNOWN | ✗ |
| 2 | 30 | TRUE | FALSE | ✗ |
| 3 | NULL | UNKNOWN | UNKNOWN | ✗ |
| 4 | 50 | TRUE | FALSE | ✗ |
| 5 | 20 | FALSE | TRUE | ✓ |
| 6 | NULL | UNKNOWN | UNKNOWN | ✗ |
| 7 | NULL | UNKNOWN | UNKNOWN | ✗ |
→ 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;
| ename | sal | hiredate |
|---|---|---|
| 김하늘 | 500 | 2019-03-01 |
| 최지우 | 450 | 2018-11-20 |
| 이도윤 | 350 | 2021-07-15 |
| 정민재 | 300 | 2022-05-09 |
| 한유나 | 300 | 2024-02-01 |
| 박서준 | 280 | 2023-01-02 |
| 오세린 | 250 | 2025-01-06 |
sal 300 동점인 정민재·한유나는 둘째 키(입사일 빠른 순)로 순서가 정해진다.
7.2 정렬 키로 쓸 수 있는 것
| 정렬 키 | 예 | 비고 |
|---|---|---|
| 열 이름 | ORDER BY sal | SELECT 에 없는 열도 가능 (DISTINCT·GROUP BY 가 없을 때) |
| SELECT 별칭 | ORDER BY 연봉 | ⑥ 단계라 가능 |
| 열 번호 | ORDER BY 3 DESC | SELECT 목록의 n번째 항목(1부터). 테이블의 n번째 열이 아님 |
| 식 | ORDER BY sal * 12 |
SELECT ename, dno, sal FROM 사원 WHERE dno = 20 ORDER BY 3 DESC, 1;
| ename | dno | sal |
|---|---|---|
| 최지우 | 20 | 450 |
| 정민재 | 20 | 300 |
| 한유나 | 20 | 300 |
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 에서 NULL | DESC 에서 NULL | NULLS 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;
| ename | bonus |
|---|---|
| 정민재 | 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, SQLite | LIMIT 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 <= n | Oracle (전통 방식) | 아래 함정 참고 |
SELECT TOP n … | SQL Server, MS Access | SELECT TOP 3 ename … |
8.1 LIMIT / OFFSET
SELECT ename, sal FROM 사원 ORDER BY sal DESC, eno LIMIT 3;
| ename | sal |
|---|---|
| 김하늘 | 500 |
| 최지우 | 450 |
| 이도윤 | 350 |
OFFSET m 은 앞의 m행을 건너뛰고 그다음부터. 페이지 나누기(한 페이지 2행, 2페이지)에 쓴다.
SELECT ename, sal FROM 사원 ORDER BY sal DESC, eno LIMIT 2 OFFSET 2;
| ename | sal |
|---|---|
| 이도윤 | 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 실행
| ename | sal |
|---|---|
| 이도윤 | 350 |
| 정민재 | 300 |
WITH TIES 는 마지막 행과 정렬 키 값이 같은 행까지 함께 가져온다.
SELECT ename, sal FROM 사원 ORDER BY sal DESC FETCH FIRST 4 ROWS WITH TIES;
| ename | sal |
|---|---|
| 김하늘 | 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)으로 통과 |
| 2 | 1 | NULL 보너스 4행은 NOT UNKNOWN = UNKNOWN 으로 탈락, 30·50은 FALSE. 20(정민재)만 TRUE |
| 3 | X | 별칭은 ⑤ SELECT 에서 생기고 WHERE 는 ② 라서 참조 불가. WHERE sal * 12 > 4000 으로 써야 한다 (SQLite 는 확장으로 허용하지만 표준은 오류) |
| 4 | _도% | _ 가 첫 글자 하나, 이어서 '도', 그 뒤 %. 결과: 이도윤 |
| 5 | (가) 3 / (나) 2 | DISTINCT 는 NULL 도 하나의 행으로 남기지만(10, 20, NULL), COUNT 는 NULL 을 세지 않는다 |
| 6 | 0 | dno <> 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 HAVING | WHERE 는 행을(집계 함수 불가), HAVING 은 그룹을 거른다 |
| 연결 | 표준·Oracle ||, MySQL CONCAT, SQL Server +. Oracle 만 NULL 을 빈 문자열로 연결 |
| DISTINCT | SELECT 목록 전체에 걸리고, 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 |