working_helen

[코테 연습] HackerRank 코딩테스트 연습 Medium & Hard

HaeWon_Seo — Sun, 13 Jul 2025 17:04:17 +0900

HackerRank 코딩테스트 연습 Medium & Hard

Occupations

: pivot the Occupation column in OCCUPATIONS so that each Name is sorted alphabetically and displayed underneath its corresponding Occupation. The output should consist of four columns (Doctor, Professor, Singer, and Actor) in that specific order, with their respective names listed alphabetically under each column.

풀이 1 > PIVOT 함수

SELECT *
FROM 테이블명
PIVOT (VALUE칼럼 FOR UNSTACK칼럼 IN (값1, 값2, 값3, ...))

- 기존 테이블에는 있지만 PIVOT 함수 내에서는 사용되지 않은 칼럼들

→ PIVOT 결과에서 STACK 칼럼 역할을 함, 해당 칼럼들 조합별로 UNSTACK 칼럼 집계

- VALUE 칼럼에는 반드시 집계 함수 사용해야 함

- PIVOT 이후에 정렬 : 기존 테이블에 있던 칼럼을 기준으로 정렬 가능

- FROM절 서브쿼리에서 RNK를 정의

→ PIVOT 결과에서 RNK 칼럼을 STACK 칼럼으로 사용하여 집계하므로

VALUE 칼럼에서 집계함수 사용을 위해 MAX(NAME)를 해주어도 모든 NAME 출력 가능

→ PIVOT 테이블을 RNK를 기준으로 정렬 가능

- OCCUPATION에 해당되는 NAME이 없으면 MAX( NULL )은 NULL 리턴

SELECT Doctor, Professor, Singer, Actor
FROM (
    SELECT NAME, OCCUPATION,
        RANK() OVER (PARTITION BY OCCUPATION ORDER BY NAME) AS RNK
    FROM OCCUPATIONS)
PIVOT (
    MAX(NAME)
    FOR OCCUPATION IN ('Doctor' AS Doctor,
                       'Professor' AS Professor,
                       'Singer' AS Singer,
                       'Actor' AS Actor)
    )
ORDER BY RNK;

풀이 2

- row_number 값을 그루핑에 사용

각 OCCUPATION마다 RN 값이 하나씩 배정되므로 각 RN 그룹 내에서 OCCUPTAION 4개로 나누기

- OCCUPATION에 해당되는 NAME이 없으면 MAX( NULL )은 NULL 리턴

SELECT
    MAX(CASE WHEN OCCUPATION = 'Doctor' THEN NAME END) AS Doctor,
    MAX(CASE WHEN OCCUPATION = 'Professor' THEN NAME END) AS Professor,
    MAX(CASE WHEN OCCUPATION = 'Singer' THEN NAME END) AS Singer,
    MAX(CASE WHEN OCCUPATION = 'Actor' THEN NAME END) AS Actor
FROM (
    SELECT NAME, OCCUPATION,
         ROW_NUMBER() OVER (PARTITION BY OCCUPATION ORDER BY NAME) AS RN
    FROM OCCUPATIONS) TMP
GROUP BY RN
ORDER BY RN;

Symmetric Pairs

: Two pairs (X1, Y1) and (X2, Y2) are said to be symmetric pairs if X1 = Y2 and X2 = Y1. Write a query to output all such symmetric pairs in ascending order by the value of X. List the rows such that X1 ≤ Y1.

(X1, Y1) = (20, 20), (X2, Y2) = (20,20), (X3, Y3) = (10,10) 인 경우

그냥 cartessian product 수행한 후 X1=Y2, X2=Y1 조건으로 필터링하면

(X1, Y1)과 (X2, Y2)을 원하는 symmetric pairs로 찾아낼 수 있지만

자기 자신과 pair가 되는 (X3, Y3)과 (X3, Y3) 경우도 symmetric pairs로 인식되어 버리는 문제 발생

풀이 1

- 각 (X, Y)가 고유하게 인식될 수 있도록 index 만들어버리기

- row_number 사용해서 행에 index 붙히기

with tmp as (
    select x, y, row_number() over(order by x, y) as rn
    from functions
) 
select distinct t1.x, t1.y 
from tmp t1 join tmp t2
    on t1.x = t2.y  and t1.y = t2.x and t1.rn != t2.rn
where t1.x <= t1.y
order by 1;

풀이 2

- 두 (X, Y)가 완전히 동일해서 symmetric pairs인 경우와

두 (X, Y)가 동일하지 않으면서 symmetric pairs 경우, 2가지를 분리해서 구한 후 UNION

- (X, Y)로 그루핑 → COUNT(*) > 1이면 2개 이상의 (X, Y)가 완전히 동일하면서 symmetric pairs인 경우

select x, y
from (select x, y 
    from functions 
    where  x = y
    group by x, y 
    having count(*) > 1
    union all
    select distinct f1.x, f1.y
    from functions f1 
    join functions f2 on f1.x = f2.y and f1.y = f2.x
                      and f1.x != f2.x and f1.y != f2.y
) tmp
where x <= y
order by 1;

SQL Project Planning

: If the End_Date of the tasks are consecutive, then they are part of the same project. Samantha is interested in finding the total number of different projects completed. Write a query to output the start and end dates of projects listed by the number of days it took to complete the project in ascending order. If there is more than one project that have the same number of completion days, then order by the start date of the project.

풀이

- 같은 프로젝트이면 end_date가 하나씩 차이 + end_date 기준으로 정렬했을때 row_number도 하나씩 차이

- 같은 프로젝트이다 → end_date - row_number 값이 같다

→ end_date - row_number 값으로 프로젝트 그루핑하기!

with tmp as (
    select start_date, end_date,
        end_date - row_number() over(order by end_date) as gp
    from Projects
)
select min(start_date), max(end_date)
from tmp
group by gp
order by max(end_date)-min(start_date), min(start_date);

15 Days of Learning SQL

: Conducted a days of learning SQL contest. The start date of the contest was March 01, 2016 and the end date was March 15, 2016. Write a query to print total number of unique hackers who made at least submission each day (starting on the first day of the contest), and find the hacker_id and name of the hacker who made maximum number of submissions each day. If more than one such hacker has a maximum number of submissions, print the lowest hacker_id. The query should print this information for each day of the contest, sorted by the date.

풀이

이번 문제는 다 해결하지 못해 Leaderboard 내 솔루션을 참고했습니다.

Hacker 아이디 : L0r3nz0

솔루션 출처 : https://www.hackerrank.com/rest/contests/master/challenges/15-days-of-learning-sql/hackers/L0r3nz0/download_solution?primary=true

SUB_DAY : submission_date, hacker_id, name 별로 제출될 submissions 개수 세기
RNK : submission_date별로 subs 값이 최대인 해커들 중에서 hacker_id가 가장 작은 한 명만 선택

CONSEC : 계층형 쿼리로 연속된 날짜 동안 모두 존재하는 record 찾기

START WITH : '2016-03-01'에 제출한 해커를 기준으로 시작
CONNECT BY
- 같은 hacker_id의 해커가 그 다음날 제출한 record가 있으면 계층형 쿼리 연결
- 같은 hacker_id의 해커가 그 다음날 제출한 record가 없으면 해당 날짜 이후부터 계층형 탐색에 포함되지 않음

➡️ '2016-03-01'부터 각 해커가 연속으로 제출한 날짜까지만 CONSEC에 포함!

최종 출력 SELECT문

SUB_DAY 테이블에 submission_date를 기준으로 CONSEC 정보를 LEFT JOIN
→ count(CONSEC에서의 hacker_id 개수)로 연속으로 제출한 해커 수 세기
SUB_DAY 테이블에 submission_date를 기준으로 RNK 정보를 LEFT JOIN
같은 submission_date에는 모두 같은 r.hacker_id, r.name
→ group by 집계함수를 사용해야 하므로 그냥 MIN, MAX 사용해버기 스킬

WITH SUBS_DAY AS (
    SELECT submission_date, hacker_id, name, COUNT(*) AS subs
    FROM SUBMISSIONS s LEFT JOIN HACKERS h USING(hacker_id)
    GROUP BY submission_date, hacker_id, name
),
RNK AS (
    SELECT submission_date, hacker_id, name
    FROM (SELECT submission_date, hacker_id, name,
               ROW_NUMBER() OVER (PARTITION BY submission_date
                                ORDER BY subs DESC, hacker_id ASC) AS rn
          FROM SUBS_DAY) tmp
    WHERE rn = 1
),
CONSEC AS (
SELECT hacker_id, name, submission_date, subs
    FROM SUBS_DAY
    START WITH submission_date = DATE '2016-03-01'
    CONNECT BY 
        PRIOR submission_date = submission_date - 1
        AND PRIOR hacker_id = hacker_id
)
SELECT
    sd.submission_date, COUNT(c.hacker_id) AS dist_hacker_subs,
    MIN(r.hacker_id), MIN(r.name)
FROM SUBS_DAY sd LEFT JOIN CONSEC c 
        ON c.submission_date = sd.submission_date AND c.hacker_id = sd.hacker_id
    LEFT JOIN RNK r ON r.submission_date = sd.submission_date
GROUP BY sd.submission_date
ORDER BY 1;

[코테 연습] HackerRank 코딩테스트 연습 Easy & Medium

HaeWon_Seo — Tue, 1 Jul 2025 13:41:26 +0900

HackerRank 코딩테스트 연습 Easy & Medium

Weather Observation Station 5

: Query the two cities in STATION with the shortest and longest CITY names, as well as their respective lengths (i.e.: number of characters in the name). If there is more than one smallest or largest city, choose the one that comes first when ordered alphabetically.

풀이 1

- 정렬만을 가지고 쉽게 record를 얻기 위해

LENGTH(CITY) 오름차순 정렬했을 때, 내림차순 정렬했을 때, 따로따로 진행

