데이터 사이언스 100번의 노크(구조화 데이터 처리편)- SQL Part 3 (Q41 to Q60)의 해설입니다.

참고(Reference) : 「데이터 사이언티스트 협회 스킬 정의 위원」의 「데이터 사이언스 100번의 노크(구조화 데이터 처리편)」입니다.

데이터 사이언티스트 소사이어티 깃허브 : https://github.com/The-Japan-DataScientist-Society/100knocks-preprocess

데이터 사이언스 100 노크 (구조화된 데이터 처리) URL : https://github.com/The-Japan-DataScientist-Society/100knocks-preprocess/blob/master/docker/work/answer/ans_preprocess_knock_SQL.ipynb

– 참고: 원래 데이터 사이언티스트 소사이어티(データサイエンティスト協会スキル定義委員)에서 만든 ipynb 파일을 DeepL 에서 일본어에서 영어로 번역한 파일입니다.

– 이 파일을 업데이트한 이유는 초보자부터 고급 엔지니어까지 SQL을 사용하고자 하는 모든 사람에게 유용한 이 실습을 전파하기 위해서입니다.

– 이 데이터는 일본어로 작성되었으므로 연습할 때 언어 문제가 발생할 수 있습니다. 그러나 크게 영향을 미치지 않으므로 걱정하지 마십시오.

처음에
사용법
데이터 가동 100번 노크

처음에

데이터베이스는 PostgreSQL13입니다.
먼저 다음 셀을 실행합니다.
셀에 %%sql을 명시하여 SQL을 발행할 수 있습니다.
jupyter에서는 describe 명령으로 테이블 구조를 확인할 수 없으므로, 테이블 구조를 확인하려면 limit을 지정한 SELECT 등으로 대체해 주세요.
익숙한 SQL 클라이언트를 사용해도 문제 없습니다(접속 정보는 아래와 같습니다).
- IP 주소 : Docker Desktop의 경우 localhost, Docker toolbox의 경우 192.168.99.100
- Port:5432
- database 이름: dsdojo_db
- 사용자 이름: padawan
- 비밀번호:padawan12345
대량 출력을 하면 Jupyter가 멈출 수 있으므로 출력 건수를 제한하는 것을 권장합니다(질문에도 출력 건수를 기재).
- 결과 확인을 위해 표시하는 양을 적절히 조절하여 작업을 가볍게 진행할 수 있는 기술도 데이터 처리에는 필요합니다.
대량의 결과가 출력된 경우, 파일이 무거워져 이후 열리지 않을 수 있습니다.
- 이 경우, 작업 결과는 사라지지만 파일을 GitHub에서 다시 불러와야 합니다.
- vim 에디터 등으로 대량 출력 범위를 삭제할 수도 있습니다.
이름, 주소 등은 더미 데이터이며 실제 존재하는 것이 아닙니다.

In [1]:

%load_ext sql
import os

pgconfig = {
    'host': 'db',
    'port': os.environ['PG_PORT'],
    'database': os.environ['PG_DATABASE'],
    'user': os.environ['PG_USER'],
    'password': os.environ['PG_PASSWORD'],
}
dsl = 'postgresql://{user}:{password}@{host}:{port}/{database}'.format(**pgconfig)

# Magic 명령어로 SQL을 작성하기 위한 환경 설정
%sql $dsl

Out[1]:

'Connected: padawan@dsdojo_db'

사용법

셀의 맨 앞에 %%sql을 기재하고, 두 번째 줄 이후에 SQL을 작성하면 Jupyter에서 PostgreSQL에 대해 SQL을 실행할 수 있습니다.

In [2]:

%%sql
SELECT '다음과 같이 실행됩니다' AS sample;

 * postgresql://padawan:***@db:5432/dsdojo_db
1 rows affected.

Out[2]:

sample
다음과 같이 실행됩니다

데이터 가동 100번 노크

S-041: 영수증 내역 데이터(df_receipt)의 매출 금액(amount)을 날짜(sales_ymd)별로 집계하여, 지난번 매출이 있었던 날로부터의 매출 금액 증감을 계산하라. 그리고 결과를 10건 표시하라.

In [45]:

%%sql

WITH sales_amount_by_date AS (
    SELECT
        sales_ymd,
        SUM(amount) AS amount
    FROM receipt
    GROUP BY
        sales_ymd
),
sales_amount_by_date_with_lag as (
    SELECT
        sales_ymd,
        LAG(sales_ymd, 1) OVER(ORDER BY sales_ymd) lag_ymd,
        amount,
        LAG(amount, 1) OVER(ORDER BY sales_ymd) AS lag_amount
    FROM sales_amount_by_date
)
SELECT
    sales_ymd,
    amount,
    lag_ymd,
    lag_amount,
    amount - lag_amount AS diff_amount
FROM sales_amount_by_date_with_lag
ORDER BY
    sales_ymd
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[45]:

sales_ymd	amount	lag_ymd	lag_amount	diff_amount
20170101	33723	None	None	None
20170102	24165	20170101	33723	-9558
20170103	27503	20170102	24165	3338
20170104	36165	20170103	27503	8662
20170105	37830	20170104	36165	1665
20170106	32387	20170105	37830	-5443
20170107	23415	20170106	32387	-8972
20170108	24737	20170107	23415	1322
20170109	26718	20170108	24737	1981
20170110	20143	20170109	26718	-6575

설명:

이 코드는 SQL 언어로 작성되었으며, 'WITH' 절을 사용하여 'sales_amount_by_date'와 'sales_amount_by_date_with_lag'라는 두 개의 임시 테이블을 생성하고 있다. 그리고 'sales_amount_by_date_with_lag' 테이블에서 특정 열을 선택하고 'LAG' 함수를 사용하여 연속된 날짜 간의 매출 금액 차이를 계산하고 있습니다.

구체적으로 이 코드는 다음과 같은 처리를 수행한다.

첫 번째 'WITH' 절은 'sales_amount_by_date'라는 임시 테이블을 생성하고 'RECIPATE' 테이블의 각 날짜별 매출 금액의 합계를 계산한다.

두 번째 'WITH' 절은 'sales_amount_by_date_with_lag'라는 또 다른 임시 테이블을 생성하고, 'LAG' 함수를 사용하여 전날의 매출 금액과 연속된 날짜 사이의 매출 금액의 차이를 계산한다.

마지막 'SELECT' 문에서는 'sales_amount_by_date_with_lag' 테이블에서 판매일, 판매금액, 전날, 이전 판매금액, 연속된 날짜의 판매금액 차이 등의 열을 선택한다.

그리고 결과는 판매 날짜의 오름차순으로 정렬되어 처음 10개의 행으로 제한된다.

요약하면, 이 코드는 "LAG" 함수를 사용하여 "영수증" 테이블의 연속된 날짜 사이의 판매 금액 차이를 계산하고 처음 10개의 행의 결과를 표시한다.

S-042: 영수증 내역 데이터(df_receipt)의 매출 금액(amount)을 날짜(sales_ymd)별로 집계하고, 각 날짜의 데이터에 대해 이전, 전전, 3회 전에 매출이 있었던 날의 데이터를 결합하라. 그리고 결과를 10건 표시하라.

In [46]:

%%sql

# 코드 예시 1: 세로형 케이스
WITH sales_amount_by_date AS (
    SELECT
        sales_ymd,
        SUM(amount) AS amount
    FROM receipt
    GROUP BY
        sales_ymd
),
sales_amount_lag_date AS (
    SELECT
        sales_ymd,
        LAG(sales_ymd, 3) OVER (ORDER BY sales_ymd) AS lag_date_3,
        amount
    FROM sales_amount_by_date
)
SELECT
    a.sales_ymd,
    a.amount,
    b.sales_ymd AS lag_ymd,
    b.amount AS lag_amount
FROM sales_amount_lag_date a
JOIN sales_amount_lag_date b
ON
    (
        a.lag_date_3 IS NULL
        OR a.lag_date_3 <= b.sales_ymd
    )
    AND b.sales_ymd < a.sales_ymd
ORDER BY
    sales_ymd,
    lag_ymd
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[46]:

sales_ymd	amount	lag_ymd	lag_amount
20170102	24165	20170101	33723
20170103	27503	20170101	33723
20170103	27503	20170102	24165
20170104	36165	20170101	33723
20170104	36165	20170102	24165
20170104	36165	20170103	27503
20170105	37830	20170102	24165
20170105	37830	20170103	27503
20170105	37830	20170104	36165
20170106	32387	20170103	27503

설명:

이 코드도 SQL 언어로 작성되었으며, 'WITH' 절을 사용하여 'sales_amount_by_date'와 'sales_amount_lag_date'라는 두 개의 임시 테이블을 생성하고 있다. 그리고 'sales_amount_lag_date' 테이블에 대해 자체 결합을 수행하여 특정 조건에 따라 결과를 필터링하고 있습니다.

구체적으로 이 코드는 다음과 같은 처리를 수행하고 있습니다.

첫 번째 'WITH' 절은 'sales_amount_by_date'라는 임시 테이블을 생성하고, 'receive' 테이블의 각 날짜별 매출 금액의 합계를 계산한다.

두 번째 'WITH' 절은 'sales_amount_lag_date'라는 또 다른 임시 테이블을 생성하고 'LAG' 함수를 사용하여 'sales_amount_by_date' 테이블의 3일 전 판매일과 각 날짜의 판매금액을 계산한다.

마지막 'SELECT' 문은 'sales_amount_lag_date' 테이블에서 특정 열을 선택하여 자신과 자체 결합을 수행한다. 결합 조건은 한 행의 판매일이 다른 행의 판매일보다 작고, 두 번째 행의 판매일이 3일 전의 첫 번째 행의 판매일 이하인 행만 포함하도록 결과를 필터링한다.

그리고 결과는 판매일과 이전 판매일의 오름차순으로 정렬되어 처음 10개의 행으로 제한됩니다.

요약하면, 이 코드는 'receipt' 테이블의 각 날짜별 매출 날짜와 매출 금액이 포함된 테이블에 대해 자체 결합을 실행하고 있습니다. 결합 조건은 한 행의 매출 날짜가 다른 행의 매출 날짜보다 작고, 두 번째 행의 매출 날짜가 3일 전의 첫 번째 행의 매출 날짜 이하인 행만 포함하도록 결과를 필터링합니다. 결과는 처음 10개 행의 판매일, 판매금액, 이전 판매일, 이전 판매금액이 표시됩니다.

In [47]:

%%sql

# 코드 예시 2: 가로형 케이스
WITH sales_amount_by_date AS (
    SELECT
        sales_ymd,
        SUM(amount) AS amount
    FROM receipt
    GROUP BY
        sales_ymd
),
sales_amount_with_lag AS (
    SELECT
        sales_ymd,
        amount, 
        LAG(sales_ymd, 1) OVER (ORDER BY sales_ymd) AS lag_ymd_1,
        LAG(amount, 1) OVER (ORDER BY sales_ymd) AS lag_amount_1,
        LAG(sales_ymd, 2) OVER (ORDER BY sales_ymd) AS lag_ymd_2,
        LAG(amount, 2) OVER (ORDER BY sales_ymd) AS lag_amount_2,
        LAG(sales_ymd, 3) OVER (ORDER BY sales_ymd) AS lag_ymd_3,
        LAG(amount, 3) OVER (ORDER BY sales_ymd) AS lag_amount_3
    FROM sales_amount_by_date
)
SELECT
    sales_ymd,
    amount, 
    lag_ymd_1,
    lag_amount_1,
    lag_ymd_2,
    lag_amount_2,
    lag_ymd_3,
    lag_amount_3
FROM sales_amount_with_lag
WHERE
    lag_ymd_3 IS NOT NULL
ORDER BY
    sales_ymd
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[47]:

sales_ymd	amount	lag_ymd_1	lag_amount_1	lag_ymd_2	lag_amount_2	lag_ymd_3	lag_amount_3
20170104	36165	20170103	27503	20170102	24165	20170101	33723
20170105	37830	20170104	36165	20170103	27503	20170102	24165
20170106	32387	20170105	37830	20170104	36165	20170103	27503
20170107	23415	20170106	32387	20170105	37830	20170104	36165
20170108	24737	20170107	23415	20170106	32387	20170105	37830
20170109	26718	20170108	24737	20170107	23415	20170106	32387
20170110	20143	20170109	26718	20170108	24737	20170107	23415
20170111	24287	20170110	20143	20170109	26718	20170108	24737
20170112	23526	20170111	24287	20170110	20143	20170109	26718
20170113	28004	20170112	23526	20170111	24287	20170110	20143

설명:

이 코드도 SQL 언어로 작성되었으며, 'WITH' 절을 사용하여 'sales_amount_by_date'라는 이름의 임시 테이블을 생성하고 있다. 다음으로 'LAG' 함수를 사용하여 'sales_amount_with_lag'라는 이름의 또 다른 임시 테이블에 추가 열을 생성하고 있다. 마지막으로 'sales_amount_with_lag' 테이블에서 특정 컬럼을 선택하여 특정 조건에 따라 결과를 필터링하고 있습니다.

구체적으로 이 코드에서는 다음과 같은 처리를 수행하고 있습니다.

첫 번째 "WITH" 절은 "sales_amount_by_date"라는 임시 테이블을 생성하고 "receive" 테이블의 각 날짜별 매출 금액의 합계를 계산한다.

두 번째 "WITH" 절은 "sales_amount_with_lag"라는 또 다른 임시 테이블을 생성하고 "sales_amount_by_date" 테이블의 각 날짜의 판매 금액과 이전 3 일간의 판매 금액을 계산하기 위해 "LAG" 함수를 사용합니다.

마지막 "SELECT" 문은 "sales_amount_with_lag" 테이블에서 특정 열을 선택하고, 3 일 전 날짜가 NULL이 아닌 행만 포함하도록 결과를 필터링한다. 즉, 테이블의 첫 두 행은 세 번째 이전 날짜가 없기 때문에 제외된다.

그런 다음 결과를 판매 날짜의 오름차순으로 정렬하여 처음 10 개 행으로 제한합니다.

요약하면, 이 코드는 "영수증" 테이블의 각 날짜의 판매 금액의 합계를 계산하고 "LAG" 함수를 사용하여 각 날짜의 이전 3 일의 판매 날짜와 판매 금액을 계산한다. 결과는 각 날짜의 판매일과 판매금액, 이전 3일간의 판매일과 판매금액을 표시한다. 결과는 처음 두 행은 세 번째 이전 날짜가 없기 때문에 제외하도록 필터링된다. 결과의 처음 10개의 행은 매출 날짜의 오름차순으로 표시됩니다.

S-043: 영수증 내역 데이터(df_receipt)와 고객 데이터(df_customer)를 결합하여 성별 코드(gender_cd)와 연령(age에서 계산)별 매출 금액(amount)을 합산한 매출 요약 데이터를 생성한다. 성별 코드는 0은 남성, 1은 여성, 9는 알 수 없음을 나타낸다.
단, 항목 구성은 연령, 여성 매출금액, 남성 매출금액, 남성 매출금액, 성별 미상 매출금액의 4개 항목으로 구성한다(세로로 연령, 가로로 성별 교차 집계). 또한 연령은 10세 단위의 계급으로 한다.

In [48]:

%%sql

DROP TABLE IF EXISTS sales_summary;

CREATE TABLE sales_summary AS
    WITH gender_era_amount AS (
        SELECT
            TRUNC(age / 10) * 10 AS era,
            c.gender_cd,
            SUM(r.amount) AS amount
        FROM customer c
        JOIN receipt r
        ON
            c.customer_id = r.customer_id
        GROUP BY
            era,
            c.gender_cd
    )
    SELECT
        era,
        SUM(CASE WHEN gender_cd = '0' THEN amount END) AS male,
        SUM(CASE WHEN gender_cd = '1' THEN amount END) AS female,
        SUM(CASE WHEN gender_cd = '9' THEN amount END) AS unknown
    FROM gender_era_amount
    GROUP BY
        era
    ORDER BY
        era
;

SELECT
    *
FROM sales_summary
;

 * postgresql://padawan:***@db:5432/dsdojo_db
Done.
9 rows affected.
9 rows affected.

Out[48]:

era	male	female	unknown
10.0	1591	149836	4317
20.0	72940	1363724	44328
30.0	177322	693047	50441
40.0	19355	9320791	483512
50.0	54320	6685192	342923
60.0	272469	987741	71418
70.0	13435	29764	2427
80.0	46360	262923	5111
90.0	None	6260	None

설명:

이 SQL 코드에서는 연령대(시대)와 성별에 따른 매출 금액의 합계를 정리한 sales_summary라는 테이블을 생성합니다.

먼저 고객 테이블과 영수증 테이블을 결합하여 gender_era_amount라는 공통 테이블 표현식(CTE)을 생성합니다. 이 CTE는 연령대(시대)와 성별에 따라 레코드를 그룹화하고 총 매출액을 계산한다.

