[DATABASE] DQL SECTION2

성장일기·2024년 7월 2일

boot camp db

[SWCAMP] DB

목록 보기

4/14

JOIN

ALIAS

SQL문의 컬럼 또는 테이블에 별칭을 달아줄 수 있다.
컬럼 별칭
- resultSet의 컬럼명이 별칭으로 바뀜
- 별칭에 띄어쓰기나 특수기호가 없다면 홑따옴표(')와 AS는 생략 가능하다.
테이블 별칭
- 테이블에 별칭을 작성할 수 있으며 어떤 테이블 소속인지를 쉽게 알 수 있게 한다.
- 테이블 별칭은 AS를 써도 되고 생략도 가능하다.
```
SELECT
       a.category_code
     , a.menu_name
--   FROM tbl_menu AS a
  FROM tbl_menu a
 ORDER BY a.category_code, a.menu_name;
```
  실행결과

JOIN의 종류

INNER JOIN

두 테이블의 교집합을 반환하는 SQL JOIN 유형

INNER JOIN에서 INNER 키워드는 생략이 가능하다.

ON을 활용한 JOIN

컬럼명이 같거나 다를 경우 ON으로 서로 연관있는 컬럼에 대한 조건을 작성하여 JOIN하는 경우

SELECT
       a.menu_name
     , b.category_name

  FROM tbl_menu a
--  INNER JOIN tbl_category b ON a.category_code = b.category_code;
  JOIN tbl_category b ON a.category_code = b.category_code;

USING을 활용한 JOIN

컬럼명이 같을 경우 USING으로 서로 연관있는 컬럼에 대한 조건을 작성하여 JOIN하는 경우

SELECT
       a.menu_name
     , b.category_name
  FROM tbl_menu a
--  INNER JOIN tbl_category b USING (category_code);
  JOIN tbl_category b USING (category_code);

LEFT JOIN

첫 번째(왼쪽) 테이블의 모든 레코드와 두 번째(오른쪽) 테이블에서 일치하는 레코드를 반환하는 SQL JOIN 유형

SELECT
       a.menu_name
     , b.category_name
  FROM tbl_menu a
  LEFT JOIN tbl_category b ON a.category_code = b.category_code;

RIGHT JOIN

두 번째(오른쪽) 테이블의 모든 레코드와 첫 번째(왼쪽) 테이블에서 일치하는 레코드를 반환하는 SQL JOIN 유형

SELECT                                                          
       a.menu_name                                              
     , b.category_name                                          
  FROM tbl_menu a                                               
 RIGHT JOIN tbl_category b ON a.category_code = b.category_code;

CROSS JOIN

두 테이블의 모든 가능한 조합을 반환하는 SQL JOIN 유형

SELECT
       a.menu_name
     , b.category_name
  FROM tbl_menu a
 CROSS JOIN tbl_category b;

SELF JOIN

같은 테이블 내에서 행과 행 사이의 관계를 찾기 위해 사용되는 SQL JOIN 유형

카테고리별 대분류 확인을 위한 SELF JOIN 조회

SELECT
       a.category_name
     , b.category_name
  FROM tbl_category a
  JOIN tbl_category b ON a.ref_category_code = b.category_code
 WHERE a.ref_category_code IS NOT NULL;

JOIN 알고리즘

MariaDB 5.3 버전까지는 네스티드 루프(Nested Loop) 알고리즘 형태밖에 없었지만 현재는 다양해 졌다.
- 단순 네스티드 루프(Simple Nested Loop)
  - 가장 기본적인 조인 알고리즘으로 한 테이블의 각 행에 대해 다른 테이블의 모든 행을 순회하면서 조인 조건을 만족하는지 확인한다.
  - 매우 단순하지만 큰 데이터 세트에서는 비효율적일 수 있다.
- 블록 네스티드 루프(Block Nested Loop)
  - 단순 네스티드 루프를 개선한 버전으로 데이터를 테이블(드라이빙 테이블)로부터 블록 단위로 불러와서 한 블록의 모든 행을 다른 테이블(드리븐 테이블)의 블록과 비교한다.
  - I/O 작업을 줄여 성능을 향상시킬 수 있다.
- 블록 네스티드 루프 해쉬(Block Nested Loop Hash)
  - 블록 네스티드 루프와 유사하지만 해쉬 테이블을 사용하여 조인 조건을 만족하는 행을 더 효율적으로 찾는다.
  - 해쉬 함수를 사용하여 조인 키를 빠르게 매칭할 수 있어 성능이 더욱 향상된다.
- 블록 인덱스(Block Index Join, Batched Key Access)
  - 인덱스를 활용하여 조인을 수행한다.
  - 인덱스를 사용하여 필요한 행만을 효율적으로 액세스하고, 불필요한 행의 검색을 최소화하여 성능을 개선한다.
- 블록 인덱스 해쉬(Block Index Hash Join, Batched Key Access Hash)
  - 블록 인덱스 조인에 해쉬 기능이 추가된 것이다.
  - 해쉬 테이블을 활용하여 인덱스의 조인 성능을 더욱 향상시켜 빠른 매칭이 필요한 경우 유용하다.
조인 캐시 레벨(join_cache_level)
- MariaDB 10.0에서는 4가지 형태의 블록 기반 조인 알고리즘을 제공하고 있는데, 이들은 모두 조인 버퍼에 예전 방식으로 레코드 필드를 복사하는 플랫(flat)방식과 중복값 없이 포인터만 조인 버퍼에 저장하는 인크리멘탈(incremental)방식이 있다.
- BNL
  - 블록 네스티드 루프(Block Nested Loop - Flat)
  - 블록 네스티드 루프(Block Nested Loop - Incremental)
- BNLH
  - 블록 네스티드 루프 해쉬(Block Nested Loop Hash - Flat)
  - 블록 네스티드 루프 해쉬(Block Nested Loop Hash - Incremental)
- BKA
  - 배치 키 액세스(Batched Key Access - Flat)
  - 배치 키 액세스(Batched Key Access - Incremental)
- BKAH
  - 배치 키 액세스 해쉬(Batched Key Access Hash - Flat)
  - 배치 키 액세스 해쉬(Batched Key Access Hash - Incremental)
join_cache_level을 통해 알고리즘을 고를 수 있다.

Server System Variables

DROP TABLE t1;
DROP TABLE t2;

CREATE TABLE t1 (
id int(10) NOT NULL AUTO_INCREMENT ,
c1 int(10) NOT NULL DEFAULT '0',
c2 int(10) NOT NULL DEFAULT '0',
PRIMARY KEY (id),
KEY idx_c1 (c1)
) ENGINE=InnoDB;

CREATE TABLE t2 (
id int(10) NOT NULL AUTO_INCREMENT ,
c1 int(10) NOT NULL DEFAULT '0',
c2 int(10) NOT NULL DEFAULT '0',
PRIMARY KEY (id),
KEY idx_c1 (c1)
) ENGINE=InnoDB;

insert into t1 select null,round(rand()*100),round(rand()*1000)
from information_schema.columns a1, information_schema.columns b1  
LIMIT 100;

insert INTO t2 select null,round(rand()*100),round(rand()*1000)
from information_schema.columns a1, information_schema.columns b1  
LIMIT 100;

SELECT * FROM t1;
SELECT * FROM t2;

BLOCK NESTED LOOP(BNL)

MariaDB(MySQL)은 기본적으로 BLOCK NESTED LOOP JOIN을 사용한다.
두 개 이상의 테이블에서 하나의 집합을 기준으로 순차적으로 상대방 Row를 결합하여 조합하는 방식

중첩 반복문처럼 첫번 째 테이블의 Row와 관련된 두번째 테이블에 대한 Row를 검색하고 이후 첫 번째 테이블의 다음 Row에 대해 두번째 테이블에 대한 것을 검색하며 이후 이와 같은 방식을 반복한다.

SET SESSION optimizer_switch='join_cache_incremental=on';
SET SESSION optimizer_switch='join_cache_hashed=on';
SET SESSION optimizer_switch='join_cache_bka=on';
SET SESSION join_cache_level=2;

select count(*) from t1 join t2 on t1.c2 = t2.c2;
explain select count(*) from t1 join t2 on t1.c2 = t2.c2;

Block Nested Loop Hash(BNLH)

MySQL8.0.18버전 이후 지원하게 되었다.
대규모 데이터 세트에 대한 조인 연산을 효과적으로 진행할 수 있다.
빌드 단계(Build phase): 해싱 단계에서 조인을 수행하는 두 테이블 중 작은 쪽을 선택하여 해시 테이블을 만들어 메모리(PGA 영역)에 저장하고 해시 함수를 사용해서 각 행을 특정 "해시 버킷"에 할당한다.
프로브 단계(Probe phase): 조인 단계에서 다른 테이블을 순회하며 각 행에 대해 동일한 해시 함수를 사용하여 해당 행이 어떤 버킷에 속하는지 결정하고 이 버킷의 모든 행과 해당 행을 비교하여 조인 조건을 만족한다.
이 방법은 조인할 테이블 중 하나가 메모리에 적합할 만큼 충분히 작아야 한다. 그렇지 않으면 해시 테이블이 메모리를 넘어서 디스크로까지 넘어가고 이는 성능 저하를 초래한다.

HASH JOIN은 등가 조인('=' 연산자를 사용하는 조인)에만 사용할 수 있고 비등가 조인에는 사용할 수 없다.

SET SESSION optimizer_switch='join_cache_incremental=on';
SET SESSION optimizer_switch='join_cache_hashed=on';
SET SESSION optimizer_switch='join_cache_bka=on';
SET SESSION join_cache_level=3;

select count(*) from t1 join t2 on t1.c2 = t2.c2;
explain select count(*) from t1 join t2 on t1.c2 = t2.c2;

-- join_cache_hashed를 off로 하면 BNL 결과가 나온다.
-- SET SESSION optimizer_switch='join_cache_hashed=on';
-- explain select count(*) from t1 join t2 on t1.c2 = t2.c2;

GROUPING

GROUP BY

GROUP BY를 활용한 메뉴가 존재하는 카테고리 그룹 조회

SELECT
       category_code
  FROM tbl_menu
 GROUP BY category_code;

COUNT 함수 활용

SELECT
       category_code
     , COUNT(*)
  FROM tbl_menu
 GROUP BY category_code;

SUM 함수 활용

SELECT
       category_code
     , SUM(menu_price)
  FROM tbl_menu
 GROUP BY category_code;

AVG 함수 활용

SELECT
       category_code
     , AVG(menu_price)
  FROM tbl_menu
 GROUP BY category_code;

2개 이상의 그룹 생성

SELECT
       menu_price
     , category_code
  FROM tbl_menu
 GROUP BY menu_price, category_code;

join과 함께 사용

SELECT
       a.category_code
     , b.category_name
     , AVG(menu_price)
  FROM tbl_menu a
  JOIN tbl_category b ON (a.category_code = b.category_code)
 GROUP BY a.category_code, b.category_name;

HAVING

HAVING을 활용해 5번(중식) 카테고리부터 8번(커피) 카테고리까지의 메뉴 카테고리 번호 조회

SELECT                               
       category_code                 
  FROM tbl_menu                      
 GROUP BY category_code              
HAVING category_code BETWEEN 5 AND 8;

ROLLUP

컬럼 한 개를 활용한 ROLLUP(카테고리별 총합)

SELECT
       category_code
     , SUM(menu_price)
  FROM tbl_menu
 GROUP BY category_code
  WITH ROLLUP;

컬럼 두 개를 활용한 ROLLUP(같은 메뉴 가격별 총합 및 해당 메뉴 가격별 같은 카테고리의 총합과 전체 )
- ROLLUP을 통해 먼저 나온 컬럼의 총합을 구하고 이후 나오는 컬럼과의 합도 구하는 방식이다.
```
SELECT
       menu_price
     , category_code
     , SUM(menu_price)
  FROM tbl_menu
 GROUP BY menu_price, category_code
  WITH ROLLUP;
```
  실행결과

연도별, 월별, 상품별 합계를 구할 수도 있다.

CREATE TABLE sales (
    code INT AUTO_INCREMENT,
    year VARCHAR(4),
    month VARCHAR(2),
    product VARCHAR(50),
    amount DECIMAL(10,2),
    PRIMARY KEY(code)
);

INSERT INTO sales (code, year, month, product, amount) VALUES
(null, '2023', LPAD('1', 2, '0'), 'Product A', 1000.00),
(null, '2023', LPAD('1', 2, '0'), 'Product B', 1500.00),
(null, '2023', LPAD('2', 2, '0'), 'Product A', 2000.00),
(null, '2023', LPAD('2', 2, '0'), 'Product B', 2500.00),
(null, '2023', LPAD('3', 2, '0'), 'Product A', 1200.00),
(null, '2024', LPAD('3', 2, '0'), 'Product B', 1700.00);

SELECT
       year
	   , month
	   , product
	   , SUM(amount) AS total_sales
  FROM sales
 GROUP BY year, month, product WITH ROLLUP;

SUBQUERIES

SUBQUERY 활용

서브쿼리와 메인 쿼리를 활용한 다중열 결과 조회

서브쿼리

SELECT
       category_code
  FROM tbl_menu
 WHERE menu_name = '민트미역국';

메인쿼리

SELECT
       menu_code
     , menu_name
     , menu_price
     , category_code
     , orderable_status
  FROM tbl_menu;

서브쿼리를 활용한 메인 쿼리

SELECT                                                   
       menu_code                                         
     , menu_name                                         
     , menu_price                                        
     , category_code                                     
     , orderable_status                                  
  FROM tbl_menu                                          
 WHERE category_code = (SELECT category_code             
                          FROM tbl_menu                  
                         WHERE menu_name = '민트미역국');

SUBQUERY를 활용해 가장 많은 메뉴가 포함된 카테고리 조회
- 서브쿼리
```
SELECT
       COUNT(*) AS 'count'
  FROM tbl_menu
 GROUP BY category_code;
```
  실행결과
- 서브쿼리를 활용한 메인 쿼리
  - FROM 절에 쓰인 서브쿼리(derived table, 파생 테이블)는 반드시 자신의 별칭이 있어야 한다.(feat. 이러한 서브쿼리를 ‘인라인 뷰’라고 한다.)
```
SELECT
       MAX(count)
  FROM (SELECT COUNT(*) AS 'count'
          FROM tbl_menu
         GROUP BY category_code) AS countmenu;
```
  실행결과

상관 서브쿼리

메인 쿼리가 서브쿼리의 결과에 영향을 주는 경우 상관 서브쿼리라고 한다.

SUBQUERY를 활용해 카테고리별 평균 가격보다 높은 가격의 메뉴 조회

서브쿼리

SELECT
       AVG(menu_price)
  FROM tbl_menu
 WHERE category_code = 4;

서브쿼리를 활용한 메인 쿼리

SELECT                                                   
       menu_code                                         
     , menu_name                                         
     , menu_price                                        
     , category_code                                     
     , orderable_status                                  
  FROM tbl_menu a     
                                     
 WHERE menu_price > (SELECT AVG(menu_price)
                       FROM tbl_menu                  
                      WHERE category_code = a.category_code);

EXISTS

조회 결과가 있을 때 true 아니면 false

EXISTS와 SUBQUERY를 활용한 메뉴가 있는 카테고리 조회

SELECT
       category_name
  FROM tbl_category a
 WHERE EXISTS(SELECT 1
                FROM tbl_menu b
                WHERE b.category_code = a.category_code)
	 ORDER BY 1;

파생 테이블과 비슷한 개념이며 코드의 가독성과 재사용성을 위해 파생 테이블 대신 사용하게 된다.)

