*프로시져 ( PROCEDURE) : 

 ->PL/SQL 문을 저장하는 객체

 -> 필요할 떄마다 복잡한 구문을 다시 입력할 필요 없이 간단하게 호출해 결과를 얻을 수 있음

 -> 특정 로직을 처리하기만 하고 결과값을 반환하지 않음 (FUNCTION 과의 차이)

 

<프로시져 생성 방법>

 CREATE OR REPLACE PROCEDURE 프로시저명

    ( 매개변수명1 (IN / OUT / IN OUT) 데이터타입 [ := DEFAULT값],

        ....

     )

  IS

      선언부

 BEGIN

      실행부

  [EXCEPTION ~]

 END [프로시저명] ;

 

<프로시져 실행>

 EXECUTE/EXEC  `프로시져명` ;

 

<EX 매개변수 없는 프로시져>

CREATE OR REPLACE PROCEDURE TEST_P
IS
BEGIN
	DELETE FROM TABLE_A;
    DELETE FROM TABLE_B;
    COMMIT;
END;
/

EXECUTE TEST_P;

SELECT * FROM USER_SOURCE; --프로시져 작성 구문 저장 출력

<EX 매개변수 있는 프로시져>

CREATE OR REPLACE PROCEDURE TEST_P2(
	P2_VAR TABLE_A.A_NAME%TYPE;   
)
IS
BEGIN
	DELETE FROM TABLE_A
    WHERE A_NAME = P2_VAR;
    COMMIT;
END;
/

EXECUTE TEST_P2('MYNAME');  --지정 입력

EXEC TEST_P2('&NAME');  -- 입력창 입력

<EX IN, OUT 매개변수 있는 프로시져>

 

* IN 매개변수 

    -> 프로시져 내부에서 사용될 변수

* OUT 매개변수

    -> 프로시저 외부(호출해서) 에서 사용될 변수

CREATE OR REPLACE PROCEDURE TEST_P3(
	P3_ID IN TABLE_A.A_ID%TYPE,
    P3_NAME OUT TABLE_A.A_NAME,
    P3_PHONE OUT TABLE_A.A_PHONE,
    P3_ADDRESS OUT TABLE_A.A_ADDRESS
)
IS
BEGIN
	SELECT A_NAME, A_PHONE, A_ADDRESS
    INTO P3_NAME, P3_PHONE, P3_ADDRESS
    FROM TABLE_A
    WHERE A_ID = P3_ID;
END;
/

/*
프로시져에서 OUT으로 저장되어있는 매개변수를 호출해서
외부에서 받아낸 변수가 필요하다
--> 바인딩 변수
*/

VAR RESULT_NAME VARCHAR2(30);
VAR RESULT_PHONE VARCHAR2(15);
VAR RESULT_ADDRESS VARCHAR2(200);
EXECUTE TEST_P3('&ID', :RESULT_NAME, :RESULT_PHONE, :RESULT_ADDRESS);

PRINT RESULT_NAME;
PRINT RESULT_PHONE;
PRINT RESULT_ADDRESS;  --PRINT -> 변수 출력 명령어

SET AUTOPRINT ON; -- 바인드 변수값 자동 출력 설정

*FUNCTION : 프로시져와 사용 용도가 거의 비슷하지만 프로시져와 다르게 

                   OUT 매개변수를 사용하지 않아도 결과를 되돌려 받을 수 있다 (RETURN)

 <FUNCTION 생성 방법>

 CREATE OR REPLACE FUNCTION 함수명(매개변수1 매개변수타입 , ...)

 RETURN 데이터타입

 IS

    선언부

 BEGIN

    실행부

  RETURN 반환값;

[EXCEPTION~ ]

END [함수명];

 

<EX>