- ROW_NUMBER(), RANK() 다 가능 / DENSE_RANK()는 불가능

WITH TBL AS (
  SELECT CITY, LENGTH(CITY) AS LEN,
         ROW_NUMBER() OVER (ORDER BY LENGTH(CITY), CITY) AS RN_MIN,
         ROW_NUMBER() OVER (ORDER BY LENGTH(CITY) DESC, CITY) AS RN_MAX
  FROM STATION
)
SELECT CITY, LEN
FROM TBL
WHERE RN_MIN = 1 OR RN_MAX = 1;

풀이 2

- 원하는 정보 하나씩 추출한 후 UNION하기

- where절에서 rownum을 사용하기 위해 서브쿼리로 묶기

- 절대적인 행 번호가 아닌 가상의 번호이므로 '<' 연산만 가능

(
    SELECT CITY, LENGTH(CITY) AS LEN
    FROM (
      SELECT CITY
      FROM STATION
      ORDER BY LENGTH(CITY), CITY
    )
    WHERE ROWNUM = 1
) UNION (
    SELECT CITY, LENGTH(CITY) AS LEN
    FROM (
      SELECT CITY
      FROM STATION
      ORDER BY LENGTH(CITY) DESC, CITY
    )
    WHERE ROWNUM = 1
);

Draw The Triangle 1

: P(R) represents a pattern drawn by Julia in R rows. The following pattern represents P(5). Write a query to print the pattern P(20).

* * * * * 
* * * * 
* * * 
* * 
*

풀이

- 테이블 없이 SQL로 결과를 리턴하고 싶을 때, FROM DUAL 사용

- RPAD(대상 문자열, n, 추가 문자열)

'대상 문자열'의 오른쪽에, '추가 문자열'을 연결해서, 길이가 n까지 리턴
이때 '추가 문자열' 연결로 길이가 n 이상이 되면, 연결 후 n까지만 잘려서 리턴

> START WITH 없이 CONNECT BY

→ 특정한 행을 root로 지정하지 않고 가능한 가능한 모든 경로를 탐색하는 계층형 쿼리

Oracle이 알아서 DUAL 테이블에서 LEVEL = 1부터 시작해서 계층형 탐색 진행
LEVEL 20까지만 탐색하기 위해, 탐색에서 연결 조건을 지정하는 CONNECT BY를 사용

SELECT RPAD('* ', 2*LEVEL-1, '* ') AS PATTERN
FROM DUAL
CONNECT BY LEVEL <= 20
ORDER BY LEVEL DESC;

The PADS

: Query an alphabetically ordered list of all names in OCCUPATIONS, immediately followed by the first letter of each profession as a parenthetical (i.e.: enclosed in parentheses). For example: AnActorName(A), ADoctorName(D), ProfessorName(P), and ASingerName(S). Query the number of ocurrences of each occupation in OCCUPATIONS. Sort the occurrences in ascending order, and output them in the following format: "There are a total of [occupation_count] [occupation]s."

> Oracle에서 문자열 연결

CONCAT(문자열1, 문자열2) : 2개의 문자열을 연결할 때 사용
문자열1 || 문자열2 || 문자열3 || ... : 3개 이상의 문자열을 연결할 때 사용

- UNION 사용시 개별 쿼리 내에서 ORDER BY를 사용할 수 없음!

→ 정렬에 사용할 칼럼을 서브쿼리 내에서 별도로 리턴하기

- 여러 개의 쿼리 결과를 한번에 리턴하는 경우

→ 쿼리 순서대로 출력될 수 있도록 쿼리의 순서를 의미하는 칼럼을 서브쿼리 내에서 리턴하기

SELECT OUTPUT
FROM(
    SELECT NAME || '(' || (CASE WHEN OCCUPATION = 'Actor' THEN 'A'
                            WHEN OCCUPATION = 'Doctor' THEN 'D'
                            WHEN OCCUPATION = 'Professor' THEN 'P'
                            ELSE 'S' END) || ')' AS OUTPUT,
            NAME AS FIRST_ORDER, NULL AS SEC_ORDER, '1' AS QUEST_ORDER
    FROM OCCUPATIONS
    UNION
    SELECT 'There are a total of ' || COUNT(*) || ' ' || LOWER(OCCUPATION) || 's.' AS OUTPUT,
            TO_CHAR(COUNT(*)) AS FIRST_ORDER, OCCUPATION AS SEC_ORDER, '2' AS QUEST_ORDER
    FROM OCCUPATIONS
    GROUP BY OCCUPATION
    ) TMP
ORDER BY QUEST_ORDER, FIRST_ORDER, SEC_ORDER;

The Report

: You are given two tables: Students and Grades. Generate a report containing three columns: Name, Grade and Mark. Ketty doesn't want the NAMES of those students who received a grade lower than 8. The report must be in descending order by grade. If there is more than one student with the same grade (8-10) assigned to them, order those particular students by their name alphabetically. Finally, if the grade is lower than 8, use "NULL" as their name and list them by their grades in descending order.

풀이

- 원하는 정보 하나씩 추출한 후 UNION하기

- UNION 사용시 개별 쿼리 내에서 ORDER BY를 사용할 수 없음!

→ 정렬에 사용할 칼럼을 서브쿼리 내에서 별도로 리턴하기 (여기서는 GRADE, NAME으로 정렬)

- ON절 조건을 사용해 JOIN 방법에 관한 조건을 설정

JOIN을 할 때 G의 MIN_MARK와 MAX_MARK 값을 S의 MAKRS 값과 비교하도록

WITH TMP AS (
    SELECT NAME, GRADE, MARKS
    FROM STUDENTS S JOIN GRADES G
        ON S.MARKS BETWEEN G.MIN_MARK AND G.MAX_MARK
)
SELECT * FROM TMP
WHERE GRADE > 7
UNION
SELECT NULL AS NAME, GRADE, MARKS FROM TMP
WHERE GRADE <= 7
ORDER BY 2 DESC, 1;

Binary Tree Nodes

: You are given a table, BST, containing two columns: N and P, where N represents the value of a node in Binary Tree, and P is the parent of N. Write a query to find the node type of Binary Tree ordered by the value of the node.

> col값 IN (비교값1, 비교값 2, 비교값3, ...)

- IN 은 col값을 리스트 내에 있는 모든 비교값과 '=' 연산 + 'or' 연결

'='를 만족하는 비교값이 적어도 하나 있으면 True를 리턴

- 비교값에 NULL이 있더라도 True를 리턴하는 비교값이 하나라도 있으면 True를 리턴하므로

즉 IN 함수는 비교값 리스트에 NULL이 있든 없든 영향을 받지 않음

> col값 NOT IN (비교값1, 비교값 2, 비교값3, ...)

- NOT IN은 col값을 리스트 내에 있는 모든 비교값과 '=' 연산 + 'and' 연결

'='를 만족하지 않는 비교값이 하나라도 있으면 True를 리턴

- 비교값에 NULL이 있으면 col값이 무엇이든 NULL과의 '=' 연산은 unknown으로 False 취급되므로

실제로 col값이 리스트 내에 없어 True가 나와야하지만 NULL과의 비교로 인해 Fasle가 출력될 수 있음

- 정확한 비교를 비교해서 NOT IN 함수는 비교값 리스트에 NULL이 없어야 함

NOT NULL로 제거, NOT EXISTS로 대체 등 방법 이용

풀이 1 : IN 사용

select N, case when P is null then 'Root'
            when N in (select distinct P from BST) then 'Inner'
            else 'Leaf' end
from BST
order by 1;

풀이 2 : NOT IN 사용

- 비교값 리스트에서 not null 조건 넣어서 NULL 제거해야 함

select N, case when P is null then 'Root'
            when N not in (select distinct P from BST where P is not null) then 'Leaf'
            else 'Inner' end
from BST
order by 1;

[코테 연습] Leetcode 코딩테스트 연습 Hard

HaeWon_Seo — Fri, 27 Jun 2025 15:32:14 +0900

Leetcode 코딩테스트 연습 MySQL Hard

✅ 계층형 질의

1) 계층형 데이터
- 동일한 table 내 행끼리 상위/하위 관계가 있는 경우
- 하나의 table에서 특정 행이 다른 행의 상위(부모) 또는 하위(자식) 역할을 하는 데이터 구조

- 계층형 데이터는 트리 구조로 설명 가능

root node : 최상위 부모 행
leaf node : 자식이 없는 최하위 행
depth : root node 로부터 특정 노드까지의 거리, root부터 1이며 leaf로 내려갈 때마다 1씩 증가

2) 계층형 질의 Hierarchical Query
- 계층형 데이터를 탐색하기 위한 SQL문
- 계층형 데이터를 특정 시작 지점부터 상위/하위 관계를 따라 depth를 탐색하며 쿼리 수행

SELECT 칼럼명
FROM 테이블명
START WITH 시작지점
CONNECT BY [ NOCYCLE ] PRIOR 연결조건

START WITH : 쿼리 처리가 시작되는 행을 지정
CONNECT BY : 행과 행을 연결해나가는 조건 지정
PRIOR : 상위(부모)-하위(자식) 관계의 방향 지정에 사용
NOCYCLE : 연결 과정에서 순환 구조가 생기는 것을 방지하여 무한 루프 방지

- 계층형 질의 가상 컬럼

LEVEL : 각 행의 depth를 리턴
CONNECT_BY_ISLEAF : leaf node이면 1, 아니면 0을 리턴

- 계층형 질의 가상 함수

CONNECT_BY_ROOT 컬럼명 : 현재 행의 출발 root를 찾아 root의 칼럼 리턴
SYS_CONNECT_BY_PATH(컬럼, 구분자) : root부터 현재 행까지 경로를 구분자로 연결해 출력
ORDER SIBLINGS BY 컬럼 : 같은 LEVEL의 행끼리 정렬 수행
CONNECT_BY_ISCYCLE : 계층형 쿼리에서 순환 구조 발생 여부 리턴