그런 다음 gender_era_amount CTE의 데이터를 집계하여 sales_summary 테이블이 생성된다. 이 테이블에는 시대, 남성, 여성, 여성, 알 수 없음의 4개 컬럼이 있으며, SELECT 구문 내의 SUM(CASE...) 문은 성별별 매출 금액을 별도의 열로 피벗하는 데 사용됩니다.

마지막으로 SELECT 문을 사용하여 새로 생성된 sales_summary 테이블에서 모든 행을 가져옵니다.

S-044: 043에서 만든 매출 요약 데이터(df_sales_summary)는 성별 매출을 가로로 나열한 데이터였다. 이 데이터에서 성별을 세로로 가져와서 연령, 성별 코드, 매출 금액의 세 가지 항목으로 변환하라. 단, 성별 코드는 남성을 ’00’, 여성을 ’01’, 알 수 없음을 ’99’로 한다.

In [49]:

%%sql

-- SQL에 적합하지 않기 때문에 다소 강압적으로 기술한다(카테고리 수가 많을 때는 매우 긴 SQL이 될 수 있다는 점에 유의)
SELECT era, '00' AS gender_cd , male AS amount FROM sales_summary
UNION ALL
SELECT era, '01' AS gender_cd, female AS amount FROM sales_summary
UNION ALL
SELECT era, '99' AS gender_cd, unknown AS amount FROM sales_summary
;

 * postgresql://padawan:***@db:5432/dsdojo_db
27 rows affected.

Out[49]:

era	gender_cd	amount
10.0	00	1591
20.0	00	72940
30.0	00	177322
40.0	00	19355
50.0	00	54320
60.0	00	272469
70.0	00	13435
80.0	00	46360
90.0	00	None
10.0	01	149836
20.0	01	1363724
30.0	01	693047
40.0	01	9320791
50.0	01	6685192
60.0	01	987741
70.0	01	29764
80.0	01	262923
90.0	01	6260
10.0	99	4317
20.0	99	44328
30.0	99	50441
40.0	99	483512
50.0	99	342923
60.0	99	71418
70.0	99	2427
80.0	99	5111
90.0	99	None

설명:

이 코드는 SQL로 작성되었으며, sales_summary라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 sales_summary 테이블의 데이터를 보다 쉽게 분석할 수 있는 형식으로 변환하는 것이다.

SELECT 문을 사용하여 sales_summary 테이블에서 데이터를 가져오고, UNION ALL 연산자를 사용하여 여러 SELECT 문 결과를 하나의 결과 집합으로 결합한다.

첫 번째 SELECT 문은 sales_summary 테이블에서 데이터를 가져와 era와 male 컬럼을 선택한다. 또한 gender_cd라는 새로운 컬럼도 포함되며, 이 컬럼의 값은 00이다. 이 컬럼은 문자열 리터럴 '00' AS gender_cd를 사용하여 추가되었으며, AS 키워드는 컬럼의 이름을 gender_cd로 변경하는 데 사용된다. 이 SELECT 문 결과 집합에는 era, gender_cd, amount의 세 개의 컬럼이 포함되어 있다.

두 번째 SELECT 문은 첫 번째 문과 비슷하지만, era와 female 열을 선택하고 gender_cd 열을 01로 설정하고 있다. 이 SELECT 문의 결과 집합에도 era, gender_cd, amount의 세 개의 컬럼이 포함되어 있다.

이 SELECT 문 결과 집합에도 era, gender_cd, amount 세 개의 컬럼이 포함되어 있다.

마지막으로 UNION ALL 연산자를 사용하여 3개의 SELECT 문 결과 집합을 하나의 결과 집합으로 합친다. 결과 테이블은 era와 gender_cd의 각 조합에 대해 하나의 행을 가지며, amount 열은 gender_cd의 값에 따라 남성, 여성 또는 알 수 없음 중 하나의 값을 포함하게 된다.

S-045: 고객 데이터(df_customer)의 생년월일(birth_day)은 날짜형으로 데이터를 보유하고 있다. 이를 YYYYMMDD 형식의 문자열로 변환하여 고객 ID(customer_id)와 함께 10건 표시하라.

In [50]:

%%sql

SELECT
    customer_id, 
    TO_CHAR(birth_day, 'YYYYMMDD') AS birth_day
FROM customer 
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[50]:

customer_id	birth_day
CS021313000114	19810429
CS037613000071	19520401
CS031415000172	19761004
CS028811000001	19330327
CS001215000145	19950329
CS020401000016	19740915
CS015414000103	19770809
CS029403000008	19730817
CS015804000004	19310502
CS033513000180	19620711

설명:

이 코드는 SQL로 작성되었으며, customer라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 customer 테이블에서 customer_id와 birth_day 컬럼을 가져오고, birth_day 컬럼을 특정 방식으로 서식을 지정하는 것이다.

SELECT 문을 사용하여 customer 테이블에서 데이터를 가져오고 LIMIT 절을 사용하여 반환되는 행 수를 10행으로 제한하고 있다.

TO_CHAR 함수는 birth_day 컬럼을 지정된 형식의 문자열로 변환하는 데 사용된다. 이 경우 형식은 'YYYYMMDD'이며, 생일의 년, 월, 일을 나타냅니다. 결과 문자열의 길이는 8자이며, 연도는 4자, 월은 2자, 일은 2자로 표현된다.

AS 키워드는 결과 컬럼의 이름을 birth_day로 변경하는 데 사용된다. 이 SELECT 문 결과 집합에는 customer_id와 birth_day라는 두 개의 열이 포함되어 있으며, birth_day 열에는 각 고객의 생년월일이 지정된 형식으로 포함되어 있습니다.

전체적으로 이 코드는 customer 테이블에서 customer_id와 birth_day 컬럼을 가져오고 birth_day 컬럼을 특정 방식으로 서식을 지정하고 싶을 때 유용하다. 이 형식화된 데이터는 분석이나 보고서 작성에 유용합니다.

S-046: 고객 데이터(df_customer)의 신청일(application_date)은 YYYYMMDD 형식의 문자열 형태로 데이터를 보유하고 있다. 이를 날짜형으로 변환하여 고객 ID(customer_id)와 함께 10건씩 표시하라.

In [51]:

%%sql

SELECT
    customer_id,
    TO_DATE(application_date, 'YYYYMMDD') AS application_date
FROM customer
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[51]:

customer_id	application_date
CS021313000114	2015-09-05
CS037613000071	2015-04-14
CS031415000172	2015-05-29
CS028811000001	2016-01-15
CS001215000145	2017-06-05
CS020401000016	2015-02-25
CS015414000103	2015-07-22
CS029403000008	2015-05-15
CS015804000004	2015-06-07
CS033513000180	2015-07-28

설명:

이 코드는 SQL로 작성되었으며, customer라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 customer 테이블에서 customer_id 열과 application_date 열을 가져와 application_date 열을 날짜 형식으로 변환하는 것이다.

SELECT 문을 사용하여 customer 테이블에서 데이터를 가져오고 LIMIT 절을 사용하여 반환되는 행 수를 10행으로 제한하고 있다.

TO_DATE 함수는 application_date 컬럼을 문자열에서 날짜 형식으로 변환하는 데 사용된다. 이 경우 형식은 'YYYYMMDD'이며, 신청일의 년, 월, 일을 나타낸다. 결과적으로 날짜 값은 yyyy-mm-dd 형식이 된다.

AS 키워드는 결과 컬럼의 이름을 application_date로 바꾸기 위해 사용된다. 이 SELECT 문 결과 집합에는 customer_id와 application_date라는 두 개의 컬럼이 포함되며, application_date 컬럼에는 각 고객의 신청 날짜가 날짜 형식으로 포함되어 있다.

전체적으로 이 코드는 고객 테이블에서 customer_id와 application_date 컬럼을 가져와 application_date 컬럼을 날짜 형식으로 변환하고 싶을 때 유용하다. 이 형식화된 데이터는 특히 날짜 계산이나 비교가 포함되는 경우 분석이나 보고서 작성에 유용합니다.

S-047: 영수증 내역 데이터(df_receipt)의 매출일(sales_ymd)은 YYYYMMDD 형식의 숫자형으로 데이터를 보유하고 있다. 이를 날짜형으로 변환하여 영수증 번호(receipt_no), 영수증 하위번호(receipt_sub_no)와 함께 10건씩 표시하라.

In [52]:

%%sql

SELECT  
    receipt_no, 
    receipt_sub_no,
    TO_DATE(CAST(sales_ymd AS VARCHAR), 'YYYYMMDD') AS sales_ymd
FROM receipt 
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[52]:

receipt_no	receipt_sub_no	sales_ymd
112	1	2018-11-03
1132	2	2018-11-18
1102	1	2017-07-12
1132	1	2019-02-05
1102	2	2018-08-21
1112	1	2019-06-05
1102	2	2018-12-05
1102	1	2019-09-22
1112	2	2017-05-04
1102	1	2019-10-10

설명:

이 코드는 SQL로 작성되었으며, receipt라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 reciport 테이블에서 reciport_no, reciport_sub_no, sales_ymd 열을 가져와 sales_ymd 열을 날짜 형식으로 변환하는 것이다.

SELECT 문은 RECIPATE 테이블에서 데이터를 가져오는 데 사용되며, LIMIT 구문은 반환되는 행의 수를 10으로 제한하는 데 사용된다.

CAST 함수는 sales_ymd 컬럼을 정수에서 문자열로 변환하는 데 사용된다. 결과 문자열에는 'YYYYMMDD' 형식으로 판매 날짜의 년, 월, 일이 포함될 것이다.

TO_DATE 함수는 sales_ymd의 문자열을 날짜 형식으로 변환하는 데 사용된다. 이 경우 형식은 'YYYYMMDD'이며, 이는 판매 날짜의 년, 월, 일을 나타낸다. 결과 날짜 값은 yyyy-mm-dd 형식이 된다.

AS 키워드는 결과 컬럼의 이름을 sales_ymd로 변경하는 데 사용된다. 이 SELECT 문 결과 집합에는 receive_no, receive_sub_no, sales_ymd의 세 개의 열이 포함되어 있으며, sales_ymd 열에는 각 영수증의 판매 날짜가 날짜 형식으로 포함되어 있습니다.

전체적으로 이 코드는 receipt 테이블에서 receive_no, receive_sub_no, sales_ymd 컬럼을 가져오고 sales_ymd 컬럼을 날짜 형식으로 변환하고 싶을 때 유용하다. 이 형식화된 데이터는 특히 날짜 계산이나 비교가 포함되는 경우 분석이나 보고서 작성에 유용하다.

S-048: 영수증 내역 데이터(df_receipt)의 매출 에포크 초(sales_epoch)는 숫자형 UNIX 초로 데이터를 보유하고 있다. 이를 날짜형으로 변환하여 영수증 번호(receipt_no), 영수증 서브번호(receipt_sub_no)와 함께 10건을 표시하라.

In [53]:

%%sql

SELECT 
    receipt_no,
    receipt_sub_no,
    CAST(TO_TIMESTAMP(sales_epoch) AS DATE) AS sales_ymd
FROM receipt 
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[53]:

receipt_no	receipt_sub_no	sales_ymd
112	1	2018-11-03
1132	2	2018-11-18
1102	1	2017-07-12
1132	1	2019-02-05
1102	2	2018-08-21
1112	1	2019-06-05
1102	2	2018-12-05
1102	1	2019-09-22
1112	2	2017-05-04
1102	1	2019-10-10

설명:

이 코드는 SQL로 작성되었으며, receiport라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 receive 테이블에서 receive_no, receive_sub_no, sales_epoch 열을 가져와 sales_epoch 열을 날짜 형식으로 변환하는 것이다.

SELECT 문을 사용하여 영수증 테이블에서 데이터를 가져오고 LIMIT 절을 사용하여 반환되는 행 수를 10행으로 제한하고 있다.

TO_TIMESTAMP 함수를 사용하여 sales_epoch 컬럼을 정수 값에서 타임스탬프 형식으로 변환하고 있다. 결과 타임스탬프는 1970년 1월 1일 00:00:00:00 UTC로부터 몇 초가 지났는지를 나타냅니다.

CAST 함수는 타임스탬프를 날짜 형식으로 변환하는 데 사용됩니다. 이 경우 결과 날짜 값은 yyyy-mm-dd 형식이 된다.

AS 키워드는 결과 컬럼의 이름을 sales_ymd로 변경하는 데 사용된다. 이 SELECT 문 결과 집합에는 receive_no, receive_sub_no, sales_ymd 세 개의 컬럼이 포함되어 있으며, sales_ymd 컬럼에는 각 영수증의 판매 날짜가 날짜 형식으로 포함되어 있다.

전체적으로 이 코드는 receipt 테이블에서 receipt_no, receive_sub_no 및 sales_epoch 열을 가져오고 sales_epoch 열을 날짜 형식으로 변환하고 싶을 때 유용하다. 이 형식화된 데이터는 특히 날짜 계산이나 비교가 포함된 경우 분석이나 보고서 작성에 유용하다.

S-049: 영수증 내역 데이터(df_receipt)의 매출 에포크 초(sales_epoch)를 날짜형으로 변환하여 ‘연도’만 추출하여 영수증 번호(receipt_no), 영수증 하위 번호(receipt_sub_no)와 함께 10건 표시하라.

In [54]:

%%sql

SELECT 
    receipt_no, 
    receipt_sub_no,
    EXTRACT(YEAR FROM TO_TIMESTAMP(sales_epoch)) AS sales_year
FROM receipt 
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[54]:

receipt_no	receipt_sub_no	sales_year
112	1	2018
1132	2	2018
1102	1	2017
1132	1	2019
1102	2	2018
1112	1	2019
1102	2	2018
1102	1	2019
1112	2	2017
1102	1	2019

설명:

이 코드는 SQL로 작성되었으며, receiport라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 receive 테이블에서 receive_no, receive_sub_no, sales_epoch 열을 가져오고, sales_epoch의 타임스탬프 열에서 연도를 추출하는 것이다.

영수증 테이블에서 데이터를 가져오기 위해 SELECT 문을 사용하고, LIMIT 절을 사용하여 반환되는 행 수를 10행으로 제한하고 있다.

TO_TIMESTAMP 함수를 사용하여 sales_epoch 열을 정수 값에서 타임스탬프 형식으로 변환한다. 결과 타임스탬프는 1970년 1월 1일 00:00:00:00 UTC로부터의 초 단위가 된다.

EXTRACT 함수는 sales_epoch의 타임스탬프에서 연도를 추출하는 데 사용된다. 결과 값은 연도를 나타내는 정수가 됩니다.

AS 키워드는 결과 컬럼의 이름을 sales_year로 변경하는 데 사용됩니다. 이 SELECT 문 결과 집합에는 receive_no, receive_sub_no, sales_year의 세 개의 열이 포함되어 있으며, sales_year 열에는 각 영수증의 판매일 연도가 포함되어 있다.

전체적으로 이 코드는 receipt 테이블에서 receipt_no, receive_sub_no 및 sales_epoch 열을 가져오고 sales_epoch 타임스탬프 열에서 연도를 추출하고 싶을 때 유용하다. 이 추출된 데이터는 판매일 연도에 따라 데이터를 그룹화하거나 필터링하는 데 유용하다.

S-050: 영수증 내역 데이터(df_receipt)의 매출 에포크 초(sales_epoch)를 날짜형으로 변환하여 ‘월’만 추출하여 영수증 번호(receipt_no), 영수증 하위 번호(receipt_sub_no)와 함께 10건을 표시한다. 단, ‘월’은 0으로 채워진 2자리로 추출한다.

In [55]:

%%sql

SELECT 
    receipt_no, 
    receipt_sub_no,
    TO_CHAR(
        EXTRACT(MONTH FROM TO_TIMESTAMP(sales_epoch)), 
        'FM00'
    ) AS sales_month
FROM receipt
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[55]:

receipt_no	receipt_sub_no	sales_month
112	1	11
1132	2	11
1102	1	07
1132	1	02
1102	2	08
1112	1	06
1102	2	12
1102	1	09
1112	2	05
1102	1	10

설명:

이 코드는 SQL로 작성되었으며, receiport라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 receiport 테이블에서 receiport_no, receiport_sub_no, sales_epoch 열을 가져오고, sales_epoch 타임스탬프 열에서 월을 추출하고, 결과 월을 앞의 0이 두 자리 숫자로 된 문자열로 포맷하는 것이다.

SELECT 문은 영수증 테이블에서 데이터를 가져오는 데 사용되며, LIMIT 구문은 반환되는 행 수를 10으로 제한하는 데 사용된다.

TO_TIMESTAMP 함수를 사용하여 sales_epoch 컬럼을 정수 값에서 타임스탬프 형식으로 변환하고 있다. 결과 타임스탬프는 1970년 1월 1일 00:00:00:00 UTC로부터의 초 단위가 된다.

EXTRACT 함수는 sales_epoch의 타임스탬프에서 월을 추출하는 데 사용된다. 결과 값은 월을 나타내는 정수가 됩니다.