CREATE OR REPLACE FUNCTION P_CALCUL(
	P_ID IN TABLE_A.A_ID%TYPE   --받는 매개변수
 )
 RETURN NUMBER  --리턴 타입
 IS 
 	P_INCOME TABLE_A.A_SALARY%TYPE;  -값 저장 변수 선언
    P_COMSUME TABLE_A.A_USE%TYPE;
    MONTH_NET NUMBER;
 
 BEGIN
 	SELECT A_SALARY, A_USE
    INTO P_INCOME, P_CONSUME
    FROM TABLE_A
    WHERE A_ID = P_ID;
 	
    MONTH_NET := P_INCOME - p_CONSUME ;
    RETURN MONTH_NET;
 END;
 /
 
 --사용법
 
 VAR CAL NUMBER;
 EXECUTE :CAL := P_CALCUL('&ID');
 
 --OR SELECT문에 사용
 
 SELECT A_ID, A_NAME, P_CALCUL(A_ID) 순수입
 FROM TABLE_A
 WHERE P_CALCUL(A_ID) > 300000;

* 커서(CURSOR) 

-> SELECT문 처리 결과(RESULT SET)를 담고 있는 메모리 공간에 대한 포인터

-> 커서 사용 시 여러 ROW로 나타난 처리 결과에 순차적으로 접근 가능

->  묵시적 커서:  오라클에서 자동으로 생성되어 사용되는 커서

    (묵시적 커서 속성 정보 참조 시 커서명 = SQL)
    - 커서명%ROWCOUNT : SQL 처리 결과로 얻어온 ROW 수
                       0 시작, FETCH 시 마다 1씩 증가
    - 커서명%FOUND    : 커서 영역의 ROW 수가 한 개 이상일 경우 TRUE 아님 FALSE
    - 커서명%NOTFOUND : 커서 영역의 ROW 수가 없으면 TRUE, 아님 FALSE
    - 커서명%ISOPEN   : 커서가 OPEN 상태인 경우 TRUE(묵시적 커서는 항상 FALSE)

     (EX)
     --SELECT 하면 오라클이 알아서 묵시적 커서를 생성하고 조건을 만족하는 행을 조회
     --한 행씩 이동하며 수정하고 이때 이동한 행의 개수 카운트(ROWCOUNT)
     --최종적으로 화면에 ROWCOUNT 출력

 

->  명시적 커서: 사용자가 직접 선언해서 사용할 수 있는 커서

            <작성법>

            1) CURSOR --커서 선언

            2) OPEN -- 커서 오픈

            3) FETCH --커서에서 데이터 추출

            4) CLOSE --커서 닫기

<EX>

DECLARE
	CURSOR C1 IS 
    	SELECT A_ID, A_NAME, A_SALARY
        FROM TABLE_A
        WHERE A_SALARY>=300000;
    ID TABLE_A.A_ID%TYPE;
    NAME TABLE_A.A_NAME%TYPE;
    SAL TABLE_A.A_SALARY%TYPE;
BEGIN
	OPEN C1:
    LOOP
    	FETCH C1 INTO ID, NAME, SAL
        EXIT WHEN C1%NOTFOUND;
        DBMS_OUTPUT.PUT_LINE(ID || '/' || NAME || '/' || SAL);
    END LOOP;
    CLOSE C1;
END;
/

<EX2 FOR +CURSOR>

-> FOR문을 이용한 커서 =  커서의 OPEN, FETCH, CLOSE 를 자동으로 해준다(선언만 하면 됨)

DECLARE
	CUSOR C2 IS
    	SELECT A_ID, A_NAME, A_SALARY
    	FROM TABLE_A
   		WHERE A_SALARY>=300000;
     P_C2 TABLE_A%ROWTYPE;
BEGIN
	FOR DEPT IN C2
    	LOOP
        	DBMS_OUTPUT.PUT_LINE(
            'ID : ' ||  P_C2.A_ID||
            'NAME : ' || P_C2.A_NAME ||
            'SALARY : '|| P2_C2.A_SALARY);
        END LOOP;
END;
/

 

 

* PL/SQL 의 IF 문

 -> IF( ) ~ THEN ~

     ELSIF ( ) ~ THEN ~

     ELSE ~

     END IF 

DECLARE 
	INFO_A TABLE_A%ROWTYPE;
 BEGIN 
 	SELECT *
    INTO INFO_A
    FROM TABLE_A
    WHERE A_ID = '&A_ID' ;
    
    IF (INFO_A.A_NAME = 'MYNAME')
    	THEN DBMS_OUTPUT.PUT_LINE('MY INFO');
    
    --ELSIF ~ THEN ~ ELSE ~
    
    END IF;
    