CTE(Common Table Expressions)

FROM절에서만 사용 됨(JOIN일 시 JOIN 구문에서도 가능)

인라인 뷰로 쓰인 서브쿼리(FROM 절에 쓰인 서브쿼리)를 미리 정의하고 메인쿼리가 심플해 질 수 있도록 사용하는 문법

WITH menucate AS (
    SELECT menu_name
         , category_name
      FROM tbl_menu a
      JOIN tbl_category b ON a.category_code = b.category_code
)
SELECT
       *
  FROM menucate
 ORDER BY menu_name;

SET OPERATORS

UNION

두 개 이상의 SELECT 문의 결과를 결합하여 중복된 레코드를 제거한 후 반환하는 SQL 연산자이다.

SELECT
       menu_code
     , menu_name
     , menu_price
     , category_code
     , orderable_status
  FROM tbl_menu
 WHERE category_code = 10
 UNION
SELECT
       menu_code
     , menu_name
     , menu_price
     , category_code
     , orderable_status
  FROM tbl_menu
 WHERE menu_price < 9000;

UNION ALL

두 개 이상의 SELECT 문의 결과를 결합하며 중복된 레코드를 제거하지 않고 모두 반환하는 SQL 연산자이다.

SELECT
       menu_code
     , menu_name
     , menu_price
     , category_code
     , orderable_status
  FROM tbl_menu
 WHERE category_code = 10
 UNION ALL