3) 계층형 쿼리 예문 (위의 3482번 문제 table 활용)

Employees table

① CONNECT BY PRIOR 자식칼럼 = 부모칼럼
- 현재 행의 자식 칼럼이, 어떤 행의 부모 칼럼이 되도록, 다음 행을 찾아 연결
- 즉 상위 노드 → 하위 노드 방향으로 순방향 전개

- `manager_id`가 NULL인 최상위 노드(LEVEL 1)부터 최하위 노드까지 아래로 탐색

SELECT LEVEL, employee_id, manager_id, employee_name
FROM employees
START WITH manager_id IS NULL
CONNECT BY PRIOR employee_id = manager_id;

쿼리 실행 결과

② CONNECT BY PRIOR 부모칼럼 = 자식칼럼
- 현재 행의 부모 칼럼이, 어떤 행의 자식 칼럼이 되도록, 다음 행을 찾아 연결
- 즉 하위 노드 → 상위 노드 방향으로 역방향 전개

- 자신이 `manager_id`인 하위 노드가 없는 최하위 노드 'Judy'부터 최상위 노드(LEVEL 1)까지 위로 탐색

SELECT LEVEL, employee_id, employee_name, manager_id
FROM employees
START WITH employee_name = 'Ivy'
CONNECT BY employee_id = PRIOR manager_id;

쿼리 실행 결과

③ 다양한 START WITH 조건

- START WITH 조건을 통해 root node를 다양하게 지정 가능

- `manager_id`가 2 또는 3인 노드부터 최상위 노드로 보고 탐색

SELECT LEVEL, employee_id, manager_id, employee_name
FROM employees
START WITH manager_id IN (2, 3)
CONNECT BY PRIOR employee_id = manager_id;

쿼리 실행 결과

④ 다양한 계층형 질의 가상 함수 활용

- CONNECT_BY_ROOT로 현재 행의 출발 root 찾기
- SYS_CONNECT_BY_PATH로 root부터 현재 행까지 경로 확인

SELECT LEVEL, employee_id, manager_id, employee_name,
    CONNECT_BY_ROOT employee_name AS root_name,
    SYS_CONNECT_BY_PATH(employee_name, ' -> ') AS path
FROM employees
START WITH manager_id IS NULL
CONNECT BY NOCYCLE PRIOR employee_id = manager_id;

쿼리 실행 결과

SELECT LEVEL, employee_id, manager_id, employee_name,
    CONNECT_BY_ROOT employee_name AS root_name,
    SYS_CONNECT_BY_PATH(employee_name, ' -> ') AS path
FROM employees
START WITH manager_id = 2
CONNECT BY PRIOR employee_id = manager_id;

쿼리 실행 결과

- ORDER SIBLINGS BY로 같은 LEVEL끼리는 employee_name 기준 정렬

SELECT LEVEL, employee_name, employee_id, manager_id
FROM employees
START WITH manager_id IS NULL
CONNECT BY NOCYCLE PRIOR employee_id = manager_id
ORDER SIBLINGS BY employee_name desc

쿼리 실행 결과

※ ORDER BY와 OVER SIBILINGS BY는 하나의 쿼리에서 같이 사용할 수 없음

ORDER BY를 추가적으로 사용하고 싶다면 계층형 쿼리 결과를 FROM 서브쿼리로 받아서 사용

SELECT *
FROM (
  SELECT LEVEL AS depth, employee_name, employee_id, manager_id
  FROM employees
  START WITH manager_id IS NULL
  CONNECT BY PRIOR employee_id = manager_id
  ORDER SIBLINGS BY employee_name
)
ORDER BY depth

쿼리 실행 결과

⑤ CONNECT BY절과 WHERE절 비교

CONNECT BY 절의 조건	WHERE 절의 조건
계층을 어떻게 연결하여 구성할 것인지 정의	계층형 쿼리 실행이 완료된 결과 table에 대한 필터링 조건
탐색 과정 중에 적용되는 조건	탐색 완료 후에 적용되는 조건
해당 조건을 만족하지 않으면 하위 노드를 연결하지 않음	이 조건이 만족하지 않으면 쿼리 출력 결과에서 제외
START WITH 절 행이 항상 출력됨	START WITH 절 행도 제외 대상에 포함 출력되지 않을 수 있음

- START WITH 절에서 지정한 'Alice'는 `department`가 'Sales'가 아니지만

CONNECT BY 조건에는 영향을 받지 않으므로 출력에는 포함됨

SELECT LEVEL, employee_id, manager_id, employee_name, department
FROM employees
START WITH manager_id IS NULL
CONNECT BY PRIOR employee_id = manager_id AND department = 'Sales'

쿼리 실행 결과

- START WITH 절에서 지정한 'Alice'는 `department`가 'Sales'가 아니여서 출력에서 제외

계층형 데이터 탐색 과정은 위와 동일하게 진행되므로 'Alice'가 여전히 LEVEL 1 노드

SELECT LEVEL, employee_id, manager_id, employee_name, department
FROM employees
WHERE department = 'Sales'
START WITH manager_id IS NULL
CONNECT BY PRIOR employee_id = manager_id

쿼리 실행 결과

3482. Analyze Organization Hierarchy

Hierarchy Levels: For each employee, determine their level in the organization (CEO is level 1, employees reporting directly to the CEO are level 2, and so on).
Team Size: For each employee who is a manager, count the total number of employees under them (direct and indirect reports).
Salary Budget: For each manager, calculate the total salary budget they control (sum of salaries of all employees under them, including indirect reports, plus their own salary).

① 모든 직원마다 한 번씩 root로 삼아 자신의 하위 조직 전체를 탐색

- CONNECT BY만 쓰고 START WITH를 생략하면

모든 행을 root 후보로 생각하고 가능한 모든 계층 경로를 탐색 → "Cartesian-style traversal"

- 계층형 쿼리를 작성하되 START WITH 절을 생략하기 + CONNECT_BY_ROOT로 root 노드 정보 추출

→ 가능한 모든 계층 탐색 경로 + 각 경로의 시작 root 정보를 저장한 테이블 생성

hierarchy AS (
  SELECT CONNECT_BY_ROOT employee_id AS root_id,
    employee_id, salary
  FROM employees
  CONNECT BY PRIOR employee_id = manager_id
)

hierarchy 테이블

② 각 직원별로 하위 직원 수 및 예산 계산

- hierarchy 테이블에서 root_id를 기준으로 총계 계산

team_stats AS (
  SELECT root_id AS employee_id,
    COUNT(*) - 1 AS team_size, SUM(salary) AS budget
  FROM hierarchy
  GROUP BY root_id
)

team_stats 테이블

③ 각 직원의 level 계산

- 계층형 질의, LEVEL 가상 칼럼 활용

levels AS (
  SELECT employee_id, LEVEL AS lvl
  FROM employees
  START WITH manager_id IS NULL
  CONNECT BY PRIOR employee_id = manager_id
)

levels 테이블

④ 최종 쿼리 작성

- WITH 구문을 통해 위의 3가지 테이블을 사전 정의

- 3가지 테이블을 기존 Employees 테이블을 기준으로 left join하여 최종 쿼리 정답 출력

- team_size와 budget이 NULL인 최하위 노드들에 대해서는

NVL (또는 COALESCE) 함수를 사용해 각각 0과 자신의 salary 값으로 대체

WITH hierarchy AS (
  SELECT CONNECT_BY_ROOT employee_id AS root_id,
    employee_id, salary
  FROM employees
  CONNECT BY PRIOR employee_id = manager_id
),

team_stats AS (
  SELECT root_id AS employee_id,
    COUNT(*) - 1 AS team_size, SUM(salary) AS budget
  FROM hierarchy
  GROUP BY root_id
),

levels AS (
  SELECT employee_id, LEVEL AS lvl
  FROM employees
  START WITH manager_id IS NULL
  CONNECT BY PRIOR employee_id = manager_id
)


SELECT e.employee_id, e.employee_name, l.lvl as "level",
    NVL(ts.team_size, 0) AS team_size,
    NVL(ts.budget, e.salary) AS budget
FROM employees e
    LEFT JOIN team_stats ts ON e.employee_id = ts.employee_id
    LEFT JOIN levels l ON e.employee_id = l.employee_id
ORDER BY 3, 5 DESC, 2

최종 출력 테이블

Reference

https://blog.naver.com/ilifo_book/223460894842
https://infjin.tistory.com/147

https://mjn5027.tistory.com/55

[코테 연습] Leetcode 코딩테스트 연습 MySQL Med. ~ Hard

HaeWon_Seo — Mon, 9 Jun 2025 11:35:49 +0900

Leetcode 코딩테스트 연습 MySQL Med. ~ Hard

3564. Seasonal Sales Analysis

: Find the most popular product category for each season. The popularity of a category is determined by the total quantity sold in that season. If there is a tie, select the category with the highest total revenue (quantity × price).

풀이 : WITH 구문 사용

- WITH로 여러 임시 쿼리를 생성할 땐 ' , '로 연결

- 앞서 생성한 CTE를 뒤에 생성한 CTE에서 호출 가능

반대는 불가능하므로 CTE 의존 관계 기준으로 위→아래로 나열해야 함

- 날짜를 계절로 변환 → 계절 + 카테고리별 총계 계산 → 계절별 최대값 확인

with season as (
    select sale_id, product_id, category, quantity, price,
        case when to_char(sale_date, 'MM') between 3 and 5 then 'Spring'
             when to_char(sale_date, 'MM') between 6 and 8 then 'Summer'
             when to_char(sale_date, 'MM') between 9 and 11 then 'Fall'
             else 'Winter' end as season
    from sales join products using(product_id)
), total as (
    select distinct season, category, sum(quantity) as total_quantity, sum(quantity * price) as total_revenue
    from season
    group by season, category
), ranking as (
    select season, category, total_quantity, total_revenue,
        rank() over (partition by season order by total_quantity desc, total_revenue desc) as rnk
    from total
)