END;
/


* PL/SQL 의 CASE 문

 -> ~ := CASE ~

        WHEN ~ THEN~

        WHEN ~ THEN~

        WHEN ~ THEN~

        WHEN ~ THEN~

        WHEN ~ THEN~

             END:

DECLARE
	INFO_A TABLE_A%ROWTYPE;
    ID VARCHAR2(20);
BEGIN 
	SELECT * 
    INTO INFO_A
    FROM TABLE_A
    WHERE A_ID = '&AID';
    
    ID := 
    CASE TABLE_A.A_ID
    WHEN 'AA' THEN 'FRIEND1'
    WHEN 'BB' THEN 'FRUEND2'
    WHEN 'CC' THEN 'FRUEND3'
    WHEN 'DD' THEN 'FRUEND4'
    WHEN 'EE' THEN 'FRUEND5'
    
    END;
    DBMS_OUTPUT.PUT_LINE(TABLE_A.A_ID || '는 ' || ID); 
END;
/

*PL/SQL 의 반복문

-> (BASIC LOOP) : 내부에 처리문을 작성하고 마지막에 LOOP를 벗어날 조건을 명시

    LOOP

         처리문

           

         조건문

          ( IF 조건식 THEN EXIT

          END IF )   

             or

          ( EXIT WHEN 조건식 )      

    END LOOP;

 

DECLARE 
	N NUMBER :=1;
BEGIN
	LOOP
    	DBMS_OUTPUT_PUT_LINE(N);
        EXIT WHEN N=5;
        
        N := N+1;
     END LOOP;
 END;
 /

      

* PL/SQL 의 반복문2

 -> (FOR 문) : 

    FOR 인덱스 IN (REVERSE) 초기값 ... 최종값

     LOOP

        처리문

     END LOOP;

BEGIN 
	FOR I IN 1..5
    LOOP
    	DBMS_OUTPUT.PUT_LINE(I);
    END LOOP;
END;
/
--거꾸로 
BEGIN 
	FOR I IN REVERSE 1..5
    LOOP
    	DBMS_OUTPUT.PUT_LINE(I);
    END LOOP;
END;
/

 

*반복문을 이용한 INSERT

CREATE TABLE MAKE1(
	R_NUM NUMBER(3),
    R_CHAR VARCHAR2(20),
    DT DATE
);

BEGIN 
	FOR I IN 1..10
    LOOP
    	INSERT INTO MAKE1 VALUES(I, '임의의수'||I , SYSDATE+I );
    END LOOP;
END;
/

 

*예외처리 : 오라클 내부에 미리 정의되어 있는 예외 (약 20개)

                따로 선언할 필요 없이 발생 시 예외절에 자동 트랩됨

         - 대표적인 시스템 예외
        -- NO_DATA_FOUND :  SELECT문이 아무런 데이터 행을 반환하지 못할 때
        -- TOO_MANY_ROWS : 하나만 리턴해야하는 SELECT문이 하나 이상의 행을 반환할 때
        -- INVALID_CURSOR : 잘못된 커서 연산
        -- ZERO_DIVIDE : 0으로 나눌 때
        -- DUP_VAL_ON_INDEX : UNIQUE 제약을 갖는 컬럼에 중복되는 데이터가 INSERT될 때 

<예외처리 구문>

EXCEPTION WHEN 예외명 1 THEN 예외처리구문1

                WHEN 에외명 2 THEN 예외처리구문 2

                .....

<EXAMPLE>

DECLARE 
	NUM NUMBER := 0;
BEGIN
	NIM := 10/0;
    DBMS_OUTPUT.PUT_LINE('SUCCESS');
  EXCEPTION
  	WHEN ZERO_DIVIDE 
    THEN DBMS_OUTPUT.PUT_LINE('ZERO_DIVIDE EXCEPTION발생!');
END;
/

 

 

* PL/SQL ? 

 -> 오라클 자체에 내장되어 있는 절차적 언어 (PROCEDUAL LANGUAGE)

 -> SQL 문장 내에서 변수 정의, IF LOOP FOR WHILE 등을 지원하며 SQL의 단점 보완

 