SELECT
       menu_code
     , menu_name
     , menu_price
     , category_code
     , orderable_status
  FROM tbl_menu
 WHERE menu_price < 9000;

INTERSECT

두 SELECT 문의 결과 중 공통되는 레코드만을 반환하는 SQL 연산자이다.

MySQL은 본래 기본적으로 INTERSECT를 제공하지 않는다. 하지만 INNER JOIN 또는 IN 연산자 활용해서 구현하는 것은 가능하다.

INNER JOIN 활용

SELECT
       a.menu_code
     , a.menu_name
     , a.menu_price
     , a.category_code
     , a.orderable_status
  FROM tbl_menu a
 INNER JOIN (SELECT menu_code
                  , menu_name
                  , menu_price
                  , category_code
                  , orderable_status
               FROM tbl_menu
              WHERE menu_price < 9000) b ON (a.menu_code = b.menu_code)
 WHERE a.category_code = 10;

IN 연산자 활용

SELECT
       a.menu_code
     , a.menu_name
     , a.menu_price
     , a.category_code
     , a.orderable_status
  FROM tbl_menu a
 WHERE category_code = 10 
   AND menu_code IN (SELECT menu_code
                       FROM tbl_menu
                      WHERE menu_price < 9000);

MINUS

첫 번째 SELECT 문의 결과에서 두 번째 SELECT 문의 결과가 포함하는 레코드를 제외한 레코드를 반환하는 SQL 연산자이다.