TO_CHAR 함수는 추출된 월을 필요에 따라 앞의 0이 포함된 문자열로 변환하는 데 사용되며, 'FM00' 형식 문자열은 결과 문자열이 고정된 폭의 2자이며 앞의 0은 제거된다는 것을 지정한다.

AS 키워드는 결과 컬럼의 이름을 sales_month로 변경하는 데 사용된다. 이 SELECT 문 결과 집합에는 receive_no, receive_sub_no 및 sales_month의 세 개의 열이 포함되어 있으며, sales_month 열에는 각 영수증의 판매 날짜의 월이 맨 앞의 0을 포함한 2자리 문자열로 포함되어 있다.

전체적으로 이 코드는 reciport 테이블에서 reciport_no, reciport_sub_no 및 sales_epoch 열을 가져와 sales_epoch 타임스탬프 열에서 월을 추출하고 결과 월을 앞의 0이 포함된 2자리 문자열로 서식을 지정한다. 원하는 경우에 유용하다. 이 형식화된 데이터는 판매일 월을 기준으로 데이터를 그룹화하거나 필터링하는 데 유용하다.

S-051: 영수증 내역 데이터(df_receipt)의 매출 에포크 초를 날짜형으로 변환하여 ‘일’만 추출하여 영수증 번호(receipt_no), 영수증 하위 번호(receipt_sub_no)와 함께 10건 표시한다. 단, ‘일’은 0으로 채워진 2자리로 추출한다.

In [56]:

%%sql

SELECT 
    receipt_no, receipt_sub_no,
    TO_CHAR(EXTRACT(DAY FROM TO_TIMESTAMP(sales_epoch)), 'FM00') AS sales_day
FROM receipt LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[56]:

receipt_no	receipt_sub_no	sales_day
112	1	03
1132	2	18
1102	1	12
1132	1	05
1102	2	21
1112	1	05
1102	2	05
1102	1	22
1112	2	04
1102	1	10

설명:

이 코드는 SQL로 작성되었으며, receiport라는 테이블에서 데이터를 가져온다. 이 코드의 목적은 receiport 테이블에서 receiport_no, receiport_sub_no, sales_epoch 열을 가져오고, sales_epoch 타임스탬프 열에서 날짜를 추출하고, 결과 날짜를 앞의 0이 두 자리 숫자로 된 문자열로 포맷하는 것이다.

SELECT 문은 영수증 테이블에서 데이터를 가져오는 데 사용되며, LIMIT 구문은 반환되는 행 수를 10으로 제한하는 데 사용된다.

TO_TIMESTAMP 함수를 사용하여 sales_epoch 컬럼을 정수 값에서 타임스탬프 형식으로 변환하고 있다. 결과 타임스탬프는 1970년 1월 1일 00:00:00:00 UTC로부터의 초 단위가 된다.

EXTRACT 함수는 sales_epoch의 타임스탬프에서 날짜를 추출하는 데 사용됩니다. 결과 값은 날짜를 나타내는 정수가 됩니다.

TO_CHAR 함수는 추출된 날짜를 필요에 따라 앞의 0이 포함된 문자열로 변환하는 데 사용되며, 'FM00' 형식 문자열은 결과 문자열이 고정된 폭의 2자이며 앞의 0이 제거된다는 것을 지정한다.

AS 키워드는 결과 컬럼의 이름을 sales_day로 변경하는 데 사용된다. 이 SELECT 문 결과 집합에는 receive_no, receive_sub_no, sales_day의 세 개의 열이 포함되어 있으며, sales_day 열에는 각 영수증의 판매일 날짜가 맨 앞의 0을 포함한 2자리 문자열로 포함되어 있다.

전체적으로 이 코드는 reciport 테이블에서 reciport_no, reciport_sub_no, sales_epoch 컬럼을 가져오고, sales_epoch 타임스탬프 컬럼에서 날짜를 추출하고, 결과 날짜를 앞의 0이 포함된 두 자리 문자열로 포맷하고 싶을 때 유용하다. 이 형식화된 데이터는 판매일 날짜를 기준으로 데이터를 그룹화하거나 필터링하는 데 유용하다.

S-052: 영수증 내역 데이터(df_receipt)의 매출 금액(amount)을 고객 ID(customer_id)별로 합산한 후, 매출 금액 총합에 대해 2,000원 이하를 0, 2,000원보다 큰 금액을 1로 이분화하여 고객 ID, 매출 금액 총합과 함께 10건씩 표시한다. 단, 고객 ID가 “Z”로 시작하는 것은 비회원을 의미하므로 제외하여 계산한다.

In [57]:

%%sql

SELECT
    customer_id,
    SUM(amount) AS sum_amount,
    CASE
        WHEN SUM(amount) > 2000 THEN 1
        ELSE 0
    END AS sales_flg
FROM receipt
WHERE customer_id NOT LIKE 'Z%'
GROUP BY customer_id
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[57]:

customer_id	sum_amount	sales_flg
CS001311000059	2302	1
CS004614000122	248	0
CS003512000043	298	0
CS011615000061	246	0
CS029212000033	3604	1
CS007515000119	7157	1
CS034515000123	3699	1
CS004315000058	490	0
CS026414000014	6671	1
CS001615000099	768	0

설명:

이 SQL 코드는 receive라는 테이블에서 데이터를 선택하고 있다. 이 코드의 목적은 RECIPATE 테이블의 각 고객의 매출 총액을 계산하는 것과 각 고객의 매출 총액이 2000보다 큰지 여부를 나타내는 플래그를 생성하는 것입니다.

SELECT 문은 customer_id 열, SUM 함수로 계산한 각 고객의 매출 총액, 매출 총액이 2000보다 크면 1, 그렇지 않으면 0을 반환하는 CASE 식을 가져온다. 플래그가 포함된 결과 컬럼은 sales_flg로 명명한다.

WHERE 절은 고객 ID가 'Z'로 시작하는 레코드를 필터링하여 제외한다. 이는 특정 고객을 계산이나 플래그 설정에서 제외하는 데 사용할 수 있습니다.

GROUP BY 구문은 고객별 총 매출 금액과 플래그가 계산되도록 결과를 고객 ID별로 그룹화합니다.

LIMIT 절은 출력을 처음 10개의 결과로 제한합니다.

전체적으로 이 코드는 영수증 테이블의 각 고객에 대한 총 판매액을 계산하고 총 판매액이 특정 임계값(이 경우 2000)보다 큰지 여부를 나타내는 플래그를 생성하고자 할 때 유용합니다. 이는 고액 쇼핑을 하는 고객을 식별하거나 고객의 매출 금액을 집계하여 분석해야 하는 다른 유형의 분석에 유용할 수 있습니다.

S-053: 고객 데이터(df_customer)의 우편번호(postal_cd)에 대해 도쿄(앞 3자리가 100~209인 것)를 1, 그 외의 것을 0으로 이진화하라. 또한 영수증 내역 데이터(df_receipt)와 결합하여 전체 기간 동안 매출 실적이 있는 고객 수를 생성한 이항대수별로 계산하라.

In [58]:

%%sql

WITH cust AS (
    SELECT
        customer_id,
        postal_cd,
        CASE
            WHEN CAST(SUBSTR(postal_cd, 1, 3) AS INTEGER) BETWEEN 100 AND 209 THEN 1
            ELSE 0
        END AS postal_flg
    FROM
        customer
),
rect AS(
    SELECT DISTINCT
        customer_id
    FROM
        receipt
)
SELECT 
    c.postal_flg, 
    COUNT(DISTINCT c.customer_id) AS customer_cnt
FROM
    cust c
JOIN
    rect r
USING (customer_id)
GROUP BY
    c.postal_flg
;

 * postgresql://padawan:***@db:5432/dsdojo_db
2 rows affected.

Out[58]:

postal_flg	customer_cnt
0	3906
1	4400

설명:

이 SQL 코드에는 cust라는 공통 테이블 표현식(CTE)이 포함되어 있으며, customer 테이블에서 데이터를 선택하여 postal_cd를 기반으로 각 고객의 postal_flg 플래그를 계산하고 있습니다.

postal_flg 플래그는 CASE 수식을 사용하여 계산되며, postal_cd의 첫 세 글자가 100에서 209(포함)까지인지 확인하고, 참이면 1, 거짓이면 0이라는 값을 할당한다. 이 플래그는 예를 들어 우편번호 범위에 따라 고객을 그룹화하는 데 사용할 수 있다.

두 번째 CTE인 rect는 recipate 테이블에서 개별 customer_id를 선택한다.