*PL/SQL 구조

1) 선언부 : DECLARE ~  변수나 상수 선언

2) 실행부 : BEGIN ~ 제어문, 반복문, 함수 정의 등 로직 

3) 예외처리부 : EXCEPTION~ 예외 발생 시 해결하기 위한 문장

 

* PL/SQL의 장점

1. BLOCK 구조로 다수의 SQL문을 한번에 ORACLE DB로 보내 처리하므로 수행 속도 향상

2. 모든 요소는 하나 또는 두 개 이상의 블록으로 구성하여 모듈화 가능

3. 동적으로 변수 선언 가능

4. EXCEPTION 을 통해여  ORACLE SERVER ERROR 처리가능 (사용자 정의 에러 정의 및 처리도 가능)

 

※프로시저 사용 시 출력하는 내용을 화면에 보이도록 하는 명령어

SET SERVEROUTPUT ON;

 

<HELLO WORLD 출력>

 

BEGIN

 DBMS_OUTPUT.PUT_LINE('HELLO WORLD');

END;

/

(/ : PL/SQL 블록 종료 의미) 

 

<변수 선언, 초기화> 

 

DECLARE 
	C1 NUMBER;
    C2 VARCHAR2(30);
    C3 VARCHAR(30):= 'MY' ;
    C4 CONSTANT NUMBER := 3.141592;
BEGIN
	C1 := 999;
   	C2 := 'NAME'
END;
/

오라클의 대입연산자 ->  :=

 

<레퍼런스 변수>  -> 변수의 데이터 타입을 테이블 또는 뷰의 컬럼을 참조하여 지정하는 변수

 -> 종류 : %TYPE, %ROWTYPE

 -> %TYPE : 해당 컬럼의 데이터 타입을 얻음

 -> %ROWTYPE : 해당 테이블 행 전체의 타입을 얻음

 

DECLARE 
	ID TABLE_A.A_ID%TYPE; 			--변수 선언
    NAME TABLE_A.A_NAME%TYPE;		--자료형은 해당 테이블컬럼을 참조
    
BEGIN 
	SELECT A_ID, A_NAME 			--변수에 SELECT 값 각각 대입
    INTO ID, NAME
    FROM TABLE_A
    WHERE A_ID = '&ID';
    
    DBMS_OUTPUT.PUT_LINE(ID); 		--저장된 변수 출력
    DBMS_OUTPUT.PUT_LINE(NAME);
END;
/

오라클 값 입력창 : '&이름'

 

<%ROWTYPE 활용>

DECLARE 
	ROW_V TABLE_A%ROWTYPE;

BEGIN 
	SELECT * 
    INTO ROW_V
    FROM TABLE_A
    WHERE A_ID = '&ID';

	DBMS_OUTPUT.PUT_LINE('A_ID: ' || TABLE_A.A_ID);
	DBMS_OUTPUT.PUT_LINE('A-NAME: ' || TABLE_A.A_NAME);    
	DBMS_OUTPUT.PUT_LINE('A_PHONE: ' || TABLE_A.A_PHONE);    --원하는 변수 출력
    
 END;
 /

 

*오라클 주요 객체 : VIEW , SEQUENCE, INDEX ..

 

1. VIEW : SELECT문의 실행 경과(RESULT SET)을 저장하는 객체

   ->논리적 가상 테이블로서 실제 값을 저장하고 있진 않음

   ->복잡한 SELECT 문의 쉬운 재사용을 위해서 사용하고

   ->테이블의 진짜 모습을 감출 수 있어 보안상으로도 장점이 있다

※ VIEW 사용시

 - ALTER 구문은 사용이 불가하다

 - VIEW 를 이용한 DML (SELECT, UPDATE, DELETE ) 가 가능은 하나 제약이 많이 따르기 떄문에 

   보통 조회 용도로만 쓰는것이 좋다

 -VIEW 를 이용해 INSERT를 진행하면 VIEW에 삽입된것 처럼 보이지만 원본 테이블에 삽입이 되는 것이다.

 

<VIEW 생성방법>

 