MySQL은 MINUS를 제공하지 않는다. 하지만 LEFT JOIN을 활용해서 구현하는 것은 가능하다.

SELECT
       a.menu_code
     , a.menu_name
     , a.menu_price
     , a.category_code
     , a.orderable_status
  FROM tbl_menu a
  LEFT JOIN (SELECT menu_code
                  , menu_name
                  , menu_price
                  , category_code
                  , orderable_status
               FROM tbl_menu b
              WHERE menu_price < 9000) b ON (a.menu_code = b.menu_code)
 WHERE a.category_code = 10
   AND b.menu_code IS NULL;

6가지 절의 종류와 실행 순서

ex)

select                            -- 5th
from (join)                       -- 1st
where (한 행 씩 조건을 분별)        -- 2nd
group by                          -- 3rd
having (그룹별로 조건)              -- 4th
order by (limit)                  -- 6th

활용 데이터셋

-- 테이블 삭제
DROP TABLE IF EXISTS tbl_payment_order CASCADE;
DROP TABLE IF EXISTS tbl_payment CASCADE;
DROP TABLE IF EXISTS tbl_order_menu CASCADE;
DROP TABLE IF EXISTS tbl_order CASCADE;
DROP TABLE IF EXISTS tbl_menu CASCADE;
DROP TABLE IF EXISTS tbl_category CASCADE;