select season, category, total_quantity, total_revenue
from ranking 
where rnk = 1

3521. Find Product Recommendation Pairs

: Amazon wants to implement the Customers who bought this also bought... feature based on co-purchase patterns. Identify distinct product pairs frequently purchased together by the same customers (where product1_id < product2_id). For each product pair, determine how many customers purchased both products. A product pair is considered for recommendation if at least 3 different customers have purchased both products.

풀이 : WITH 구문 사용

- frequent pairs만 추출한 CTE 먼저 생성 → product 정보 join

with pairs as(
    select p1.product_id as product1_id, p2.product_id as product2_id, count(distinct p1.user_id) as customer_count
    from ProductPurchases p1 join ProductPurchases p2
    on p1.user_id = p2.user_id and p1.product_id < p2.product_id
    group by p1.product_id, p2.product_id
    having count(distinct p1.user_id) >= 3
)

select product1_id, product2_id, p1.category as product1_category, p2.category as product2_category, customer_count
from pairs p left join ProductInfo p1 on p.product1_id = p1.product_id
    left join ProductInfo p2 on p.product2_id = p2.product_id
order by 5 desc, 1, 2

3554. Find Category Recommendation Pairs

: Amazon wants to understand shopping patterns across product categories. Write a solution to find all category pairs (where category1 < category2). For each category pair, determine the number of unique customers who purchased products from both categories. A category pair is considered reportable if at least 3 different customers have purchased products from both categories.

풀이

- 앞선 문제와 달리 id가 아닌 category를 기준으로 그룹화

- LEAST( ) 함수 : 여러 인자 중에서 가장 작은 값을 반환
GREATEST( ) 함수 : 여러 인자 중에서 가장 큰 값을 반환
하나라도 NULL이 들어가면 결과는 NULL이 됨을 주의해야 함

LEAST(value1, value2, ..., valueN)
GREATEST(value1, value2, ..., valueN)

with pairs as(
    select p1.product_id as product1_id, p2.product_id as product2_id, p1.user_id
    from ProductPurchases p1 join ProductPurchases p2
    on p1.user_id = p2.user_id and p1.product_id < p2.product_id
)

select least(p1.category, p2.category) as category1,
        greatest(p1.category, p2.category) as category2, count(distinct p.user_id) as customer_count
from pairs p join ProductInfo p1 on p.product1_id = p1.product_id
    join ProductInfo p2 on p.product2_id = p2.product_id and p1.category != p2.category
group by least(p1.category, p2.category), greatest(p1.category, p2.category)
having count(distinct p.user_id) >= 3
order by 3 desc, 1, 2

262. Trips and Users

: Find the cancellation rate of requests with unbanned users (both client and driver must not be banned) each day between "2013-10-01" and "2013-10-03" with at least one completed trip. Round Cancellation Rate to two decimal points.

풀이

- 집계함수 안에 case when ~ then ~ else ~ end 구문 바로 사용해서 계산하기

- JOIN 시 ON절에 바로 AND로 필터링 조건 연결

- 칼럼 별칭 지정 시 띄어쓰기를 포함하려면, 이름을 큰 따옴표 " "로 지정해야 함

with tmp as (
    select t.*
    from Trips t join Users u1 on t.client_id = u1.users_id and u1.banned = 'No'
                join Users u2 on t.driver_id = u2.users_id and u2.banned = 'No'
    where request_at between '2013-10-01' and '2013-10-03'
)


# avg 사용
select request_at as Day,
    round(avg(case when status != 'completed' then 1 else 0 end), 2) as "Cancellation Rate"
from tmp
group by request_at

# sum + count 사용
select request_at as Day,
    round(sum(case when status != 'completed' then 1 else 0 end) / count(*), 2) as "Cancellation Rate"
from tmp
group by request_at

3451. Find Invalid IP Addresses

: Find invalid IP addresses. An IPv4 address is invalid if it meets any of these conditions : Contains numbers greater than 255 in any octet, Has leading zeros in any octet (like 01.02.03.04), Has less or more than 4 octets

풀이 > 문자열 정규 표현식 활용

# 대상 문자열에서 찾을 문자열을 찾아서 반환
# n번째 위치부터 검색해서 m번재로 매칭되는 문자열 반환
regexp_substr(대상, 찾을문자열, n, m)

# 대상 문자열에서 찾을 문자열이 나온 횟수 반환
regexp_count(대상, 찾을문자열)

# 대상 문자열이 찾을 문자열을 포함하고 있는지 여부 반환
regexp_like(대상, 찾을문자열)

with parts as (
    select ip, regexp_substr(ip, '[^\.]+', 1, 1) as part from logs
    union all
    select ip, regexp_substr(ip, '[^\.]+', 1, 2) as part from logs
    union all
    select ip, regexp_substr(ip, '[^\.]+', 1, 3) as part from logs
    union all
    select ip, regexp_substr(ip, '[^\.]+', 1, 4) as part from logs
)

select ip, count(distinct log_id) as invalid_count
from parts join logs using(ip)
where regexp_count(ip, '\.') != 3 or regexp_like(ip, '(^|\.)(0[0-9]+)') or to_number(part) > 255
group by ip
order by 2 desc, 1 desc

601. Human Traffic of Stadium

: Display the records with three or more rows with consecutive id's, and the number of people is greater than or equal to 100 for each.

풀이 1 : WINDOW 함수 사용

LAG(num, k) OVER (ORDER BY id)
LEAD(num, k) OVER (ORDER BY id)

- 현재 행을 기준으로 k행 이전 / 이후의 num 값을 가져옴

- 연속되는 숫자의 처음 or 마지막 or 중간인 경우로 WHERE절 조건

select id, to_char(visit_date, 'YYYY-MM-DD') as visit_date, people
from (select id, visit_date, people,
            lag(id, 1) over (order by id) as pre1,
            lag(id, 2) over (order by id) as pre2,
            lead(id, 1) over (order by id) as post1,
            lead(id, 2) over (order by id) as post2
    from Stadium where people >= 100) s
where (pre1 = id-1 and pre2 = id-2) or (post1 = id+1 and post2 = id+2)
        or (pre1 = id-1 and post1 = id+1)
order by 2

풀이 2

- 연속된 id는 row_number()와의 차가 일정하게 유지됨을 활용

- `id - row_number() = ind`가 같은 값이면 연속된 그룹

같은 ind 그룹 내 record가 3개 이상인 것만 필터링하면 됨

with tmp as (
    select id, visit_date, people,
            id - row_number() over (order by id) as ind
    from Stadium
    where people >= 100
)

select id, to_char(visit_date, 'YYYY-MM-DD') as visit_date, people
from tmp
where ind in (select ind from tmp
                group by ind
                having count(distinct id) >= 3)
order by 2

[코테 연습] Leetcode 코딩테스트 연습 MySQL Med.

HaeWon_Seo — Mon, 2 Jun 2025 12:58:30 +0900

Leetcode 코딩테스트 연습 MySQL Med.

1341. Movie Rating

: Find the name of the user who has rated the greatest number of movies. In case of a tie, return the lexicographically smaller user name. Find the movie name with the highest average rating in February 2020. In case of a tie, return the lexicographically smaller movie name.

풀이 : ROWNUM

- where절에서 rownum을 사용하기 위해 서브쿼리로 묶기

- 절대적인 행 번호가 아닌 가상의 번호이므로 '<' 연산만 가능

(select name as results
from (select name, count(*) as rated_num
    from Users u join MovieRating r using(user_id)
    group by user_id, name
    order by 2 desc, 1)
where rownum < 2)
union all
(select title as results
from (select title, avg(rating) as agv_rating
    from Movies m join MovieRating r using(movie_id)
    where to_char(created_at, 'YYYY-MM')= '2020-02'
    group by movie_id, title
    order by 2 desc, 1)
where rownum < 2)

176. Second Highest Salary

: Find the second highest distinct salary from the Employee table. If there is no second highest salary, return null (return None in Pandas).

풀이 1

- WINDOW 함수 이용 : DENSE_RANK에서 2등인 salary 추출

- 이때 where rank=2를 만족하는 record가 없으면 빈 테이블이 출력되므로
NULL 값이 나오게 하기 위해서는 집계함수를 사용하는 전략 이용

# 집계함수를 사용함으로써 빈 테이블일 경우 NULL로 출력
select max(salary) as SecondHighestSalary
from (select salary, dense_rank() over (order by salary desc) as rank
    from Employee) e
where rank = 2

# 집계함수를 쓰지 않으면 빈 테이블이 출력
select *
from (select salary, dense_rank() over (order by salary desc) as rank
    from Employee) e
where rank = 2

풀이 2

- 2등 = max보다 작은 것 record들 중 max값

select max(salary) as SecondHighestSalary
from Employee
where salary < (select max(salary) from Employee)

풀이 3

- ALL/ANY 연산자 + 다중행 서브쿼리 사용

- 2등 = 자신보다 큰 값이 적어도 하나 존재하는 record들 중 max값

select max(salary) as SecondHighestSalary
from Employee
where salary < any(select salary from Employee)

1070. Product Sales Analysis III

: Find all sales that occurred in the first year each product was sold. For each product_id, identify the earliest year it appears in the Sales table. Return all sales entries for that product in that year.

풀이 1

- IN, NOT IN 연산자 + 다중컬럼 서브쿼리 사용

select product_id, year as first_year, quantity, price
from Sales
where (product_id, year) in (select product_id, min(year)
                            from Sales group by product_id)

풀이 2