CREATE  VIEW `VIEW_NAME` 

AS `SUBQUERY` 

※ 추가옵션: 

 1. OR REPLACE : CREATE 뒤

  -> 동일 뷰 이름이 존재하면 덮어 쓰고 없으면 새로 생성

 2. FORCE / NOFORCE : CREATE 뒤

  -> FORCE : 서브쿼리에 사용된 테이블이 존재하지 않아도 뷰 생성

  -> NOFORCE : 서브쿼리에 사용된 테이블이 존재해야만 뷰 생성(기본 DEFAULT) 

 3. WITH CHECK OPTION : 서브쿼리 뒤

  ->옵션을 설정한 컬럼의 값을 수정 불가능하게 함 (조건을 벗어나게 변경 불가)

 4. WITH READ ONLY : 서브쿼리 뒤

  -> 조회만 가능하도록 함 (DML 전부 수행 불가) 


2. SEQUENCE : 순차적 번호 자동 발생기 역할의 객체

 -> PRIMARY 키 값으로 주로 사용

 

<SEQUENCE  생성방법> 

 

 CREATE SEQUENCE `SE_NAME`

※ 추가옵션: 뒤에 차례로 추가 가능

 1.  START WITH N : N부터 시작 , 기본 1

 2.  INCREMENT BY N : N씩 증가함 , 기본 1

 3. MAXVALUE N : 발생시킬 최대값 지정(10의 27승까지 가능) , 기본 NOMAXVALUE

 4. MINVALUE N : 발생시킬 최소값 지정(-10의 26승까지 가능) , 기본 NOMINVALUE

 5. CYCLE : 값 순환 여부 지정, 기본 NO

 6. CACHE BYTE크기 : 캐쉬메모리 지정, 기본 20BYTE

 (시퀀스 호출 시 미리 저장되어진 값들을 가져와 반환하므로 매번 시퀀스 생성 후 반환하는 것보다 속도 향상)

 

<SEQUENCE  사용방법>

1. `SE_NAME` . NEXTVAL : 다음 번호를 불러온다. 시작점이면 시작값 불러옴

2. `SE_NAME` . CURRVAL : 현재 번호를 불러온다

 

*시퀀스는 오류 / 롤백 등과 관계없이 NEXTVAL 구문이 수행되면 무조건 숫자를 증가시킨다

<SEQUENCE  변경방법>

 ALTER SEQUENCE `SE_NAME`

 ~옵션

*START WITH 는 변경이 불가하므로 DROP 후 재생성해야한다


3. INDEX : SQL명령문 중 SELECT 처리 속도를 향상시키기 위해서 컬럼에 대해 생성하는 객체

  -> 인덱스 내부 구조는 B트리로 이루어져있으며

  -> 이진트리 특성상 자동 정렬 및 검색 속도에 장점이 생김

  -> 시스템의 부하를 줄이므로 전체 성능 향상을 시킬 수 있다.

  -> 다만 , 인덱스를 추가하기 위한 저장공간이 필요하고

  ->    인덱스 생성의 시간이 걸리며

  ->   DML이 빈번한 경우에는 오히려 성능이 저하되는 단점이 있다.

  ->  PRIMARY KEY 또는 UNIQUE 제약조건이 설정되는 경우 인덱스가 자동으로 생성된다.

<INDEX 생성방법> 

 

  CREATE INDEX `INDEX_NAME`

  ON `TABLE_NAME` ( `COL_NAME1`, `COL_NAME2` ...  -또는 함수명/ 함수계산식)

  (인덱스를 생성했다고 자동적으로 사용되지는 않는다)

 

<INDEX 사용 방법>

 -> WHERE 절에 INDEX가 추가된 컬럼이 언급되는 것이 사용 방법

 

 

*DCL : 데이터 제어 언어

-데이터베이스, 데이터베이스 내의 객체에 대한 권한을 제어(부여, 회수) 하는 언어

 

1. GRANT : 권한 부여

  - GRANT 권한 1 , 권한 2, ...   TO 사용자 이름;

  - 한번에 여러개 부여 가능

2. REVOKE 권한 회수

  - REVOKE 권한 FROM 사용자 이름;

 

