인동머스크

LeetCode 코딩 테스트 - Department Top Three Salaries(LV.Hard)

indongspace — Sun, 20 Apr 2025 21:56:20 +0900

Table: Employee

+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| id           | int     |
| name         | varchar |
| salary       | int     |
| departmentId | int     |
+--------------+---------+
id is the primary key (column with unique values) for this table.
departmentId is a foreign key (reference column) of the ID from the Department table.
Each row of this table indicates the ID, name, and salary of an employee. It also contains the ID of their department.

Table: Department

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| id          | int     |
| name        | varchar |
+-------------+---------+
id is the primary key (column with unique values) for this table.
Each row of this table indicates the ID of a department and its name.

A company's executives are interested in seeing who earns the most money in each of the company's departments. A high earner in a department is an employee who has a salary in the top three unique salaries for that department.

Write a solution to find the employees who are high earners in each of the departments.

Return the result table in any order.

The result format is in the following example.

Example 1:

Input: 
Employee table:
+----+-------+--------+--------------+
| id | name  | salary | departmentId |
+----+-------+--------+--------------+
| 1  | Joe   | 85000  | 1            |
| 2  | Henry | 80000  | 2            |
| 3  | Sam   | 60000  | 2            |
| 4  | Max   | 90000  | 1            |
| 5  | Janet | 69000  | 1            |
| 6  | Randy | 85000  | 1            |
| 7  | Will  | 70000  | 1            |
+----+-------+--------+--------------+
Department table:
+----+-------+
| id | name  |
+----+-------+
| 1  | IT    |
| 2  | Sales |
+----+-------+
Output: 
+------------+----------+--------+
| Department | Employee | Salary |
+------------+----------+--------+
| IT         | Max      | 90000  |
| IT         | Joe      | 85000  |
| IT         | Randy    | 85000  |
| IT         | Will     | 70000  |
| Sales      | Henry    | 80000  |
| Sales      | Sam      | 60000  |
+------------+----------+--------+
Explanation: 
In the IT department:
- Max earns the highest unique salary
- Both Randy and Joe earn the second-highest unique salary
- Will earns the third-highest unique salary

In the Sales department:
- Henry earns the highest salary
- Sam earns the second-highest salary
- There is no third-highest salary as there are only two employees

Constraints:

There are no employees with the exact same name, salary and department.

# 쿼리를 작성하는 목표, 확인할 지표 : 각 부서에서 탑 3의 연봉값을 가지고 있는 직원 추출 / salary
# 쿼리 계산 방법 : 1. 부서별 연봉(distinct) 탑 3 추출 -> 2. 탑3와 같은 연봉을 가지고 있는 직원 추출 -> 3. join으로 부서명 붙이기 
# 데이터의 기간 : x
# 사용할 테이블 : employee, department
# JOIN KEY : departmentid, id
# 데이터 특징 : x
# 1
WITH top_3 AS (
    SELECT
        departmentid,
        salary
    FROM (
        SELECT
            departmentid,
            salary,
            DENSE_RANK() OVER(PARTITION BY departmentid ORDER BY salary DESC) AS rnk
        FROM employee
    ) AS a
    WHERE
        rnk IN (1,2,3)
), base AS (
    # 2
    SELECT
        DISTINCT
            e.name,
            e.salary,
            e.departmentid
    FROM employee AS e
    INNER JOIN  top_3 AS t
    ON e.salary = t.salary AND e.departmentid = t.departmentid
)
# 3
SELECT
    d.name AS department,
    b.name AS employee,
    b.salary AS salary
FROM base AS b
INNER JOIN department AS d
ON b.departmentid = d.id

LeetCode 코딩 테스트 - Find Students Who Improved(LV.Medium)

indongspace — Sun, 6 Apr 2025 22:16:34 +0900

Table: Scores

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| student_id  | int     |
| subject     | varchar |
| score       | int     |
| exam_date   | varchar |
+-------------+---------+
(student_id, subject, exam_date) is the primary key for this table.
Each row contains information about a student's score in a specific subject on a particular exam date. score is between 0 and 100 (inclusive).

Write a solution to 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.

The result format is in the following example.

Example:

Input:

Scores table:

+------------+----------+-------+------------+
| student_id | subject  | score | exam_date  |
+------------+----------+-------+------------+
| 101        | Math     | 70    | 2023-01-15 |
| 101        | Math     | 85    | 2023-02-15 |
| 101        | Physics  | 65    | 2023-01-15 |
| 101        | Physics  | 60    | 2023-02-15 |
| 102        | Math     | 80    | 2023-01-15 |
| 102        | Math     | 85    | 2023-02-15 |
| 103        | Math     | 90    | 2023-01-15 |
| 104        | Physics  | 75    | 2023-01-15 |
| 104        | Physics  | 85    | 2023-02-15 |
+------------+----------+-------+------------+

Output:

+------------+----------+-------------+--------------+
| student_id | subject  | first_score | latest_score |
+------------+----------+-------------+--------------+
| 101        | Math     | 70          | 85           |
| 102        | Math     | 80          | 85           |
| 104        | Physics  | 75          | 85           |
+------------+----------+-------------+--------------+

Explanation:

Student 101 in Math: Improved from 70 to 85
Student 101 in Physics: No improvement (dropped from 65 to 60)
Student 102 in Math: Improved from 80 to 85
Student 103 in Math: Only one exam, not eligible
Student 104 in Physics: Improved from 75 to 85

Result table is ordered by student_id, subject.

# 쿼리를 작성하는 목표, 확인할 지표 : 성적이 오른 학생 찾기 / subject, score, exam_date
# 쿼리 계산 방법 : 1. 시험을 두 번 이상 본 학생만 추출 -> 2. 과목별 첫 시험의 성적과 비교해서 가장 최근에 본 성적이 더 높은 학생만 추출 -> 3. 정렬
# 데이터의 기간 : x
# 사용할 테이블 : scores
# JOIN KEY : student_id, subject
# 데이터 특징 : x
WITH twice AS (
    # 1
    SELECT
        student_id,
        subject,
        COUNT(*) AS subject_cnt
    FROM scores
    GROUP BY
        student_id, subject
    HAVING
        COUNT(*) > 1
), base AS (
    SELECT
        s.student_id,
        s.subject,
        s.score,
        s.exam_date
    FROM scores AS s
    # 1
    INNER JOIN twice AS t
    ON s.student_id = t.student_id AND
        s.subject = t.subject
)
# 2
SELECT
    DISTINCT
        student_id,
        subject,
        first_score,
        latest_score
FROM (
SELECT
    student_id,
    subject,
    FIRST_VALUE(score) OVER(PARTITION BY student_id, subject ORDER BY exam_date ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) 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
FROM base   
) AS a
WHERE
    first_score < latest_score
# 3
ORDER BY
    student_id, subject

LeetCode 코딩 테스트 - Odd and Even Transactions(LV.Medium)

indongspace — Fri, 4 Apr 2025 00:29:48 +0900

Table: transactions

+------------------+------+
| Column Name      | Type | 
+------------------+------+
| transaction_id   | int  |
| amount           | int  |
| transaction_date | date |
+------------------+------+
The transactions_id column uniquely identifies each row in this table.
Each row of this table contains the transaction id, amount and transaction date.

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.

The result format is in the following example.

Example:

Input:

transactions table:

+----------------+--------+------------------+
| transaction_id | amount | transaction_date |
+----------------+--------+------------------+
| 1              | 150    | 2024-07-01       |
| 2              | 200    | 2024-07-01       |
| 3              | 75     | 2024-07-01       |
| 4              | 300    | 2024-07-02       |
| 5              | 50     | 2024-07-02       |
| 6              | 120    | 2024-07-03       |
+----------------+--------+------------------+

Output:

+------------------+---------+----------+
| transaction_date | odd_sum | even_sum |
+------------------+---------+----------+
| 2024-07-01       | 75      | 350      |
| 2024-07-02       | 0       | 350      |
| 2024-07-03       | 0       | 120      |
+------------------+---------+----------+