- EXISTS, NOT EXISTS 연산자 + 연관 서브쿼리 사용

- 더 작은 year 값을 가지는 record가 없는 경우 = 가장 작은 year인 경우, not exists 조건 만족하도록

select product_id, year as first_year, quantity, price
from Sales s1
where not exists (select 1
                from Sales s2
                where s1.product_id = s2.product_id and s1.year > s2.year)

풀이 3

- ALL/ANY 연산자 + 다중행 서브쿼리 사용

- 모든 같은 product_id에 속하는 record의 year보다 작은 경우, ALL 조건 만족하도록

select product_id, year as first_year, quantity, price
from Sales s1
where s1.year <= all (select s2.year
                from Sales s2
                where s1.product_id = s2.product_id)

풀이 4

- 조건을 만족하는 value만 가지고 있는 table과 inner join

- ON절에 AND를 바로 연결해서 JOIN 과정에서 불필요한 record 제거

select s1.product_id, s1.year as first_year, s1.quantity, s1.price
from Sales s1 join (select product_id, min(year) as year
                    from Sales
                    group by product_id) s2 on s1.product_id = s2.product_id and s1.year = s2.year

✅ WITH문
- 쿼리의 결과에 이름 붙여 저장한 후 이후 쿼리에서 재사용하도록 만든 임시 쿼리(CTE)
- 복잡한 서브쿼리를 여러 번 재사용하거나 쿼리 가독성을 높이기 위해 사용

- View와 달리 DB에 영구적으로 저장되지 않고 일시적으로 정의
해당 쿼리가 실행될 때에만 일시적으로 존재하며, 쿼리 내에서만 유효하게 사용 가능

- CTE(Common Table Expression) : WITH문에서 사용하는 재사용 가능한 이름 있는 서브쿼리

WITH 임시쿼리이름 AS (
    SELECT ..
    FROM ...
    WHERE ...
)

# 여러 임시 쿼리를 생성하는 경우 ,로 연결
WITH 임시쿼리이름1 AS (
    SELECT ..
    FROM ...
    WHERE ...
), 임시쿼리이름2 AS (
    SELECT ..
    FROM ...
    WHERE ...
), ....

550. Game Play Analysis IV

: Write a solution to report the fraction of players that logged in again on the day after the day they first logged in, rounded to 2 decimal places. In other words, you need to count the number of players that logged in for at least two consecutive days starting from their first login date, then divide that number by the total number of players.

풀이 1

- 조건을 만족하는 value만 가지고 있는 table과 inner join

a 테이블에다가 연속해서 접근한 경우일때만 f 테이블 record를 join

a = 모든 player_id가 존재, f = 연속해서 접근한 player_id만 존재

- ON절에 AND를 바로 연결해서 JOIN 과정에서 불필요한 record 제거

select round(count(distinct f.player_id) / count(distinct a.player_id), 2) as fraction
from Activity a left join
        (select player_id, min(event_date) as first_date
        from Activity group by player_id) f
    on a.player_id = f.player_id and a.event_date = f.first_date + 1

풀이 2

- WITH문을 사용해 from절에 사용할 서브쿼리 f를 사전에 정의

with f as (select player_id, min(event_date) as first_date
        from Activity
        group by player_id)

select round(count(distinct f.player_id) / count(distinct a.player_id), 2) as fraction
from Activity a left join f
    on a.player_id = f.player_id and a.event_date = f.first_date + 1

3421. Find Students Who Improved

: Find the students who have shown improvement. A student is considered to have shown improvement if they meet both of these conditions : Have taken exams in the same subject on at least two different dates. Their latest score in that subject is higher than their first score. Return the result table ordered by student_id, subject in ascending order.

풀이 : FIRST_VALUE, LAST_VALUE

- 정렬 순서대로 정해진 범위에서의 처음 값, 마지막 값 출력

- 이때 범위의 default가 처음 ~ 현재행

exam_date를 기준으로 오름차순 정렬했기 때문에 first_value는 범위를 그대로 사용해도 되지만

last_value는 범위를 지정하지 않을 경우 최대 score값을 가지는 행이 아니라, 항상 현재행이 출력됨

→ last_value의 범위를 처음(UNBOUNDED PRECEDING) ~ 끝(UNBOUNDED FOLLOWING)으로 변경

→ first_value + 내림차순 정렬 조건으로 바꾸기

## from절에 들어갈 서브쿼리가 김 → WITH문 사용
# last_value의 범위를 변경
with tmp as (
    select distinct student_id, subject,
            first_value(score) over (partition by student_id, subject order by exam_date) as first_score, 
            last_value(score) over (partition by student_id, subject order by exam_date
                rows between unbounded preceding and unbounded following) as latest_score,
            count(*) over (partition by student_id, subject) as tries
    from Scores
)

# first_value 사용하고 정렬 순서를 바꾸기
with tmp as (
    select distinct student_id, subject,
            first_value(score) over (partition by student_id, subject order by exam_date) as first_score, 
            first_value(score) over (partition by student_id, subject order by exam_date desc) as latest_score,
            count(*) over (partition by student_id, subject) as tries
    from Scores
)


select student_id, subject, first_score, latest_score
from tmp
where tries >= 2 and first_score < latest_score
order by student_id, subject

[코테 연습] Leetcode 코딩테스트 연습 MySQL Med.

HaeWon_Seo — Mon, 26 May 2025 12:51:48 +0900

Leetcode 코딩테스트 연습 MySQL Med.

1158. Market Analysis I

: Write a solution to find for each user, the join date and the number of orders they made as a buyer in 2019.

> 존재하지 않는 경우도 결과에 포함하여 출력하는 문제

풀이

- 포함되어야 하는 모든 value를 가지고 있는 Users table을 기준으로 outer join

- ON절에 AND를 바로 연결해서 JOIN 과정에서 불필요한 record 제거

select u.user_id as buyer_id, to_char(u.join_date, 'YYYY-MM-DD') as join_date, count(o.order_date) as orders_in_2019
from Users u left outer join Orders o on u.user_id = o.buyer_id
    and o.order_date between '2019-01-01' and '2019-12-31'
group by u.user_id, u.join_date

select u.user_id as buyer_id, to_char(u.join_date, 'YYYY-MM-DD') as join_date, count(o.order_date) as orders_in_2019
from Users u left outer join Orders o on u.user_id = o.buyer_id
    and to_char(o.order_date, 'YYYY') = 2019
group by u.user_id, u.join_date

1321. Restaurant Growth

: Compute the moving average of how much the customer paid in a seven days window (i.e., current day + 6 days before). average_amount should be rounded to two decimal places.

풀이 : WINDOW 함수 연산 범위 지정

ROWS|RANGE BETWEEN A AND B

A : 시작점 정의
- CURRENT ROW : 현재 행부
- UNBOUNDED PRECEDING : 처음부터(DEFAULT)
- N PRECEDING : N 이전부터
B : 마지막 지점 정의
- CURRENT ROW : 현재 범위까지(DEFAULT)
- UNBOUNDED FOLLOWING : 마지막까지
- N FOLLOWING : N 이후까지
지정 범위가 테이블을 넘어가는 경우 존재하는 행들까지의 record만 계산에 사용

- visited_on을 기준으로 내림차순 정렬 후

WINDOW 함수로 '현재 행의 6개 이전 ~ 현재 행'까지 집계함수 계산

- '현재 행의 6개 이전 ~ 현재 행'으로 할 경우 visited_on 값이 중복되지 않지만

'현재 행 ~ 현재 행의 6개 이후'로 할 경우 visited_on의 최댓값이 여러번 출력되기 때문에
WHERE절로 원하는 행만 추출할 수 없게 되어 주의

select *
from (
    select to_char(visited_on, 'YYYY-MM-DD') as visited_on,
        sum(amount) over (order by visited_on ROWS BETWEEN 6 preceding AND CURRENT ROW) as amount,
        round(avg(amount) over (order by visited_on ROWS BETWEEN 6 preceding AND CURRENT ROW), 2) as average_amount
    from (select visited_on, sum(amount) as amount
        from Customer
        group by visited_on
        order by visited_on) C
    ) c
WHERE visited_on >= (select min(visited_on) + 6 FROM Customer)

180. Consecutive Numbers

: Find all numbers that appear at least three times consecutively.

풀이 1 : WINDOW 함수 사용

LAG(num, k) OVER (ORDER BY id)
LEAD(num, k) OVER (ORDER BY id)

- 현재 행을 기준으로 k행 이전 / 이후의 num 값을 가져옴

- LAG, LEAD의 경우 행이 존재하지 않으면 null 리턴

select distinct num as ConsecutiveNums
from (select num,
        lag(num, 1) over(order by id) as post1, 
        lag(num, 2) over(order by id) as post2
    from Logs) l
where num = post1 and num = post2

풀이 2

- JOIN에서 ON절에 바로 이어서 AND 연결해 조건 추가하기

select distinct l1.num as ConsecutiveNums
from Logs l1 join Logs l2 on l1.num = l2.num and l1.id = l2.id-1
    join Logs l3 on l1.num = l3.num and l1.id = l3.id-2

184. Department Highest Salary

: Write a solution to find employees who have the highest salary in each of the departments.

풀이 1

- IN, NOT IN 연산자 + 다중컬럼 서브쿼리 사용

select d.name as Department, e.name as Employee, e.salary as Salary
from Employee e join Department d on e.departmentId = d.id
where (salary, departmentId) in (select max(salary), departmentId
    from Employee group by departmentId)

풀이 2

- EXISTS, NOT EXISTS 연산자 + 연관 서브쿼리 사용

- 더 큰 salary 값을 가지는 record가 없는 경우 = 가장 큰 salary인 경우, not exists 조건 만족하도록