마지막 SELECT 문은 customer_id 열에서 cust와 rect CTE를 결합하고, postal_flg 열에서 결과를 그룹화하며, COUNT(DISTINCT c.customer_id) 함수는 각 postal_flg 값에 대해 서로 다른 고객 수를 계산한다. 를 계산합니다.

전체적으로 이 코드는 고객 테이블과 영수증 테이블에 저장된 데이터를 기반으로 우편번호 범위에 따라 고객을 그룹화하고 각 범위의 다른 고객 수를 계산하고 싶을 때 유용하다.

S-054: 고객 데이터(df_customer)의 주소(address)는 사이타마현, 지바현, 도쿄도, 가나가와현 중 하나이다. 도도부현별로 코드 값을 생성하여 고객 ID, 주소와 함께 10건씩 표시하라. 값은 사이타마현을 11, 지바현을 12, 도쿄도를 13, 가나가와현을 14로 한다.

In [59]:

%%sql

-- SQL에 적합하지 않기 때문에 다소 강압적으로 기술한다(카테고리 수가 많으면 매우 긴 SQL이 된다는 점에 주의) 
-- 코드 예시 1(고정으로 잘라내기)
SELECT
    customer_id,
    address,
    CASE SUBSTR(address,1, 3)
        WHEN '埼玉県' THEN '11'
        WHEN '千葉県' THEN '12'
        WHEN '東京都' THEN '13'
        WHEN '神奈川' THEN '14'
    END AS prefecture_cd
FROM
    customer
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[59]:

customer_id	address	prefecture_cd
CS021313000114	神奈川県伊勢原市粟窪**********	14
CS037613000071	東京都江東区南砂**********	13
CS031415000172	東京都渋谷区代々木**********	13
CS028811000001	神奈川県横浜市泉区和泉町**********	14
CS001215000145	東京都大田区仲六郷**********	13
CS020401000016	東京都板橋区若木**********	13
CS015414000103	東京都江東区北砂**********	13
CS029403000008	千葉県浦安市海楽**********	12
CS015804000004	東京都江東区北砂**********	13
CS033513000180	神奈川県横浜市旭区善部町**********	14

설명:

이 SQL 코드는 customer 테이블에서 각 고객의 customer_id, address, prefecture_cd code를 선택한다.

이 코드의 CASE 표현식은 address 열의 첫 3글자를 체크하고 다음 조건에 따라 해당 prefecture_cd의 값을 할당한다.

주소란의 첫 3글자가 '사이타마현'이면 prefecture_cd 값은 '11'로 설정된다.

주소란의 첫 3글자가 '치바현'인 경우, prefecture_cd의 값은 '12'로 설정된다.

주소란의 첫 3글자가 '도쿄도'인 경우, prefecture_cd의 값은 '13'으로 설정된다.

주소란의 첫 3글자가 '가나가와'인 경우, prefecture_cd의 값은 '14'로 설정된다.

이 코드는 고객 테이블에 저장된 주소 정보를 바탕으로 고객을 도도부현별로 분류하고 싶을 때 유용하다. 결과값인 prefecture_cd 컬럼은 추가 분석이나 그룹화에 활용할 수 있다.

In [60]:

%%sql

-- 코드 예시 2 (정규 표현식 사용)
SELECT
    customer_id,
    address,
    CASE SUBSTRING(address, '^.*?[都道府県]')
        WHEN '埼玉県' THEN '11'
        WHEN '千葉県' THEN '12'
        WHEN '東京都' THEN '13'
        WHEN '神奈川県' THEN '14'
    END AS prefecture_cd
FROM
    customer
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[60]:

customer_id	address	prefecture_cd
CS021313000114	神奈川県伊勢原市粟窪**********	14
CS037613000071	東京都江東区南砂**********	13
CS031415000172	東京都渋谷区代々木**********	13
CS028811000001	神奈川県横浜市泉区和泉町**********	14
CS001215000145	東京都大田区仲六郷**********	13
CS020401000016	東京都板橋区若木**********	13
CS015414000103	東京都江東区北砂**********	13
CS029403000008	千葉県浦安市海楽**********	12
CS015804000004	東京都江東区北砂**********	13
CS033513000180	神奈川県横浜市旭区善部町**********	14

설명:

이 SQL 코드는 customer 테이블에서 각 고객의 customer_id, address, prefecture_cd code를 선택한다.

이 코드의 CASE 표현식은 정규식 패턴 '^. *? [도도부현]'을 사용하여 주소열에서 도도부현 이름을 추출하고, 아래 조건에 따라 해당 도도부현_cd 값을 할당하고 있다.

추출된 도도부현 이름이 '사이타마현'인 경우, prefecture_cd 값은 '11'로 설정된다.
추출된 도도부현 이름이 '지바현'인 경우, prefecture_cd 값은 '12'로 설정된다.
추출된 도도부현 이름이 '도쿄도'인 경우, prefecture_cd의 값은 '13'으로 설정된다.
추출된 도도부현이 '가나가와현'이라면 prefecture_cd의 값은 '14'로 설정된다.

이 코드는 앞의 예제와 비슷하지만, SUBSTR 함수 대신 SUBSTRING 함수를 사용하여 주소란에서 도도부현 이름을 추출하고 있다. 정규 표현식 패턴 '^. *? [都道府県]」는 임의의 문자(^. *?) 로 시작해서 도, 시, 도, 부, 현 중 하나로 끝나는 문자열과 일치합니다. 이 코드는 고객 테이블의 주소 정보가 표준화되지 않아 도도부현 명칭의 형식이 제각각인 경우에 유효하다. 생성된 prefecture_cd 컬럼은 추가 분석 및 그룹화에 사용할 수 있다.

In [61]:

%%sql

-- 코드 예시 3 (LIKE 사용)
SELECT
    customer_id,
    address,
    CASE
        WHEN address LIKE '埼玉県%' THEN '11'
        WHEN address LIKE '千葉県%' THEN '12'
        WHEN address LIKE '東京都%' THEN '13'
        WHEN address LIKE '神奈川県%' THEN '14'
    END AS prefecture_cd
FROM
    customer
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[61]:

customer_id	address	prefecture_cd
CS021313000114	神奈川県伊勢原市粟窪**********	14
CS037613000071	東京都江東区南砂**********	13
CS031415000172	東京都渋谷区代々木**********	13
CS028811000001	神奈川県横浜市泉区和泉町**********	14
CS001215000145	東京都大田区仲六郷**********	13
CS020401000016	東京都板橋区若木**********	13
CS015414000103	東京都江東区北砂**********	13
CS029403000008	千葉県浦安市海楽**********	12
CS015804000004	東京都江東区北砂**********	13
CS033513000180	神奈川県横浜市旭区善部町**********	14

설명:

이 SQL 코드는 customer라는 테이블에 대한 쿼리를 수행하여 처음 10행의 customer_id, address, prefecture_cd 컬럼을 선택하고 있습니다. 일치하도록 CASE 문장을 사용하여 작성되었습니다.

구체적으로 CASE 문장은 일본의 도도부현(사이타마현%, 지바현%, 도쿄도%, 가나가와현%) 뒤에 임의의 문자열이 이어지는 문자열 패턴과 LIKE 연산자를 사용하여 주소 컬럼을 확인한다. 주소 컬럼이 어느 한 패턴과 일치하면 해당 도도부현 코드(11, 12, 13, 14)가 prefecture_cd 컬럼에 부여된다.

이 코드는 앞서 제시한 다른 두 가지 예제와 비교하여 주소 컬럼에서 도도부현 코드를 추출하는 대체적인 방법이다.

S-055: 영수증 명세서(df_receipt) 데이터의 매출 금액(amount)을 고객 ID(customer_id)별로 합산하고, 그 합산 금액의 사분위수를 구하시오. 그 후, 고객별 매출금액 합계에 대해 아래 기준으로 카테고리 값을 생성하여 고객 ID, 매출금액 합계와 함께 10건씩 표시하라. 카테고리 값은 순서대로 1~4로 한다.
최소값 이상 1사분위수 미만 ・・・ 1을 부여
1사분위 이상 2사분위 미만 ・・・ 2를 부여
2사분위 이상 3사분위 미만 ・・・ 3을 부여
3사분위 이상 ・・・ 4을 부여

In [62]:

%%sql