# 쿼리를 작성하는 목표, 확인할 지표 : 홀수/짝수 별로 amount의 합산 구하기 / amount, transaction_date
# 쿼리 계산 방법 : 1. group by sum(case when)으로 홀수 짝수 별 amount의 sum 구하기 -> 2. 정렬
# 데이터의 기간 : x
# 사용할 테이블 : transactions
# JOIN KEY : x
# 데이터 특징 : x
SELECT
    transaction_date,
    # 1
    SUM(CASE WHEN amount % 2 != 0 THEN amount ELSE 0 END) AS odd_sum,
    SUM(CASE WHEN amount % 2 = 0 THEN amount ELSE 0 END) AS even_sum
FROM transactions
GROUP BY
    transaction_date
# 2
ORDER BY
    transaction_date

LeetCode 코딩 테스트 - Analyze Subscription Conversion(LV.Medium)

indongspace — Wed, 2 Apr 2025 23:17:31 +0900

Table: UserActivity

+------------------+---------+
| Column Name      | Type    | 
+------------------+---------+
| user_id          | int     |
| activity_date    | date    |
| activity_type    | varchar |
| activity_duration| int     |
+------------------+---------+
(user_id, activity_date, activity_type) is the unique key for this table.
activity_type is one of ('free_trial', 'paid', 'cancelled').
activity_duration is the number of minutes the user spent on the platform that day.
Each row represents a user's activity on a specific date.

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. Write a solution to:

Find users who converted from free trial to paid subscription
Calculate each user's average daily activity duration during their free trial period (rounded to 2 decimal places)
Calculate each user's average daily activity duration during their paid subscription period (rounded to 2 decimal places)

Return the result table ordered by user_id in ascending order.

The result format is in the following example.

Example:

Input:

UserActivity table:

+---------+---------------+---------------+-------------------+
| user_id | activity_date | activity_type | activity_duration |
+---------+---------------+---------------+-------------------+
| 1       | 2023-01-01    | free_trial    | 45                |
| 1       | 2023-01-02    | free_trial    | 30                |
| 1       | 2023-01-05    | free_trial    | 60                |
| 1       | 2023-01-10    | paid          | 75                |
| 1       | 2023-01-12    | paid          | 90                |
| 1       | 2023-01-15    | paid          | 65                |
| 2       | 2023-02-01    | free_trial    | 55                |
| 2       | 2023-02-03    | free_trial    | 25                |
| 2       | 2023-02-07    | free_trial    | 50                |
| 2       | 2023-02-10    | cancelled     | 0                 |
| 3       | 2023-03-05    | free_trial    | 70                |
| 3       | 2023-03-06    | free_trial    | 60                |
| 3       | 2023-03-08    | free_trial    | 80                |
| 3       | 2023-03-12    | paid          | 50                |
| 3       | 2023-03-15    | paid          | 55                |
| 3       | 2023-03-20    | paid          | 85                |
| 4       | 2023-04-01    | free_trial    | 40                |
| 4       | 2023-04-03    | free_trial    | 35                |
| 4       | 2023-04-05    | paid          | 45                |
| 4       | 2023-04-07    | cancelled     | 0                 |
+---------+---------------+---------------+-------------------+

Output:

+---------+--------------------+-------------------+
| user_id | trial_avg_duration | paid_avg_duration |
+---------+--------------------+-------------------+
| 1       | 45.00              | 76.67             |
| 3       | 70.00              | 63.33             |
| 4       | 37.50              | 45.00             |
+---------+--------------------+-------------------+

# 쿼리를 작성하는 목표, 확인할 지표 : free_trial에서 paid로 전환한 사람들의 free_trial / paid 별 평균 사용 시간 구하기 / activity_type, activity_date, activity_duration
# 쿼리 계산 방법 : 1. free_trial -> paid로 전환한 유저 구하기 -> 2. 이들 중에서 free_trial or paid 별 평균 사용 시간 구하기 -> 3. 정렬
# 데이터의 기간 : x
# 사용할 테이블 : useractivity
# JOIN KEY : x
# 데이터 특징 : x
WITH base AS (
    SELECT
        user_id,
        activity_type,
        activity_duration
    FROM useractivity
    # 1
    WHERE
        user_id IN (SELECT user_id FROM useractivity WHERE activity_type = 'free_trial') AND
        user_id IN (SELECT user_id FROM useractivity WHERE activity_type = 'paid')
), ft AS (
    # 2
    SELECT
        user_id,
        AVG(activity_duration) AS trial_avg_duration
    FROM base
    WHERE
        activity_type = 'free_trial'
    GROUP BY
        user_id
), p AS (
    # 2
    SELECT
        user_id,
        AVG(activity_duration) AS paid_avg_duration
    FROM base
    WHERE
        activity_type = 'paid'
    GROUP BY
        user_id
)
SELECT
    ft.user_id,
    ROUND(ft.trial_avg_duration, 2) AS trial_avg_duration,
    ROUND(p.paid_avg_duration, 2) AS paid_avg_duration