select d.name as Department, e.name as Employee, e.salary as Salary
from Employee e join Department d on e.departmentId = d.id
where not exists (select 1
    from Employee e2 where e2.departmentId = e.departmentId
    and e2.salary > e.salary)

풀이 3

- ALL/ANY 연산자 + 다중행 서브쿼리 사용

- 모든 같은 departmentId에 속하는 record의 salary보다 큰 경우, ALL 조건 만족하도록

select d.name as Department, e.name as Employee, e.salary as Salary
from Employee e join Department d on e.departmentId = d.id
where salary >= all (select salary
    from Employee e2 where e2.departmentId = e.departmentId)

585. Investments in 2016

: report the sum of all total investment values in 2016 tiv_2016, for all policyholders who have the same tiv_2015 value as one or more other policyholders, and are not located in the same city as any other policyholder.

풀이 1

- IN, NOT IN 연산자 + 서브쿼리 사용

- GROUP BY + HAVING 절로 필터링

(lat, lon)는 여러개 있으면 안되고, tiv_2015는 여러개 있도록

select round(sum(tiv_2016), 2) as tiv_2016
from Insurance
where (lat, lon) not in (select lat, lon from Insurance
                        group by lat, lon
                        having count(pid) > 1)
    and tiv_2015 in (select tiv_2015 from Insurance
                    group by tiv_2015
                    having count(pid) > 1)

풀이 2

- EXISTS, NOT EXISTS 연산자 + 연관 서브쿼리 사용

- 서브쿼리에서 a.pid != b.pid, a.pid != c.pid 조건 필수

(lat, lon)값이 같은 다른 record는 없고, tiv_2015 값이 같은 다른 record는 존재하도록

select round(sum(tiv_2016), 2) as tiv_2016
from Insurance a
where not exists (select 1 from Insurance b
                where a.pid != b.pid and a.lat = b.lat and a.lon = b.lon)
    and exists (select 1 from Insurance c
                where a.pid != c.pid and a.tiv_2015 = c.tiv_2015)

풀이 3

- 인라인뷰 서브쿼리 사용

- 필터링에 사용할 값들을 먼저 계산한 집계 테이블 → WHERE절로 필터링

select round(sum(tiv_2016), 2) as tiv_2016
from (select tiv_2016,
            count(pid) over (partition by lat, lon) as same_place,
            count(pid) over (partition by tiv_2015) as same_2015
        from Insurance) i
where same_place = 1 and same_2015 > 1

[코테 연습] Leetcode 코딩테스트 연습 MySQL Med.

HaeWon_Seo — Mon, 19 May 2025 10:28:31 +0900

Leetcode 코딩테스트 연습 MySQL Med.

1934. Confirmation Rate

: The confirmation rate of a user is the number of 'confirmed' messages divided by the total number of requested confirmation messages. The confirmation rate of a user that did not request any confirmation messages is 0.

> 존재하지 않는 경우도 결과에 포함하여 출력하는 문제

풀이 1

- 서브 쿼리로 원하는 정보를 가진 table 생성한 후

포함되어야 하는 모든 value를 가지고 있는 table과 outer join

select user_id, coalesce(round(avg(confirmation), 2), 0) as confirmation_rate
from (select user_id,
            case when c.action = 'confirmed' then 1
                else 0 end as confirmation from Confirmations c) C
    right outer join Signups S using(user_id)
group by user_id

풀이 2

- 원하는 정보를 가진 table + 부족한 정보용 table 각각 생성한 후 table union

(select user_id, round(avg(confirmation), 2) as confirmation_rate
    from (select user_id,
                case when c.action = 'confirmed' then 1
                    else 0 end as confirmation from Confirmations c) C
    group by user_id)
union
(select user_id, 0 as confirmation_rate
    from Signups where user_id not in (select user_id from Confirmations))

1907. Count Salary Categories

: Write a solution to calculate the number of bank accounts for each salary category. The result table must contain all three categories. If there are no accounts in a category, return 0.

> 존재하지 않는 경우도 결과에 포함하여 출력하는 문제

풀이 1

- 포함되어야 하는 모든 value를 가지고 있는 dummy table을 직접 생성

- dummy table과의 outer join을 통해 포함되어야 하는 모든 value를 출력

- Oracle의 경우 from절 생략이 안됨, dummy table 생성 시 from dual 이용

select d.category, coalesce(a.accounts_count, 0) as accounts_count
from (select 'Low Salary' as category from dual
    	union
    	select 'Average Salary' as category from dual
    	union
    	select 'High Salary' as category from dual) d left outer join
    (select category, count(*) as accounts_count
    from (select (case
                    when income < 20000 then 'Low Salary'
                    when income <= 50000 then 'Average Salary'
                    else 'High Salary'
                    end) as category
        from Accounts) A
    	group by category) a on d.category = a.category

풀이 2

- 원하는 정보를 가진 table = 각각의 value별로 table 생성 후 table union

- where절을 이용해 각각의 group별로 필터링, count(*)를 이용해 NULL인 경우 0으로 계산되도록

select 'Low Salary' as category, count(account_id) as accounts_count
	from accounts where income <20000
union 
select 'Average Salary' as category, count(account_id) as accounts_count
	from accounts where income between 20000 and 50000
union
select 'High Salary' as category, count(account_id) as accounts_count
	from accounts where income > 50000;

602. Friend Requests II: Who Has the Most Friends

: Write a solution to find the people who have the most friends and the most friends number.

> Oracle에서 출력 행 수 제한

풀이 : ROWNUM

- where절에서 rownum을 사용하기 위해 서브쿼리로 묶기

- 절대적인 행 번호가 아닌 가상의 번호이므로 '<' 연산만 가능, '='나 '>' 조건 전달 불가능

select * from (
    select id, count(*) as num
    from
        (select requester_id as id
        from RequestAccepted
        union all
        select accepter_id as id
        from RequestAccepted) A
    group by id
    order by num desc
    )
where rownum < 2

1164. Product Price at a Given Date

: Write a solution to find the prices of all products on 2019-08-16. Assume the price of all products before any change is 10.

> Oracle에서 출력 행 수 제한

ROWNUM을 사용하면

- where절에서 rownum을 사용하기 위해 서브쿼리로 묶기

- '<' 연산으로 하나만 남도록, n개만 남도록도 조절 가능

SELECT *
FROM (SELECT product_id
           ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY change_date DESC) AS rn
    FROM Products)
WHERE rn < 2

FIRST_VALUE를 사용하면

- 서브쿼리로 1번 더 감쌀 필요 없이 바로 한 행만 출력 가능

- 모든 같은 partition 그룹끼리 같은 price값을 가지게 됨 → distinct로 하나만 남도록

- n개만 남도록 조절하는 건 어려움

SELECT distinct product_id
       FIRST_VALUE(new_price) OVER (PARTITION BY product_id ORDER BY change_date DESC) AS price
FROM Products;

> 존재하지 않는 경우도 결과에 포함하여 출력하는 문제

풀이 1

- 서브 쿼리로 원하는 정보를 가진 table 생성한 후

포함되어야 하는 모든 value를 가지고 있는 table과 outer join

select product_id, coalesce(price, 10) as price
from (select distinct product_id,
        first_value(new_price) over(partition by product_id order by change_date desc) as price
        from Products
        where change_date <= '2019-08-16') a right outer join 
    (select distinct product_id from Products) b using(product_id)

풀이 2

- 원하는 정보를 가진 table + 부족한 정보용 table 각각 생성한 후 table union

(select distinct product_id,
        first_value(new_price) over(partition by product_id order by change_date desc) as price
    from Products
    where change_date <= '2019-08-16')
union
(select product_id, 10 as price
    from Products
    where product_id not in (select product_id from Products
                             where change_date <= '2019-08-16'))

[코테 연습] Leetcode 코딩테스트 연습 MySQL Med.

HaeWon_Seo — Mon, 12 May 2025 16:11:45 +0900

Leetcode 코딩테스트 연습 MySQL Med.

3497. Analyze Subscription Conversion

: A subscription service wants to analyze user behavior patterns. The company offers a 7-day free trial, after which users can subscribe to a paid plan or cancel. Find users who converted from free trial to paid subscription. Calculate each user's average daily activity duration during their free trial period. Calculate each user's average daily activity duration during their paid subscription period. Return the result table ordered by user_id in ascending order.

풀이 1 : CASE WHEN ELSE END 구문

- 조건에 맞지 않은 행 먼저 필터링 후 집계함수 적용

- 집계함수는 자동으로 null 제거하고 계산함을 이용

이때 null이 아닌 0으로 하면 평균 계산에서 분모가 전체 데이터 수가 되므로 옳지 않음

select user_id,
    round(avg(case when activity_type = 'free_trial' then activity_duration else null end),2) as trial_avg_duration,
    round(avg(case when activity_type = 'paid' then activity_duration else null end),2) as paid_avg_duration
from UserActivity
where user_id in (select user_id from UserActivity
                    where activity_type = 'paid')
group by user_id
order by user_id

풀이 2 : DECODE

- 위와 동일하게 조건에 맞지 않은 행 먼저 필터링 후 집계함수 적용

- decode(대상, 값1, 리턴1, 값2, 리턴2, ..., 그외 리턴): 대상이 값n과 일치하면 리턴n, 없으면 그외 리턴 출력

- `case when 대상 = 값 then 리턴 else 그외 리턴`

이 구조는 `decode(대상, 값, 리턴, 그외 리턴)`과 같은 동작

select user_id,
    round(avg(decode(activity_type, 'free_trial', activity_duration , null)),2) as trial_avg_duration,
    round(avg(decode(activity_type, 'paid', activity_duration, null)),2) as paid_avg_duration
from UserActivity
where user_id in (select user_id from UserActivity
                    where activity_type = 'paid')
group by user_id
order by user_id

풀이 2

- 집계함수 적용 후 조건에 맞지 않아 null로 출력되는 행을 제거