WITH sales_amount AS(
    SELECT
        customer_id,
        SUM(amount) AS sum_amount
    FROM
        receipt
    GROUP BY
        customer_id
),
sales_pct AS (
    SELECT
        PERCENTILE_CONT(0.25) WITHIN GROUP(ORDER BY sum_amount) AS pct25,
        PERCENTILE_CONT(0.50) WITHIN GROUP(ORDER BY sum_amount) AS pct50,
        PERCENTILE_CONT(0.75) WITHIN GROUP(ORDER BY sum_amount) AS pct75
    FROM
        sales_amount
)
SELECT
    a.customer_id,
    a.sum_amount,
    CASE
        WHEN a.sum_amount < pct25 THEN 1
        WHEN pct25 <= a.sum_amount AND a.sum_amount < pct50 THEN 2
        WHEN pct50 <= a.sum_amount AND a.sum_amount < pct75 THEN 3
        WHEN pct75 <= a.sum_amount THEN 4
    END AS pct_group
FROM sales_amount a
CROSS JOIN sales_pct p
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[62]:

customer_id	sum_amount	pct_group
CS001311000059	2302	3
CS004614000122	248	1
CS003512000043	298	1
CS011615000061	246	1
CS029212000033	3604	3
CS007515000119	7157	4
CS034515000123	3699	4
CS004315000058	490	1
CS026414000014	6671	4
CS001615000099	768	2

설명:

이 SQL 코드는 다음 작업을 수행합니다.

SUM 함수를 사용하여 영수증 테이블의 금액 열을 고객 ID별로 합산하고 고객 ID별로 그룹화하여 각 고객의 판매 금액 합계를 계산합니다. 결과 테이블은 sales_amount라는 이름의 하위 쿼리로 저장됩니다.

창 함수인 PERCENTILE_CONT 함수를 사용하여 sales_amount 하위 쿼리에서 sum_amount 열의 사분위수(25위, 50위, 75위)를 계산한다.

CROSS JOIN 연산으로 sales_amount 하위 쿼리와 sales_pct 하위 쿼리를 결합하여 sales_amount 테이블의 각 행에 대한 사분위수 값을 얻는다.

마지막으로 새로운 열 pct_group을 계산하여 총 매출액을 기준으로 각 고객에게 다음과 같이 백분위수 그룹을 할당한다.

1:sum_amount가 25번째 백분위수보다 작은 경우(pct25)
2:sum_amount가 25백분위수 이상 50백분위수 미만인 경우(pct50).
3:sum_amount가 50번째 백분위수 이상 75번째 백분위수 미만인 경우(pct75).
sum_amount가 75 백분위수 이상이면 4.

최종 결과는 처음 10개의 행으로 제한된다.

S-056: 고객 데이터(df_customer)의 나이(age)를 기준으로 10세 단위로 연령을 계산하여 고객 ID(customer_id), 생년월일(birth_day)과 함께 10건씩 표시한다. 단, 60세 이상은 모두 60대 이상으로 한다. 연령을 나타내는 카테고리 명칭은 임의대로 한다.

In [63]:

%%sql

SELECT
    customer_id,
    birth_day,
    -- 확인용 항목
    -- age,
    LEAST(CAST(TRUNC(age / 10) * 10 AS INTEGER), 60) AS era
FROM
    customer
GROUP BY
    customer_id,
    birth_day
-- 확인 조건
-- HAVING LEAST(CAST(TRUNC(age / 10) * 10 AS INTEGER), 60) >= 60
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[63]:

customer_id	birth_day	era
CS001105000001	2000-01-14	10
CS001112000009	2006-08-24	10
CS001112000019	2001-01-31	10
CS001112000021	2001-12-15	10
CS001112000023	2004-01-26	10
CS001112000024	2001-01-16	10
CS001112000029	2005-01-24	10
CS001112000030	2003-03-02	10
CS001113000004	2003-02-22	10
CS001113000010	2005-05-09	10

설명:

이 코드는 customer 테이블에서 customer_id, birth_day, era(계산 필드)를 선택하고, era 필드는 고객의 나이(명시적으로 선택되지 않았지만 계산에 사용됨)를 결정하고, 10세 미만으로 잘린 나이와 60 사이의 낮은 값을 가져와서 계산한다. 낮은 값을 취하여 계산된다.

결과는 customer_id와 birth_day로 그룹화된다. 그런 다음 HAVING 절을 사용하여 연령이 60세 미만인 고객을 필터링한다.

요컨대, 이 코드는 고객 테이블에서 고객 정보를 선택하고, 나이와 시대를 계산하고, customer_id와 birth_day로 결과를 그룹화하여 연령이 60세 미만인 고객을 필터링하고 있다.

S-057: 056의 추출 결과와 성별 코드(gender_cd)에 따라 성별×연령의 조합을 나타내는 카테고리 데이터를 새로 만들어 10개를 표시하라. 조합을 나타내는 카테고리의 값은 임의로 정한다.

In [64]:

%%sql

-- 성별 코드 1자리와 연대 코드 2자리를 연결한 성연령 코드를 생성한다.
SELECT
    customer_id,
    birth_day,
    gender_cd || TO_CHAR(LEAST(CAST(TRUNC(age / 10) * 10 AS INTEGER), 60), 'FM00') AS gender_era
FROM
    customer
GROUP BY
    customer_id,
    birth_day
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[64]:

customer_id	birth_day	gender_era
CS001105000001	2000-01-14	010
CS001112000009	2006-08-24	110
CS001112000019	2001-01-31	110
CS001112000021	2001-12-15	110
CS001112000023	2004-01-26	110
CS001112000024	2001-01-16	110
CS001112000029	2005-01-24	110
CS001112000030	2003-03-02	110
CS001113000004	2003-02-22	110
CS001113000010	2005-05-09	110

설명:

이 SQL 코드는 customer_id, birth_day, 그리고 gender_cd와 era로 구성된 연결 문자열을 선택한다. era는 고객의 나이를 10년 단위로 반올림한 것으로 최대 era는 60세까지이며, gender_era의 문자열은 gender_cd와 era를 연결하여 생성됩니다.

SQL 코드는 customer_id와 birth_day로 결과를 그룹화하고 결과의 처음 10줄만 반환한다.

전체적으로 이 코드는 연령과 성별을 포함한 고객 데이터의 요약을 생성하고 시대 차원을 추가한다. 생성된 테이블은 연령과 성별에 따라 고객을 추가로 분석하거나 세분화하는 데 사용할 수 있다.

S-058: 고객 데이터(df_customer)의 성별 코드(gender_cd)를 더미 변수로 만들어 고객 ID(customer_id)와 함께 10건 표시하라.

In [65]:

%%sql

-- 카테고리 수가 많을 경우 매우 긴 SQL이 될 수 있다는 점에 주의
-- 카테고리를 하나 줄이고 싶다면 CASE 문장을 하나만 빼면 OK
SELECT
    customer_id,
    CASE WHEN gender_cd = '0' THEN '1' ELSE '0' END AS gender_cd_0,
    CASE WHEN gender_cd = '1' THEN '1' ELSE '0' END AS gender_cd_1,
    CASE WHEN gender_cd = '9' THEN '1' ELSE '0' END AS gender_cd_9
FROM
    customer
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[65]:

customer_id	gender_cd_0	gender_cd_1	gender_cd_9
CS021313000114	0	1	0
CS037613000071	0	0	1
CS031415000172	0	1	0
CS028811000001	0	1	0
CS001215000145	0	1	0
CS020401000016	1	0	0
CS015414000103	0	1	0
CS029403000008	1	0	0
CS015804000004	1	0	0
CS033513000180	0	1	0

설명:

이 SQL 코드는 customer_id를 선택하고 gender_cd_0, gender_cd_1, gender_cd_9라는 3개의 새로운 열을 생성한다. 이 새로운 컬럼은 CASE 문장을 사용하여 만들어졌습니다.

CASE 문은 조건문으로, 일련의 조건을 평가하고 해당 결과를 반환한다. 이 경우 각 고객에 대해 코드는 gender_cd 열의 값을 확인하고, gender_cd가 '0'인 경우 코드는 gender_cd_0 열에 '1'을 반환하고 다른 열에 '0'을 반환하고, gender_cd가 '1'인 경우 코드는 gender_cd_1 열에 '1'을 반환하고 다른 열에는 '0'을 반환하며, gender_cd가 '9'인 경우 코드는 gender_cd_9 열에 '1'을 반환하고 다른 열에는 '0'을 반환한다.

결과 출력은 customer_id, gender_cd_0, gender_cd_1, gender_cd_9 컬럼을 가지며, 각 고객에 대해 새로운 컬럼 중 하나만 고객의 성별을 나타내는 '1'이라는 값을 가지게 된다.

S-059: 영수증 내역 데이터(df_receipt)의 매출 금액(amount)을 고객 ID(customer_id)별로 합산하고, 매출 금액 합계를 평균 0, 표준편차 1로 표준화하여 고객 ID, 매출 금액 합계와 함께 10건씩 표시하라. 표준화에 사용하는 표준편차는 분산 제곱근 또는 불균형 분산 제곱근 중 어느 것이든 상관없다. 단, 고객 ID가 “Z”로 시작하는 것은 비회원을 의미하므로 제외하여 계산한다.