FROM ft
INNER JOIN p
ON ft.user_id = p.user_id
# 3
ORDER BY
    user_id

LeetCode 코딩 테스트 - DNA Pattern Recognition(LV.Medium)

indongspace — Tue, 1 Apr 2025 21:11:35 +0900

Table: Samples

+----------------+---------+
| Column Name    | Type    | 
+----------------+---------+
| sample_id      | int     |
| dna_sequence   | varchar |
| species        | varchar |
+----------------+---------+
sample_id is the unique key for this table.
Each row contains a DNA sequence represented as a string of characters (A, T, G, C) and the species it was collected from.

Biologists are studying basic patterns in DNA sequences. Write a solution to identify sample_id with the following patterns:

Sequences that start with ATG (a common start codon)
Sequences that end with either TAA, TAG, or TGA (stop codons)
Sequences containing the motif ATAT (a simple repeated pattern)
Sequences that have at least 3 consecutive G (like GGG or GGGG)

Return the result table ordered by sample_id in ascending order.

The result format is in the following example.

Example:

Input:

Samples table:

+-----------+------------------+-----------+
| sample_id | dna_sequence     | species   |
+-----------+------------------+-----------+
| 1         | ATGCTAGCTAGCTAA  | Human     |
| 2         | GGGTCAATCATC     | Human     |
| 3         | ATATATCGTAGCTA   | Human     |
| 4         | ATGGGGTCATCATAA  | Mouse     |
| 5         | TCAGTCAGTCAG     | Mouse     |
| 6         | ATATCGCGCTAG     | Zebrafish |
| 7         | CGTATGCGTCGTA    | Zebrafish |
+-----------+------------------+-----------+

Output:

+-----------+------------------+-------------+-------------+------------+------------+------------+
| sample_id | dna_sequence     | species     | has_start   | has_stop   | has_atat   | has_ggg    |
+-----------+------------------+-------------+-------------+------------+------------+------------+
| 1         | ATGCTAGCTAGCTAA  | Human       | 1           | 1          | 0          | 0          |
| 2         | GGGTCAATCATC     | Human       | 0           | 0          | 0          | 1          |
| 3         | ATATATCGTAGCTA   | Human       | 0           | 0          | 1          | 0          |
| 4         | ATGGGGTCATCATAA  | Mouse       | 1           | 1          | 0          | 1          |
| 5         | TCAGTCAGTCAG     | Mouse       | 0           | 0          | 0          | 0          |
| 6         | ATATCGCGCTAG     | Zebrafish   | 0           | 1          | 1          | 0          |
| 7         | CGTATGCGTCGTA    | Zebrafish   | 0           | 0          | 0          | 0          |
+-----------+------------------+-------------+-------------+------------+------------+------------+

Explanation:

Sample 1 (ATGCTAGCTAGCTAA):
- Starts with ATG (has_start = 1)
- Ends with TAA (has_stop = 1)
- Does not contain ATAT (has_atat = 0)
- Does not contain at least 3 consecutive 'G's (has_ggg = 0)
Sample 2 (GGGTCAATCATC):
- Does not start with ATG (has_start = 0)
- Does not end with TAA, TAG, or TGA (has_stop = 0)
- Does not contain ATAT (has_atat = 0)
- Contains GGG (has_ggg = 1)
Sample 3 (ATATATCGTAGCTA):
- Does not start with ATG (has_start = 0)
- Does not end with TAA, TAG, or TGA (has_stop = 0)
- Contains ATAT (has_atat = 1)
- Does not contain at least 3 consecutive 'G's (has_ggg = 0)
Sample 4 (ATGGGGTCATCATAA):
- Starts with ATG (has_start = 1)
- Ends with TAA (has_stop = 1)
- Does not contain ATAT (has_atat = 0)
- Contains GGGG (has_ggg = 1)
Sample 5 (TCAGTCAGTCAG):
- Does not match any patterns (all fields = 0)
Sample 6 (ATATCGCGCTAG):
- Does not start with ATG (has_start = 0)
- Ends with TAG (has_stop = 1)
- Starts with ATAT (has_atat = 1)
- Does not contain at least 3 consecutive 'G's (has_ggg = 0)
Sample 7 (CGTATGCGTCGTA):
- Does not start with ATG (has_start = 0)
- Does not end with TAA, "TAG", or "TGA" (has_stop = 0)
- Does not contain ATAT (has_atat = 0)
- Does not contain at least 3 consecutive 'G's (has_ggg = 0)

Note:

The result is ordered by sample_id in ascending order
For each pattern, 1 indicates the pattern is present and 0 indicates it is not present

# 쿼리를 작성하는 목표, 확인할 지표 : dna_sequence의 글자로 인한 분류 / dna_sequence
# 쿼리 계산 방법 : 1. ATG로 시작하는지, TAA로 끝나는지, ATAT를 포함하는지, GGG를 포함하는지 CASE WHEN 으로 분류 -> 2. 정렬
# 데이터의 기간 : x
# 사용할 테이블 : samples
# JOIN KEY : x
# 데이터 특징 : x
SELECT
    sample_id,
    dna_sequence,
    species,
    # 1
    IF(dna_sequence LIKE('ATG%'), 1, 0) AS has_start,
    IF(dna_sequence LIKE('%TAA') OR dna_sequence LIKE('%TAG') OR dna_sequence LIKE('%TGA'), 1, 0) AS has_stop,
    IF(dna_sequence LIKE('%ATAT%'), 1, 0) AS has_atat,
    IF(dna_sequence REGEXP 'G{3,}', 1, 0) AS has_ggg
FROM samples
# 2
ORDER BY
    sample_id

# REGEXP : 정규 표현식(Regular Expression)을 사용하여 패턴 매칭을 수행하는 연산자
# G{3,} : G(문자), {3,}(최소 3번 이상 반복 = 3개 이상 연속)
# 다만 REGEXP는 대소문자를 구분하지 않음. (ggg도 인식)

LeetCode 코딩 테스트 - Confirmation Rate(LV.Medium)

indongspace — Sun, 30 Mar 2025 22:51:52 +0900

Table: Signups

+----------------+----------+
| Column Name    | Type     |
+----------------+----------+
| user_id        | int      |
| time_stamp     | datetime |
+----------------+----------+
user_id is the column of unique values for this table.
Each row contains information about the signup time for the user with ID user_id.

Table: Confirmations

+----------------+----------+
| Column Name    | Type     |
+----------------+----------+
| user_id        | int      |
| time_stamp     | datetime |
| action         | ENUM     |
+----------------+----------+
(user_id, time_stamp) is the primary key (combination of columns with unique values) for this table.
user_id is a foreign key (reference column) to the Signups table.
action is an ENUM (category) of the type ('confirmed', 'timeout')
Each row of this table indicates that the user with ID user_id requested a confirmation message at time_stamp and that confirmation message was either confirmed ('confirmed') or expired without confirming ('timeout').

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. Round the confirmation rate to two decimal places.

Write a solution to find the confirmation rate of each user.

Return the result table in any order.

The result format is in the following example.

Example 1:

Input: 
Signups table:
+---------+---------------------+
| user_id | time_stamp          |
+---------+---------------------+
| 3       | 2020-03-21 10:16:13 |
| 7       | 2020-01-04 13:57:59 |
| 2       | 2020-07-29 23:09:44 |
| 6       | 2020-12-09 10:39:37 |
+---------+---------------------+
Confirmations table:
+---------+---------------------+-----------+
| user_id | time_stamp          | action    |
+---------+---------------------+-----------+
| 3       | 2021-01-06 03:30:46 | timeout   |
| 3       | 2021-07-14 14:00:00 | timeout   |
| 7       | 2021-06-12 11:57:29 | confirmed |
| 7       | 2021-06-13 12:58:28 | confirmed |
| 7       | 2021-06-14 13:59:27 | confirmed |
| 2       | 2021-01-22 00:00:00 | confirmed |
| 2       | 2021-02-28 23:59:59 | timeout   |
+---------+---------------------+-----------+
Output: 
+---------+-------------------+
| user_id | confirmation_rate |
+---------+-------------------+
| 6       | 0.00              |
| 3       | 0.00              |
| 7       | 1.00              |
| 2       | 0.50              |
+---------+-------------------+
Explanation: 
User 6 did not request any confirmation messages. The confirmation rate is 0.
User 3 made 2 requests and both timed out. The confirmation rate is 0.
User 7 made 3 requests and all were confirmed. The confirmation rate is 1.
User 2 made 2 requests where one was confirmed and the other timed out. The confirmation rate is 1 / 2 = 0.5.

# 쿼리를 작성하는 목표, 확인할 지표 : 유저 별로 confirmed의 비율 구하기 / action
# 쿼리 계산 방법 : 1. signup 테이블을 기준으로 join -> 2. 유저별로 total과 confirmed 수 구하기(action 기록이 아예 없거나 confirmed가 없으면 0으로 표시되어야 함) -> 3. confirmed 비율 계산 -> 4. NULL 이면 0
# 데이터의 기간 : x
# 사용할 테이블 : signups, confirmations
# JOIN KEY : user_id
# 데이터 특징 : x
# 1
WITH base AS (
    SELECT
        s.user_id,
        c.action
    FROM signups AS s
    LEFT JOIN confirmations AS c
    ON s.user_id = c.user_id
)
SELECT
    # 3 & 4
    DISTINCT 
        user_id,
        COALESCE(ROUND(confirmed_cnt / total_cnt, 2), 0) AS confirmation_rate
FROM (
    # 2
    SELECT
        user_id,
        SUM(CASE WHEN action IS NOT NULL THEN 1 ELSE 0 END) OVER(PARTITION BY user_id) AS total_cnt,
        SUM(CASE WHEN action = 'confirmed' THEN 1 ELSE 0 END) OVER(PARTITION BY user_id) AS confirmed_cnt
    FROM base
) AS a

LeetCode 코딩 테스트 - Count Salary Categories(LV.Medium)

indongspace — Thu, 27 Mar 2025 20:23:09 +0900

Table: Accounts

+-------------+------+
| Column Name | Type |
+-------------+------+
| account_id  | int  |
| income      | int  |
+-------------+------+
account_id is the primary key (column with unique values) for this table.
Each row contains information about the monthly income for one bank account.

Write a solution to calculate the number of bank accounts for each salary category. The salary categories are:

"Low Salary": All the salaries strictly less than $20000.
"Average Salary": All the salaries in the inclusive range [$20000, $50000].
"High Salary": All the salaries strictly greater than $50000.

The result table must contain all three categories. If there are no accounts in a category, return 0.

Return the result table in any order.

The result format is in the following example.

Example 1:

Input: 
Accounts table:
+------------+--------+
| account_id | income |
+------------+--------+
| 3          | 108939 |
| 2          | 12747  |
| 8          | 87709  |
| 6          | 91796  |
+------------+--------+
Output: 
+----------------+----------------+
| category       | accounts_count |
+----------------+----------------+
| Low Salary     | 1              |
| Average Salary | 0              |
| High Salary    | 3              |
+----------------+----------------+
Explanation: 
Low Salary: Account 2.
Average Salary: No accounts.
High Salary: Accounts 3, 6, and 8.

# 쿼리를 작성하는 목표, 확인할 지표 : 범위에 맞게 salary의 카테고리 부여 / income
# 쿼리 계산 방법 : 1. if 문으로 조건에 따라 category부여 -> 2. null일 경우 0 -> 3. union all로 병합
# 데이터의 기간 : x
# 사용할 테이블 : accounts
# JOIN KEY : x
# 데이터 특징 : x
SELECT
    'Low Salary' AS category,
    # 1 & 2
    COALESCE(COUNT(IF(income < 20000, 1, NULL)), 0) AS accounts_count