권한 종류 

  • CREATE SESSION   : 데이터베이스 접속 권한
  • CREATE TABLE     : 테이블 생성 권한
  • CREATE VIEW      : 뷰 생성 권한
  • CREATE SEQUENCE  : 시퀀스 생성 권한
  • CREATE PROCEDURE : 함수(프로시져) 생성 권한
  • CREATE USER      : 사용자(계정) 생성 권한
  • DROP USER        : 사용자(계정) 삭제 권한
  • DROP ANY TABLE   : 임의 테이블 삭제 권한

계정의 종류 : 

-관리자 계정 : 모든 권한과 책임 가짐

-사용자 계정 : 업무에 필요한 최소한의 권한만 가지는 것을 원칙

 

** ROLE **

-권한의 묶음

-여러가지 관련된 권한들을 묶어서 한번에 부여, 회수하는 용도로 사용

1)CONNECT : 데이터베이스 접속 권한 (= CREATE SESSION)

2)RESOURCE : 데이터베이스를 사용하기 위한 기본 객체 생성 권한을 묶어둔 롤

=> TABLE 외 7가지 생성 권한 + 테이블스페이스를 기본값 자동 부여

 

** 객체 권한 **

-특정 객체를 조작할 수 있는 권한을 부여

GRANT 권한 종류 [(컬럼명)] | ALL 
    ON 객체명 | ROLE 이름 | PUBLIC
    TO 사용자 이름;

 권한 종류   설정 객체
SELECT               TABLE, VIEW, SEQUENCE
INSERT               TABLE, VIEW
UPDATE                TABLE, VIEW
DELETE               TABLE, VIEW
ALTER                 TABLE, SEQUENCE
REFERENCES           TABLE
INDEX                TABLE
EXECUTE              PROCEDURE

 

<EXAMPLE>

 

CREATE USER A IDENTIFIED BY PW; (유저 생성)

 

GRANT SELECT ON TABLE_T TO A (권한 부여)

 

REVOKE INSERT ON TABLE_T FROM A (권한 회수) 

 

 

*DDL :

 -Data Definition Language

 -데이터 정의 언어.

 -객체를 만들고 수정하고 삭제하는 구문 ( CREATE , ALTER, DROP)

 

1. CREATE : 객체(테이블 , 인덱스 , 뷰 등..) 를 생성하는 구문

 -CREATE TABLE `이름` (

  `컬럼명`  `자료형`  (DEFAULT ~ ) (` 제약조건~` )

   ...

  )

*서브쿼리를 이용한 테이블 복사(서브쿼리로 JOIN, 지정 가능 , WHERE 조건 가능)

 CREATE TABLE BCOPY AS ( SELECT * FROM B);

  -->제약조건 중 NOT NULL 제약조건만 복사되고 나머지는 사라진다.

*오라클의 데이터타입

1.CHAR : 고정길이 문자(빈칸이 있어도 고정)

2.VARCHAR2 : 가변길이 문자(빈칸 생기면 날림)

3.NUMBER : 숫자 (정수, 실수)

4.DATE : 날짜

5.CLOB : 대용량 문자

6.BLOB : 대용량 이진 데이터

7.TIMESTAMP : 밀리세컨드 단위 추가 DATE

 

*컬럼에 주석 넣기

 -COMMENT ON COLUMN `테이블명`.`컬럼명` IS `내용`

 

*제약조건 : 데이터 무결성( 저장된 데이터의 정확성과 일관성을 보증) 을 목적으로

                조건을 설정하는 강제 제약     

 1. NOT NULL        : 널을 허용하지 않는다

  컬럼 레벨에서만 가능하다

 `컬럼명` `자료형` (생략가능)[CONSTRAINT 제약조건명] NOT NULL 

 2. UNIQUE           :  중복값을 허용하지 않는다 (NULL은 가능하다)

   컬럼 레벨     --`컬럼명` `자료형` (생략가능)[CONSTRAINT 제약조건명] UNIQUE

   테이블 레벨  --(생략가능)[CONSTRAINT 제약조건명] UNIQUE (`컬럼명1` , `컬럼명2` )

    *테이블 레벨에서 묶어서 UNIQUE 복합키 설정이 가능하다 ( 두 컬럼이 모두 중복되는 경우만 걸러냄)

 3. PRIMARY KEY   :  널과 중복을 허용하지 않으며 테이블의 식별자로 사용한다

                              한 테이블당 한 개만 설정 가능하고 테이블 레벨에서 여러 컬럼을 묶어 설정할 수 있다.