-- 테이블 생성
-- category 테이블 생성
CREATE TABLE IF NOT EXISTS tbl_category
(
    category_code    INT AUTO_INCREMENT COMMENT '카테고리코드',
    category_name    VARCHAR(30) NOT NULL COMMENT '카테고리명',
    ref_category_code    INT COMMENT '상위카테고리코드',
    CONSTRAINT pk_category_code PRIMARY KEY (category_code),
    CONSTRAINT fk_ref_category_code FOREIGN KEY (ref_category_code) REFERENCES tbl_category (category_code)
) ENGINE=INNODB COMMENT '카테고리';

CREATE TABLE IF NOT EXISTS tbl_menu
(
    menu_code    INT AUTO_INCREMENT COMMENT '메뉴코드',
    menu_name    VARCHAR(30) NOT NULL COMMENT '메뉴명',
    menu_price    INT NOT NULL COMMENT '메뉴가격',
    category_code    INT NOT NULL COMMENT '카테고리코드',
    orderable_status    CHAR(1) NOT NULL COMMENT '주문가능상태',
    CONSTRAINT pk_menu_code PRIMARY KEY (menu_code),
    CONSTRAINT fk_category_code FOREIGN KEY (category_code) REFERENCES tbl_category (category_code)
) ENGINE=INNODB COMMENT '메뉴';