FROM accounts
# 3
UNION ALL
SELECT
    'Average Salary' AS category,
    # 1 & 2
    COALESCE(COUNT(IF(income BETWEEN 20000 AND 50000, 1, NULL)), 0) AS accounts_count
FROM accounts
# 3
UNION ALL
SELECT
    'High Salary' AS category,
    # 1 & 2
    COALESCE(COUNT(IF(income > 50000, 1, NULL)), 0) AS accounts_count
FROM accounts

컨텍스트 필터

indongspace — Wed, 26 Mar 2025 21:52:09 +0900

필터 선택(ALL or 특정 지역)에 따라 차원이 드릴 다운(지역 -> 주)되는 화면을 만들어보자.

IF ALL이 선택되었을 때 THEN Region ELSE State

또는

IF 특정지역이 선택되었을 때 THEN State ELSE Region

Region과 State는 집계되지 않은 Raw Level의 값이다.

그래서, IF 바로 뒤에도 집계되지 않은 값이 필요하다.

선택은 곧 전체 레코드 수가 달라진다는 의미이다.

종합하면 Fixed LOD와 SUM(Number of Records) 조합사용.

{ SUM(Number of Records) } - A

모든 지역(데이터셋 전체) 레코드(Row) 수

{ Fixed[Region] : SUM(Number of Records) } - B

각 지역별 전체 레코드(Row) 수

특징 지역을 선택하여 필터가 적용되면, A와 B는 같아지고, 계산된 필드는 [State]를 반환

필터가 적용되지 않은 (ALL)이 선택되면, A는 전체 데이터셋의 행의 개수 , B는 각 지역별 행의 개수(총 4개의 값)

이므로 계산된 필드는 [Region]을 반환한다.

준비

Central이라는 특정 한 지역만 선택되었는데도 주 레벨로 나오지 않는 것을 확인할 수 있다.(= Region 레벨에 머물러있다.)

Region or State를 행에, 수량을 열에, 지역을 필터로 올려서 만들었는데

필터가 드릴 다운 방식으로 작동하지 않는다.

계산된 필드를 다시 한 번 살펴보자.

이 필드가 제대로 작동하기 위한 가장 중요한 조건은, 사용자가 특정한 지역을 선택했을 때(= 지역 필터가 적용되었을 때)

A, B 두 개의 Fixed LOD가 필터에 의해 값이 바뀌어야만 한다.

그런데 Fixed LOD는 차원 필터보다 적용 우선 순위가 높다.(= 필터의 영향을 받지 않는다는 의미.)

Fixed LOD를 제어하기 위해서, Fixed LOD보다 우선 순위가 낮은 차원 필터를 Fixed LOD보다 먼저 작동하는 '컨텍스트 필터'로 만들면 된다.

result

화면이 주 레벨로 드릴다운 된 것을 확인 가능하다.

※ 차원 필터는 작동 우선순위에 따라서 Fixed LOD를 필터링 할 수 없었지만, 컨텍스트 필터는 Fixed LOD에 앞서 적용된다는 것을 알 수 있다.

Fixed LOD 결과를 필터링할 때에는 '컨텍스트 필터'를 활용하자.

공부내용 :

https://www.inflearn.com/course/%ED%83%9C%EB%B8%94%EB%A1%9C-%EC%A4%91%EA%B8%89

[지금 무료]태블로 레벨UP 강의 | VizLab - 인프런

VizLab | , 강의소개 강의를 만들게된 계기가 어떻게 되시나요? 왜 이 강의를 만들게 되신거죠?저는 2015년 말에 태블로라는 툴을 처음 접하게 되었습니다. 당시에도 한국에 태블로가 소개되지

www.inflearn.com

액션(차원) 필터와 FIXED LOD

indongspace — Wed, 26 Mar 2025 19:43:24 +0900

주 별 매출을 표현한 지도를 통해 카테고리별 수익률을 필터링하는 대시보드를 만들기

준비 (1)

준비 (2)

참조선 추가

대시보드에 시트를 올린다.

