sql.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0a52d60b",
   "metadata": {},
   "source": [
    "# SQL 기초 배워보기\n",
    "\n",
    "데이터베이스는 각각의 테이블로 이루어져 있으며, 테이블의 구성요소는 크게 다음과 같다. \n",
    "\n",
    "- 열(컬럼): 테이블에 보관하는 데이터 항목이다.\n",
    "- 행(레코드): 데이터 한 건에 해당하며, RDBMS는 반드시 행 단위로 데이터를 읽고 쓴다.\n",
    "- 셀(값): 행과 열이 교차하는 하나의 값이며, 하나의 셀 안에는 하나의 데이터만 넣을 수 있다.\n",
    "\n",
    "```{figure} image/sql/table.png\n",
    "---\n",
    "name: table\n",
    "---\n",
    "테이블의 구성요소\n",
    "```\n",
    "\n",
    "## 데이터베이스와 테이블 만들기\n",
    "\n",
    "먼저 각각의 테이블이 저장될 데이터베이스(스키마)를 만들어 보도록 하자. MySQL Workbench를 열어 아래의 쿼리를 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87ca0ee4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create database shop;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb3a706c",
   "metadata": {},
   "source": [
    "```{figure} image/sql/create_schema.png\n",
    "---\n",
    "name: create_schema\n",
    "---\n",
    "데이터베이스 만들기\n",
    "```\n",
    "\n",
    "`create database [데이터베이스명]`은 데이터베이스를 만드는 SQL 쿼리다. 쿼리를 실행하는 방법은 원하는 부분을 선택한 후 Ctrl + Shift + Enter(맥 사용자의 경우  Modifier + Shift + Return) 키를 누른다. SQL 쿼리문의 끝에는 세미콜론(;)을 붙이며, 대문자나 소문자는 구분하지 않는다. 단 테이블에 등록된 데이터는 대/소문자가 구분된다.\n",
    "\n",
    "쿼리가 실행되면 하단의 [Action Output] 부분에 **create database shop** 이라는 문구가 뜨며, shop이라는 데이터베이스가 만들어졌음을 알 수 있다. 이를 확인할 수 있는 방법은 {numref}`check_schema`와 같이 [Navigator]부분 하단에서 [Schemas]를 선택한 후 우측 상단의 새로고침 마크를 클릭하면 shop 데이터베이스가 생겼음이 확인된다.\n",
    "\n",
    "```{figure} image/sql/check_schema.png\n",
    "---\n",
    "name: check_schema\n",
    "---\n",
    "데이터베이스 확인하기\n",
    "```\n",
    "\n",
    "데이터베이스를 만들고 난 후에는 사용하고자 하는 데이터베이스를 지정해야하며, 이는 MySQL을 새로 열때마다 실행해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f5756ef",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "use shop;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc3d33ff",
   "metadata": {},
   "source": [
    "`use [데이터베이스명];` 쿼리를 통해 shop 데이터베이스를 사용할 것을 지정하였다.\n",
    "\n",
    "이제 데이터베이스 하부에 테이블을 만들어보도록 하자. 테이블을 만드는 쿼리 형식은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49c1e627",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create table <테이블명>\n",
    "(\n",
    "<열 이름 1> <데이터 형태> <이 열의 제약>,\n",
    "<열 이름 2> <데이터 형태> <이 열의 제약>,\n",
    "<열 이름 3> <데이터 형태> <이 열의 제약>,\n",
    "….\n",
    "<테이블의 제약 1>, <테이블의 제약 2>, …. \n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e644c73e",
   "metadata": {},
   "source": [
    "위 형식에 맞춰 goods 테이블을 만들어주도록 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49464bac",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create table goods\n",
    "(\n",
    "goods_id char(4) not null,\n",
    "goods_name varchar(100) not null,\n",
    "goods_classify varchar(32) not null,\n",
    "sell_price integer,\n",
    "buy_price integer,\n",
    "register_date date,\n",
    "primary key (goods_id)\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c79cc53",
   "metadata": {},
   "source": [
    "모든 열에 integer나 char 등의 데이터 형식을 지정해 주어야 한다. MySQL에서 사용할 수 있는 데이터 타입의 종류는 크게 CHAR, BINARY, TEXT, VARCHAR, BLOB, 숫자형 데이터 타입이 있으며, 입력되는 데이터에 맞는 타입을 설정한다. 또한 각종 제약을 설정해줄 수 있다. null이란 데이터가 없음을 의미하며, not null은 반드시 데이터가 존재해야 한다는 의미이다. 마지막으로 goods_id 열을 기본 키(primary key)로 지정해준다.\n",
    "\n",
    "위 쿼리를 실행한 후 좌측의 SCHEMAS 부분에서 새로고침을 해보면, shop 데이터베이스의 Tables에 [goods]가 생성되며, Columns 부분에서 우리가 입력한 열들을 확인할 수 있다. 또한 열 이름을 클릭하면 하단의 Information 부분에서 해당 열의 데이터 타입 또한 확인할 수 있다.\n",
    "\n",
    "```{figure} image/sql/goods_table.png\n",
    "---\n",
    "name: goods_table\n",
    "---\n",
    "테이블 확인하기\n",
    "```\n",
    "\n",
    "```{note}\n",
    "데이터베이스나 테이블, 열 이름으로 사용할 수 있는 문자는 다음과 같다.\n",
    "- 영문자(간혹 한글이 되기는 하나 추천하지 않음)\n",
    "- 숫자\n",
    "- 언더바(_)\n",
    "```\n",
    "\n",
    "### 테이블 정의 변경하기\n",
    "\n",
    "테이블에 열을 추가로 만들거나 삭제를 해야하는 등 테이블의 정의를 변경해야 하는 경우 `ALTER TABLE` 문을 사용하면 된다. 먼저 열을 추가하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ddb60bb",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "alter table <테이블명> add column <열 이름> <열 정의>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ec49f63",
   "metadata": {},
   "source": [
    "shop 테이블에 goods_name이라는 열을 추가하며, 데이터 타입은 varchar(100)으로 설정하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b537bc1b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "alter table goods add column goods_name_eng varchar(100);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ce0cdd0",
   "metadata": {},
   "source": [
    "쿼리를 실행하고 SCHEMAS 부분에서 새로고침을 누르면 shop 데이터베이스 내 goods 테이블에 goods_name_eng 열이 추가된 것이 확인된다.\n",
    "\n",
    "```{figure} image/sql/add_col.png\n",
    "---\n",
    "name: add_col\n",
    "---\n",
    "테이블에 열 추가하기\n",
    "```\n",
    "\n",
    "반대로 열을 삭제하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fb79a11",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "alter table <테이블명> drop column <열명>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa7e2cb",
   "metadata": {},
   "source": [
    "이를 이용해 위에서 만든 goods_name_eng 열을 삭제하도록 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1191a98b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "alter table goods drop column goods_name_eng;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "604c106c",
   "metadata": {},
   "source": [
    "쿼리 실행후 SCHEMAS 부분에서 새로고침을 누르면 goods 테이블에서 해당 열이 삭제된 것을 확인할 수 있다.\n",
    "\n",
    "### 테이블에 데이터 등록하기\n",
    "\n",
    "현재 goods 테이블은 아무런 데이터가 없는 빈 테이블 상태이므로, 데이터를 등록해주어야 한다. SQL에서 데이터를 등록하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4752bfe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "insert into <테이블명> values (값);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b546772",
   "metadata": {},
   "source": [
    "아래 쿼리를 입력하여 goods 테이블에 데이터를 등록해주도록 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a90d7bc",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "insert into goods values ('0001', '티셔츠', '의류', 1000, 500, '2020-09-20');\n",
    "insert into goods values ('0002', '펀칭기', '사무용품', 500, 320, '2020-09-11');\n",
    "insert into goods values ('0003', '와이셔츠', '의류', 4000, 2800, NULL);\n",
    "insert into goods values ('0004', '식칼', '주방용품', 3000, 2800, '2020-09-20');\n",
    "insert into goods values ('0005', '압력솥', '주방용품', 6800, 5000, '2020-01-15');\n",
    "insert into goods values ('0006', '포크', '주방용품', 500, NULL, '2020-09-20');\n",
    "insert into goods values ('0007', '도마', '주방용품', 880, 790, '2020-04-28');\n",
    "insert into goods values ('0008', '볼펜', '사무용품', 100, NULL, '2020-11-11');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cdc13db",
   "metadata": {},
   "source": [
    "```{figure} image/sql/add_data.png\n",
    "---\n",
    "name: add_data\n",
    "---\n",
    "데이터 추가하기\n",
    "```\n",
    "\n",
    "쿼리가 제대로 실행되었으면 하단의 Output 부분이 {numref}`add_data`와 같이 나타난다. 이 부분에서 SQL 초보자들에게 발생하는 대부분의 오류는 다음과 같다.\n",
    "\n",
    "- 한 번 입력한 데이터를 다시 입력(Error Code: 1062. Duplicate entry '000x' for key 'goods.PRIMARY' 오류 메세지 발생)\n",
    "- 테이블 내 열의 갯수와 입력하는 데이터의 열 갯수가 같지 않음(Error Code: 1136. Column count doesn't match value count at row 1\t오류 메세지 발생)\n",
    "\n",
    "이 외에도 발생하는 오류들은 하단의 Output 부분에 그 원인이 있으므로, 당황하지 말고 해당 메세지를 살펴보고 수정하면 된다.\n",
    "\n",
    "## SQL 기초구문 익히기\n",
    "\n",
    "위에서 만든 테이블을 바탕으로 SQL에서 자주 사용되는 기초 구문들을 실습해보겠다.\n",
    "\n",
    "### `select`: 열 선택하기\n",
    "\n",
    "테이블에서 원하는 열을 선택할 때는 `select` 문을 사용하며, 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2997141",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select <열 이름 1> , <열 이름 2>, … <열 이름 n>\n",
    "from <테이블명>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cdc2d33",
   "metadata": {},
   "source": [
    "goods 테이블 중 goods_id, goods_name, buy_price 열만 선택해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2245b1f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_name, buy_price\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a76066b7",
   "metadata": {},
   "source": [
    "```{figure} image/sql/select.png\n",
    "---\n",
    "name: select\n",
    "---\n",
    "열 선택하기\n",
    "```\n",
    "\n",
    "쿼리를 실행하면 하단의 [Result Grid]에 결과가 표시되며, 우리가 선택한 열만 표시된다. 만일 모든 데이터를 한번에 보고 싶다면 `select * from <테이블명>;` 형태로 입력하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84319f1e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select * from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b12e88",
   "metadata": {},
   "source": [
    "```{figure} image/sql/select_all.png\n",
    "---\n",
    "name: select_all\n",
    "---\n",
    "모든 열 출력하기\n",
    "```\n",
    "\n",
    "`as` 키워드를 사용하면 열에 별명을 부여할 수도 있다. 만일 저장된 테이블의 열 이름이 길 경우 이를 모두 출력하면 직관적으로 내용을 이해하기 힘드므로 이름을 간결하게 변경하는 것이 나을 때도 있다. as 키워드를 사용하는 방법은 다음과 같다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6213fac1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select <열 이름 1> as <별명>\n",
    "from <테이블명>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "939efd5f",
   "metadata": {},
   "source": [
    "이를 이용해 goods_id, goods_name, buy_price의 이름을 바꾼 후 출력해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89374a97",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id as id,\n",
    "\tgoods_name as name,\n",
    "\tbuy_price as price\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc11037e",
   "metadata": {},
   "source": [
    "```{figure} image/sql/select_as.png\n",
    "---\n",
    "name: select_as\n",
    "---\n",
    "열에 별명 부여하기\n",
    "```\n",
    "\n",
    "select 구를 통해 단순히 현재 있는 열을 선택할 뿐만 아니라 상수 및 계산식도 작성이 가능하다. 아래 쿼리를 실행해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9bf740f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select '상품' as category,\n",
    "    38 as num,\n",
    "    '2022-01-01' as date,\n",
    "    goods_id,\n",
    "    goods_name,\n",
    "    sell_price, buy_price, sell_price - buy_price as profit\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83baa90",
   "metadata": {},
   "source": [
    "```{figure} image/sql/select_adv.png\n",
    "---\n",
    "name: select_adv\n",
    "---\n",
    "열에 상수 및 계산식 작성하기\n",
    "```\n",
    "\n",
    "category, num, date 열에는 각각 상품, 38, 2022-01-01이라는 상수가 입력된다. 또한 `sell_price - buy_price`를 통해 두 열의 차이를 계산할 수 있으며, as 키워드를 통해 해당 열을 profit 으로 출력한다. 만일 별명을 부여하지 않을 경우 해당 열 이름은 계산식인 [sell_price - buy_price]가 그대로 출력된다.\n",
    "\n",
    "### `distinct`: 중복 제거하기\n",
    "\n",
    "중복된 데이터가 있는 경우 중복되는 값을 제거하고 고유한 값만 확인하고 싶을 때는 distinct 키워드를 사용하며, 사용법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efac06f6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select distinct <열 이름>\n",
    "from <테이블명>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "602f5891",
   "metadata": {},
   "source": [
    "상품 분류에 해당하는 goods_classify 열에는 중복된 값들이 존재한다. 만일 상품 분류가 어떤 것이 있는지 고유한 값만을 확인하고 싶을 경우 아래 쿼리를 실행하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c9e1a7c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select distinct goods_classify\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2928c0cc",
   "metadata": {},
   "source": [
    "```{figure} image/sql/distinct.png\n",
    "---\n",
    "name: distinct\n",
    "---\n",
    "중복 제거하기\n",
    "```\n",
    "\n",
    "상품 분류 중 고유한 값인 의류, 사무용품, 주방용품만이 출력된다.\n",
    "\n",
    "### `where`: 원하는 행 선택하기\n",
    "\n",
    "여러 데이터 중 조건에 부합하는 행만 선택할 때는 where 구를 사용하면 된다. 이는 엑셀에서 필터 기능과도 비슷하다. where 구는 from 구 바로 뒤에 사용해야 작동한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "403ac32c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select <열 이름>, …\n",
    "from <테이블명>\n",
    "where <조건식>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7738ad9c",
   "metadata": {},
   "source": [
    "테이블에서 상품 분류(goods_classify)가 의류인 데이터만 선택해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e73d7025",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify\n",
    "from goods\n",
    "where goods_classify = '의류';"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "392d0726",
   "metadata": {},
   "source": [
    "```{figure} image/sql/where.png\n",
    "---\n",
    "name: where\n",
    "---\n",
    "행 선택하기\n",
    "```\n",
    "\n",
    "여러 데이터 중 goods_classify가 의류인 데이터 2개(티셔츠, 와이셔츠)만 선택되었다.\n",
    "\n",
    "## 연산자\n",
    "\n",
    "연산자는 SQL 문에서 연산을 수행하기 위해 사용되는 사전에 예약된 단어 또는 문자로써 일반적으로 where 구 안에서 사용된다. 흔히 사용되는 연산자는 다음과 같다.\n",
    "\n",
    "- 산술 연산자\n",
    "- 비교 연산자\n",
    "- 논리 연산자\n",
    "\n",
    "### 산술 연산자\n",
    "\n",
    "산술 연산자는 더하기, 빼기, 곱하기, 나누기 등 계산을 할 때 사용되는 연산자이다. 만일 판매가에서 구매가를 뺀 이익이 500 이상인 데이터만 선택하려면 다음과 같은 쿼리를 실행한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e028d7d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *, sell_price - buy_price as profit\n",
    "from goods\n",
    "where sell_price - buy_price >= 500;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d4c932",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_cal.png\n",
    "---\n",
    "name: ope_cal\n",
    "---\n",
    "산술 연산자\n",
    "```\n",
    "\n",
    "where 구문 내애 [sell_price - buy_price]를 계산하여 이익이 500 이상인 조건에 만족하는 데이터만을 선택하였다.\n",
    "\n",
    "### 비교 연산자\n",
    "\n",
    "비교 연산자는 데이터의 크기를 비교할 때 사용되는 연산자이며, 종류는 다음과 같다.\n",
    "\n",
    "```{table} 비교 연산자 종류\n",
    "| 연산자 | 의미|\n",
    "| --- | --- | \n",
    "| = | ~와 같다 |\n",
    "| <> |  ~와 같지 않다 |\n",
    "| >= | ~ 이상 |\n",
    "| > |~ 보다 크다 |\n",
    "| <= | ~ 이하 |\n",
    "| < | ~ 보다 작다 |\n",
    "```\n",
    "\n",
    "sell_price가 1000 이상인 데이터만 선택하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cacb5ba",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, sell_price\n",
    "from goods\n",
    "where sell_price >= 1000;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51982c2e",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_1.png\n",
    "---\n",
    "name: ope_1\n",
    "---\n",
    "비교 연산자 (1)\n",
    "```\n",
    "\n",
    "숫자 뿐 아니라 날짜에도 비교 연산자를 사용할 수 있다. 등록일(register_date)이 2020년 9월 27일 이전인 데이터만 선택하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd6ca5bd",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, register_date\n",
    "from goods\n",
    "where register_date < '2020-09-27';"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56630eaa",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_2.png\n",
    "---\n",
    "name: ope_2\n",
    "---\n",
    "비교 연산자 (2)\n",
    "```\n",
    "\n",
    "### 논리 연산자\n",
    "\n",
    "where 구 내에 `and` 연산자와 `or` 연산자와 같은 논리 연산자를 사용하면 복수의 검색 조건을 조합할 수 있다. 예를 들어 상품 분류가 주방용품이고 판매가가 3000 이상인 데이터를 조회하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c51af021",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, sell_price\n",
    "from goods\n",
    "where goods_classify = '주방용품'\n",
    "and sell_price >= 3000;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ecf2843",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_and.png\n",
    "---\n",
    "name: ope_and\n",
    "---\n",
    "논리 연산자 (and)\n",
    "```\n",
    "\n",
    "두 조건을 모두 만족하는 데이터가 선택되었다. 만약 상품 분류가 주방용품이거나 판매가가 3000 이상인 경우처럼 여러 조건 중 하나만 만족해도 되는 경우를 검색하고 싶을 경우에는 `or` 연산자를 사용하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc57d653",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, sell_price\n",
    "from goods\n",
    "where goods_classify = '주방용품'\n",
    "or sell_price >= 3000;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91c51554",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_or.png\n",
    "---\n",
    "name: ope_or\n",
    "---\n",
    "논리 연산자 (or)\n",
    "```\n",
    "\n",
    "## 집약 함수\n",
    "\n",
    "집약 함수란 여러 개의 레코드를 하나로 집약시키는 기능으로써, 대표적으로 사용되는 집약 함수는 다음과 같다.\n",
    "\n",
    "```{table} 집약 함수의 종류\n",
    "| 함수명 | 의미|\n",
    "| --- | --- | \n",
    "| count | 행 숫자를 계산 |\n",
    "| sum | 합계를 계산 |\n",
    "| avg |  평균을 구함 |\n",
    "| max | 최댓값을 구함 |\n",
    "| min | 최솟값을 구함 |\n",
    "```\n",
    "\n",
    "### `count`: 행 숫자를 계산\n",
    "\n",
    "`count` 함수는 행의 숫자를 계산한다. goods 테이블에 몇 개의 행이 있는 확인하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3aaa1e72",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select count(*)\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2851ad2e",
   "metadata": {},
   "source": [
    "```{figure} image/sql/count.png\n",
    "---\n",
    "name: count\n",
    "---\n",
    "count 함수\n",
    "```\n",
    "\n",
    "별표(\\*)는 모든 열을 의미하며 총 8개의 행이 있다는 것이 확인되었다. 그러나 이는 null이 포함된 행의 수이다. 만일 null을 제외한 행의 수를 계산하고자 할 때는 인수에 특정 열을 지정한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac1af693",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select count(buy_price)\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2083848d",
   "metadata": {},
   "source": [
    "```{figure} image/sql/count_2.png\n",
    "---\n",
    "name: count_2\n",
    "---\n",
    "count 함수 (2)\n",
    "```\n",
    "\n",
    "'buy_price' 열의 8개 데이터 중에는 총 2개의 null값이 있다. 따라서 count 함수를 실행하면 null을 제외한 6개의 행이 있음이 확인된다. 즉 count(\\*)는 null을 포함한 행의 갯수를, count(열 이름)은 null을 제외한 행 수를 계산한다.\n",
    "\n",
    "### `sum`: 합계를 계산\n",
    "\n",
    "`sum` 함수는 특정 열의 합계를 계산하며, null 값은 무시하고 계산이 된다. sell_price와 buy_price 열의 합계를 구하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85c0f16a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select sum(sell_price), sum(buy_price)\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "147538b3",
   "metadata": {},
   "source": [
    "```{figure} image/sql/sum.png\n",
    "---\n",
    "name: sum\n",
    "---\n",
    "sum 함수\n",
    "```\n",
    "\n",
    "### `avg`: 산술평균을 계산\n",
    "\n",
    "`avg` 함수는 산술평균을 구하며, 사용법은 `sum`과 동일하다. sell_price 열의 평균을 구하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32fe8d78",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select avg(sell_price)\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecc71eaa",
   "metadata": {},
   "source": [
    "```{figure} image/sql/avg.png\n",
    "---\n",
    "name: avg\n",
    "---\n",
    "avg 함수\n",
    "```\n",
    "\n",
    "### 중복값 제외 후 집약함수 사용하기\n",
    "\n",
    "만일 상품 분류가 몇 개가 있는지 확인하고 싶을 때는 어떻게 하면 될까? `count` 함수의 인자에 `distict` 키워드를 사용해 중복되지 않은 데이터의 갯수를 계산할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b653214",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select count(distinct goods_classify) \n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85035b88",
   "metadata": {},
   "source": [
    "```{figure} image/sql/count_distinct.png\n",
    "---\n",
    "name: count_distinct\n",
    "---\n",
    "중복값 제외 후 집약함수 사용하기\n",
    "```\n",
    "\n",
    "goods_classify 에는 의류, 사무용품, 주방용품 3개가 있으므로 이에 해당하는 값이 계산되었다. 이는 count 뿐만 아니라 `sum(distinct 열 이름)`과 같이 다른 집약함수에도 동일하게 적용이 가능하다.\n",
    "\n",
    "## 그룹화와 정렬\n",
    "\n",
    "데이터를 특정 기준으로 그룹을 나누어 값을 계산해야 하는 경우가 많다. 예를 들어 상품 분류 별 혹은 등록일 별 그룹을 나누어 손익을 계산한다고 생각해 보자. 이러한 경우 SQL에서는 `group by` 구를 사용하여 데이터를 그룹화할 수 있다. 또한 검색 결과를 특정 기준으로 정렬할 필요가 있을 경우 `order by` 구를 사용하면 된다.\n",
    "\n",
    "### 그룹 나누기\n",
    "\n",
    "```{figure} image/sql/group.png\n",
    "---\n",
    "name: group\n",
    "---\n",
    "데이터의 그룹 나누기\n",
    "```\n",
    "\n",
    "{numref}`group`의 경우 category 별로 그룹을 나누어 평균을 계산하기 위해서는 데이터를 Blue, Green, Red 별로 그룹을 나누어 평균을 계산해야 한다. 이러한 그룹화 작업을 수행하는 구가 `group by`이며, 사용법은 아래와 같이 그룹을 나누고자 하는 열을 입력하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2555d00",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select <열 이름 1>, <열 이름 2>, …..\n",
    "from <테이블명>\n",
    "group by <열 이름 1>, <열 이름 2>, …."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f642a08c",
   "metadata": {},
   "source": [
    "상품 분류 별 데이터의 수를 계산하기 위한 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0756b37",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_classify, count(*)\n",
    "from goods\n",
    "group by goods_classify;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e257b4eb",
   "metadata": {},
   "source": [
    "```{figure} image/sql/group_count.png\n",
    "---\n",
    "name: group_count\n",
    "---\n",
    "그룹 별 계산하기\n",
    "```\n",
    "\n",
    "goods_classify 별로 그룹을 나눈 후 `count(*)`를 통해 각 그룹 별 행 갯수를 구할 수 있다. `group by` 구는 반드시 `from` 구 뒤에 두어야 한다. 이번에는 buy_price 별 행 갯수를 구해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9667f48a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select buy_price, count(*)\n",
    "from goods\n",
    "group by buy_price;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4ecfa62",
   "metadata": {},
   "source": [
    "```{figure} image/sql/group_null.png\n",
    "---\n",
    "name: group_null\n",
    "---\n",
    "그룹 별 계산하기(null 포함)\n",
    "```\n",
    "\n",
    "buy_price 열에는 null 데이터도 포함되어 있으며, 이 역시 별도의 그룹으로 분류됨을 알 수 있다. 만일 `where` 구를 통해 조건에 맞는 데이터를 선택한 후 `group by` 구를 통해 그룹을 나눌때는 어떻게 해야 할까? 이 경우 `where` 구 뒤에 `group by` 구를 작성해야 한다. 상품 분류가 의류인 것 중 buy_price 별 데이터의 수를 구하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f41dd32",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select buy_price, count(*)\n",
    "from goods\n",
    "where goods_classify = '의류'\n",
    "group by buy_price;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "772e5322",
   "metadata": {},
   "source": [
    "```{figure} image/sql/group_where.png\n",
    "---\n",
    "name: group_where\n",
    "---\n",
    "조건 검색 이후 그룹 별 계산하기\n",
    "```\n",
    "\n",
    "만일 `group by`를 통해 나온 결과에 조건을 지정하려면 어떻게 해야 할까? 이 경우 `where`이 아닌 `having` 구를 사용해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "613fc354",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select <열 이름 1>, <열 이름 2>, …\n",
    "from <테이블 명>\n",
    "group by <열 이름 1>, <열 이름 2>, …\n",
    "having <그룹값에 대한 조건>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec9b08b0",
   "metadata": {},
   "source": [
    "예를 들어 상품 분류별로 판매가의 평균을 구한 후, 이 값이 2500 이상인 데이터를 구하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee0b3932",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_classify, avg(sell_price)\n",
    "from goods\n",
    "group by goods_classify\n",
    "having avg(sell_price) >= 2500;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8d64805",
   "metadata": {},
   "source": [
    "```{figure} image/sql/group_having.png\n",
    "---\n",
    "name: group_having\n",
    "---\n",
    "그룹 별 계산 후 조건 검색\n",
    "```\n",
    "\n",
    "요약하자면 `where`는 `group by` 계산 이전, `having`은 `group by` 계산 이후 적용된다.\n",
    "\n",
    "### 검색 결과 정렬하기\n",
    "\n",
    "SQL에서는 결과가 무작위로 정렬되므로 쿼리를 실행할 때 마다 결과가 변한다. 오름차순이나 내림차순으로 결과를 정렬하고자 할 경우에는 `order by` 구를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d6cd642",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select <열 이름 1>, <열 이름 2>, …\n",
    "from <테이블명>\n",
    "order by <재정렬 기준 열 1>, <재정렬 기준 열 2>, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fb50ee9",
   "metadata": {},
   "source": [
    "예를 들어 sell_price가 싼 순서, 즉 오름차순으로 정렬할 경우 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d1978c5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "order by sell_price;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdeba7e3",
   "metadata": {},
   "source": [
    "```{figure} image/sql/order.png\n",
    "---\n",
    "name: order\n",
    "---\n",
    "데이터 정렬하기\n",
    "```\n",
    "\n",
    "`order by` 구는 기본적으로 오름차순으로 데이터를 정렬한다. 만일 내림차순으로 정렬하고자 할 경우 재정렬 기준 뒤에 desc 키워드를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5e75d43",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "order by sell_price desc;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6198fc3f",
   "metadata": {},
   "source": [
    "```{figure} image/sql/order_desc.png\n",
    "---\n",
    "name: order_desc\n",
    "---\n",
    "데이터 정렬하기 (내림차순)\n",
    "```\n",
    "\n",
    "## 뷰와 서브쿼리\n",
    "\n",
    "기초구문 만으로는 복잡한 형태의 데이터분석을 하는게 한계가 있으며, 뷰와 서브쿼리를 이용하면 이러한 작업을 쉽게 할 수 있다.\n",
    "\n",
    "### 뷰 만들기\n",
    "\n",
    "뷰는 기본적으로 테이블과 거의 동일하다. 그러나 테이블과의 차이는 실제 데이터를 저장하고 있지 않다는 점이다. 뷰는 데이터를 저장하지 않고 있으며, 뷰에서 데이터를 꺼내려고 할 때 내부적으로 쿼리를 실행하여 일시적인 가상 테이블을 만든다. 즉, 데이터가 아닌 쿼리를 저장하고 있다고 보면 된다. 이러한 뷰가 가진 장점은 다음과 같다.\n",
    "\n",
    "1. 데이터를 저장하지 않기 때문에 기억 장치 용량을 절약할 수 있다.\n",
    "2. 자주 사용하는 쿼리를 매번 작성하지 않고 뷰로 저장하면 반복해서 사용이 가능한다. 뷰는 원래의 테이블과 연동되므로, 데이터가 최신 상태로 갱신되면 뷰의 결과 역시 자동으로 최신 상태를 보여준다.\n",
    "\n",
    "뷰는 `create view` 문을 사용해 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "166e3b29",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create view 뷰 이름 (<뷰의 열 이름 1>, <뷰의 열 이름 2>, ...)\n",
    "as\n",
    "<쿼리>;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "996883b5",
   "metadata": {},
   "source": [
    "만일 **상품 분류 별 행 갯수**를 매일 조회해야 한다면, 매번 쿼리를 실행하는 것 보다 뷰를 만들어 이를 확인하는 것이 훨씬 효율적이다. 아래의 쿼리를 통해 해당 뷰를 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a460b82",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create view GoodSum (goods_classify, cnt_goods)\n",
    "as\n",
    "select goods_classify, count(*)\n",
    "from goods\n",
    "group by goods_classify;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29a17a04",
   "metadata": {},
   "source": [
    "```{figure} image/sql/view.png\n",
    "---\n",
    "name: view\n",
    "---\n",
    "뷰 생성하기\n",
    "```\n",
    "\n",
    "위 쿼리를 실행한 후 SCHEMAS 부분에서 새로고침을 눌러보면 Views 하부에 goodsum 이라는 뷰가 생긴것이 확인된다. 뷰의 데이터를 확인하는 방법은 테이블의 데이터를 확인하는 방법과 동일하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7767d6a4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from GoodSum;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20e32efe",
   "metadata": {},
   "source": [
    "```{figure} image/sql/view_2.png\n",
    "---\n",
    "name: view_2\n",
    "---\n",
    "뷰 확인하기\n",
    "```\n",
    "\n",
    "### 뷰 삭제하기\n",
    "\n",
    "뷰를 삭제하려면 `drop view 뷰명` 문을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2321756f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "drop view GoodSum;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58578dbd",
   "metadata": {},
   "source": [
    "혹은 SCHEMAS 영역에서 삭제하고자 하는 뷰를 선택한 후 마우스 우클릭을 눌러 [Drop View]를 클릭해도 해당 뷰가 삭제된다.\n",
    "\n",
    "```{figure} image/sql/view_delete.png\n",
    "---\n",
    "name: view_delete\n",
    "---\n",
    "뷰 삭제하기\n",
    "```\n",
    "\n",
    "```{note}\n",
    "뷰 위에 뷰를 겹쳐 사용하면 성능저하가 일어나므로, 겹쳐서 사용하지 않는 것이 좋다.\n",
    "```\n",
    "\n",
    "### 서브쿼리\n",
    "\n",
    "서브쿼리란 쿼리 내의 쿼리이며, 일회용 뷰를 의미한다. 즉, 뷰를 정의하는 구문을 그대로 다른 구 안에 삽입하는 것이다. 먼저 뷰를 만든 후 이를 확인하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b3342a2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create view GoodSum (goods_classify, cnt_goods)\n",
    "as\n",
    "select goods_classify, count(*)\n",
    "from goods\n",
    "group by goods_classify;\n",
    "\n",
    "select * from GoodSum;\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f894ffbd",
   "metadata": {},
   "source": [
    "이와 동일한 결과가 나오게 하는 서브쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52fca710",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_classify, cnt_goods\n",
    "from (\n",
    " select goods_classify, count(*) as cnt_goods\n",
    " from goods\n",
    " group by goods_classify\n",
    ") as GoodsSum;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e007d171",
   "metadata": {},
   "source": [
    "from 구 뒤의 괄호안에 해당하는 부분은 뷰를 만들 때 사용하던 코드와 동일하다. 즉, ① from 구 안의 select 문(서브쿼리)가 실행되고, ② 이 결과를 바탕으로 바깥쪽 select 문이 실행된다.\n",
    "\n",
    "### 스칼라 서브쿼리\n",
    "\n",
    "스칼라 서브쿼리란 단이 값이 반환되는 서브쿼리다. 이를 통해 =, <, > 등 비교 연산자의 입력값으로 사용할 수 있다. 예를 들어 판매단가가 전체 평균 판매단가보다 높은 상품만을 검색하려면 어떻게 해야할까? 먼저 평균 단가를 계산해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a608b9e3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select avg(sell_price)\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4505d59",
   "metadata": {},
   "source": [
    "```{figure} image/sql/sub_scala.png\n",
    "---\n",
    "name: sub_scala\n",
    "---\n",
    "평균 단가 계산하기\n",
    "```\n",
    "\n",
    "해당 쿼리를 서브쿼리에 넣어 원하는 값을 찾을 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdfd4494",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where sell_price > (select avg(sell_price) from goods);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12ff98ab",
   "metadata": {},
   "source": [
    "```{figure} image/sql/sub_scala_2.png\n",
    "---\n",
    "name: sub_scala_2\n",
    "---\n",
    "스칼라 서브쿼리를 이용한 조건 검색\n",
    "```\n",
    "\n",
    "스칼라 서브쿼리는 where 구 뿐만 아니라 select, group by, having, order by 구 등 거의 모든 곳에 쓸 수 있다. 평균 판매가격을 새로운 열로 만드는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9a605ba",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_name, sell_price,\n",
    "\t(select avg(sell_price) from goods) as avg_price\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6226afb",
   "metadata": {},
   "source": [
    "```{figure} image/sql/sub_select.png\n",
    "---\n",
    "name: sub_select\n",
    "---\n",
    "select 내 서브쿼리\n",
    "```\n",
    "\n",
    "select 구문 내에 `select avg(sell_price) from goods` 쿼리를 입력하여 평균 판매가격을 계산한 후 이를 avg_price 라는 열 이름으로 출력한다. \n",
    "\n",
    "이번에는 좀 더 복잡한 조건에 해당하는 데이터를 찾아보도록 하자. 상품 분류 별 평균 판매가격이 전체 데이터의 평균 판매가격 이상인 데이터만 출력하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd466580",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_classify, avg(sell_price)\n",
    "from goods\n",
    "group by goods_classify\n",
    "having avg(sell_price) > (select avg(sell_price) from goods);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deef0f33",
   "metadata": {},
   "source": [
    "```{figure} image/sql/sub_having.png\n",
    "---\n",
    "name: sub_having\n",
    "---\n",
    "having 내 서브쿼리\n",
    "```\n",
    "\n",
    "먼저 `group by` 구문을 이용해 상품 분류 별 평균 판매가격을 계산한다. 그 후 having 구문 내에 전체 평균 판매가격을 계산하는 서브쿼리인 `select avg(sell_price) from goods` 를 입력하여 2097.5 라는 값을 계산하고, 그룹별 평균 판매가격이 이 값보다 큰 데이터만을 선택하게 된다.\n",
    "\n",
    "## 함수, 술어와 case 식\n",
    "\n",
    "SQL에서도 함수를 이용해 다양한 연산을 할 수 있으며, 다음과 같은 함수가 존재한다. 본 책에서는 수치 계산을 위한 '산술 함수', 문자열 처리를 위한 '문자열 함수', 날짜 처리를 위한 '날짜 함수'에 대해 대해 알아보겠다. 또한 함수의 변형 형태인 술어는 반환 값이 진리값(TRUE/FALSE/UNKNOWN)인 함수라 볼 수 있다. 마지막으로 `case` 식 역시 함수의 일종으로써, SQL 내에서의 if문 이라고도 볼 수 있다.  `case`는 조건에 해당하는 목록을 평가하고 가능한 여러 결과 식 중 하나를 반환한다.\n",
    "\n",
    "### 산술 함수\n",
    "\n",
    "산술 함수는 숫자형 데이터의 절대값, 올림, 내림, 반올림 등을 계산할 수 있게 해준다. 먼저 m, n, p 3개 열로 구성된 테이블(SampleMath)을 만들어 주도록 한다({numref}`samplemath`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5505d2d6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create table SampleMath\n",
    "(m  numeric (10,3),\n",
    " n  integer,\n",
    " p  integer);\n",
    "\n",
    "insert into SampleMath(m, n, p) values (500, 0, NULL);\n",
    "insert into SampleMath(m, n, p) values (-180, 0, NULL);\n",
    "insert into SampleMath(m, n, p) values (NULL, NULL, NULL);\n",
    "insert into SampleMath(m, n, p) values (NULL, 7, 3);\n",
    "insert into SampleMath(m, n, p) values (NULL, 5, 2);\n",
    "insert into SampleMath(m, n, p) values (NULL, 4, NULL);\n",
    "insert into SampleMath(m, n, p) values (8, NULL, 3);\n",
    "insert into SampleMath(m, n, p) values (2.27, 1, NULL);\n",
    "insert into SampleMath(m, n, p) values (5.555,2, NULL);\n",
    "insert into SampleMath(m, n, p) values (NULL, 1, NULL);\n",
    "insert into SampleMath(m, n, p) values (8.76, NULL, NULL);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a899a97",
   "metadata": {},
   "source": [
    "```{figure} image/sql/samplemath.png\n",
    "---\n",
    "name: samplemath\n",
    "---\n",
    "SampleMath 테이블\n",
    "```\n",
    "\n",
    "#### `abs`: 절대값 계산하기\n",
    "\n",
    "`abs` 함수는 해당 열에 있는 값들의 절대값을 구해준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5c4a46c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select m, abs(m) as abs_m\n",
    "from SampleMath;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fd2efc3",
   "metadata": {},
   "source": [
    "```{figure} image/sql/abs.png\n",
    "---\n",
    "name: abs\n",
    "---\n",
    "abs 함수\n",
    "```\n",
    "\n",
    "abs_m은 m열의 절대값을 계산한 것이며, 두번째 행을 보면 -180의 절대값에 해당하는 180이 계산되었다.\n",
    "\n",
    "#### `mod`: 나눗셈의 나머지 구하기\n",
    "\n",
    "7 나누기 3의 몫은 2이며 나머지는 1이다. `mod` 함수는 이 나머지에 해당하는 값을 구해준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9756fb08",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select n, p, mod(n, p) as mod_col\n",
    "from SampleMath;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b943266",
   "metadata": {},
   "source": [
    "```{figure} image/sql/mod.png\n",
    "---\n",
    "name: mod\n",
    "---\n",
    "mod 함수\n",
    "```\n",
    "\n",
    "`mod(n, p)`를 통해 n/p의 나머지를 구한다. 즉 7/3의 나머지인 1, 5/2의 나머지인 1이 계산되며, null은 계산이 불가한 데이터이므로 결과 역시 null로 나온다.\n",
    "\n",
    "### `round`: 반올림 하기\n",
    "\n",
    "`round` 함수를 통해 반올림을 할 수 있으며, 몇 째자리에서 반올림을 할지 정할 수 있다. `round(m, 2)`의 경우 할 경우 m열의 데이터를 소수 둘째자리까지 반올림한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfd094ba",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select m, n, round(m, n) as round_col\n",
    "from SampleMath;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd56a7ba",
   "metadata": {},
   "source": [
    "```{figure} image/sql/round.png\n",
    "---\n",
    "name: round\n",
    "---\n",
    "round 함수\n",
    "```\n",
    "\n",
    "위의 쿼리는 m 열을 n 자리까지 반올림한다. n이 0인 경우 소수 0번째 자리, 즉 정수부분까지 반올림을 한다. n이 1인 경우에는 소수 첫째자리까지 반올림을 하기 위해 소수 둘째자리에서 반올림을 한다. `round`와 비슷한 함수로 올림에는 `ceil`, 내림에는 `floor` 함수가 있으므로 상황에 맞게 사용하면 된다.\n",
    "\n",
    "### 문자열 함수\n",
    "\n",
    "문자열 함수는 문자 데이터를 처리할 때 사용되는 함수들이다. 먼저 아래의 샘플 테이블(SampleStr)을 만들도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48934c4f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create table SampleStr\n",
    "(str1  varchar(40),\n",
    " str2  varchar(40),\n",
    " str3  varchar(40));\n",
    "\n",
    "insert into SampleStr (str1, str2, str3) values ('가나다', '라마', NULL);\n",
    "insert into SampleStr (str1, str2, str3) values ('abc', 'def', NULL);\n",
    "insert into SampleStr (str1, str2, str3) values ('김', '철수', '입니다');\n",
    "insert into SampleStr (str1, str2, str3) values ('aaa', NULL, NULL);\n",
    "insert into SampleStr (str1, str2, str3) values (NULL, '가가가', NULL);\n",
    "insert into SampleStr (str1, str2, str3) values ('@!#$%', NULL,\tNULL);\n",
    "insert into SampleStr (str1, str2, str3) values ('ABC',\tNULL, NULL);\n",
    "insert into SampleStr (str1, str2, str3) values ('aBC',\tNULL, NULL);\n",
    "insert into SampleStr (str1, str2, str3) values ('abc철수', 'abc', 'ABC');\n",
    "insert into SampleStr (str1, str2, str3) values ('abcdefabc','abc', 'ABC');\n",
    "insert into SampleStr (str1, str2, str3) values ('아이우', '이','우');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd396361",
   "metadata": {},
   "source": [
    "```{figure} image/sql/samplestr.png\n",
    "---\n",
    "name: samplestr\n",
    "---\n",
    "SampleStr 테이블\n",
    "```\n",
    "\n",
    "#### `concat`: 문자열 연결\n",
    "\n",
    "`concat` 함수는 여러 열의 문자열을 연결하는데 사용됩니다. (타 RDMS에서는 ||로 문자를 합치기도 한다.) 먼저 str1과 str2 열의 문자를 합쳐보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "610b3faf",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select str1, str2, concat(str1, str2) as str_concat\n",
    "from SampleStr;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3fdccf9",
   "metadata": {},
   "source": [
    "```{figure} image/sql/concat.png\n",
    "---\n",
    "name: concat\n",
    "---\n",
    "concat 함수\n",
    "```\n",
    "\n",
    "두 열의 문자가 하나로 합쳐지며, null이 포함된 경우는 결과 역시 null이 반환된다.\n",
    "\n",
    "#### `lower`: 소문자로 변환\n",
    "\n",
    "`lower` 함수는 모든 알파벳을 소문자로 변환한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "545aff0f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select str1, lower(str1) as low_str\n",
    "from SampleStr;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a2f6844",
   "metadata": {},
   "source": [
    "```{figure} image/sql/lower.png\n",
    "---\n",
    "name: lower\n",
    "---\n",
    "lower 함수\n",
    "```\n",
    "\n",
    "ABC가 abc로 변환되는 등 모든 알파벳이 소문자로 변환되었다. 반대로 모든 알파벳을 대문자로 변환하고자 할 경우 `upper` 함수를 사용하면 된다.\n",
    "\n",
    "#### `replace`: 문자를 변경\n",
    "\n",
    "`replace` 함수는 문자열 안에 있는 일부 문자를 다른 문자열로 변경하며, `replace(대상 문자열, 치환 전 문자열, 치환 후 문자열)` 형태로 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b61a751b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select str1, str2, str3,\n",
    "\treplace(str1, str2, str3) as rep_str\n",
    "from SampleStr;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dcd2c58",
   "metadata": {},
   "source": [
    "```{figure} image/sql/replace.png\n",
    "---\n",
    "name: replace\n",
    "---\n",
    "replace 함수\n",
    "```\n",
    "\n",
    "str1열 중 str2열에 해당하는 문자가 있을 경우 str3열의 문자로 변경된다.\n",
    "\n",
    "### 날짜 함수\n",
    "\n",
    "SQL에는 날짜를 다루는 많은 함수가 있으며, DBMS 종류마다 그 형태가 약간씩 다르다.\n",
    "\n",
    "#### 현재 날짜, 시간, 일시\n",
    "\n",
    "현재 날짜(`current_date`)와 시간(`current_time`), 일시(`current_timestamp`)를 다루는 함수의 경우 from 구문이 없이 사용이 가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "253d3f26",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select current_date, current_time, current_timestamp;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c497b5",
   "metadata": {},
   "source": [
    "```{figure} image/sql/current.png\n",
    "---\n",
    "name: current\n",
    "---\n",
    "현재 날짜 및 시간 관련 함수\n",
    "```\n",
    "\n",
    "#### 날짜 요소 추출하기\n",
    "\n",
    "`extract(날짜 요소 from 날짜)` 함수를 통해 년, 월, 시, 초 등을 추출할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36760e2c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select\n",
    "    current_timestamp,\n",
    "    extract(year from current_timestamp) as year,\n",
    "    extract(month from current_timestamp) as month,\n",
    "    extract(day\tfrom current_timestamp) as day,\n",
    "    extract(hour from current_timestamp) as hour,\n",
    "    extract(minute from current_timestamp) as minute,\n",
    "    extract(second from current_timestamp) as second;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe2e1a1f",
   "metadata": {},
   "source": [
    "```{figure} image/sql/extract.png\n",
    "---\n",
    "name: extract\n",
    "---\n",
    "날짜 요소 추출하기\n",
    "```\n",
    "\n",
    "### 술어\n",
    "\n",
    "술어란 반환 값이 진리값(TRUE, FALSE, UNKNOWN)인 함수를 가리킨다. 대표적인 예로는 `like`, `between`, `is null`, `in` 등이 있다.\n",
    "\n",
    "#### `like`: 문자열 부분 일치\n",
    "\n",
    "앞에서 문자열을 검색할 때는 등호(=)를 사용했지만, 이는 완전히 일치하는 경우에만 참이 된다. 반면 `like` 술어는 문자열 중 **부분 일치를 검색**할 때 사용한다. 먼저 아래의 테이블을 만들도록 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e252a758",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "create table SampleLike\n",
    "(strcol varchar(6) not null,\n",
    "primary key (strcol));\n",
    "\n",
    "insert into SampleLike (strcol) values ('abcddd');\n",
    "insert into SampleLike (strcol) values ('dddabc');\n",
    "insert into SampleLike (strcol) values ('abdddc');\n",
    "insert into SampleLike (strcol) values ('abcdd');\n",
    "insert into SampleLike (strcol) values ('ddabc');\n",
    "insert into SampleLike (strcol) values ('abddc');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29493cdc",
   "metadata": {},
   "source": [
    "```{figure} image/sql/samplelike.png\n",
    "---\n",
    "name: samplelike\n",
    "---\n",
    "SampleLike 테이블\n",
    "```\n",
    "\n",
    "일치에는 크게 3가지 종류가 있다. \n",
    "\n",
    "- 전방 일치: 검색 조건이 되는 문자열이 검색 대상 문자열의 가장 앞에 위치하고 있는 레코드를 선택한다.\n",
    "- 중간 일치: 검색 조건이 되는 문자열이 검색 대상 문자열의 어딘가에 포함되어 있으면 레코드를 검색하며 위치는 어디든 상관없다.\n",
    "- 후방 일치: 검색 조건이 되는 문자열이 검색 대상 문자열의 가장 뒤에 위치하고 있는 레코드를 검색한다.\n",
    "\n",
    "먼저 전방 일치 검색은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5ab46f3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from samplelike\n",
    "where strcol like 'ddd%';"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efbbbcad",
   "metadata": {},
   "source": [
    "```{figure} image/sql/find_1.png\n",
    "---\n",
    "name: find_1\n",
    "---\n",
    "전방 일치 검색\n",
    "```\n",
    "\n",
    "`%`는 '0문자 이상의 임의 문자열' 을 의미하는 특수 기호이며, 위의 예에서 'ddd%'는 'ddd로 시작하는 모든 문자열'을 의미한다. \n",
    "\n",
    "다음으로 중간 일치 검색은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e042438",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from SampleLike\n",
    "where strcol like '%ddd%';"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c12cbb",
   "metadata": {},
   "source": [
    "```{figure} image/sql/find_2.png\n",
    "---\n",
    "name: find_2\n",
    "---\n",
    "중간 일치 검색\n",
    "```\n",
    "\n",
    "위의 예에서 '%ddd%' 처럼 문자열 처음과 끝을 %로 감쌀 경우 '문자열 안에 ddd를 포함하고 있는 모든 문자열'을 나타낸다. {numref}`find_2`의 결과를 살펴보면 ddd로 시작하거나 끝나는, 혹은 문자열 가운데에 ddd가 있는 문자열이 검색된다.\n",
    "\t\n",
    "마지막으로 후방 일치 검색을 해보도록 하겠다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43fcc0c7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from SampleLike\n",
    "where strcol like '%ddd';"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe7d8d7c",
   "metadata": {},
   "source": [
    "```{figure} image/sql/find_3.png\n",
    "---\n",
    "name: find_3\n",
    "---\n",
    "후방 일치 검색\n",
    "```\n",
    "\n",
    "'%ddd'의 경우 전방 일치와 반대로 ddd로 끝나는 문자열을 검색한다. \n",
    "\n",
    "#### `between`: 범위 검색\n",
    "\n",
    "`between`은 범위 검색을 수행한다. goods 테이블에서 sell_price가 100원부터 1000원까지인 상품을 선택할 때 `between` 술어를 사용하면 다음과 같이 나타낼 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c45f32d5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where sell_price between 100 and 1000;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d70ed673",
   "metadata": {},
   "source": [
    "```{figure} image/sql/between.png\n",
    "---\n",
    "name: between\n",
    "---\n",
    "between 술어\n",
    "```\n",
    "\n",
    "`between`을 사용할 경우 범위에 해당하는 100과 1000 데이터도 포함한다.\n",
    "\n",
    "#### `is null`, `is not null`: null 데이터 선택\n",
    "\n",
    "만일 null이 포함된 행을 선택하려면 어떻게 해야 할까? where 구를 `where buy_price == null` 형식으로 작성하면 될 듯 하지만 해당 쿼리를 실행하면 오류가 발생한다. 이는 null이 비교가 불가능한 특별한 표시어이기 때문이며, 이때는 `is null` 술어를 사용해야 한다. 먼저 buy_price가 null인 데이터를 선택하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d28e1279",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where buy_price is null;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28f2d67f",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_isnull.png\n",
    "---\n",
    "name: ope_isnull\n",
    "---\n",
    "is null 술어\n",
    "```\n",
    "\n",
    "buy_price가 null인 데이터만 선택된다. 반대로 null이 포함되지 않은 데이터만 선택하고 싶을 때는 `is not null` 술어를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cf6da44",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where buy_price is not null;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbcff073",
   "metadata": {},
   "source": [
    "```{figure} image/sql/ope_isnotnull.png\n",
    "---\n",
    "name: ope_isnotnull\n",
    "---\n",
    "is not null 술어\n",
    "```\n",
    "\n",
    "#### `in`: 복수의 값을 지정\n",
    "\n",
    "만일 buy_price가 320, 500, 5000인 상품을 선택할 경우, or을 쓰면 다음과 같이 쿼리를 작성해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba8a14f0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where buy_price = 320 \n",
    "\tor buy_price = 500\n",
    "\tor buy_price = 5000;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15b1534a",
   "metadata": {},
   "source": [
    "그러나 이러한 나열식의 쿼리는 조건이 많아질수록 길어지고 효율성이 떨어진다. 이 때 사용할 수 있는 것이 `in` 술어로써 `in(값 1, 값 2, …)` 형태를 통해 간단하게 표현할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c97441a3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where buy_price in (320, 500, 5000);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2d071c2",
   "metadata": {},
   "source": [
    "```{figure} image/sql/in.png\n",
    "---\n",
    "name: in\n",
    "---\n",
    "in 술어\n",
    "```\n",
    "\n",
    "반대로 buy_price가 320, 500, 5000이 아닌 데이터만 선택하고 싶을 때는 `not in` 술어를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f7dcc41",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "where buy_price not in (320, 500, 5000);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5590e10",
   "metadata": {},
   "source": [
    "```{figure} image/sql/not_in.png\n",
    "---\n",
    "name: not_in\n",
    "---\n",
    "not in 술어\n",
    "```\n",
    "\n",
    "### `case` 식\n",
    "\n",
    "case 식은 경우에 따라 값을 구분하며, 쿼리 형식은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b28cc4be",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "case when <평가식 1> then <식 1>\n",
    "    when <평가식 2> then <식 2>\n",
    "    when <평가식 3> then <식 3>\n",
    "        ⋮\n",
    "    else <식 n>\n",
    "end"
   ]
  },
  {
   "cell_type": "raw",
   "id": "fdda404e",
   "metadata": {},
   "source": [
    "예를 들어 sell_price가 6000 이상이면 고가, 3000과 6000 사이면 저가, 3000 미만이면 저가로 구분할 경우, `case`식을 사용하여 각 평가식에 따른 구분을 할 수 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb34a205",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, sell_price,\n",
    "\tcase when sell_price >=  6000 then '고가'    \n",
    "\t\t when sell_price >= 3000 and sell_price < 6000 then '중가'\n",
    "         when sell_price < 3000 then '저가'\n",
    "\t\t else null\n",
    "end as price_classify\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba041d3e",
   "metadata": {},
   "source": [
    "```{figure} image/sql/case.png\n",
    "---\n",
    "name: case\n",
    "---\n",
    "case 식\n",
    "```\n",
    "\n",
    "`else` 구문은 위에서 만족하는 조건이 없을 때의 반환값으로써 생략할 수도 있지만 명시적으로 기술하는 것이 좋으며, `end`는 생략이 불가능하다. 조건에 따른 결과가 end as 뒤에 입력한 'price_classify' 열에 표시된다.\n",
    "\n",
    "## 테이블의 집합과 결합\n",
    "\n",
    "SQL을 사용할 경우 하나의 테이블만 이용해 데이터를 다루는 일은 거의 없으며, 한번에 여러개의 테이블을 더하거나 결합하여 원하는 데이터를 얻을 수 있다. 이번에는 테이블의 집합 연산과 각종 결합 방법에 대해 알아보도록 하겠다.\n",
    "\n",
    "### 테이블 더하기\n",
    "\n",
    "`union` 구문을 사용하면 테이블을 위 아래로 더할 수 있다. 먼저 샘플 테이블(Goods2)을 추가로 만든 후, 데이터를 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e13e931",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "CREATE TABLE Goods2\n",
    "(goods_id CHAR(4) NOT NULL,\n",
    " goods_name VARCHAR(100) NOT NULL,\n",
    " goods_classify VARCHAR(32) NOT NULL,\n",
    " sell_price INTEGER,\n",
    " buy_price INTEGER,\n",
    " register_date DATE,\n",
    " PRIMARY KEY (goods_id));\n",
    "\n",
    "insert into Goods2 values ('0001', '티셔츠' ,'의류', 1000, 500, '2020-09-20');\n",
    "insert into Goods2 values ('0002', '펀칭기', '사무용품', 500, 320, '2020-09-11');\n",
    "insert into Goods2 values ('0003', '와이셔츠', '의류', 4000, 2800, NULL);\n",
    "insert into Goods2 values ('0009', '장갑', '의류', 800, 500, NULL);\n",
    "insert into Goods2 values ('0010', '주전자', '주방용품', 2000, 1700, '2020-09-20');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f776d2c4",
   "metadata": {},
   "source": [
    "```{figure} image/sql/goods2.png\n",
    "---\n",
    "name: goods2\n",
    "---\n",
    "Goods2 테이블\n",
    "```\n",
    "\n",
    "기존의 Goods 테이블과 새로 만든 Goods2 테이블을 위아래로 합쳐보도록 한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d1ae661",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "union\n",
    "select *\n",
    "from goods2;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc76ab76",
   "metadata": {},
   "source": [
    "```{figure} image/sql/union_1.png\n",
    "---\n",
    "name: union_1\n",
    "---\n",
    "테이블 합치기\n",
    "```\n",
    "\n",
    "상품ID가 001, 002, 003인 3개 행은 양쪽 테이블에 모두 존재하며, `union` 구문에서는 중복행을 제외하고 테이블을 합쳤다. 만일 중복 행을 포함하여 테이블을 합치고자 할 경우에는 `union all` 구문을 사용하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dc816eb",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select *\n",
    "from goods\n",
    "union all\n",
    "select *\n",
    "from goods2;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "354bcbd3",
   "metadata": {},
   "source": [
    "```{figure} image/sql/union_2.png\n",
    "---\n",
    "name: union_2\n",
    "---\n",
    "테이블 합치기 (중복 행 포함)\n",
    "```\n",
    "\n",
    "이처럼 집합 연산을 사용할 때의 주의점은 다음과 같다.\n",
    "\n",
    "- 연산 대상이 되는 레코드의 열 갯수가 같아야 한다.\n",
    "- 덧셈 대상이 되는 레코드의 열이 같은 데이터형이어야 한다.\n",
    "- order by 구는 마지막에 하나만 사용 가능하다.\n",
    "\n",
    "```{note}\n",
    "공통 부분을 선택하는 교집합이나 레코드 뺄셈을 하는 여집합의 경우 타 DBMS에서는 각각 `intersect`와 `except` 구문을 사용하면 되지만, MySQL에서는 아직 이를 지원하지 않는다.\n",
    "```\n",
    "\n",
    "### 테이블 결합\n",
    "\n",
    "앞서 살펴 본 `union` 은 행으로 테이블을 합치는 것이었다. 이번에 살펴 볼 결합(`join`)은 다른 테이블에서 열을 가지고 와 **열을 늘리는** 작업을 한다. 실무에서는 원하는 데이터가 여러 테이블에 분산되어 있는 경우가 많으므로, 테이블을 결합하여 사용해야 한다. `join`을 시각화하면 다음과 같다.\n",
    "\n",
    "```{figure} image/sql/join.png\n",
    "---\n",
    "name: join\n",
    "---\n",
    "테이블 결합 방법들\n",
    "```\n",
    "\n",
    "먼저 아래의 테이블(StoreGoods)을 만든다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56623992",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "CREATE TABLE StoreGoods\n",
    "(store_id CHAR(4) NOT NULL,\n",
    " store_name VARCHAR(200) NOT NULL,\n",
    " goods_id CHAR(4) NOT NULL,\n",
    " num INTEGER NOT NULL,\n",
    " PRIMARY KEY (store_id, goods_id));\n",
    "\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000A', '서울',\t'0001',\t30);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000A', '서울',\t'0002',\t50);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000A', '서울',\t'0003',\t15);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000B', '대전',\t'0002',\t30);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000B',' 대전',\t'0003',\t120);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000B', '대전',\t'0004',\t20);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000B', '대전',\t'0006',\t10);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000B', '대전',\t'0007',\t40);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000C', '부산',\t'0003',\t20);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000C', '부산',\t'0004',\t50);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000C', '부산',\t'0006',\t90);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000C', '부산',\t'0007',\t70);\n",
    "insert into StoreGoods (store_id, store_name, goods_id, num) values ('000D', '대구',\t'0001',\t100);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f06f44ba",
   "metadata": {},
   "source": [
    "```{figure} image/sql/StoreGoods.png\n",
    "---\n",
    "name: StoreGoods\n",
    "---\n",
    "StoreGoods 테이블\n",
    "```\n",
    "\n",
    "Goods와 StoreGoods 테이블에 있는 열들을 정리하면 다음과 같다.\n",
    "\n",
    "```{table} 샘플 테이블 내 열 비교\n",
    ":name: sample_table_compare\n",
    "| | Goods와 | StoreGoods |\n",
    "| --- | --- | --- | \n",
    "| goods_id (상품ID) | O | O |\n",
    "| goods_name (상품명) | O |  |\n",
    "| goods_classify (상품분류) | O | |\n",
    "| sell_price (판매단가) | O |  |\n",
    "| buy_price (매입단가) | O | |\n",
    "| register_date (등록일) | O | |\n",
    "| store_id (점포ID) | | O |\n",
    "| store_name (점포명) | | O |\n",
    "| num (수량) | | O |\n",
    "```\n",
    "\n",
    "#### `inner join`: 내부 결합\n",
    "\n",
    "내부 결합(inner join)은 가장 많이 사용되는 결합 방법이다. {numref}`sample_table_compare`를 살펴보면 goods_id는 두 테이블에 모두 존재하며, 다른 열들은 한쪽 테이블에만 존재한다. 따라서 goods_id를 기준으로 StoreGoods 테이블에 Goods 테이블을 결합하는 방법은 다음과 같으며, 이는 마치 엑셀의 vlookup과도 비슷하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75921be2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select store.store_id, store.store_name, store.goods_id,\n",
    "\tgoods.goods_name, goods.sell_price\n",
    "from StoreGoods as store \n",
    "inner join Goods as goods\n",
    "\ton store.goods_id = goods.goods_id;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d17e2d77",
   "metadata": {},
   "source": [
    "```{figure} image/sql/inner_join.png\n",
    "---\n",
    "name: inner_join\n",
    "---\n",
    "inner join\n",
    "```\n",
    "\n",
    "1. 지금까지는 from에 하나의 테이블만 지정했지만, join 시에는 두 테이블(StoreGoods, Goods)에서 내용을 가지고 온다. 따라서 두 테이블에 store와 goods라는 별명을 붙였다. (원래 테이블명을 그대로 사용해도 되나 테이블명이 길면 가독성이 떨어지므로 일반적으로 별명을 붙인다.)\n",
    "2. on 뒤에 결합 조건을 붙인다. 이는 `* join` 구문 바로 뒤에 붙이며, store의 goods_id 열과 goods 열의 goods_id 열을 이용해 두 테이블을 연결한다는 의미다.\n",
    "3. select 구에서는 <테이블 별명>.<열 이름> 형식으로 기술한다. 이는 테이블이 여러개가 있으므로, 어느 테이블에서 데이터를 가지고 오는지 혼동하는 것을 방지하기 위해서이다.\n",
    "\n",
    "#### `outer join` 외부 결합\n",
    "\n",
    "inner join은 두 테이블에 모두 존재하는 데이터를 합쳤지만, outer join은 한쪽 테이블에만 존재하는 데이터도 출력한다. 먼저 StoreGoods와 Goods에 존재하는 상품ID를 검색한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "002f089b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select distinct(goods_id) from StoreGoods;\n",
    "select distinct(goods_id) from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7425ff5",
   "metadata": {},
   "source": [
    "- StoreGoods: 0001, 0002, 0003, 0004, 0006, 0007\n",
    "- Goods: 0001, 0002, 0003, 0004, 0005, 0006, 0007, 0008\n",
    "\n",
    "StoreGoods 1~4, 6~7번이, Goods 1번부터 8번까지 상품이 있다. 즉, StoreGoods 5번(압력솥)과 8번(볼펜) ID에 해당하는 물건이 없다. 이제 `outer join`을 해보도록 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caa768d2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select store.store_id, store.store_name, goods.goods_id,\n",
    "\tgoods.goods_name, goods.sell_price\n",
    "from StoreGoods as store \n",
    "right outer join Goods as goods\n",
    "\ton store.goods_id = goods.goods_id;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27204f99",
   "metadata": {},
   "source": [
    "```{figure} image/sql/outer_join_right.png\n",
    "---\n",
    "name: outer_join_right\n",
    "---\n",
    "outer join (right)\n",
    "```\n",
    "\n",
    "goods_id가 5(압력솥)와 8(볼펜)의 경우 StoreGoods 테이블에 데이터가 존재하지 않는다. 즉, 현재 어떤 점포에서도 취급하지 않는 상품이다. `inner join`은 양쪽 테이블에 모두 존재하는 정보만을 선택하기 때문에 Goods 테이블에만 존재하는 두 상품은 결과로 출력되지 않았다. 반면 `outer join`은 한쪽 테이블에만 존재해도 누락 없이 모두 출력하며, 정보가 없는 부분은 NULL로 표시한다.\n",
    "\n",
    "또한 `outer join`은 어느 쪽 테이블을 마스터로 할 것인지 정해야 한다. 즉 left 혹은 right를 지정해주어야 한다. left를 사용하면 from 구에서 왼쪽에 지정한 테이블을 마스터로 설정하며, right를 사용하면 오른쪽 테이블을 마스터로 한다. 위의 쿼리는 마스터 테이블을 right로 지정하였기에 오른쪽에 해당하는 Goods 테이블의 내용이 모두 출력되고, goods_id를 기준으로 왼쪽에 해당하는 StoreGoods 테이블의 내용이 결합되었다. 위 쿼리를 `left outer join` 으로 바꿔보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee691327",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select store.store_id, store.store_name, goods.goods_id,\n",
    "\tgoods.goods_name, goods.sell_price\n",
    "from StoreGoods as store \n",
    "left outer join Goods as goods\n",
    "\ton store.goods_id = goods.goods_id;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b8cd6aa",
   "metadata": {},
   "source": [
    "```{figure} image/sql/outer_join_left.png\n",
    "---\n",
    "name: outer_join_left\n",
    "---\n",
    "outer join (left)\n",
    "```\n",
    "\n",
    "마스터 테이블인 StoreGoods에 존재하는 goods_id(1~4, 6~7)는 결합되는 테이블인 Goods에도 모두 존재하므로 이번에는 NULL이 생성되지 않는다. 어떤 테이블을 기준으로 삼아야 하는가를 미리 생각하여 `left outer join`을 할지 `right outer join`을 할지 결정해야 한다.\n",
    "\n",
    "```{note}\n",
    "join 할 수 있는 테이블의 갯수는 제한이 없다.\n",
    "```\n",
    "\n",
    "## SQL 고급 처리\n",
    "\n",
    "이번에는 마지막으로 순위 계산, 누적합 계산, 소계를 구하는 등 고급 집계 처리를 하는 방법인 윈도우 함수에 대해 배워보겠다.\n",
    "\n",
    "### 윈도우 함수\n",
    "\n",
    "윈도우 함수를 이용하면 랭킹, 순번 생성 등 일반적인 집약 함수로는 불가능한 고급처리를 할 수 있다. 윈도우 함수의 사용법은 크게 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11a96a7b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "<윈도우 함수> over ([partition by <열 리스트>] order by <정렬용 열 리스트>)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c27a2ec",
   "metadata": {},
   "source": [
    "이 중 `partition by`는 생략이 가능하다. \n",
    "\n",
    "윈도우 함수로 사용할 수 있는 함수는 크게 다음과 같다.\n",
    "\n",
    "- 윈도우 전용 함수: `rank`, `dense_rank`, `row_number` 등\n",
    "- 집약함수: `sum`, `avg`, `count`, `max`, `min` 등\n",
    "\n",
    "```{note}\n",
    "윈도우 전용 함수는 원칙적으로 select 구에만 사용할 수 있다.\n",
    "```\n",
    "\n",
    "#### `rank`: 순위를 계산\n",
    "\n",
    "`rank` 함수는 순위를 구하는 함수다. 예를 들어 Goods 테이블의 상품 중 상품분류(goods_classify) 별로 판매단가(sell_price)가 낮은 순서대로 순위를 구하는 방법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4440a41",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, sell_price,\n",
    "\trank() over (partition by goods_classify order by sell_price) as ranking\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2970fba2",
   "metadata": {},
   "source": [
    "```{figure} image/sql/rank.png\n",
    "---\n",
    "name: rank\n",
    "---\n",
    "rank 함수\n",
    "```\n",
    "\n",
    "1. `partition by`는 순위를 정할 대상 범위를 설정하며, 어떤 조건으로 그룹을 나눈다고 생각하면 이해가 쉽다. 상품 분류마다 순위를 구하고자 하므로 goods_classify를 입력한다.\n",
    "2. `order by`는 윈도우 함수를 어떤 열에 어떤 순서로 적용할지 정한다. 판매단가를 오름차순으로 순위를 구하고자 하므로 sell_price를 입력하였다. 만일 내림차순으로 순위를 구하고자 할 경우 `desc` 를 입력하면 된다. (기본적으로 asc 즉 오름차순이 적용된다.)\n",
    "3. 순위를 구하는 윈도우 전용 함수인 `rank()`를 입력한다.\n",
    "\n",
    "이 중 `partition by`를 통해 구분된 레코드 집합을 '윈도우'라고 하며, 이는 '범위'를 나타낸다. 만일 `partition by`를 지정하지 않으면 전체 테이블이 윈도우가 되므로, 아래와 같이 sell_price 열 자체를 기준으로 순위가 구해진다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71f425c0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, sell_price,\n",
    "\trank () over (order by sell_price) as ranking\n",
    "from Goods; "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dbe5346",
   "metadata": {},
   "source": [
    "```{figure} image/sql/rank_2.png\n",
    "---\n",
    "name: rank_2\n",
    "---\n",
    "rank 함수 (전체 기준)\n",
    "```\n",
    "\n",
    "순위를 구하는 함수는 rank 외에도 다양하게 존재하며, 그 결과가 약간씩 다르다.\n",
    "\n",
    "- `rank`: 같은 순위인 행이 복수개 있으면 후순위를 건너뛴다.\n",
    "예) 1위가 3개인 경우: 1위, 1위, 1위, 4위, …\n",
    "- `dense_rank`: 같은 순위인 행이 복수가 있어도 후순위를 건너뛰지 않는다.\n",
    "예) 1위가 3개인 경우: 1위, 1위, 1위, 2위, …\n",
    "- `row_number`: 순위와 상관없이 연속 번호를 부여한다.\n",
    "예: 1위가 3개인 레코드인 경우: 1위, 2위, 3위, 4위, …\n",
    "\n",
    "각 함수 별 차이를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06b0922e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_name, goods_classify, sell_price,\n",
    "\trank() over (order by sell_price) as ranking,\n",
    "    dense_rank() over (order by sell_price) as ranking,\n",
    "    row_number() over (order by sell_price) as ranking\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17c9bfb1",
   "metadata": {},
   "source": [
    "```{figure} image/sql/rank_3.png\n",
    "---\n",
    "name: rank_3\n",
    "---\n",
    "순위를 구하는 함수들\n",
    "```\n",
    "\n",
    "#### 윈도우 함수에서 집약 함수의 사용\n",
    "\n",
    "`sum`이나 `avg`와 같은 집약 함수도 윈도우 함수로 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa91e66a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_name, sell_price,\n",
    "\tsum(sell_price) over() as current_sum\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a3649b2",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_sum.png\n",
    "---\n",
    "name: window_sum\n",
    "---\n",
    "윈도우 함수에서 sum\n",
    "```\n",
    "\n",
    "`over()`를 빈 칸으로 둘 경우 current_sum 열에는 모든 sell_price의 합계가 나타난다. 이번에는 누적합계를 구해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b943815",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_name, sell_price,\n",
    "\tsum(sell_price) over(order by goods_id) as current_sum\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "703901e1",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_sum_2.png\n",
    "---\n",
    "name: window_sum_2\n",
    "---\n",
    "윈도우 함수에서 sum (누적합계)\n",
    "```\n",
    "\n",
    "`order by`에 열을 지정할 경우 goods_id를 기준으로 오름차순으로 정렬한 후 누적합계를 구한다. 즉 첫번째 행은 1000, 두번째 행은 1000+500=1500, 세번째 행은 1000+500+4000=5500 과 같이 누적해서 합계가 계산되며, 이는 다른 집계함수도 마찬가지이다. 이번에는 누적평균을 계산해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d72a8fb",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_name, sell_price,\n",
    "\tavg(sell_price) over(order by goods_id) as current_avg\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d958bc37",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_avg.png\n",
    "---\n",
    "name: window_avg\n",
    "---\n",
    "윈도우 함수에서 avg (누적평균)\n",
    "```\n",
    "\n",
    "누적합계와 동일하게 첫번째 행은 (1000)/1=1000, 두번째 행은 (1000+500)/2=750, 세번째 행은 (1000+500+4000)/3=1833.33과 같이 누적해가며 평균을 계산한다.\n",
    "\n",
    "`partition by`를 추가하면 윈도우 별로 집계도 가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8b27ef9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_classify, goods_name, sell_price,\n",
    "\tsum(sell_price) over(partition by goods_classify order by goods_id) as current_sum\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b87ff28",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_sum_3.png\n",
    "---\n",
    "name: window_sum_3\n",
    "---\n",
    "윈도우 별 집계\n",
    "```\n",
    "\n",
    "{numref}`window_sum_3`을 보면 partition by에 해당하는 goods_classify 별로(사무용품, 의류, 주방용품) 누적합계가 계산된다.\n",
    "\n",
    "#### 이동평균 계산하기\n",
    "\n",
    "윈도우 함수에서는 그 범위를 정해 '프레임'을 만들 수도 있다. 이는 `over` 내의 `order by` 구문 뒤에 범위 지정 키워드를 사용하면 된다. 예를 들어 모든 열에 대한 누적평균이 아닌 최근 3개 데이터만 이용해 평균을 구하는 이동평균을 계산하는 쿼리는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87c0867e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_classify, goods_name, sell_price,\n",
    "\tavg(sell_price) over(order by goods_id rows 2 preceding) as moving_avg\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61191cff",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_ma.png\n",
    "---\n",
    "name: window_ma\n",
    "---\n",
    "이동평균 계산하기\n",
    "```\n",
    "\n",
    "`rows n proceding`을 입력할 경우 앞의 n 행까지만 프레임을 만들어 계산한다. 위 예제에서는 n=2를 입력했으므로 현재 행과 앞의 두개 행, 즉 3개 행으로만 이동평균을 계산한다. {numref}`window_ma`의 결과를 살펴보면 1행과 2행은 앞의 두개 행에 해당하는 데이터가 없으므로 존재하는 데이터들로 평균이 계산된다. 3행은 1~3행을 이용해 평균이 계산되며 4행은 2~4행, 5행은 3~5행 등 프레임이 움직이며 이동평균이 계산된다.\n",
    "\n",
    "앞의 행이 아닌 뒤의 행을 이용해 계산하고 싶을 경우 `preceding` 대신 `following`을 입력한다. 현재 행과 뒤의 두개 행으로 이동평균을 계산하는 법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29505313",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_classify, goods_name, sell_price,\n",
    "\tavg(sell_price) over(order by goods_id rows between current row and 2 following) as moving_avg\n",
    "from Goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0c65457",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_ma_2.png\n",
    "---\n",
    "name: window_ma_2\n",
    "---\n",
    "이동평균 계산하기 (2)\n",
    "```\n",
    "\n",
    "`current row and 2 following`는 현재 행과 뒤의 두개 행을 의미하며, 앞서 살펴 본 `preceding`과 반대로 뒤에서 부터 이동평균의 계산된다. `preceding`과 `following`을 동시에 사용하는 것도 가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b28d619d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "select goods_id, goods_classify, goods_name, sell_price,\n",
    "\tavg(sell_price) over(order by goods_id\n",
    "    rows between 1 preceding and 1 following)\n",
    "    as moving_avg\n",
    "from goods;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34550253",
   "metadata": {},
   "source": [
    "```{figure} image/sql/window_ma_3.png\n",
    "---\n",
    "name: window_ma_3\n",
    "---\n",
    "이동평균 계산하기 (3)\n",
    "```\n",
    "\n",
    "`rows between n preceding and m following`을 입력하면 앞의 n행과 뒤의 m행 까지를 프레임으로 지정한다. 위의 예에서는 앞의 1개 행과 뒤의 1개 행, 총 3개 행을 이용해 이동평균이 계산된다"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}