[유튜브 방송] (즐겁게 배우는 SQL #51) (보충) where와 having 차이점 설명

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 51편을 공개해드리겠다. 51편은 보충 설명으로 where와 having 차이점을 설명한다.

방송 스크립트는 전체 공개되어 있으며, 슬라이드셰어에서 보거나 다운로드 받을 수도 있다.

즐겁게 배우는 SQL 51일차 where와 having 차이점 설명 from Jay Park

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 도입
• 01:14 WHERE와 HAVING을 언제 어느 때 사용할까?
• 02:16 GROUP BY로 살펴보는 표준 템플릿
• 03:34 성능 고려

EOB

[유튜브 방송] (즐겁게 배우는 SQL #50) 윈도우 함수 - 윈도우 함수(2)

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 50편을 공개해드리겠다. 50편은 몇 가지 윈도우 함수를 소개한다.

2021년 2월 16일자 [즐겁게 배우는 SQL #50] 윈도우 함수 - 윈도우 함수(2) 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 윈도우 함수 개괄
• 01:02 (값) LAST VALUE(정해진 윈도우 프레임 내에서 마지막 행의 값을 반환)
• 04:55 (값) LEAD(직후에 물리적으로 떨어진 오프셋 값을 가져오기)
• 08:20 (값) NTH_VALUE(정해진 윈도우 프레임 내에서 N번째 행의 값을 반환)
• 11:34 (순위) NTILE(순서가 있는 결과 집합을 정해진 버킷에 나눠서 넣기)
• 14:51 (순위) PERCENT_RANK(순위를 퍼센트로 보여줌)
• 17:13 (순위) RANK(순위를 보여줌, 중복 가능, 빈 순서 있음)
• 20:51 (순위) ROW_NUMBER(연속적인 정수를 부여, 중복 불가능)

온라인 실습 사이트는 SQL Online IDE에서 진행하면 되고, 원본 학습자료는 SQLite Window Functions를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 윈도우 함수 개괄
  1. 윈도우 함수는 현재 행을 기준으로 일련의 행 집합에 대해 연산을 수행한다
  2. 집계 함수는 계산 결과를 한 행으로 합치는 특성이 있는 반면에 윈도우 함수는 원래 행을 그대로 유지하는 특성이 있다
  3. 값과 순위를 매기는 함수가 대표적이다.
• 단계 2: (값) LAST VALUE(정해진 윈도우 프레임 내에서 마지막 행의 값을 반환)
  1. SQL> SELECT Name, printf ( '%.f minutes', Milliseconds / 1000 / 60 ) AS Length, LAST_VALUE ( Name ) OVER ( ORDER BY Milliseconds RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS LongestTrack FROM tracks WHERE AlbumId = 4;
  2. SQL> SELECT AlbumId, Name, printf ( '%.f minutes', Milliseconds / 1000 / 60 ) AS Length, LAST_VALUE ( Name ) OVER ( PARTITION BY AlbumId ORDER BY Milliseconds DESC RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS ShortestTrack FROM tracks;
• 단계 3: LEAD(직후에 물리적으로 떨어진 오프셋 값을 가져오기)
  1. SQL> CREATE VIEW CustomerInvoices AS SELECT CustomerId, strftime('%Y',InvoiceDate) Year, SUM( total ) Total FROM invoices GROUP BY CustomerId, strftime('%Y',InvoiceDate);
  2. SQL> SELECT * FROM CustomerInvoices ORDER BY CustomerId, Year, Total;
  3. SQL> SELECT CustomerId, Year, Total, LEAD ( Total,1,0 ) OVER ( ORDER BY Year ) NextYearTotal FROM CustomerInvoices WHERE CustomerId = 1;
  4. SQL> SELECT CustomerId, Year, Total, LEAD ( Total,1,0 ) OVER ( PARTITION BY CustomerId ORDER BY Year ) NextYearTotal FROM CustomerInvoices;
• 단계 4: (값) NTH_VALUE(정해진 윈도우 프레임 내에서 N번째 행의 값을 반환)
  1. SQL> SELECT Name, Milliseconds Length, NTH_VALUE ( name,2 ) OVER ( ORDER BY Milliseconds DESC ) SecondLongestTrack FROM tracks;
  2. SQL> SELECT AlbumId, Name, Milliseconds Length, NTH_VALUE ( Name,2 ) OVER ( PARTITION BY AlbumId ORDER BY Milliseconds DESC RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS SecondLongestTrack FROM tracks;
• 단계 5: (순위) NTILE(순서가 있는 결과 집합을 정해진 버킷에 나눠서 넣기)
  1. SQL> SELECT Name, Milliseconds, NTILE ( 4 ) OVER ( ORDER BY Milliseconds ) LengthBucket FROM tracks WHERE AlbumId = 1;
  2. SQL> SELECT AlbumId, Name, Milliseconds, NTILE ( 3 ) OVER ( PARTITION BY AlbumId ORDER BY Bytes ) SizeBucket FROM tracks;
• 단계 6: (순위) PERCENT_RANK(순위를 퍼센트로 보여줌)
  1. SQL> SELECT Name, Milliseconds, PERCENT_RANK() OVER( ORDER BY Milliseconds ) LengthPercentRank FROM tracks WHERE AlbumId = 1;
  2. SQL> SELECT Name, Milliseconds, printf('%.2f',PERCENT_RANK() OVER( ORDER BY Milliseconds )) LengthPercentRank FROM tracks WHERE AlbumId = 1;
  3. SQL> SELECT AlbumId, Name, Bytes, printf('%.2f',PERCENT_RANK() OVER( PARTITION BY AlbumId ORDER BY Bytes )) SizePercentRank FROM tracks;
• 단계 7: (순위) RANK(순위를 보여줌, 중복 가능, 빈 순서 있음)
  1. SQL> CREATE TABLE RankDemo ( Val TEXT );
  2. SQL> INSERT INTO RankDemo(Val) VALUES('A'),('B'),('C'),('C'),('D'),('D'),('E');
  3. SQL> SELECT * FROM RankDemo;
  4. SQL> SELECT Val, RANK () OVER ( ORDER BY Val ) ValRank FROM RankDemo;
  5. SQL> SELECT Name, Milliseconds, RANK () OVER ( ORDER BY Milliseconds DESC ) LengthRank FROM tracks;
  6. SQL> SELECT Name, Milliseconds, AlbumId, RANK () OVER ( PARTITION BY AlbumId ORDER BY Milliseconds DESC ) LengthRank FROM tracks;
  7. SQL> SELECT * FROM ( SELECT Name, Milliseconds, AlbumId, RANK () OVER ( PARTITION BY AlbumId ORDER BY Milliseconds DESC ) LengthRank FROM tracks ) WHERE LengthRank = 2;
  8. SQL>
• 단계 8: (순위) ROW_NUMBER(연속적인 정수를 부여, 중복 불가능)
  1. SQL> SELECT ROW_NUMBER () OVER ( ORDER BY Country ) RowNum, FirstName, LastName, country FROM customers;
  2. SQL> SELECT ROW_NUMBER () OVER ( PARTITION BY Country ORDER BY FirstName ) RowNum, FirstName, LastName, country FROM customers;
  3. SQL> SELECT * FROM ( SELECT ROW_NUMBER () OVER ( ORDER BY FirstName ) RowNum, FirstName, LastName, Country FROM customers ) WHERE RowNum > 20 AND RowNum <= 30
  4. SQL> CREATE VIEW Sales AS SELECT CustomerId, FirstName, LastName, Country, SUM( total ) Amount FROM invoices INNER JOIN customers USING (CustomerId) GROUP BY CustomerId;
  5. SQL> SELECT Country, FirstName, LastName, Amount FROM ( SELECT Country, FirstName, LastName, Amount, ROW_NUMBER() OVER ( PARTITION BY country ORDER BY Amount DESC ) RowNum FROM Sales ) WHERE RowNum = 1;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #49) 윈도우 함수 - 윈도우 함수(1)

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 49편을 공개해드리겠다. 49편은 윈도우 함수를 개괄하고 몇 가지 윈도우 함수를 소개한다.

2021년 2월 15일자 [즐겁게 배우는 SQL #49] 윈도우 함수 - 윈도우 함수(1) 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 윈도우 함수 개괄
• 06:40 (순위) CUME_DIST(누적 분포)
• 11:41 (순위) DENSE_RANK(순서있는 행들의 집합에서 행의 순위 계산, 빈 순서 없음)
• 17:00 (값) FIRST_VALUE(정해진 윈도우 프레임 내에서 첫 행의 값을 반환)
• 22:12 (값) LAG(직전에 물리적으로 떨어진 오프셋 값을 가져오기)

온라인 실습 사이트는 SQL Online IDE에서 진행하면 되고, 원본 학습자료는 SQLite Window Functions를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 윈도우 함수 개괄
  1. 윈도우 함수는 현재 행을 기준으로 일련의 행 집합에 대해 연산을 수행한다
  2. 집계 함수는 계산 결과를 한 행으로 합치는 특성이 있는 반면에 윈도우 함수는 원래 행을 그대로 유지하는 특성이 있다
  3. 값과 순위를 매기는 함수가 대표적이다.
• 단계 2: (순위) CUME_DIST(누적 분포)
  1. SQL> CREATE TABLE CumeDistDemo( Id INTEGER PRIMARY KEY, value INT );
  2. SQL> INSERT INTO CumeDistDemo(value) VALUES(1000),(1200),(1200),(1400),(2000);
  3. SQL> SELECT Id, Value FROM CumeDistDemo;
  4. SQL> SELECT Value, CUME_DIST() OVER ( ORDER BY value ) CumulativeDistribution FROM CumeDistDemo;
• 단계 3: (순위) DENSE_RANK(순서있는 행들의 집합에서 행의 순위 계산, 빈 순서 없음)
  1. SQL> CREATE TABLE DenseRankDemo ( Val TEXT );
  2. SQL> INSERT INTO DenseRankDemo(Val) VALUES('A'),('B'),('C'),('C'),('D'),('D'),('E');
  3. SQL> SELECT Val, DENSE_RANK () OVER ( ORDER BY Val ) ValRank FROM DenseRankDemo;
  4. SQL> SELECT AlbumId, Name, Milliseconds, DENSE_RANK () OVER ( PARTITION BY AlbumId ORDER BY Milliseconds ) LengthRank FROM tracks;
• 단계 4: (값) FIRST_VALUE(정해진 윈도우 프레임 내에서 첫 행의 값을 반환)
  1. SQL> SELECT Name, printf('%,d',Bytes) Size, FIRST_VALUE(Name) OVER ( ORDER BY Bytes ) AS SmallestTrack FROM tracks WHERE AlbumId = 1;
  2. SQL> SELECT AlbumId, Name, printf('%,d',Bytes) Size, FIRST_VALUE(Name) OVER ( PARTITION BY AlbumId ORDER BY Bytes DESC ) AS LargestTrack FROM tracks;
• 단계 5: (값) LAG(직전에 물리적으로 떨어진 오프셋 값을 가져오기)
  1. SQL> SELECT * FROM CustomerInvoices ORDER BY CustomerId, Year, Total;
  2. SQL> SELECT CustomerId, Year, Total, LAG ( Total,1,0 ) OVER ( ORDER BY Year ) PreviousYearTotal FROM CustomerInvoices WHERE CustomerId = 4;
  3. SQL> SELECT CustomerId, Year, Total, LAG ( Total,1,0 ) OVER ( PARTITION BY CustomerId ORDER BY Year ) PreviousYearTotal FROM CustomerInvoices;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #48) 트리거 - INSTEAD OF 트리거

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 48편을 공개해드리겠다. 48편은 INSTEAD OF 트리거를 소개한다.

2021년 2월 10일자 [즐겁게 배우는 SQL #48] 트리거 - INSTEAD OF 트리거 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 INSTEAD OF 트리거 기본 형식
• 01:03 INSTEAD OF 트리거 예제

원본 학습자료는 SQLite INSTEAD OF Triggers를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: INSTEAD OF 트리거 기본 형식

  CREATE TRIGGER [IF NOT EXISTS] schema_ame.trigger_name
      INSTEAD OF [DELETE | INSERT | UPDATE OF column_name]
      ON table_name
  BEGIN
      -- insert code here
  END;
  

• 단계 2: INSTEAD OF 트리거 예제
  1. SQL> CREATE VIEW AlbumArtists( AlbumTitle, ArtistName ) AS SELECT Title, Name FROM Albums INNER JOIN Artists USING (ArtistId);
  2. SQL> SELECT * FROM AlbumArtists;
  3. SQL> INSERT INTO AlbumArtists(AlbumTitle,ArtistName) VALUES('Who Do You Trust?','Papa Roach');
  4. SQL> CREATE TRIGGER insert_artist_album_trg INSTEAD OF INSERT ON AlbumArtists BEGIN INSERT INTO Artists(Name) VALUES(NEW.ArtistName); INSERT INTO Albums(Title, ArtistId) VALUES(NEW.AlbumTitle, last_insert_rowid()); END;
  5. SQL> INSERT INTO AlbumArtists(AlbumTitle,ArtistName) VALUES('Who Do You Trust?','Papa Roach');
  6. SQL> SELECT * FROM Artists ORDER BY ArtistId DESC;
  7. SQL> SELECT * FROM Albums ORDER BY AlbumId DESC;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #47) 트리거 - 트리거

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 47편을 공개해드리겠다. 47편은 트리거를 소개한다.

2021년 2월 9일자 [즐겁게 배우는 SQL #47] 트리거 - 트리거 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 트리거 기본 형식
• 07:13 BEFORE INSERT 트리거 예제
• 13:03 AFTER UPDATE 트리거 예제
• 17:47 트리거 제거 예제

원본 학습자료는 SQLite Trigger를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 트리거 기본 형식

  CREATE TRIGGER [IF NOT EXISTS] trigger_name 
     [BEFORE|AFTER|INSTEAD OF] [INSERT|UPDATE|DELETE] 
     ON table_name
     [WHEN condition]
  BEGIN
   statements;
  END;
  

• 단계 2: BEFORE INSERT 트리거 예제
  1. SQL> CREATE TABLE leads ( id integer PRIMARY KEY, first_name text NOT NULL, last_name text NOT NULL, phone text NOT NULL, email text NOT NULL, source text NOT NULL );
  2. SQL> CREATE TRIGGER validate_email_before_insert_leads BEFORE INSERT ON leads BEGIN SELECT CASE WHEN NEW.email NOT LIKE '%_@__%.__%' THEN RAISE (ABORT,'Invalid email address') END; END;
  3. SQL> INSERT INTO leads (first_name,last_name,email,phone) VALUES('John','Doe','jjj','4089009334');
  4. SQL> INSERT INTO leads (first_name, last_name, email, phone) VALUES ('John', 'Doe', 'john.doe@sqlitetutorial.net', '4089009334');
  5. SQL> INSERT INTO leads (first_name, last_name, email, phone, source) VALUES ('John', 'Doe', 'john.doe@sqlitetutorial.net', '4089009334', 'company');
  6. SQL> SELECT * FROM leads;
• 단계 3: AFTER UPDATE 트리거 예제
  1. SQL> CREATE TABLE lead_logs ( id INTEGER PRIMARY KEY, old_id int, new_id int, old_phone text, new_phone text, old_email text, new_email text, user_action text, created_at text );
  2. SQL> CREATE TRIGGER log_contact_after_update AFTER UPDATE ON leads WHEN old.phone <> new.phone OR old.email <> new.email BEGIN INSERT INTO lead_logs ( old_id, new_id, old_phone, new_phone, old_email, new_email, user_action, created_at ) VALUES ( old.id, new.id, old.phone, new.phone, old.email, new.email, 'UPDATE', DATETIME('NOW') ); END;
  3. SQL> UPDATE leads SET last_name = 'Smith' WHERE id = 1;
  4. SQL> UPDATE leads SET phone = '4089998888', email = 'john.smith@sqlitetutorial.net' WHERE id = 1;
  5. SQL> SELECT old_phone, new_phone, old_email, new_email, user_action FROM lead_logs;
• 단계 4: 트리거 제거 예제
  1. SQL> DROP TRIGGER validate_email_before_insert_leads;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #46) 색인 - 표현식 기반의 색인

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 46편을 공개해드리겠다. 46편은 표현식 기반의 색인을 소개한다.

2021년 2월 8일자 [즐겁게 배우는 SQL #46] 색인 - 표현식 기반의 색인 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 표현식 기반의 색인 예제
• 03:21 표현식 기반의 색인 동작 원리
• 05:29 표현식 기반의 색인 제약

원본 학습자료는 SQLite Expression-based Index를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 표현식 기반의 색인 예제
  1. SQL> SELECT customerid, company FROM customers WHERE length(company) > 10 ORDER BY length(company) DESC;
  2. SQL> EXPLAIN QUERY PLAN SELECT customerid, company FROM customers WHERE length(company) > 10 ORDER BY length(company) DESC;
  3. SQL> CREATE INDEX customers_length_company ON customers(LENGTH(company));
  4. SQL> EXPLAIN QUERY PLAN SELECT customerid, company FROM customers WHERE length(company) > 10 ORDER BY length(company) DESC;
• 단계 2: 표현식 기반의 색인 동작 원리
  1. SQL> CREATE INDEX invoice_line_amount ON invoice_items(unitprice*quantity);
  2. SQL> EXPLAIN QUERY PLAN SELECT invoicelineid, invoiceid, unitprice*quantity FROM invoice_items WHERE quantity*unitprice > 10;
  3. SQL> EXPLAIN QUERY PLAN SELECT invoicelineid, invoiceid, unitprice*quantity FROM invoice_items WHERE unitprice*quantity > 10;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #45) 색인 - 색인

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 45편을 공개해드리겠다. 45편은 색인을 거는 방법을 소개한다.

2021년 2월 5일자 [즐겁게 배우는 SQL #45] 색인 - 색인 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 색인 개념과 색인 생성 기본 형식
• 04:13 단일 컬럼 색인 생성
• 10:04 다중 컬럼 색인 생성
• 14:05 색인 확인
• 15:59 색인 제거

원본 학습자료는 SQLite Index를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 색인 개념과 색인 생성 기본 형식

  CREATE [UNIQUE] INDEX index_name 
  ON table_name(column_list);
  

• 단계 2: 단일 컬럼 색인 생성
  1. SQL> CREATE TABLE contacts ( first_name text NOT NULL, last_name text NOT NULL, email text NOT NULL );
  2. SQL> CREATE UNIQUE INDEX idx_contacts_email ON contacts (email);
  3. SQL> INSERT INTO contacts (first_name, last_name, email) VALUES('John','Doe','john.doe@sqlitetutorial.net');
  4. SQL> INSERT INTO contacts (first_name, last_name, email) VALUES('Johny','Doe','john.doe@sqlitetutorial.net');
  5. SQL> INSERT INTO contacts (first_name, last_name, email) VALUES('David','Brown','david.brown@sqlitetutorial.net'), ('Lisa','Smith','lisa.smith@sqlitetutorial.net');
  6. SQL> SELECT first_name, last_name, email FROM contacts WHERE email = 'lisa.smith@sqlitetutorial.net';
  7. SQL> EXPLAIN QUERY PLAN SELECT first_name, last_name, email FROM contacts WHERE email = 'lisa.smith@sqlitetutorial.net';
• 단계 3: 다중 컬럼 색인 생성
  1. SQL> CREATE INDEX idx_contacts_name ON contacts (first_name, last_name);
  2. SQL> EXPLAIN QUERY PLAN SELECT first_name, last_name, email FROM contacts WHERE first_name = 'John';
  3. SQL> EXPLAIN QUERY PLAN SELECT first_name, last_name, email FROM contacts WHERE first_name = 'John' AND last_name = 'Doe';
  4. SQL> EXPLAIN QUERY PLAN SELECT first_name, last_name, email FROM contacts WHERE last_name = 'Doe';
  5. SQL> EXPLAIN QUERY PLAN SELECT first_name, last_name, email FROM contacts last_name = 'Doe' OR first_name = 'John';
  6. SQL>
• 단계 4: 색인 확인
  1. SQL> PRAGMA index_list('contacts');
  2. SQL> PRAGMA index_info('idx_contacts_name');
  3. SQL> SELECT type, name, tbl_name, sql FROM sqlite_master WHERE type= 'index';
• 단계 5: 색인 제거
  1. SQL> DROP INDEX idx_contacts_name;
  2. SQL> PRAGMA index_list('contacts');
  3. SQL> PRAGMA index_info('idx_contacts_name');
  4. SQL> DROP INDEX idx_contacts_email;
  5. SQL> PRAGMA index_list('contacts');
  6. SQL> PRAGMA index_info('idx_contacts_email');

EOB

[유튜브 방송] (즐겁게 배우는 SQL #44) 뷰 - 뷰 제거

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 44편을 공개해드리겠다. 44편은 뷰 제거 방법을 소개한다.

2021년 2월 4일자 [즐겁게 배우는 SQL #44] 뷰 - 뷰 제거 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 뷰 제거 기본 형식
• 01:19 뷰 제거 예제

원본 학습자료는 SQLite DROP VIEW를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 뷰 제거 기본 형식

  DROP VIEW [IF EXISTS] [schema_name.]view_name;
  

• 단계 2: 뷰 제거 예제
  1. SQL> CREATE VIEW v_billings ( invoiceid, invoicedate, total ) AS SELECT invoiceid, invoicedate, sum(unitprice * quantity) FROM invoices INNER JOIN invoice_items USING ( invoiceid );
  2. SQL> SELECT * FROM v_billings;
  3. SQL> DROP VIEW v_billings;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #43) 뷰 - 뷰 생성

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 43편을 공개해드리겠다. 43편은 뷰 생성 방법을 소개한다.

2021년 2월 2일자 [즐겁게 배우는 SQL #43] 뷰 - 뷰 생성 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 뷰 생성 기본 형식
• 05:52 복잡한 질의를 단순화하기 위한 뷰 생성
• 09:38 전용 컬럼 이름을 제공하기 위한 뷰 생성

원본 학습자료는 SQLite Create View를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1:뷰 생성 기본 형식

  CREATE [TEMP] VIEW [IF NOT EXISTS] view_name[(column-name-list)]
  AS 
     select-statement;
  

• 단계 2: 복잡한 질의를 단순화하기 위한 뷰 생성
  1. SQL> SELECT trackid, tracks.name, albums.Title AS album, media_types.Name AS media, genres.Name AS genres FROM tracks INNER JOIN albums ON Albums.AlbumId = tracks.AlbumId INNER JOIN media_types ON media_types.MediaTypeId = tracks.MediaTypeId INNER JOIN genres ON genres.GenreId = tracks.GenreId;
  2. SQL> CREATE VIEW v_tracks AS SELECT trackid, tracks.name, albums.Title AS album, media_types.Name AS media, genres.Name AS genres FROM tracks INNER JOIN albums ON Albums.AlbumId = tracks.AlbumId INNER JOIN media_types ON media_types.MediaTypeId = tracks.MediaTypeId INNER JOIN genres ON genres.GenreId = tracks.GenreId;
  3. SQL> SELECT * FROM v_tracks;
• 단계 3: 전용 컬럼 이름을 제공하기 위한 뷰 생성
  1. SQL> CREATE VIEW v_albums ( AlbumTitle, Minutes ) AS SELECT albums.title, SUM(milliseconds) / 60000 FROM tracks INNER JOIN albums USING ( AlbumId ) GROUP BY albums.title;
  2. SQL> SELECT * FROM v_albums;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #42) 제약 조건 - AUTOINCREMENT 제약

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 42편을 공개해드리겠다. 42편은 AUTOINCREMENT 제약 조건을 소개한다.

2021년 1월 29일자 [즐겁게 배우는 SQL #42] 제약 조건 - AUTOINCREMENT 제약 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 ROWID 소개
• 03:35 PK와 ROWID 연계 방안 소개
• 11:29 AUTOINCREMENT 제약 예제

원본 학습자료는 SQLite AUTOINCREMENT를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: ROWID 소개
  1. SQL> CREATE TABLE people ( first_name TEXT NOT NULL, last_name TEXT NOT NULL );
  2. SQL> INSERT INTO people (first_name, last_name) VALUES('John', 'Doe');
  3. SQL> INSERT INTO people (first_name, last_name) VALUES('Lily', 'Bush');
  4. SQL> SELECT rowid, _rowid_, oid, first_name, last_name FROM people;
• 단계 2: PK와 ROWID 연계 방안 소개
  1. SQL> DROP TABLE people;
  2. SQL> CREATE TABLE people ( person_id INTEGER PRIMARY KEY, first_name TEXT NOT NULL, last_name TEXT NOT NULL );
  3. SQL> INSERT INTO people (person_id,first_name,last_name) VALUES( 9223372036854775807,'Johnathan','Smith');
  4. SQL> INSERT INTO people (first_name,last_name) VALUES('William','Gate');
  5. SQL> SELECT rowid, _rowid_, oid, first_name, last_name FROM people;
  6. SQL> CREATE TABLE t1(c text);
  7. SQL> INSERT INTO t1(c) VALUES('A');
  8. SQL> INSERT INTO t1(c) values('B');
  9. SQL> INSERT INTO t1(c) values('C');
  10. SQL> INSERT INTO t1(c) values('D');
  11. SQL> SELECT rowid, c FROM t1;
  12. SQL> DELETE FROM t1;
  13. SQL> INSERT INTO t1(c) values('E');
  14. SQL> INSERT INTO t1(c) values('F');
  15. SQL> INSERT INTO t1(c) values('G');
  16. SQL> SELECT rowid, c FROM t1;
• 단계 3: AUTOINCREMENT 제약 예제
  1. SQL> DROP TABLE people;
  2. SQL> CREATE TABLE people ( person_id INTEGER PRIMARY KEY AUTOINCREMENT, first_name text NOT NULL, last_name text NOT NULL );
  3. SQL> INSERT INTO people (person_id,first_name,last_name) VALUES(9223372036854775807,'Johnathan','Smith');
  4. SQL> INSERT INTO people (first_name,last_name) VALUES('John','Smith');
  5. SQL> SELECT rowid, _rowid_, oid, first_name, last_name FROM people;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #41) 제약 조건 - CHECK 제약

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 41편을 공개해드리겠다. 41편은 CHECK 제약 조건을 소개한다.

2021년 1월 27일자 [즐겁게 배우는 SQL #41] 제약 조건 - CHECK 제약 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 CHECK 제약 기본 형식 소개
• 03:06 컬럼 CHECK 예제
• 06:02 테이블 CHECK 예제
• 08:04 기존 테이블에 CHECK 제약 걸기

원본 학습자료는 SQLite CHECK constraints를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: CHECK 제약 기본 형식

  CREATE TABLE table_name(
      ...,
      column_name data_type CHECK(expression),
      ...
  );
  
  CREATE TABLE table_name(
      ...,
      CHECK(expression)
  );
  
  BEGIN;
  -- create a new table 
  CREATE TABLE new_table (
      [...],
      CHECK ([...])
  );
  -- copy data from old table to the new one
  INSERT INTO new_table SELECT * FROM old_table;
  
  -- drop the old table
  DROP TABLE old_table;
  
  -- rename new table to the old one
  ALTER TABLE new_table RENAME TO old_table;
  
  -- commit changes
  COMMIT;
  

• 단계 2: 컬럼 CHECK 예제
  1. SQL> CREATE TABLE contacts ( contact_id INTEGER PRIMARY KEY, first_name TEXT NOT NULL, last_name TEXT NOT NULL, email TEXT, phone TEXT OT NULL CHECK (length(phone) >= 10) );
  2. SQL> INSERT INTO contacts(first_name, last_name, phone) VALUES('John','Doe','408123456');
  3. SQL> INSERT INTO contacts(first_name, last_name, phone) VALUES('John','Doe','(408)-123-456');
• 단계 3: 테이블 CHECK 예제
  1. SQL> CREATE TABLE products ( product_id INTEGER PRIMARY KEY, product_name TEXT NOT NULL, list_price DECIMAL (10, 2) NOT NULL, discount DECIMAL (10, 2) NOT NULL DEFAULT 0, CHECK (list_price >= discount AND discount >= 0 AND list_price >= 0) );
  2. SQL> INSERT INTO products(product_name, list_price, discount) VALUES('New Product #1',2000,1000);
  3. SQL> INSERT INTO products(product_name, list_price, discount) VALUES('New Product #2',900,1000);
  4. SQL> INSERT INTO products(product_name, list_price, discount) VALUES('New XFactor',1000,-10);
• 단계 4: 기존 테이블에 CHECK 제약 걸기
  1. SQL> CREATE TABLE contacts ( contact_id INTEGER PRIMARY KEY, first_name TEXT NOT NULL, last_name TEXT NOT NULL, email TEXT, phone TEXT NOT NULL );
  2. SQL> INSERT INTO contacts(first_name, last_name, phone) VALUES('John','Doe','(408)-123-456');
  3. SQL> BEGIN;
  4. SQL> CREATE TABLE new_contacts ( contact_id INTEGER PRIMARY KEY, first_name TEXT NOT NULL, last_name TEXT NOT NULL, email TEXT, phone TEXT NOT NULL CHECK (length(phone) >= 10) );
  5. SQL> INSERT INTO new_contacts SELECT * FROM contacts;
  6. SQL> DROP TABLE contacts;
  7. SQL> ALTER TABLE new_contacts RENAME TO contacts;
  8. SQL> COMMIT;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #40) 제약 조건 - UNIQUE 제약

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 40편을 공개해드리겠다. 40은 UNIQUE 제약 조건을 소개한다.

2021년 1월 26일자 [즐겁게 배우는 SQL #40] 제약 조건 - UNIQUE 제약 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 UNIQUE 기본 형식 소개
• 02:11 UNIQUE 예제(하나)
• 04:43 UNIQUE 예제(여러 개)
• 06:55 UNIQUE와 NULL

원본 학습자료는 SQLite UNIQUE Constraint를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: UNIQUE 기본 형식 소개

  CREATE TABLE table_name(
      ...,
      column_name type UNIQUE,
      ...
  );
  
  CREATE TABLE table_name(
      ...,
      UNIQUE(column_name)
  );
  
  CREATE TABLE table_name(
      ...,
      UNIQUE(column_name1,column_name2,...)
  );
  

• 단계 2: UNIQUE 예제(하나)
  1. SQL> CREATE TABLE contacts( contact_id INTEGER PRIMARY KEY, first_name TEXT, last_name TEXT, email TEXT NOT NULL UNIQUE );
  2. SQL> INSERT INTO contacts(first_name,last_name,email) VALUES ('John','Doe','john.doe@gmail.com');
  3. SQL> INSERT INTO contacts(first_name,last_name,email) VALUES ('Johnny','Doe','john.doe@gmail.com');
• 단계 3: UNIQUE 예제(여러 개)
  1. SQL> CREATE TABLE shapes( shape_id INTEGER PRIMARY KEY, background_color TEXT, foreground_color TEXT, UNIQUE(background_color,foreground_color) );
  2. SQL> INSERT INTO shapes(background_color,foreground_color) VALUES('red','green');
  3. SQL> INSERT INTO shapes(background_color,foreground_color) VALUES('red','blue');
  4. SQL> INSERT INTO shapes(background_color,foreground_color) VALUES('red','green');
• 단계 4: UNIQUE와 NULL
  1. SQL> CREATE TABLE lists( list_id INTEGER PRIMARY KEY, email TEXT UNIQUE );
  2. SQL> INSERT INTO lists(email) VALUES(NULL),(NULL);
  3. SQL> SELECT * FROM lists;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #39) 제약 조건 - NOT NULL 제약

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 39편을 공개해드리겠다. 39편은 NOT NULL 제약 조건을 소개한다.

2021년 1월 22일자 [즐겁게 배우는 SQL #39] 제약 조건 - NOT NULL 제약 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 NOT NULL 기본 형식 소개
• 03:14 NOT NULL 예제

원본 학습자료는 SQLite NOT NULL Constraint를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: NOT NULL 기본 형식 소개

  CREATE TABLE table_name (
      ...,
      column_name type_name NOT NULL,
      ...
  );
  

• 단계 2: NOT NULL 예제
  1. SQL> CREATE TABLE suppliers( supplier_id INTEGER PRIMARY KEY, name TEXT NOT NULL );
  2. SQL> INSERT INTO suppliers(name) VALUES(NULL);

EOB

[유튜브 방송] (즐겁게 배우는 SQL #38) 제약 조건 - 외래 키

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 38편을 공개해드리겠다. 38편은 외래 키 제약 조건을 소개한다.

2021년 1월 21일자 [즐겁게 배우는 SQL #38] 제약 조건 - 외래 키 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 외래 키 기능 확인
• 03:47 외래 키 예제
• 06:41 외래 키 제약 행위(SET NULL)
• 12:21 외래 키 제약 행위(RESTRICT)
• 15:00 외래 키 제약 행위(CASCADE)

원본 학습자료는 SQLite Foreign Key를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 외래 키 기능 확인

  FOREIGN KEY (foreign_key_columns)
     REFERENCES parent_table(parent_key_columns)
        ON UPDATE action 
        ON DELETE action;
  

  1. 참고: 3.6.19 버전 이후에 외래 키를 지원
  2. 주의: SQLite을 컴파일할 때 SQLITE_OMIT_FOREIGN_KEY나 SQLITE_OMIT_TRIGGER를 정의하면 외래 키 제약을 사용할 수 없다
  3. 외래 키를 보고, 끄고 켜는 방법:
  4. SQL> PRAGMA foreign_keys;
  5. SQL> PRAGMA foreign_keys = OFF;
  6. SQL> PRAGMA foreign_keys = ON;
• 단계 2: 외래 키 예제
  1. SQL> PRAGMA foreign_keys = ON;
  2. SQL> CREATE TABLE suppliers ( supplier_id integer PRIMARY KEY, supplier_name text NOT NULL, group_id integer NOT NULL );
  3. SQL> CREATE TABLE supplier_groups ( group_id integer PRIMARY KEY, group_name text NOT NULL );
  4. SQL> DROP TABLE suppliers;
  5. SQL> CREATE TABLE suppliers ( supplier_id INTEGER PRIMARY KEY, supplier_name TEXT NOT NULL, group_id INTEGER NOT NULL, FOREIGN KEY (group_id) REFERENCES supplier_groups (group_id) );
  6. SQL> INSERT INTO supplier_groups (group_name) VALUES ('Domestic'), ('Global'), ('One-Time');
  7. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES ('HP', 2);
  8. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES('ABC Inc.', 4);
• 단계 3: 외래 키 제약 행위(SET NULL)
  1. SQL> PRAGMA foreign_keys = ON;
  2. SQL> DROP TABLE suppliers;
  3. SQL> CREATE TABLE suppliers ( supplier_id INTEGER PRIMARY KEY, supplier_name TEXT NOT NULL, group_id INTEGER, FOREIGN KEY (group_id) REFERENCES supplier_groups (group_id) ON UPDATE SET NULL ON DELETE SET NULL );
  4. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES('XYZ Corp', 3);
  5. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES('ABC Corp', 3);
  6. SQL> DELETE FROM supplier_groups WHERE group_id = 3;
  7. SQL> SELECT * FROM suppliers;
• 단계 4: 외래 키 제약 행위(RESTRICT)
  1. SQL> PRAGMA foreign_keys = ON;
  2. SQL> DROP TABLE suppliers;
  3. SQL> CREATE TABLE suppliers ( supplier_id INTEGER PRIMARY KEY, supplier_name TEXT NOT NULL, group_id INTEGER, FOREIGN KEY (group_id) REFERENCES supplier_groups (group_id) ON UPDATE RESTRICT ON DELETE RESTRICT );
  4. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES('XYZ Corp', 1);
  5. SQL> DELETE FROM supplier_groups WHERE group_id = 1;
  6. SQL> DELETE FROM suppliers WHERE group_id =1;
  7. SQL> DELETE FROM supplier_groups WHERE group_id = 1;
• 단계 5: 외래 키 제약 행위(CASCADE)
  1. SQL> PRAGMA foreign_keys = ON;
  2. SQL> DELETE FROM supplier_groups;
  3. SQL> DROP TABLE suppliers;
  4. SQL> CREATE TABLE suppliers ( supplier_id INTEGER PRIMARY KEY, supplier_name TEXT NOT NULL, group_id INTEGER, FOREIGN KEY (group_id) REFERENCES supplier_groups (group_id) ON UPDATE CASCADE ON DELETE CASCADE );
  5. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES('XYZ Corp', 1);
  6. SQL> INSERT INTO suppliers (supplier_name, group_id) VALUES('ABC Corp', 2);
  7. SQL> UPDATE supplier_groups SET group_id = 100 WHERE group_name = 'Domestic';
  8. SQL> SELECT * FROM suppliers;
  9. SQL> DELETE FROM supplier_groups WHERE group_id = 2;
  10. SQL> SELECT * FROM suppliers;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #37) 제약 조건 - 기본 키

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 37편을 공개해드리겠다. 37편은 기본(주) 키 제약 조건을 소개한다.

2021년 1월 20일자 [즐겁게 배우는 SQL #37] 제약 조건 - 기본 키 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 기본 키 형식 소개
• 06:07 기본 키 예제
• 08:06 기본 키 추가하기

원본 학습자료는 SQLite Primary Key를 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 기본 키 형식 소개

  CREATE TABLE table_name(
     column_1 INTEGER NOT NULL PRIMARY KEY,
     ...
  );
  
  CREATE TABLE table_name(
     column_1 INTEGER NOT NULL,
     column_2 INTEGER NOT NULL,
     ...
     PRIMARY KEY(column_1,column_2,...)
  );
  
  
  PRAGMA foreign_keys=off;
  
  BEGIN TRANSACTION;
  
  ALTER TABLE table RENAME TO old_table;
  
  -- define the primary key constraint here
  CREATE TABLE table ( ... );
  
  INSERT INTO table SELECT * FROM old_table;
  
  COMMIT;
  
  PRAGMA foreign_keys=on;
  

• 단계 2: 기본 키 예제
  1. SQL> CREATE TABLE countries ( country_id INTEGER PRIMARY KEY, name TEXT NOT NULL );
  2. SQL> CREATE TABLE languages ( language_id INTEGER, name TEXT NOT NULL, PRIMARY KEY (language_id) );
  3. SQL> CREATE TABLE country_languages ( country_id INTEGER NOT NULL, language_id INTEGER NOT NULL, PRIMARY KEY (country_id, language_id), FOREIGN KEY (country_id) REFERENCES countries (country_id) ON DELETE CASCADE ON UPDATE NO ACTION, FOREIGN KEY (language_id) REFERENCES languages (language_id) ON DELETE CASCADE ON UPDATE NO ACTION );
  4. SQL> INSERT INTO addresses ( house_no, street, city, postal_code, country ) VALUES ( '3960', 'North 1st Street', 'San Jose ', '95134', 'USA ' );
  5. SQL> INSERT INTO people ( first_name, last_name, address_id ) VALUES ('John', 'Doe', 1);
  6. SQL> DROP TABLE addresses;
• 단계 3: 기본 키 추가하기
  1. SQL> CREATE TABLE cities ( id INTEGER NOT NULL, name text NOT NULL );
  2. SQL> INSERT INTO cities (id, name) VALUES(1, 'San Jose');
  3. SQL> PRAGMA foreign_keys=off;
  4. SQL> BEGIN TRANSACTION;
  5. SQL> ALTER TABLE cities RENAME TO old_cities;
  6. SQL> CREATE TABLE cities ( id INTEGER NOT NULL PRIMARY KEY, name TEXT NOT NULL );
  7. SQL> INSERT INTO cities SELECT * FROM old_cities;
  8. SQL> DROP TABLE old_cities;
  9. SQL> COMMIT;
  10. SQL> PRAGMA foreign_keys=on;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #36) 데이터를 정의하자 - 청소(Vacuum)

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 36편을 공개해드리겠다. 36편은 테이블 청소 방법을 소개한다.

2021년 1월 19일자 [즐겁게 배우는 SQL #36] 데이터를 정의하자 - 청소(Vacuum) 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 SQLite에서 청소(Vacuum)가 필요한 이유
• 04:55 VACUUM 명령과 pragma를 사용한 VACUUM 방식 지정
• 05:35 VACUUM INTO 살펴보기

원본 학습자료는 SQLite VACUUM을 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: SQLite에서 청소(Vacuum)가 필요한 이유
  1. DROP이나 DELETE 등으로 자료를 삭제하더라도 데이터베이스 파일 크기는 그대로 --> 향후 사용을 위해 확보된 상태로 유지
  2. INSERT/DELETE 등으로 데이터를 삭제하면, 색인과 테이블이 조각화되는 상황이 발생
  3. 이런 문제점을 보완하기 위해 VACUUM을 도입(비고: PostgreSQL)
  4. 주의: VACUUM은 임시 데이터베이스 파일을 만들고 조각모음을 수행하고 다시 원본 데이터베이스 파일에 반영하므로 실시간성이 떨어짐
  5. 큰 테이블이나 색인을 데이터베이스에서 삭제하고 나면 수작업으로 VACUUM을 실행할 필요가 있음
  6. 주의: 3.9.2 버전에서 main 데이터베이스에만 VACUUM 명령을 실행할 수 있음
  7. 참고: SQLite는 자동으로 VACUUM 명령을 수행할 수 있지만, 제약으로 인해 수동으로 돌리는 편이 바람직함
• 단계 2: VACUUM 명령과 pragma를 사용한 VACUUM 방식 지정
  1. SQL> VACUUM; # 수동으로 VACUUM
  2. SQL> PRAGMA auto_vacuum = FULL; # 전체
  3. SQL> PRAGMA auto_vacuum = INCREMENTAL; # 증분
  4. SQL> PRAGMA auto_vacuum = NONE; # 하지 않음
• 단계 3: VACUUM INTO 살펴보기
  1. SQL> VACUUM main INTO 'c:\sqlite\db\chinook_backup.db';

EOB

[유튜브 방송] (즐겁게 배우는 SQL #35) 데이터를 정의하자 - 테이블 제거

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 35편을 공개해드리겠다. 35편은 테이블 제거 방법을 소개한다.

2021년 1월 18일자 [즐겁게 배우는 SQL #35] 데이터를 정의하자 - 테이블 제거 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 테이블 제거 방법 소개
• 02:00 테이블 제거 예제
• 05:21 FK 문제 해결 방안

원본 학습자료는 SQLite Drop Table을 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 테이블 제거 방법 소개

  DROP TABLE [IF EXISTS] [schema_name.]table_name;
  

• 단계 2: 테이블 제거 예제
  1. SQL> PRAGMA foreign_keys = ON;
  2. SQL> CREATE TABLE IF NOT EXISTS people ( person_id INTEGER PRIMARY KEY, first_name TEXT, last_name TEXT, address_id INTEGER, FOREIGN KEY (address_id) REFERENCES addresses (address_id) );
  3. SQL> CREATE TABLE IF NOT EXISTS addresses ( address_id INTEGER PRIMARY KEY, house_no TEXT, street TEXT, city TEXT, postal_code TEXT, country TEXT );
  4. SQL> INSERT INTO addresses ( house_no, street, city, postal_code, country ) VALUES ( '3960', 'North 1st Street', 'San Jose ', '95134', 'USA ' );
  5. SQL> INSERT INTO people ( first_name, last_name, address_id ) VALUES ('John', 'Doe', 1);
  6. SQL> DROP TABLE addresses;
• 단계 3: FK 문제 해결 방안
  1. SQL> PRAGMA foreign_keys = OFF;
  2. SQL> DROP TABLE addresses;
  3. SQL> UPDATE people SET address_id = NULL;
  4. SQL> PRAGMA foreign_keys = ON;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #34) 데이터를 정의하자 - 테이블 열 이름 변경

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 34편을 공개해드리겠다. 34편은 테이블 열 이름 변경 방법을 소개한다.

2021년 1월 15일자 [즐겁게 배우는 SQL #34] 데이터를 정의하자 - 테이블 열 이름 변경 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 테이블 열 이름 변경 방법 소개
• 01:14 테이블 열 이름 변경 예제
• 02:30 테이블 열 이름 변경 예제(2)

원본 학습자료는 SQLite Rename Column을 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 테이블 열 이름 변경 방법 소개

  ALTER TABLE table_name
  RENAME COLUMN current_name TO new_name;
  

• 단계 2: 테이블 열 이름 변경 예제
  1. SQL> CREATE TABLE Locations( LocationId INTEGER PRIMARY KEY, Address TEXT NOT NULL, City TEXT NOT NULL, State TEXT NOT NULL, Country TEXT NOT NULL );
  2. SQL> INSERT INTO Locations(Address,City,State,Country) VALUES('3960 North 1st Street','San Jose','CA','USA');
  3. SQL> ALTER TABLE Locations RENAME COLUMN Address TO Street;
  4. SQL> SELET * FROM Locations;
• 단계 3: 테이블 열 이름 변경 예제(2)
  1. 참고: 3.25.0 이전에 사용하는 옛날 방식
  2. SQL> DROP TABLE IF EXISTS Locations;
  3. SQL> CREATE TABLE Locations( LocationId INTEGER PRIMARY KEY, Address TEXT NOT NULL, State TEXT NOT NULL, City TEXT NOT NULL, Country TEXT NOT NULL );
  4. SQL> INSERT INTO Locations(Address,City,State,Country) VALUES('3960 North 1st Street','San Jose','CA','USA');
  5. SQL> BEGIN TRANSACTION;
  6. SQL> CREATE TABLE LocationsTemp( LocationId INTEGER PRIMARY KEY, Street TEXT NOT NULL, City TEXT NOT NULL, State TEXT NOT NULL, Country TEXT NOT NULL );
  7. SQL> INSERT INTO LocationsTemp(Street,City,State,Country)
  8. SQL> SELECT Address,City,State,Country FROM Locations;
  9. SQL> DROP TABLE Locations;
  10. SQL> ALTER TABLE LocationsTemp RENAME TO Locations;
  11. SQL> COMMIT;
  12. SQL> SELECT * FROM Locations;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #33) 데이터를 정의하자 - 테이블 변경

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 33편을 공개해드리겠다. 33편은 테이블 변경 방법을 소개한다.

2021년 1월 14일자 [즐겁게 배우는 SQL #33] 데이터를 정의하자 - 테이블 변경 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 테이블 변경 방법 소개
• 03:28 테이블 이름 변경 예제
• 05:04 테이블 열 추가 예제
• 07:42 테이블 열 삭제 예제

원본 학습자료는 SQLite Rename Column을 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 테이블 변경 방법 소개

  ALTER TABLE existing_table
  RENAME TO new_table;
  ) [WITHOUT ROWID];
  
  ALTER TABLE table_name
  ADD COLUMN column_definition;
  
  ALTER TABLE table_name
  RENAME COLUMN current_name TO new_name;
  
  
  -- disable foreign key constraint check
  PRAGMA foreign_keys=off;
  
  -- start a transaction
  BEGIN TRANSACTION;
  
  -- Here you can drop column
  CREATE TABLE IF NOT EXISTS new_table( 
     column_definition,
     ...
  );
  -- copy data from the table to the new_table
  INSERT INTO new_table(column_list)
  SELECT column_list
  FROM table;
  
  -- drop the table
  DROP TABLE table;
  
  -- rename the new_table to the table
  ALTER TABLE new_table RENAME TO table; 
  
  -- commit the transaction
  COMMIT;
  
  -- enable foreign key constraint check
  PRAGMA foreign_keys=on;
  

• 단계 2: 테이블 이름 변경 예제
  1. SQL> CREATE TABLE devices ( name TEXT NOT NULL, model TEXT NOT NULL, Serial INTEGER NOT NULL UNIQUE );
  2. SQL> INSERT INTO devices (name, model, serial) VALUES('HP ZBook 17 G3 Mobile Workstation','ZBook','SN-2015');
  3. SQL> ALTER TABLE devices RENAME TO equipment;
  4. SQL> SELECT name, model, serial FROM equipment;
• 단계 3: 테이블 열 추가 예제
  1. SQL> ALTER TABLE equipment ADD COLUMN location text;
• 단계 4: 테이블 열 삭제 예제
  1. SQL> CREATE TABLE users( UserId INTEGER PRIMARY KEY, FirstName TEXT NOT NULL, LastName TEXT NOT NULL, Email TEXT NOT NULL, Phone TEXT NOT NULL );
  2. SQL> CREATE TABLE favorites( UserId INTEGER, PlaylistId INTEGER, FOREIGN KEY(UserId) REFERENCES users(UserId), FOREIGN KEY(PlaylistId) REFERENCES playlists(PlaylistId) );
  3. SQL> INSERT INTO users(FirstName, LastName, Email, Phone) VALUES('John','Doe','john.doe@example.com','408-234-3456');
  4. SQL> INSERT INTO favorites(UserId, PlaylistId) VALUES(1,1);
  5. SQL> SELECT * FROM users;
  6. SQL> SELECT * FROM favorites;
  7. SQL> PRAGMA foreign_keys=off;
  8. SQL> BEGIN TRANSACTION;
  9. SQL> CREATE TABLE IF NOT EXISTS persons ( UserId INTEGER PRIMARY KEY, FirstName TEXT NOT NULL, LastName TEXT NOT NULL, Email TEXT NOT NULL );
  10. SQL> INSERT INTO persons(UserId, FirstName, LastName, Email) SELECT UserId, FirstName, LastName, Email FROM users;
  11. SQL> DROP TABLE users;
  12. SQL> ALTER TABLE persons RENAME TO users;
  13. SQL> COMMIT;
  14. SQL> PRAGMA foreign_keys=on;
  15. SQL> SELECT * FROM users;

EOB

[유튜브 방송] (즐겁게 배우는 SQL #32) 데이터를 정의하자 - 테이블 생성

[유튜브 방송] (즐겁게 배우는 SQL) 기획 소개에서 설명드린 즐겁게 배우는 SQL 32편을 공개해드리겠다. 32편은 테이블 생성 방법을 소개한다.

2021년 1월 13일자 [즐겁게 배우는 SQL #32] 데이터를 정의하자 - 테이블 생성 방송은 다음에서 볼 수 있으며, 전체 방송 플레이리스트는 즐겁게 배우는 SQL에서 확인할 수 있다.

하이라이트를 요약 정리하면 다음과 같다:

• 00:00 테이블 생성 방법 소개
• 05:17 테이블 생성 예제

원본 학습자료는 SQLite Create Table을 참고하고, 방송에 사용한 실제 실습 자료는 다음을 참고한다:

• 단계 1: 테이블 생성 방법 소개

  CREATE TABLE [IF NOT EXISTS] [schema_name].table_name (
  	column_1 data_type PRIMARY KEY,
     	column_2 data_type NOT NULL,
  	column_3 data_type DEFAULT 0,
  	table_constraints
  ) [WITHOUT ROWID];
  

• 단계 2: 테이블 생성 예제
  1. SQL> CREATE TABLE contacts ( contact_id INTEGER PRIMARY KEY, first_name TEXT NOT NULL, last_name TEXT NOT NULL, email TEXT NOT NULL UNIQUE, phone TEXT NOT NULL UNIQUE );
  2. SQL> CREATE TABLE groups ( group_id INTEGER PRIMARY KEY, name TEXT NOT NULL );
  3. SQL> CREATE TABLE contact_groups( contact_id INTEGER, group_id INTEGER, PRIMARY KEY (contact_id, group_id), FOREIGN KEY (contact_id) REFERENCES contacts (contact_id) ON DELETE CASCADE ON UPDATE NO ACTION, FOREIGN KEY (group_id) REFERENCES groups (group_id) ON DELETE CASCADE ON UPDATE NO ACTION );

EOB