CREATE TABLE IF NOT EXISTS tbl_order
(
    order_code    INT AUTO_INCREMENT COMMENT '주문코드',
    order_date    VARCHAR(8) NOT NULL COMMENT '주문일자',
    order_time    VARCHAR(8) NOT NULL COMMENT '주문시간',
    total_order_price    INT NOT NULL COMMENT '총주문금액',
    CONSTRAINT pk_order_code PRIMARY KEY (order_code)
) ENGINE=INNODB COMMENT '주문';

CREATE TABLE IF NOT EXISTS tbl_order_menu
(
    order_code INT NOT NULL COMMENT '주문코드',
    menu_code    INT NOT NULL COMMENT '메뉴코드',
    order_amount    INT NOT NULL COMMENT '주문수량',
    CONSTRAINT pk_comp_order_menu_code PRIMARY KEY (order_code, menu_code),
    CONSTRAINT fk_order_menu_order_code FOREIGN KEY (order_code) REFERENCES tbl_order (order_code),
    CONSTRAINT fk_order_menu_menu_code FOREIGN KEY (menu_code) REFERENCES tbl_menu (menu_code)
) ENGINE=INNODB COMMENT '주문별메뉴';

CREATE TABLE IF NOT EXISTS tbl_payment
(
    payment_code    INT AUTO_INCREMENT COMMENT '결제코드',
    payment_date    VARCHAR(8) NOT NULL COMMENT '결제일',
    payment_time    VARCHAR(8) NOT NULL COMMENT '결제시간',
    payment_price    INT NOT NULL COMMENT '결제금액',
    payment_type    VARCHAR(6) NOT NULL COMMENT '결제구분',
    CONSTRAINT pk_payment_code PRIMARY KEY (payment_code)
) ENGINE=INNODB COMMENT '결제';