In [66]:

%%sql

-- 코드 예시 1 (STDDEV_POP로 표준화)
WITH sales_amount AS(
    SELECT
        customer_id,
        SUM(amount) AS sum_amount
    FROM
        receipt
    WHERE
        customer_id NOT LIKE 'Z%'
    GROUP BY
        customer_id
),
stats_amount AS (
    SELECT
        AVG(sum_amount) AS avg_amount,
        STDDEV_POP(sum_amount) AS stddev_amount
    FROM
        sales_amount
)
SELECT
    customer_id,
    sum_amount,
    (sum_amount - avg_amount) / stddev_amount AS std_amount
FROM sales_amount
CROSS JOIN stats_amount
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[66]:

customer_id	sum_amount	std_amount
CS001311000059	2302	-0.09032946448390523062
CS004614000122	248	-0.84533488878695858131
CS003512000043	298	-0.82695598361891930792
CS011615000061	246	-0.84607004499368015224
CS029212000033	3604	0.38825722609183744835
CS007515000119	7157	1.6942622273327082
CS034515000123	3699	0.42317714591111206778
CS004315000058	490	-0.75638098777364849812
CS026414000014	6671	1.5156192690993665
CS001615000099	768	-0.65419427503935013810

설명:

이 코드는 SQL 언어로 작성되었으며, SQL을 지원하는 데이터베이스 관리 시스템을 사용합니다.

이 코드는 recipate라는 테이블에 대해 데이터 분석 작업을 실행하고 있다. 이 테이블에는 customer_id, 금액 등의 열을 가진 트랜잭션 데이터가 포함되어 있습니다.

이 코드는 CTE(Common Table Expression)를 사용하여 두 개의 임시 테이블 sales_amount와 stats_amount를 생성하고 있다.

sales_amount라는 이름의 첫 번째 CTE는 문자 'Z'로 시작하지 않는 customer_id를 가진 각 고객이 사용한 금액의 합계를 계산하고 있다. 거래 데이터를 customer_id로 그룹화하여 각 customer_id의 금액 합계를 계산하고 있습니다.

stats_amount라는 이름의 두 번째 CTE는 각 고객이 사용한 총 금액의 평균과 표준편차를 계산하고 있습니다.

마지막 SELECT 문은 sales_amount 테이블에서 컬럼을 선택하고 크로스 조인을 사용하여 stats_amount 테이블과 결합합니다. 또한 총 금액에서 평균 금액을 빼고 이를 표준편차로 나누어 각 고객이 사용한 표준화된 금액을 계산하고 있습니다.

마지막 LIMIT 10은 출력을 처음 10행으로 제한하고 있다.

전체적으로 이 코드는 거래 데이터에 대한 통계 분석을 수행하여 'Z'로 시작하는 customer_id가 없는 각 고객이 사용한 표준화 된 금액을 계산하고 있습니다.

In [67]:

%%sql

-- 코드 예시 2 (STDDEV_SAMP로 표준화, 코드 예시 2와 약간 값이 달라짐)
WITH sales_amount AS(
    SELECT
        customer_id,
        SUM(amount) AS sum_amount
    FROM
        receipt
    WHERE
        customer_id NOT LIKE 'Z%'
    GROUP BY
        customer_id
),
stats_amount AS (
    SELECT
        AVG(sum_amount) AS avg_amount,
        STDDEV_SAMP(sum_amount) AS stddev_amount
    FROM
        sales_amount
)
SELECT
    customer_id,
    sum_amount,
    (sum_amount - avg_amount) / stddev_amount AS std_amount
FROM sales_amount
CROSS JOIN stats_amount
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[67]:

customer_id	sum_amount	std_amount
CS001311000059	2302	-0.09032402671702291270
CS004614000122	248	-0.84528400025253654164
CS003512000043	298	-0.82690620148098070841
CS011615000061	246	-0.84601911220339877497
CS029212000033	3604	0.38823385329429098451
CS007515000119	7157	1.6941602340010485
CS034515000123	3699	0.42315167096024706764
CS004315000058	490	-0.75633545419820630882
CS026414000014	6671	1.5155280299415258
CS001615000099	768	-0.65415489302835587608

설명:

이 코드는 이전 코드와 매우 유사하지만, stats_amount CTE에서 한 가지 중요한 차이점이 있다.

표준편차 계산에 STDDEV_POP 함수를 사용하는 대신 STDDEV_SAMP 함수를 사용합니다.

STDDEV_SAMP는 데이터 샘플을 기반으로 모집단의 표준편차 추정치인 샘플 표준편차를 계산합니다.

반면 STDDEV_POP은 전체 모집단을 분석할 수 있다고 가정하고 정확한 모집단 표준편차를 계산한다.

즉, 이 코드의 출력은 이전 코드와 비슷하지만 표준편차 계산은 전체 모집단이 아닌 데이터 샘플을 기반으로 한다.

일반적으로 데이터 세트가 매우 큰 경우 샘플과 모집단의 표준 편차의 차이가 작습니다. 그러나 데이터 세트가 작으면 그 차이가 커질 수 있습니다.

S-060: 영수증 내역 데이터(df_receipt)의 매출 금액(amount)을 고객 ID(customer_id)별로 합산하여 매출 금액 합계를 최소값 0, 최대값 1로 정규화하여 고객 ID, 매출 금액 합계와 함께 10건씩 표시한다. 단, 고객 ID가 “Z”로 시작하는 것은 비회원을 의미하므로 제외하여 계산한다.

In [68]:

%%sql

WITH sales_amount AS(
    SELECT
        customer_id,
        SUM(amount) AS sum_amount
    FROM
        receipt
    WHERE
        customer_id NOT LIKE 'Z%'
    GROUP BY
        customer_id
),
stats_amount AS (
    SELECT
        MAX(sum_amount) AS max_amount,
        MIN(sum_amount) AS min_amount
    FROM
        sales_amount
)
SELECT
    customer_id,
    sum_amount,
    1.0 * (sum_amount - min_amount)
            / (max_amount -  min_amount) AS scale_amount
FROM sales_amount
CROSS JOIN stats_amount
LIMIT 10
;

 * postgresql://padawan:***@db:5432/dsdojo_db
10 rows affected.

Out[68]:

customer_id	sum_amount	scale_amount
CS001311000059	2302	0.09697601668404588113
CS004614000122	248	0.00773375043448036149
CS003512000043	298	0.00990615224191866528
CS011615000061	246	0.00764685436218282934
CS029212000033	3604	0.15354535974973931178
CS007515000119	7157	0.30791623218630517901
CS034515000123	3699	0.15767292318387208898
CS004315000058	490	0.01824817518248175182
CS026414000014	6671	0.28680048661800486618
CS001615000099	768	0.03032672923183872089

설명:

이 코드도 영수증 테이블을 분석하지만, 표준화 된 금액을 계산하는 대신 각 고객이 사용한 계량된 금액을 계산합니다.

이 코드에서는 sales_amount와 stats_amount라는 두 개의 CTE를 사용하는데, 이는 이전 코드와 유사하다.

첫 번째 CTE는 문자 'Z'로 시작하지 않는 customer_id를 가진 각 고객이 사용한 총 금액을 계산하고, 두 번째 CTE는 임의의 고객이 사용한 총 금액의 최대값과 최소값을 계산하고 있습니다.

마지막 SELECT 문은 sales_amount 테이블에서 컬럼을 선택하고 크로스 조인을 사용하여 stats_amount 테이블과 결합하고 있다.

또한 각 고객이 사용한 스케일링된 금액을 계산합니다. 이는 사용한 총 금액에서 사용한 최소 금액을 뺀 후 사용한 총 금액 범위로 나눈 값으로, 최대 금액과 최소 금액의 차이입니다.

수식 앞의 1.0 *는 결과를 부동 소수점 숫자로 변환하는 데 사용됩니다. 수식에 사용된 값 중 하나가 부동 소수점 숫자일 때 필요합니다.

마지막 LIMIT 10은 출력을 처음 10행으로 제한합니다.

전체적으로 이 코드는 문자 'Z'로 시작하는 customer_id가 없는 각 고객이 지출한 금액(scaled amount)을 구하는 데이터 분석 작업을 수행하고 있다. 스케일링된 금액은 0에서 1 사이의 값으로, 모든 고객이 사용한 총액 범위에 대한 각 고객이 사용한 총액의 비율을 나타낸다.