컬럼 레벨     --`컬럼명` `자료형` (생략가능)[CONSTRAINT 제약조건명] PRIMARY KEY

테이블 레벨  --(생략가능)[CONSTRAINT 제약조건명] PRIMARY KEY (`컬럼명1` , `컬럼명2` )

 4. FOREIGN KEY    : 참조된 다른 테이블의 컬럼이 제공하는 값만 사용할 수 있음

                             FOREIGN KEY 제약조건으로 테이블간에 관계가 형성됨

                             제공 되는 값 외 NULL도 사용 가능

                             참조될 수 있는 컬럼은 PRIMARY KEY / UNIQUE 만 가능하며

                             참조할 테이블의 참조 컬럼명이 생략되면

                             참조 테이블의 PRIMARY KEY를 자동 참조할 컬럼으로 설정함

컬럼 레벨     --`컬럼명` `자료형` (생략가능)[CONSTRAINT 제약조건명] REFERENCES `참조 테이블명` (`참조 컬럼명`)

테이블 레벨  --(생략가능)[CONSTRAINT 제약조건명] FOREIGN KEY (컬럼명) REFERENCES `참조 테이블명` (참조

                                                                                                                                             컬럼명)

 5. CHECK             : 저장 가능한 값 조건을 미리 설정

=> 모두 테이블레벨에서도 가능하지만 NOT NULL은 테이블 레벨에 불가능하다

컬럼 레벨     --`컬럼명` `자료형` (생략가능)[CONSTRAINT 제약조건명] CHECK (`컬럼명` 비교연산자 비교값)

테이블 레벨  --(생략가능)[CONSTRAINT 제약조건명] CHECK(`컬럼명` 비교연산자 비교값)

   *비교연산자 : > ,< ,IN, BETWEEN A AND B, ...

 

 

*FOREIGN KEY 삭제 옵션 ( FOREIGN KEY 제약조건 뒤에 추가)

 - 부모 테이블의 데이터 삭제 시 자식 테이블의 데이터를 처리하는 방법

 - 입력 없어도 ON DELETE RESTRICTED 가 DEFAULT( 참조되는 컬럼이면 삭제 불가)

 - ON DELETE SET NULL : 부모키 삭제 시 자식키를 NULL로 변경하는 옵션

 - ON DELETE CASCADE : 부모키 삭제시 자식키도 함께 삭제됨

 

 

* DML?

 -Data Manipulation Language : 

 -데이터 조작 언어로 테이블에 값을 삽입 / 수정 / 삭제 하는 언어

 

 

0. SELECT : 테이블에서 값들을 조회

  -SELECT ~ FROM ~

  JOIN ~

  WHERE ~

  GRUOP BY ~

  HAVING ~

  ORDER BY ~

 

    SELECT 구문에서 실행 :

    FROM => WHERE => GROUP BY => HAVING => SELECT => ORDER BY

    순으로 이루어지므로 주의해야 한다.

 

1. INSERT : 테이블에 새로운 행 추가

- INSERT INTO `테이블명` VALUES ( 값 ...) ;

- INSERT INTO `테이블명` (`컬럼명` ...) VALUES (값 ...) ;

 * VALUES 대신 서브쿼리를 넣을수도 있다 , 값을 안넣으면 NULL이 된다

 * INSERT ALL 로 서브쿼리의 값을 여러 테이블에 한번에 삽입 가능

 

2. UPDATE : 테이블에 기록된 컬럼의 값을 수정

 - UPDATE `테이블명` SET `컬럼명`  = 값(서브쿼리 가능)

 -(WHERE ~조건)

 

3. DELETE : 테이블의 행을 삭제

 - DELETE FROM `테이블명`

 - (WHERE ~조건)

 

 

+ Recent posts