select * from
    (select user_id, 
    round(avg(case activity_type when 'free_trial' then 1.0*activity_duration else null end), 2) as trial_avg_duration,
    round(avg(case activity_type when 'paid' then 1.0*activity_duration else null end), 2) as paid_avg_duration
    from UserActivity 
    group by user_id) T
where paid_avg_duration is not null

3220. Odd and Even Transactions

: Write a solution to find the sum of amounts for odd and even transactions for each day. If there are no odd or even transactions for a specific date, display as 0. Return the result table ordered by transaction_date in ascending order.

풀이 1 : CASE WHEN ELSE END 구문

select to_char(transaction_date, 'YYYY-MM-DD') as transaction_date,
    sum(case when mod(amount, 2) = 1 then amount else 0 end) as odd_sum,
    sum(case when mod(amount, 2) = 0 then amount else 0 end) as even_sum
from transactions
group by transaction_date
order by transaction_date

풀이 2 : DECODE

select to_char(transaction_date, 'YYYY-MM-DD') as transaction_date,
    sum(decode(mod(amount, 2), 1, amount, 0)) as odd_sum,
    sum(decode(mod(amount, 2), 0, amount, 0)) as even_sum
from transactions
group by transaction_date
order by transaction_date

626. Exchange Seats

: Write a solution to swap the seat id of every two consecutive students. If the number of students is odd, the id of the last student is not swapped.

풀이

SELECT LAG(col) OVER (ORDER BY col2)

ORDER BY절에서 col2를 기준으로 정렬한 후
LAG : 이전 행의 col1 값 가져오기
LEAD : 이후 행의 col1 값 가져오기

- coalesce(대상1, 대상2, ...) : 처음으로 null이 아닌 값 리턴

- NVL(대상, 치환값) : 대상이 null이면 치환값 리턴

# coalesce 사용
select id, 
    case when mod(id, 2) = 0 then lag(student) over (order by id) 
         else coalesce(lead(student) over (order by id), student) end as student
from Seat
order by id


# nvl 사용
select id, nvl(case when mod(id, 2) = 0 then lag(student) over (order by id)
                ELSE lead(student) over (order by id) END, 
                student
                ) as student
from Seat
order by id

select id, nullif(case when mod(id, 2) = 0 then lag(student) over (order by id)
                ELSE lead(student) over (order by id) END, 
                student
                ) as student
from Seat
order by id

1204. Last Person to Fit in the Bus

: There is a queue of people waiting to board a bus. However, the bus has a weight limit of 1000 kilograms, so there may be some people who cannot board. Write a solution to find the person_name of the last person that can fit on the bus without exceeding the weight limit.

풀이

SUM(col1) OVER (ORDER BY col2)

ORDER BY절에서 col2를 기준으로 정렬한 후
위쪽부터 차례대로 col1의 누적합 계산

ROWNUM : Oracle에서 출력 행 수 제한

- 현재 출력된 데이터 상태를 기준으로 행 번호 부여

- 절대적인 행 번호가 아닌 가상의 번호이므로 특정 행을 지정할 수 없음

'<' 연산만 가능, '='나 '>' 조건 전달 불가능

select person_name
from (select person_name, turn, sum(weight) over(order by turn) as cul_weight
    from Queue
    order by turn desc) Q
where cul_weight <= 1000 and rownum < 2

1045. Customers Who Bought All Products

: Write a solution to report the customer ids from the Customer table that bought all the products in the Product table.

풀이 1

- HAVING절 안에 SELECT 서브쿼리 사용하기

select customer_id
from Customer
group by customer_id
having count(distinct product_key) = (select count(distinct product_key) from Product)

풀이 2

- NOT EXISTS 사용

- (전체 product_id - 특정 고객이 구매한 product_id) 이 결과가 NOT EXISTS이면

특정 고객이 전체 product_id를 다 구매한 것이므로

select distinct customer_id
from Customer C1
where not exists(
    select count(distinct product_key) from Product
    minus
    select count(distinct product_key) from Customer C2 where C2.customer_id = C1.customer_id
)

풀이 3

- NOT EXISTS 사용

- product_id NOT IN (특정 고객이 구매한 product_id)를 만족하는 product_id가 NOT EXISTS이면

특정 고객이 전체 product_id를 다 구매한 것이므로

select distinct customer_id
from Customer C1
where not exists(
    select 1 from Product
    where product_key not in (select distinct product_key
                             from Customer C2 where C2.customer_id = C1.customer_id)
)

[SQL 개념 정리] Database / Phase of DB design / ER model / Relational Model / SQL

HaeWon_Seo — Mon, 5 May 2025 17:11:17 +0900

SQL 구문 연습과 함께 데이터베이스와 관련된 개념적인 부분에 대해 공부해본다.

1. Database
2. Phase of DB design

3. Entity-Relationship Model (ER model)

4. Relational Model

5. SQL

1. Database

1) 등장 배경

- Big Data와 Web Scale Computing의 등장으로 대용량 데이터를 효율적으로 관리해야할 필요성이 강화
- 초기 데이터 저장 방식은 File System, 많은 문제점이 존재

redundancy : 같은 데이터가 여러 파일에 중복 저장
integrity : integrity가 보장되지 않아 무결성 문제에 취약
consistency : atomic update가 불가능
concurrent access : 다수 사용자의 동시다발적 접근을 잘 처리하지 못함
데이터 구조가 프로그램과 밀접하게 연결되어 영향을 받음
데이터 검색 및 수정이 불편함

2) DB의 특징

minimized redundancy : 동일한 데이터를 여러 위치에 중복 저장되는 것을 최소화
integrity : schema에 integrity constraint를 적용해 데이터의 정확성과 신뢰성을 유지
consistency : atomicity(원자성)을 만족하며 data consistency 보장
concurrent access : 다수 사용자의 동시다발적 접근에도 일관성과 정확성 유지
independence : DB를 사용하는 프로그램이나 application과 독립적으로 존재
권환 부여, 사용자 인증 등을 통해 security 보장
직관적이고 이해하기 쉬운 데이터 저장 방식
Big data를 저장 및 처리하기에 용이함

3) 용어 정리

출차 : https://www.learncomputerscienceonline.com/how-to-design-database/

data	객체, 이벤트, 현상 등에 대하여, 기록할 만한 가치가 있는 정보
Database DB	여러 사용자가 공유하고 사용할 목적으로 체계적으로 저장해 둔 데이터 모음 persistent data의 통합된 모음
DB management system (DBMS)	DB를 효율적으로 사용할 수 있도록 해주는 소프트웨어 data를 저장, 처리, 관리하는 프로그램들의 모음 data에 공동으로 사용되는 작업을 모으고 abstraction만 제공 MySQL, Oracle, PostgreSQL 등의 SQL Server
DB administrator (DBA)	DB 안에서 일어나는 모든 작업을 총괄하는 담당자 DB의 설계, 구축, 유지보수, 보안, 성능 최적화 등을 담당

* atomicity (원자성)

- 트랜잭션 내의 모든연산은 모두 수행되거나 전혀 수행되지 않아야 한다는 성질

- DBMS는 원자성을 만족하기 때문에 업데이트 중간에 오류가 발생하면 전체 작업을 완전히 취소함으로써 data consistency 보장

* integrity

- DB에 저장된 데이터가 정확성, 일관성, 신뢰성을 유지한다는 성질

- DB가 정의된 테이블 schema를 위반하는 데이터가 없다는 성질

- DB에는 현실 세계에서 유효한(적절한) 데이터만 저장될 수 있다는 성질

* integrity constraint (무결성 제약조건)

- DB가 integrity를 유지하도록 명시적으로 설정하는 규칙 또는 조건

- 새로 들어오는 record가 DB의 테이블 schema에 적합한지 확인하는 조건

- 컴퓨터 속 DB가 현실 세계의 조건에 벗어나지 않는 데이터만 저장하도록 조건 설정

- PK, FK, not null, check, unique, domain 범위 등

* independence

- DB를 사용하는 프로그램이나 application과 독립적으로 존재

- DB를 사용하는 사용자 application은 DB의 물리적, 논리적 구조의 변화에 영향을 받지 않음

physical data independence	- DB의 물리적 구조가 바뀌어도 사용자 application이나 논리적 스키마에는 영향을 주지 않음 - DB를 사용하는 application은 데이터가 DB에 어떻게 저장되는지 물리적 구조를 알지 못해도 됨
logical data independence	- 데이터의 논리적 스키마가 바뀌어도 사용자 application에는 영향을 주지 않음 - 사용자 뷰나 프로그램에서 사용하는 인터페이스는 그대로 유지

2. Phase of DB design

1) DB 구축 과정

Analyze requirements
: application을 만들기 위해 어떤 데이터가 필요한지, 데이터 간 관계는 무엇인지, 포함해야하는 attribute나 조건은 무엇이 있는지 등을 파악 (DB에 반영해야할 needs 파악)
Sketch table structure
: 대략적인 테이블 종류나 관계를 구상
Determine characteristics of field
: filed의 name, type, length, default, constraint 등을 구체적으로 결정
Create tables
: 실제로 테이블을 생성하고, Primary Key 등을 지정

2) Phase of DB design

출처 : https://www.learncomputerscienceonline.com/how-to-design-database/#google_vignette

conceptual design	- requirements를 분석하고 이를 만족하는 최적의 DB 구조를 표현하는 단계 - ER model (ER schema / diagram) 사용
logical design	- conceptual design 결과를 DBMS의 구조에 맞게 변환하는 단계 - Relational model (relational schema) 사용
physical design	- logical design 결과를 실제 DBMS에 구현하는 단계 - 데이터 저장 방식, 인덱스, 파일 구조 등을 결정

3) 용어 정리

출처 : https://examradar.com/relational-model/#google_vignette