액션을 걸어줘야 한다.

필터 생성

National Level의 수치가 Texas 주에 따라서 같이 변하고 있다.

문제의 원인은

Profit Ratio가 집계 계산으로, 액션 필터보다 적용 우선 순위가 낮기 때문이다. 필터가 집계보다 앞서 적용되는 것이다.

그렇기 때문에

Profit Ratio라는 단순 집계 계산을, 액션 필터보다 먼저 적용되어 액션 필터의 영향을 받지 않는 Fixed LOD로 만들어주면 된다.

액션 필터보다 작동 우선순위가 높은 Fixed LOD 참조선을 넣으면, 바 차트는 필터링되지만 참조선은 필터링되지 않는 화면을 만들 수 있다.

Fixed LOD 생성

참조선으로 활용하기 위해서는 이 필드가 화면의 View 안으로 들어가 있어야 한다.(마크카드 -> 세부정보)

참조선 삽입

서식 변경까지 해준다.

대시보드로 넘어간다.

result

※ 비교 기준선 등 (액션) 필터에 영향을 받지 않는 값이 필요할 때에는 Fixed LOD를 활용하자.

공부내용 :

https://www.inflearn.com/course/%ED%83%9C%EB%B8%94%EB%A1%9C-%EC%A4%91%EA%B8%89

[지금 무료]태블로 레벨UP 강의 | VizLab - 인프런

www.inflearn.com

테이블 계산 필터 : LOOKUP

indongspace — Wed, 26 Mar 2025 18:48:58 +0900

날짜 차원 필터는 LAST 함수로 해결할 수 있는데, 문자열 차원 필터는 어떻게 테이블 계산 필터로 바꿀 수 있을까?

고객별 매출 금액과 그에 따른 순위(테이블 계산)가 나와있다.

필터링을 통해 10명의 고객을 무작위로 뽑아 보니, 순위가 다시 계산된다.

필터(고객)가 먼저 적용된 후 테이블 계산(순위)이 나중에 이루어지기 때문이다.

필터가 들어가더라도 이렇게 전체 범위에서의 순위를 그대로 쓰려면 어떻게 해야 할까?

방법은 '차원 필터'를 '테이블 계산 필터'로 변경하면 된다!

준비

Customer Name에 필터를 걸어 랜덤으로 5명만 뽑았다.

필터링이 먼저 일어나고 나서 Rank함수가 작동한 것을 볼 수 있다.(= 5명 내에서 순위를 매김)

이 사람들이 가지고 있는, 전체범위에서의 순위 그대로 표현하기 위해 필터 카드에 있는 Customer Name을 테이블 계산 필터로 바꿔줘야 한다.

테이블 계산 생성

= 고객명이 나열되어 있는 리스트에서, 자기 자신의 줄에 있는 그 값, 결국 선택된 자기 자신을 가져와라

필터로 올리고 모두 선택

Customer Name 차원 필터를 뺀다.

result

전체 범위에서의 순위가 매겨진 것을 확인할 수 있다.

문자열 차원 필터의 경우에는 'LOOKUP(ATTR([문자열]), 0)' 이 구조로 생성해야 한다.

Customer Name 앞에 ATTR을 사용하는 이유는

테이블 계산 안에는 항상 집계값이 들어가야 하는데 차원에 대한 집계값을 만들어주기 위해서이다.

나아가서,

고객 구분(Segment)으로 필터링했을 때에도 순위를 유지시키고 싶다.

VLOD에 포함되어 있지 않던 고객 구분 에 대하여 테이블 계산 필터를 만드는 작업도 동일하다.

Segment 리스트에서 내가 선택한 줄(0)에 있는 그 값을 가지고 오라는 것.(=자기 자신의 값)

필터로 올리고 전체 선택

result

전체 범위에서의 순위를 그대로 유지하는 것을 확인할 수 있다.

Q. 지역(Region)에 대해서 테이블 계산 필터를 만들어 보자.

공부내용 :

https://www.inflearn.com/course/%ED%83%9C%EB%B8%94%EB%A1%9C-%EC%A4%91%EA%B8%89

[지금 무료]태블로 레벨UP 강의 | VizLab - 인프런