CREATE TABLE IF NOT EXISTS tbl_payment_order
(
    order_code    INT NOT NULL COMMENT '주문코드',
    payment_code    INT NOT NULL COMMENT '결제코드',
    CONSTRAINT pk_comp_payment_order_code PRIMARY KEY (payment_code, order_code),
    CONSTRAINT fk_payment_order_order_code FOREIGN KEY (order_code) REFERENCES tbl_order (order_code),
    CONSTRAINT fk_payment_order_payment_code FOREIGN KEY (order_code) REFERENCES tbl_payment (payment_code)
) ENGINE=INNODB COMMENT '결제별주문';

-- 데이터 삽입
INSERT INTO tbl_category VALUES (null, '식사', null);
INSERT INTO tbl_category VALUES (null, '음료', null);
INSERT INTO tbl_category VALUES (null, '디저트', null);
INSERT INTO tbl_category VALUES (null, '한식', 1);
INSERT INTO tbl_category VALUES (null, '중식', 1);

INSERT INTO tbl_category VALUES (null, '일식', 1);
INSERT INTO tbl_category VALUES (null, '퓨전', 1);
INSERT INTO tbl_category VALUES (null, '커피', 2);
INSERT INTO tbl_category VALUES (null, '쥬스', 2);
INSERT INTO tbl_category VALUES (null, '기타', 2);

INSERT INTO tbl_category VALUES (null, '동양', 3);
INSERT INTO tbl_category VALUES (null, '서양', 3);

INSERT INTO tbl_menu VALUES (null, '열무김치라떼', 4500, 8, 'Y');
INSERT INTO tbl_menu VALUES (null, '우럭스무디', 5000, 10, 'Y');
INSERT INTO tbl_menu VALUES (null, '생갈치쉐이크', 6000, 10, 'Y');
INSERT INTO tbl_menu VALUES (null, '갈릭미역파르페', 7000, 10, 'Y');
INSERT INTO tbl_menu VALUES (null, '앙버터김치찜', 13000, 4, 'N');

INSERT INTO tbl_menu VALUES (null, '생마늘샐러드', 12000, 4, 'Y');
INSERT INTO tbl_menu VALUES (null, '민트미역국', 15000, 4, 'Y');
INSERT INTO tbl_menu VALUES (null, '한우딸기국밥', 20000, 4, 'Y');
INSERT INTO tbl_menu VALUES (null, '홍어마카롱', 9000, 12, 'Y');
INSERT INTO tbl_menu VALUES (null, '코다리마늘빵', 7000, 12, 'N');

INSERT INTO tbl_menu VALUES (null, '정어리빙수', 10000, 10, 'Y');
INSERT INTO tbl_menu VALUES (null, '날치알스크류바', 2000, 10, 'Y');
INSERT INTO tbl_menu VALUES (null, '직화구이젤라또', 8000, 12, 'Y');
INSERT INTO tbl_menu VALUES (null, '과메기커틀릿', 13000, 6, 'Y');
INSERT INTO tbl_menu VALUES (null, '죽방멸치튀김우동', 11000, 6, 'N');

INSERT INTO tbl_menu VALUES (null, '흑마늘아메리카노', 9000, 8, 'Y');
INSERT INTO tbl_menu VALUES (null, '아이스가리비관자육수', 6000, 10, 'Y');
INSERT INTO tbl_menu VALUES (null, '붕어빵초밥', 35000, 6, 'Y');
INSERT INTO tbl_menu VALUES (null, '까나리코코넛쥬스', 9000, 9, 'Y');
INSERT INTO tbl_menu VALUES (null, '마라깐쇼한라봉', 22000, 5, 'N');

INSERT INTO tbl_menu VALUES (null, '돌미나리백설기', 5000, 11, 'Y');

COMMIT;

성장일기

엔지니어로의 성장일지

이전 포스트

[DATABASE] DQL SECTION1

다음 포스트