schema	DB의 논리적 구조를 설계한 디자인
instance	특정 시점에 DB에 실제로 저장되어 있는 데이터 instance = row = tuple = record
attribute	각 테이블의 데이터가 특정 속성이나 특징 attribute = column = field
domain	하나의 attribute가 가질 수 있는 값 범위나 타입
data model	DB의 구조를 설명하고 설계하기 위한 이론적 틀이나 표현 방법 ER model, Relational model, Key-value model 등

3. Entity-Relationship Model (ER model)

1) ER model

- 데이터를 entity(개체)와 relation(관계)로 표현한 모델
- conceptaul design에서 사용

DB에 구현해야하는 데이터와 관계를 모두 정의
DB에 포함될 내용의 전반적인 범위를 설정
ER model의 conceptual schema를 바탕으로 logical design이 생성

2) ER diagram 구성 요소

Entity	고유하게 식별될 수 있고 현실 속에 존재하는 데이터 (객체, 사건, 행동 등)
Entity set	같은 속성을 공유하는 entity의 모음 ER diagram에서 직사각형
Relationships	두 개 이상의 entity 사이의 연결, entity가 어떻게 관련되어 있는지
Relationship set	같은 속성을 공유하는 relationships의 모음, entity set과 entity set 사이에서 형성 ER diagram에서 마름모

출처 : https://www.learncomputerscienceonline.com/entity-relationship-diagram/

3) Relationship의 특징

Degree of Relationship set	relationship set이 연결하는 entity set의 개수
Relationship cardinality	relationship set에 참여하는 entity 간의 개수 대응 관계 상대 entity set에서 relationship을 맺는 entity의 개수
total participation	entity set의 모든 entity가 적어도 1번 그 relationship에 참여해야 하는 경우
weak entity set	자체적으로 PK를 가질 수 없는 entity set 의존하고 있는 strong entity set의 attribute를 함께 사용해야 PK를 가질 수 있음

4. Relational Model

1) Relational Model

- 모든 데이터를 table 형태(tabular form)로 표현한 모델
- Relational Model 에 따라 구성된 데이터베이스를 Relational DB라고 함

- logical design에서 사용

relational schema : relation의 이름, attribute(A), 도메인을 정의한 구조/설계도/디자인
여러 relations로 구성된 DB의 elational schema를 디자인

2) Relational shema 구성 요소

relation	데이터를 table 형태로 저장한 구조
relation's degree	relation의 attribute의 개수 = column의 개수
relation's cardinality	relation에 저장된 tuple의 개수 = row의 개수
Keys	relation에서 각 record를 유일하게 식별하기 위해 사용되는 특정한 attribute들의 조합

출처 : https://medium.com/@claire_logan/3-relational-data-model-examples-c9f70c61588c

3) Keys의 종류

super key	- relation의 각 record를 유일하게 식별하는 attribute들의 조합 - at most 1 record를 추출하는 attribute 조합
candidate key	- 최소성을 만족하는 super key, set의 크기가 가장 작은 super key - subset 중 어느 것도 super key가 될 수 없는 경우
primary key	- 대표성을 만족하는 candidate key - PK를 구성하는 attribute는 여러 개일 수 있지만, PK 자체는 1개 이하만 가능 - PK는 자동으로 not null + unique constraint를 가짐
foreign key	- 다른 relation의 PK를 참조하는 attribute

* Keys 관련 constraint

Referential Integrity	- FK가 참조하는 attribute는 참조 테이블의 PK여야 함 - FK는 참조되는 테이블의 PK 값과 일치하거나 null이어야 함 - FK가 존재하지 않는/유효하지 않은 외부 값을 참조하지 않도록 보장
Entity Integrity	- PK는 null이 될 수 없고 중복되지 않아야 함 - 각 record는 PK에 의해 유일하게 식별되어야 함

5. SQL

1) SQL (Structured Query Language)

Query	DB에서 원하는 정보를 검색하거나 조작하기 위해 사용되는 요청문
Query language	DB에서 원하는 정보를 조회하기 위해 사용하는 언어 (request/retrieve)
DB language	DBMS에서 DB를 정의, 조작, 관리하는 등에 사용하는 표준 언어

- SQL은 대표적인 DB language

현재 거의 모든 상용 DBMS에서는 SQL을 표준으로 사용

- SQL은 Query language의 기능을 포함하고 있으며, non-procedual query language이자 DB system language

- MySQL, Oracle, PostgreSQL 등은 SQL 언어를 사용하는 DBMS인 것

DBMS는 회사마다 서로 다르게 존재할 수 있음

출처 : 우재남, 『혼자 공부하는 SQL』, 한빛미디어(2021),p16

2) SQL 구문 종류

DDL	- Data Definition language - 테이블의 구조(schema)를 정의하거나 변경 - CREATE, ALTER, DROP, TRUNCATE, RENAME
DML	- Data Manipulation Language - 테이블 내 데이터를 조작 - SELECT, INSERT, UPDATE, DELETE
TCL	- Transaction Control Language - 트랜잭션의 실행 흐름을 제어 - COMMIT, ROLLBACK, SAVEPOINT
DCL	- Data Control Language - 사용자 권한 및 접근 제어 - GRANT, REVOKE

Reference

https://en.wikipedia.org/wiki/Entity%E2%80%93relationship_model
https://www.learncomputerscienceonline.com/entity-relationship-diagram/

https://en.wikipedia.org/wiki/Relational_model
https://medium.com/@claire_logan/3-relational-data-model-examples-c9f70c61588c

[코테 연습] Leetcode 코딩테스트 연습 MySQL Easy (3)

HaeWon_Seo — Mon, 28 Apr 2025 15:47:48 +0900

Leetcode 코딩테스트 연습 MySQL Easy

1633. Percentage of Users Attended a Contest

: find the percentage of the users registered in each contest rounded to two decimals

풀이 1

- select 문 내에서 서브쿼리 사용

select contest_id, round(count(contest_id)/(select count(*) from Users)*100, 2) as percentage
from Register 
group by contest_id
order by 2 desc, 1

풀이 2 > count가 0인 조합까지 포함해서 모든 가능한 조합별 개수 세기

- cross join으로 모든 가능한 조합이 포함된 테이블 생성

- left outer join으로 값이 존재하는 조합에 대해서만 열이 추가되도록 (USING 말고 ON절 사용해야 함)

select tmp.contest_id, round(count(r.user_id)/count(u.user_id)*100, 2) as percentage
from Users u cross join (select distinct contest_id from Register) tmp 
    left outer join Register r on u.user_id = r.user_id and tmp.contest_id = r.contest_id 
group by tmp.contest_id
order by 2 desc, 1

1667. Fix Names in a Table

: Write a solution to fix the names so that only the first character is uppercase and the rest are lowercase. Return the result table ordered by user_id

풀이

- SUBSTR(대상, m, n) : 대상 문자열의 m 위치에서부터 n개의 문자열 추출, n 생략시 끝까지 추출

- || : Oracle에서는 문자열 연결 연산자

select user_id, (upper(substr(name,1,1)) || lower(substr(name,2))) as name
from Users
order by 1

1873. Calculate Special Bonus

: calculate the bonus of each employee. The bonus of an employee is 100% of their salary if the ID of the employee is an odd number and the employee's name does not start with the character 'M'. The bonus of an employee is 0 otherwise.

풀이 1

- MOD(값1, 값2) : Oracle에서 나머지 연산 시 % 대신 MOD 함수를 사용

- regexp_like(대상, 찾을 문자열) : 찾을 문자열이 포함되어 있는지 true/false 리턴

select employee_id, case
                when (mod(employee_id, 2) = 1 and not regexp_like(name, '^M')) then salary 
                else 0 end as bonus
from Employees
order by 1

풀이 2

- LIKE 연산자 : 문자열 패턴 매칭을 할 때 사용하는 조건절

WHERE 절, HAVING 절, CASE WHEN문 안, IF문 안, JOIN 조건 안, CHECK 제약 조건 등에 사용 가능

select employee_id, case
                when (mod(employee_id, 2) = 1 and name not like 'M%') then salary 
                else 0 end as bonus
from Employees
order by 1

3436. Find Valid Emails

: find all the valid email addresses. It contains exactly one @ symbol and ends with '.com'. The part before the @ symbol contains only alphanumeric characters and underscores. The part after the @ symbol and before .com contains a domain name that contains only letters.

풀이

- [ ] 안에서는 각 특수문자에 '\'를 붙히지 않아도 됨, [ ] 밖에서는 특수문자에 '\' 붙히기

- [ ] 안에서는 or 연결끼리 '|'로 연결하지 않아도 됨, [ ] 밖에서는 '|'로 연결

- 각종 정규표현식

[:alnum:] : 알파벳 + 숫자
[:digit:] : 숫자 0~9
[:alpha:] : 알파벳 대소문자
[:lower:] : 알파벳 소문자
[:upper:] : 알파벳 대문자
a-zA-Z0-9 소문자 + 대문자 + 숫자

select *
from Users
where regexp_like(email, '^[[:alnum:]_]+@[[:alpha:]]+\.com$')
order by user_id

select *
from Users
where regexp_like(email, '^[a-zA-Z0-9_]+@[a-zA-Z]+\.com$')
order by user_id

1517. Find Users With Valid E-Mails

: find the users who have valid emails.

풀이

- [ ] 안에서는 각 특수문자에 '\'를 붙히지 않아도 됨, [ ] 밖에서는 특수문자에 '\' 붙히기

- [ ] 안에서는 or 연결끼리 '|'로 연결하지 않아도 됨, [ ] 밖에서는 '|'로 연결

select *
from Users
where regexp_like(mail, '^[[:alpha:]][[:alnum:]_.-]*@leetcode\.com$')

select *
from Users
where regexp_like(mail, '^[A-Za-z][A-Za-z0-9_.-]*@leetcode\.com$')