flowerspring

Oracle

 ** 윈도우 서버 HOST명은 제어판 -> 시스템 -> 컴퓨터 이름의 전체 컴퓨터 이름이다.

 SQL*PLUS
  ** 사용자의 생성 및 변경, 권한 부여는 SYS와 SYSTEM 사용자만이 할 수 있다

  사용자
   ** 사용자가 사용할 테이블스페이스를 만든 다음 사용자 생성시 해당 테이블스페이스를 지정한다
      
   SYS/CHANGE_ON_INSTALL AS SYSDBA  /* 오라클 슈퍼 사용자 ID */
   SYSTEM/MANAGER                               /* 오라클 데이타베이스를 유지보수 관리할때 사용하는 사용자 ID */
   SCOTT/TIGER                                       /* SAMPLE 사용자 ID */
   HR/HR                                                   /* SAMPLE 사용자 ID */

   CONNECT 또는 CONNECT 사용자ID/패스워드                   /* 로그온 */

   CREATE USER 사용자명 IDENTIFIED BY 패스워드;   /* 사용자 생성과 패스워드 설정 */
   CREATE USER 사용자명 IDENTIFIED BY 패스워드   /* 사용자 생성시 테이블스페이스 지정 */
   DEFAULT TABLESPACE 테이블스페이스명 
   TEMPORARY TABLESPACE 테이블스페이스명;
   ALTER USER 사용자명 DEFAULT TABLESPACE 테이블스페이스명; /* 사용자 디폴트 테이블스페이스 변경 */
   ALTER USER 사용자명 IDENTIFIED BY 패스워드;   /* 사용자 패스워드 변경 */   
   ALTER USER 사용자명 PASSWORD EXPIRRE;    /* 사용자 패스워드 무효 */
   ALTER USER 사용자명 ACCOUNT LOCK;    /* 사용자 접속 금지 */
   ALTER USER 사용자명 ACCOUNT UNLOCK;    /* 사용자 접속 허용 */
   DROP USER 사용자명      /* 사용자 삭제 */
   DROP USER 사용자명 INCLUDING CONTENTS;    /* 사용자와 관련된 모든 정보 삭제 */

  권한  
   ** 사용자를 만든후 해당 사용자에게 권한을 부여 해야 한다
   ** 오브젝트 권한 ALL(ALTER, DELETE, INDEX, INSERT, REFERENCE, SELECT, UPDATE)을 사용하여
      테이블에 한번에 모든 권한을 부여할 수 있거나 원하는 권한만 부여할 수 있다
      뷰는 DELETE, INSERT, SELECT, UPDATE, 시퀀스는 ALTER, SELECT, 프로시저는 EXECUTE 권한을 줄 수 있다
   ** 120여개나 되는 권한을 일일이 부여하는 단점을 해결하기 위해 ROLE을 사용한다
    GRANT 권한1, 권한2, ... TO 사용자명                    /* 사용자에 권한 부여 */

   GRANT CREATE SESSION TO 사용자명;               /* 데이타베이스에 접속할 수 있는 권한 */
   GRANT CREATE TABLE TO 사용자명;                   /* 테이블을 만들수 있는 권한 */
   GRANT SELECT ON 테이블명 TO 사용자명;           /* 테이블의 SELECT 권한 */
   GRANT ALL ON 테이블명 TO 사용자명;                 /* 테이블에서 처리할 수 있는 모든 권한 */
   GRANT EXECUTE 프로시저명 TO 사용자명;           /* 프로시저를 실행할 수 있는 권한 */
   GRANT SELECT ON A사용자명.테이블명 to B사용자명 /* A사용자 테이블의 SELECT 권한을 B사용자에게 부여 */
   REVOKE 권한1, 권한2, ... FROM 사용자명;             /* 사용자의 권한 취소 */
   REVOKE CREATE SESSION FROM 사용자명;         /* 데이타베이스에 접속할 수 있는 권한 취소 */
   REVOKE CREATE VIEW FROM 사용자명;               /* 뷰를 만들수 있는 권한 취소 */
   
   롤(ROLE)
    CONNECT             /* 데이타베이스에 접속할 수 있는 권한을 가진 롤 */
    RESOURCE            /* 테이블, 인덱스, 뷰등을 생성, 변경, 삭제할 수 있는 권한을 가진 롤 */
    DBA                      /* 데이타베이스를 관리하기 위해 필요한 권한을 가진 롤 */
    RXP_FULL_DATABASE  /* EXPORT 툴을 사용할 수 있는 권한을 가진 롤 */
    IMP_FULL_DATABASE  /* IMPORT 툴을 사용할 수 있는 권한을 가진 롤 */
    SYSDBA               /* 데이타베이스 시작과 종료및 모든 관리를 하기 위한 필요한 권한을 가진 롤 */
    SYSOPER             /* SYSDBA 권한을 포함 데이타베이스를 생성할 수 있는 권한을 가진 롤 */

    GRANT 롤1, 롤2, ... TO 사용자명;                 /* 사용자에게 롤 권한 부여 */
    REVOKE 롤1, 롤2, ... FROM 사용자명;           /* 사용자의 롤 권한 취소 */

  자료 사전(DATA DICTIONARY)
   ** 특정 테이블에 관련된 자료사전이 어떤 것인지 알고 싶을때는 DICTIONARY 테이블의
      COMMENTS 칼럼에 특정 테이블과 관련된 문자열을 찾아보면 된다

   DBA_xxxx        /* DB 전체의 관련된 정보로 SYS, SYSTEM 사용자만 볼 수 있다 */
   ALL_xxxx        /* 자신이나 다른 사용자가 생성한 오브젝트중에 자신이 볼 수 있는 정보 */
   USER_xxxx      /* 자신이 생성한 오브젝트 정보 */
   V$_xxxx          /* DB의 성능 분석, 통계 정보를 제공하면 X$의 뷰 */
   X$_xxxx          /* DB의 성능 분석, 통계 정보 */

   SELECT * FROM DICTIONATY;         /* 모든 상태 정보 */
   SELECT * FROM ALL_USERS;          /* 사용자 ID 리스트 */
   SELECT * FROM USER_USERS;       /* 사용자 정보 */
   SELECT * FROM USER_CONSTRAINTS;    /* 제약 정보 */
   SELECT * FROM USER_TABLESPACES    /* 테이블스페이스 정보 */
   SELECT * FROM USER_TABLES;     /* 테이블 정보 */

   SELECT * FROM DBA_ROLES;                              /* 전체 롤, SYS, SYSTEM에서 사용 */
   SELECT * FROM USER_ROLE_PRIVS;                   /* 현재 사용자에게 부여된 롤 확인 */
   SELECT * FROM ROLE_SYS_PRIVS WHERE ROLE=롤명;    /* 해당 롤이 어떤 권한을 가지고 있는지 확인 */
   SELECT * FROM USER_TAB_PRIVS_RECD;          /* 오브젝트에서 부여 받은 권한 */
   
 TableSpace(테이블스페이스)
  - SYSTEM 테이블스페이스
  ** 사용자2010-05-12 생성시 별도의 테이블스페이스를 지정하지 않으면 시스템으로 지정된다
  시스템이 사용자 데이타 포함을 허용하더라도 사용하지 말아야 한다

   데이타베이스와 함께 생성되고 모든 데이타베이스에서 필요하다
   데이타 딕셔너리 정보를 포함한다
   시스템 실행 취소 세그먼트를 포함한다
  - UNDO 테이블스페이스
   SQL문을 실행한 후 트랜잭션을 ROLLBACK 하기 위해 변경 이전의 데이타를 저장한다
  - TEMP 테이블스페이스
   SQL문을 실행할 때 내부 분류작업(GROUP BY, ORDER BY, ...)을 위해 사용한다
   USERS 테이블스페이스
   사용자가 테스트할 수 있는 저장공간이다
   
  - CREATE TABLESPACE 테이블스페이스명        /* 자동 확장 테이블스페이스를 만들기 */
   DATAFILE 디렉토리와파일명 SIZE 크기
   AUTOEXTEND ON NEXT 크기 MAXSIZE 크기;   /* 자동으로 NEXT 만큼 확장 MAXSIZE는 지정하지 않아도 된다 */
  ALTER TABLESPACE RENAME 테이블스페이스명 TO 새테이블스페이스명;  /* 테이블스페이스명 변경 */
  ALTER TABLESPACE 테이블스페이스명 RENAME           /* 물리적인 데이타 파일 변경 */
   DATAFILE 'c:\oracle\oradata\jerry01.dbf' TO 'c:\oracle\oradata\aaa\jerry01.dbf';
  ALTER USER 사용자명 TEMPORARY TABLESPACE 템프테이블스페이스명;   
  /* 사용자의 기본 템프데이블스페이스 변경 */ 
  DROP TABLESPACE 테이블스페이스명 INCLUDING CONTENTS;
  ** 테이블스페이스를 삭제하더라도 관련 데이타 파일은 삭제되지 않기 때문에
      탐색기에서 직접 삭제해야 한다

  테이블 스페이스 및 사용자 생성
   ** 테이블 스페이스는 저장 영역 및 임시 테이블 스페이스 두개가 필요하지만
      임시 테이블 스페이스는 기본으로 정해져 있는 TEMP TABLESPACE 영역을 사용해도 된다

   1. CREATE TABLESPACE ts_name
       DATAFILE '/home/oracle/data/ts_name.dbf' SIZE 100M
      AUTOEXTEND ON NEXT 10M
   2. CREATE TEMPORARY TABLESPACE ts_name_temp TEMPFILE '/home/oracle/data/ts_name_temp.dbf' SIZE 10M
    EXTENT MANAGEMENT LOCAL UNIFORM SIZE 512K              
   3. CREATE USER 사용자명 IDENTIFIED BY 패스워드
       DEFAULT TABLESPACE ts_name         
       TEMPORARY TABLESPACE ts_name_temp  
   4. GRANT CONNECT, RESOURCE TO 사용자명

 Table(테이블)
  ** 제약 조건에는 PRIMARY KEY, FOREIGN KEY, CHECK, UNIQUE, NOT NULL이 있다

  CREATE TABLE 테이블명 (칼럼 데이타형 제약, ...);          /* 테이블 만들기 */
  CREATE TABLE 테이블명 (칼럼1 데이타형, ...                  /* 기본 키 설정 */
                         CONSTRAINT 이름 RPIMARY KEY (칼럼1));
  ALTER TABLE 테이블명 DROP PRIMARY KEY;                 /* 기본 키 삭제 */
  ALTER TABLE 테이블명 DROP CONSTRAINT 제약명;        /* 제약 조건 삭제 */
  ALTER TABLE 테이블명 MODIFY (칼럼 데이타형, ...);        /* 칼럼의 타입 변경 */
  ALTER TABLE 테이블명 ADD (칼럼 데이타형, ...);              /* 칼럼 추가 */
  ALTER TABLE 테이블명 DROP COLUMN 칼럼;                  /* 칼럼 삭제 */
  ALTER TABLE 테이블명 RENAME COLUMN 칼럼명 TO 새칼럼명   /* 칼럼명 변경 */
  ALTER TABLE 테이블명 MOVE TABLESPACE 테이블스페이스명;  /* 테이블의 테이블스페이스 변경 */
  DROP TABLE 테이블명;                                                 /* 테이블 삭제 */
  RENAME 테이블명 TO 새테이블명;                                  /* 테이블명 변경 */
  TRUNCATE TABLE 테이블명;                                         /* 테이블내의경 데이타 삭제 */

  SELECT * FROM 테이블명;                   /* 현재 사용자인 경우 사용자명은 생략 */
  SELECT * FROM 사용자명.테이블명;      /* 다른 사용자인 경우 해당 사용자명을 지정 */
  SELECT * FROM DBA_CONSTRAINTS   /* 테이블별 CONSTRAINT(제약, PRIMARY KEY, FOREIGN KEY..) */
   WHERE OWNER=사용자명 AND TABLE_NAME=테이블명;
  SELECT USER FROM DUAL;                 /* 현재 사용자명 확인 */
  SELECT SYSDATE FROM DUAL;           /* 오늘 날짜 확인 */
  SELECT TO_CHAR(SYSDATE, 'YYYY/MM/DD') FROM DUAL;     
   ** 오라클에서는 테이블없이 SELECT문의 결과를 보고자 할때 DUAL을 사용한다
  DESC 테이블명;                                   /* 테이블 구조 */

 Sequence(시퀀스)
  ** MSSQL, MySql의 자동 증가와 같은 역할을 한다
     SEQUENCE가 한번 증가되면 데이타가 삭제 되어도 다시 사용할 수 없다
  
  CREATE SEQUENCE 시퀀스명 INCREMENT BY n     /* 증가값 */
                           START WITH n                             /* 시작값 */
      MAXVALUE n | NOMAXVALUE                           /* 최대값/최대값 지정하지 않음 */
      MINVALUE n | NOMINVALUE                             /* 최소값/최소값 지정하지 않음 */
      CYCLE | NOCYCLE                                          /* CYCLE은 최대값까지 증가가 완료되면 다시 START로 돌아간다
                                                                                 NOCYCLE은 증가가 완료되면 에러를 발생시킨다 */
      CACHE n | NOCACHE                                       /* 시퀀스를 메모리에서 관리하며 기본값은 20 */
  CREATE TABLE Temp (id number, name varchar(20));
  CREATE SEQUENCE sqe (INCREMENT BY 1, START WITH 1, NOCYCLE, NOCACHE);
  INSERT INTO Temp (id, name) VALUES (seq.NEXTVAL, '홍길동');
  
 Synonym(시노늄)
  ** 이름이 긴 다른 사용자의 객체를(사용자명.테이블명) 요약 해서 사용한다
     PUBLIC 키워드는 데이타베이스내 모든 사용자들이 시노늄을 사용할 수 있게 한다

  CREATE PUBLIC SYNONYM 시노늄명 FOR 사용자명.테이블명;  
  CREATE PUBLIC SYNONYM Emp FOR hr.employee;
  SELECT * FROM Emp;

 View(뷰)
  ** REPLACE 명령을 사용하면 만들거나 수정할때마다 다시 컴파일을 한다

  CREATE OR REPLACE VIEW 뷰명 AS SELECT 칼럼1, 칼럼2, ... FROM 테이블명 WHERE 조건;
  DROP VIEW 뷰명;

 Procedure(프로시저)
  ** IN     실행 환경에서 프로시저로 값 전달
     OUT    프로시저에서 실행 환경으로 값을 리턴
     IN OUT 실행 환경에서 프로시저로 값 전달, 프로시저에서 실행 환경으로 변경된 값 리턴
  ** REPLACE 명령을 사용하면 만들거나 수정할때마다 다시 컴파일을 한다
    
  CREATE OR REPLACE PROCEDURE 프로시저명    /* 프로시저 생성 */
      (파라미터1 데이타타입, 파라미터2 OUT 데이타타입, 파라미터3 IN OUT 데이타타입)
  IS
      변수 선언;
  BEGIN
      프로그램;
  END;
  DROP PROCEDURE 프로시저명;                /* 프로시저 삭제 */



MSSQL 
 ** SQL문은 대소문자를 구분하지 않지만 데이타는 대문자와 소문자를 구분한다
    주석을 다는 방법은 /* 주석 */ 이거나 한줄만 주석 처리를 할 경우는 문장 맨앞에 --를 붙인다
 ** 각각의 데이타베이스의 SYSOBJECTS 테이블에 해당 데이타베이스의 모든 정보가 보관되어 있다
    SYSOBJECTS의 TYPE 칼럼으로 'U'=사용자 테이블, 'P'=저장 프로시저, 'K'=프라이머리 키, 'F'=포린 키,
    'V'=뷰, 'C'=체크 제약등 오브젝트 이름과 정보를 알 수 있다

 데이타 검색
  USE 데이타베이스명     /* USE 문을 사용한 데이타베이스 선택 */
  SELECT * FROM 데이블명     /* 모든 칼럼 불러오기 */
  SELECT TOP n * FROM 테이블명    /* 상위 n개의 데이타만 가져오기 */
  SELECT 칼럼1, 칼럼2, 칼럼3 FROM 테이블명  /* 특정 칼럼 가져오기 */
  SELECT 칼럼1 별명1, 칼럼2 AS 별명2 FROM 테이블명 /* 칼럼에 별명 붙이기 */
  SELECT 칼럼3 '별  명3' FROM 테이블명                    /* 칼럼 별명에 스페이스가 들어갈 경우는 작은따옴표 사용 */
  SELECT DISTINCT 칼럼 FROM 테이블명                      /* 중복되지 않는 데이타만 가져오기 */
   ** 데이타는 오름차순으로 재배열된다
      DISTINCT를 사용하면 재배열이 될때까지 데이타가 리턴되지 않으므로 수행 속도에 영향을 미친다 */
  SELECT * FROM 테이블명 WHERE 조건절                     /* 조건에 해당하는 데이타 가져오기 */
   ** 조건식에 사용하는 비교는 칼럼=값, 칼럼!=값, 칼럼>값, 칼럼>=값, 칼럼<값, 칼럼<=값이 있다
      문자열은 ''(작은따옴표)를 사용한다
      날짜 비교를 할때는 'yy-mm-dd' 형식의 문자열로 한다(날짜='1992-02-02', 날짜>'1992-02-02')
  SELECT * FROM 테이블명 WHERE 칼럼 BETWEEN x AND y       /* 칼럼이 x>=와 y<=사이의 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼 IN (a, b...)          /* 칼럼이 a이거나 b인 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼 LIKE '패턴'           /* 칼럼이 패턴과 같은 데이타 가져오기 */
   ** 패턴에 사용되는 기호는 %, _가 있다
      'k%'(k로 시작되는), '%k%'(중간에 k가 있는), '%k'(k로 끝나는)
      'p_'(p로 시작하는 2자리), 'p___'(p로 시작하는 4자리), '__p'(3자리 데이타중 p로 끝나는)
  SELECT * FROM 테이블명 WHERE 칼럼 IS NULL               /* 칼럼이 NULL인 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼 NOT BETWEEN x AND y   /* 칼럼이 x와 y 사이가 아닌 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼 NOT IN (a, b...)      /* 칼럼이 a나 b가 아닌 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼 NOT LIKE '패턴'       /* 칼럼이 패턴과 같지 않은 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼 IS NOT NULL           /* 칼럼이 NULL이 아닌 데이타 가져오기 */
  SELECT * FROM 테이블명 WHERE 칼럼>=x AND 칼럼<=y       
  SELECT * FROM 테이블명 WHERE 칼럼=a or 칼럼=b
  SELECT * FROM 데이블명 WHERE 칼럼1>=x AND (칼럼2=a OR 칼럼2=b)
   ** 복수 조건을 연결하는 연산자는 AND와 OR가 있다
      AND와 OR의 우선순위는 AND가 OR보다 높은데 우선 순위를 바꾸고 싶다면 ()을 사용한다
  SELECT * FROM 테이블명 ORDER BY 칼럼                    /* 칼럼을 오름차순으로 재배열하기 */
  SELECT * FROM 테이블명 ORDER BY 칼럼 ASC               
  SELECT * FROM 테이블명 ORDER BY 칼럼 DESC               /* 칼럼을 내림차순으로 재배열하기 */
  SELECT * FROM 테이블명 ORDER BY 칼럼1 ASC, 칼럼2 DESC   /* 복수 칼럼 재배열하기 */
  SELECT * FROM 테이블명 ORDER BY 1 ASC, DESC 3           /* 칼럼 순서로 재배열하기 */
          ** 기본적으로 SELECT 문에서는 출력순서가 보증되지 않기 때문에
      데이타의 등록 상태나 서버의 부하 상태에 따라 출력되는 순서가 달라질 수 있다
      따라서 출력하는 경우 되도록이면 ORDER BY를 지정한다
   ** 칼럼 번호는 전체 칼럼에서의 번호가 아니라 SELECT문에서 선택한 칼럼의 번호이고 1부터 시작한다

 연산자
  ** 1순위는 수치 앞에 기술되는 + - 같은 단항 연산자
     2순위는 사칙 연산의 산술 연산자인  * / + -
     3순위는 = > 비교 연산자
     4순위는 AND OR 같은 논리 연산자
     ()을 붙이면 우선 순위를 바꿀수 있다

  1. SELECT 문의 연산
     SELECT 칼럼1, 칼럼2, 칼럼3+칼럼4 AS '별명' FROM 테이블명
  2. ORDER BY 구의 연산
     SELECT 칼럼1, 칼럼2, 칼럼3+칼럼4 AS '별명' FROM 테이블명 ORDER BY 칼럼3+칼럼4 DESC
     SELECT 칼럼1, 칼럼2, 칼럼3+칼럼4 AS '별명' FROM 테이블명 ORDER BY 3 DESC
  3. WHERE 구의 연산
     SELECT 칼럼1, 칼럼2, 칼럼3+칼럼4 AS '별명' FROM 테이블명 WHERE 칼럼2>=(칼럼3+칼럼4)
  4. NULL 연산
     SELECT 칼럼1, 칼럼2, ISNULL(칼럼3, 0) + ISNULL(칼럼4, 0) AS '별명' FROM 테이블명
   ** 수치형 데이타와 NULL값과의 연산 결과는 항상 NULL이다
      만약 NULL 값을 원치 않으면 ISNULL(칼럼, 기준값) 함수를 사용해서 기준값을 변환시킨다
  5. 날짜 연산  
     SELECT GETDATE()                                    /* 서버의 현재 날짜를 구한다 */
     SELECT 날짜칼럼, 날짜칼럼-7 FROM 테이블명
     SELECT 날짜칼럼, 날짜칼럼+30 FROM 테이블명
     SELECT 날짜칼럼, DATEDIFF(day, 날짜칼럼, GETDATE()) FROM 테이블명
   ** 날짜의 가산과 감산은 + -로 할 수 있다
      날짜와 날짜 사이의 계산은 DATEDIFF(돌려주는값, 시작날짜, 끝날짜) 함수를 사용한다
  6. 문자 연산
     SELECT 칼럼1 + 칼럼2 FROM 테이블명
     SELECT 칼럼 + '문자열'  FROM 테이블명
     SELECT 칼럼1 + '문자열' + 칼럼2 FROM 테이블명
   ** 기본 연결은 문자와 문자이고 문자와 숫자의 연결은 CONVERT 함수를 사용해야 한다

 함수
  1. 수치 함수
     ROUND(수치값, 반올림위치)            /* 반올림 및 자르기 */
     ABS(수치 데이타)                     /* 절대값 */   
     SIGN(수치 데이타)                    /* 부호 */
     SQRT(수치값)                         /* 제곱근 */
     POWER(수치값, n)                     /* n승 */
  2. 문자열 함수
     SUBSTRING(문자열, 위치, 문자수)      /* 특정 위치 문자열 추출 */
     LEFT(문자열, 문자수)                 /* 왼쪽부터 지정한 갯수 문자열 추출 */
     RIGHT(문자열, 문자수)                /* 오른쪽부터 지정한 갯수 문자열 추출 */
     LEN(문자열)                          /* 문자열의 문자수 */
     LTRIM(문자열)                        /* 문자열 왼쪽의 스페이스를 삭제 */
     RTRIM(문자열)                        /* 문자열 오른쪽의 스페이스를 삭제 */
     UPPER(문자열)                        /* 대문자로 변환 */
     LOWER(문자열)                        /* 소문자로 변환 */
   ** 위치나 문자수는 한글일 경우 2바이트가 한글자로 취급된다
      SELECT LEN('월abcd화수목')은 8을 돌려준다
  3. 날짜 함수
     GETDATE()                                /* 현재 날짜와 시각 */
     DATEADD(돌려주는값, 기간, 날짜)          /* 날짜 및 시간의 더하기와 빼기 */
     DATEDIFF(돌려주는값, 시작날짜, 끝날짜)   /* 두 날짜와 시간의 차이 */
     DATEPART(돌려주는값, 날짜)               /* 날짜와 시간의 특정값을 돌려준다 */
   ** 돌려주는값(약어)
      Year-yy, Quarter-qq, Month-mm, DayofYear-dy, Day-dd, Week-wk,
      Hour-hh, Minute-mi, Second-ss, Milisecond-ms
      SELECT DATEADD(dd, 7, 날짜칼럼) 
  4. 형변환 함수
     CONVERT(데이타 타입, 칼럼)                 /* 칼럼을 원하는 데이타 타입으로 변환 */
     CONVERT(데이타 타입, 칼럼, 날짜형 스타일)  /* 원하는 날짜 스타일로 변환 */
     CAST(칼럼 AS 데이타 타입)                  /* 칼럼을 원하는 데이타 타입으로 변환 */
   ** 스타일
      1->mm/dd/yy, 2->yy.mm.dd, 3->dd/mm/yy, 4->dd.mm.yy, 5->dd-mm-yy,
      8->hh:mm:ss, 10->mm-dd-yy, 11->yy/mm/dd, 12->yymmdd
      SELECT CONVERT(varchar(10), 날짜칼럼, 2)

 그룹화
  함수
   SELECT COUNT(*) FROM 테이블명               /* 전체 데이타의 갯수 가져오기 */
   SEELECT COUNT(칼럼) FROM 테이블명           /* NULL은 제외한 칼럼의 데이타 갯수 가져오기 */
   SELECT SUM(칼럼) FROM 테이블명              /* 칼럼의 합계 구하기 */
   SELECT MAX(칼럼) FROM 테이블명              /* 칼럼의 최대값 구하기 */
   SELECT MIN(칼럼) FROM 테이블명              /* 칼럼의 최소값 구하기 */
   SELECT AVG(칼럼) FROM 테이블명              /* 칼럼의 평균값 구하기 */
  GROUP BY문
   SELECT 칼럼 FROM 테이블명 GROUP BY 칼럼  
   SELECT 칼럼1, SUM(칼럼2) FROM 테이블명 GROUP BY 칼럼1
   SELECT 칼럼1, COUNT(*) FROM 테이블명 GROUP BY 칼럼1
   SELECT 칼럼1, 칼럼2, MAX(칼럼3) FROM 테이블명 GROUP BY 칼럼1, 칼럼2
    ** GROUP BY를 지정한 경우 SELECT 다음에는 반드시 GROUP BY에서 지정한 칼럼 또는
       그룹 함수만이 올 수 있다
  조건
   SELECT 칼럼1, SUM(칼럼2) FROM 테이블명 GROUP BY 칼럼1 HAVING SUM(칼럼2) < a
   SELECT 칼럼1, SUM(칼럼2) FROM 테이블명 ORDER BY 칼럼1 COMPUTE SUM(칼럼2)
    ** HAVING:        그룹 함수를 사용할 경우의 조건을 지정한다
       HAVING의 위치: GROUP BY의 뒤 ORDER BY의 앞에 지정한다
       COMPUTE:       각 그룹의 소계를 요약해서 보여준다
                      ORDER BY가 항상 선행해서 나와야 한다
  조건절의 서브 쿼리
   ** SELECT 또는 INSERTY, UPDATE, DELETE 같은 문의 조건절에서 SELECT문을 또 사용하는 것이다
      SELECT문 안에 또 다른 SELECT문이 포함되어 있다고 중첩 SELECT문(NESTED SELECT)이라고 한다
   ** 데이타베이스에는 여러명이 엑세스하고 있기 때문에 쿼리를 여러개 나누어서 사용하면 데이타의 값이
      달라질수 있기때문에 트랜잭션 처리를 하지 않는다면 복수의 쿼리를 하나의 쿼리로 만들어 사용해야 한다
    SELECT 칼럼1, 칼럼2 FROM 테이블명 WHERE 칼럼2 = (SELECT 칼럼2 FROM 테이블명 WHERE 조건)
    SELECT 칼럼1, 칼럼2 FROM 테이블명 WHERE 칼럼1 IN (SELECT 칼럼1 FROM 테이블명 WHERE 조건)
   ** 서브 쿼리에서는 다른 테이블을 포함할 수 있다
      두개의 테이블에서 읽어오는 서브쿼리의 경우 서브 쿼리쪽에 데이타가 적은 테이블을 주 쿼리쪽에 데이타가
      많은 테이블을 지정해야 처리 속도가 빨라진다
    SELECT 칼럼1, 칼럼2 FROM 테이블명 WHERE 칼럼1 IN (SELECT 칼럼2-1 FROM 테이블명2 WHERE 조건)
   ** FROM구에서 서브 쿼리를 사용할 수 있다
      사용시 반드시 별칭을 붙여야 하고 처리 속도가 빨라진다
    SELECT 칼럼1, 칼럼2 FROM 테이블명 WHERE 조건1 AND 조건2
    SEELCT 칼럼1, 칼럼2 FROM (SELECT 칼럼1, 칼럼2 FROM 테이블명 WHERE 조건1) 별칭 WHERE 조건2

 데이타 편집
  추가
   ** NULL 값을 허용하지도 않고 디폴트 값도 지정되어 있지 않은 칼럼에 값을 지정하지 않은채
      INSERT를 수행하면 에러가 발생한다
   ** 수치값은 그대로 문자값은 ''(작은따옴표)로 마무리 한다
   ** SELECT INTO는 칼럼과 데이타는 복사하지만 칼럼에 설정된 프라이머리, 포린 키등등의 제약 조건은
      복사되지 않기 때문에 복사가 끝난후 새로 설정해 주어야 한다

   INSERT INTO 테이블명 VALUES (값1, 값2, ...)     /* 모든 필드에 데이타를 넣을 때 */
   INSERT INTO 테이블명 (칼럼1, 칼럼2, ...) VALUES (값1, 값2, ...)   /* 특정 칼럼에만 데이타를 넣을 때 */
   INSERT INTO 테이블명 SELECT * FROM 테이블명2                      /* 이미 존재하는 테이블에 데이타 추가 */
   INSERT INTO 테이블명(칼럼1, 칼럼2, ...) SELECT 칼럼1, 칼럼2, ...) FROM 테이블명2
   SELECT * INTO 테이블명 FROM 테이블명2                             /* 새로 만든 테이블에 데이타 추가 */
   SELECT 칼럼1, 칼럼2, ... 테이블명 FROM 테이블명2
   
  갱신
   UPDATE 테이블명 SET 칼럼1=값1, 칼럼2=값2            /* 전체 데이타 갱신 */     
   UPDATE 테이블명 SET 칼럼1=값1, 칼럼2=값2 WHERE 조건               /* 조건에 해당되는 데이타 갱신 */
   
  삭제
   DELETE FROM 테이블명                                              /* 전체 데이타 삭제 */
   DELETE FROM 테이블명 WHERE 조건       /* 조건에 해당되는 데이타 삭제 */

 오브젝트
  ** 데이타베이스는 아래 오브젝트들을 각각의 유저별로 관리를 하는데 Schema(스키마)는 각 유저별 소유 리스트이다

  1. Table(테이블)
   ** CREATE일때 프라이머리 키를 설정하지 않는다면 (칼럼 int IDENTITY(1, 1) NOT NULL) 자동 칼럼을 만든다
      데이타들의 입력 순서와 중복된 데이타를 구별하기 위해서 반드시 필요하다
   ** 테이블 정보 SP_HELP 테이블명, 제약 조건은 SP_HELPCONSTRAINT 테이블명 을 사용한다

   CREATE TABLE 데이타베이스이름.소유자이름.테이블이름 (칼럼 데이타형 제약, ...) /* 테이블 만들기 */
   DROP TABLE 테이블명                                                           /* 테이블 삭제 */
   ALTER TABLE 테이블명 ADD 칼럼 데이타형 제약, ...                              /* 칼럼 추가 */
   ALTER TABLE 테이블명 DROP COLUMN 칼럼                                         /* 칼럼 삭제 */
    ** DROP COLUMN으로 다음 칼럼은 삭제를 할 수 없다
       - 복제된 칼럼
       - 인덱스로 사용하는 칼럼
       - PRIMARY KEY, FOREGIN KEY, UNIQUE, CHECK등의 제약 조건이 지정된 칼럼
       - DEFAULT 키워드로 정의된 기본값과 연결되거나 기본 개체에 바인딩된 칼럼
       - 규칙에 바인딩된 칼럼
   CREATE TABLE 테이블명 (칼럼 데이타형 DEFAULT 디폴트값, ...)                   /* 디폴트 지정 */
   CREATE TABLE 테이블명 (칼럼 데이타형 CONSTRAINT 이름 UNIQUE, ...)             /* 유니크 설정 */
    ** UNIQUE란 지정한 칼럼에 같은 값이 들어가는것을 금지하는 제약으로 기본 키와 비슷하지만
       NULL 값을 하용하는것이 다르다
   CREATE TABLE 테이블명 (칼럼 데이타형 CONSTRAINT 이름 NOT NULL, ...)           /* NOT NULL 설정 */
   CREATE TABLE 테이블명 (칼럼 데이타형 CONSTRAINT 이름 PRIMARY KEY, ...)        /* 기본 키 설정 */
    ** 기본 키는 유니크와 NOT NULL이 조합된 제약으로 색인이 자동적으로 지정되고 데이타를
       유일하게 만들어 준다
    **  기본 키는 한 테이블에 한개의 칼럼만 가능하다
   CREATE TABLE 테이블명 (칼럼 데이타형 CONSTRAINT 이름 FOREIGN KEY REFERENCES 부모테이블이름(부모칼럼), ...)       
   CREATE TABLE 테이블명 (칼럼 데이타형 CONSTRAINT 이름 CHECK(조건), ...)        /* CHECK 설정 */
    ** CHECK는 조건을 임의로 정의할 수 있는 제약으로 설정되면 조건을 충족시키는 데이타만
       등록할 수 있고 SELECT의 WHERE구와 같은 조건을 지정한다
    ** CONSTRAINT와 제약 이름을 쓰지 않으면 데이타베이스가 알아서 이름을 붙이지만
       복잡한 이름이 되기 때문에 되도록이면 사용자가 지정하도록 한다
    ** CONSTRAINT는 칼럼과 데이타형을 모두 정의한 뒤에 맨 마지막에 설정할 수 있다
     CREATE TABLE 테이블명 (칼럼1 데이타형,
             칼럼2 데이타형, ...
             CONSTRAINT 이름 PRIMARY KEY(칼럼1)
                           CONSTRAINT 이름 CHECK(칼럼2 < a) ...)       
   ALTER TABLE 테이블명 ADD CONSTRAINT 이름 제약문                                /* 제약 추가 */
   ALTER TABLE 테이블명 DROP CONSTRAINT 제약명                                    /* 제약 삭제 */
   ALTER TABLE 테이블명 NOCHECK CONSTRAINT 제약명                                 /* 제약 효력 정지 */
   ALTER TABLE 테이블명 CHECK CONSTRAINT 제약명                                   /* 제약 효력 유효 */
    ** 제약명은 테이블을 만들때 사용자가 지정한 파일 이름을 말한다

  2. View(뷰)
   ** 자주 사용하는 SELECT문이 있을때 사용한다
      테이블에 존재하는 칼럼들중 특정 칼럼을 보이고 싶지 않을때 사용한다
      테이블간의 결합등으로 인해 복잡해진 SELECT문을 간단히 다루고 싶을때 사용한다
   ** 뷰를 만들때 COMPUTE, COMPUTE BY, SELECT INTO, ORDER BY는 사용할 수 없고
      #, ##으로 시작되는 임시 테이블도 뷰의 대상으로 사용할 수 없다
   ** 뷰의 내용을 보고 싶으면 SP_HELPTEXT 뷰명 을 사용한다
      
   CREATE VIEW 뷰명 AS SELECT문                            /* 뷰 만들기 */
   CREATE VIEW 뷰명 (별칭1, 별칭2, ...) AS SELECT문    /* 칼럼의 별칭 붙이기 */
   CREATE VIEW 뷰명 AS (SELECT 칼럼1 AS 별칭1, 칼럼2 AS 별칭2, ...)
   ALTER VIEW 뷰명 AS SELECT문                                       /* 뷰 수정 */
   DROP VIEW 뷰명                                                    /* 뷰 삭제 */
   CREATE VIEW 뷰명 WITH ENCRYPTION AS SELECT문                      /* 뷰 암호 */
    ** 한번 암호화된 뷰는 소스 코드를 볼 수 없으므로 뷰를 암호화하기전에
       뷰의 내용을 스크립트 파일로 저장하여 보관한다
   INSERT INTO 뷰명 (칼럼1, 칼럼2, ...) VALUES (값1, 값2, ...)
   UPDATE 뷰명 SET 칼럼=값 WHERE 조건
    ** 원래 테이블에 있는 반드시 값을 입력해야 하는 칼럼이 포함되어 있지 않거나
       원래 칼럼을 사용하지 않고 변형된 칼럼을 사용하는 뷰는 데이타를 추가하거나
       갱신할 수 없다
    ** WHERE 조건을 지정한 뷰는 뷰를 만들었을때 WITH CHECK OPTION을 지정하지 않았다면
       조건에 맞지 않는 데이타를 추가할 수 있지만 뷰에서는 보이지 않는다
       또한 뷰를 통해서 가져온 조건을 만족하는 값도 뷰의 조건에 만족하지 않는 값으로도
       갱신할 수 있다
   CREATE VIEW 뷰명 AS SELECT문 WITH CHECK OPTION
    ** 뷰의 조건에 맞지 않는 INSERT나 UPDATE를 막을려면 WITH CHECK OPTION을 설정한다

  3. Stored Procedure(저장 프로시저)
   ** 데이타베이스내에서 SQL 명령을 컴파일할때 캐시를 이용할 수 있으므로 처리가 매우 빠르다
      반복적으로 SQL 명령을 실행할 경우 매회 명령마다 네트워크를 경유할 필요가 없다
      어플리케이션마다 새로 만들 필요없이 이미 만들어진 프로시저를 반복 사용한다
      데이타베이스 로직을 수정시 프로시저는 서버측에 있으므로 어플리케이션을 다시 컴파일할 필요가 없다
   ** 저장 프로시저의 소스 코드를 보고 싶으면 SP_HELPTEXT 프로시저명 을 사용한다

   CREATE PROC 프로시저명 AS SQL문   /* 저장 프로시저 */
   CREATE PROC 프로시저명 변수선언 AS SQL문 /* 인수를 가지는 저장 프로시저 */
   CREATE PROC 프로시저명 WITH ENCRYPTION AS SQL문 /* 저장 프로시저 보안 설정 */
   CREATE PROC 프로시저명                          /* RETURN 값을 가지는 저장 프로시저 */
       인수1 데이타형, ... 인수2 데이타형 OUTPUT
   AS
       SQL문
       RETURN 리턴값
   DROP PROCEDURE 프로시저명1, 프로시저명2, ...    /* 저장 프로시저 삭제 */
   
   명령어
    BEGIN ... END    /* 문장의 블록 지정 */
    DECLARE @변수명 데이타형  /* 변수 선언 */
    SET @변수명=값    /* 변수에 값 지정 */
    PRINT @변수명    /* 한개의 변수 출력 */
    SELECT @변수1, @변수2   /* 여러개의 변수 출력 */
    IF 조건     /* 조건 수행 */
        수행1
    ELSE
        수행2               
    WHILE 조건1    /* 반복 수행 */
        BEGIN
            IF 조건2
         BREAK    - WHILE 루프를 빠져 나간다
         CONTINUE - 수행을 처리하지 않고 조건1로 되돌아간다
     수행
        END               
    EXEC 저장프로시저   /* SQL문을 실행 */
    EXEC @(변수로 지정된 SQL문)
    GO     /* BATCH를 구분 지정 */

   에제
    1. 기본 저장 프로시저
     CREATE PROC pUpdateSalary AS UPDATE Employee SET salary=salary*2
    2. 인수를 가지는 저장 프로시저
     CREATE PROC pUpdateSalary
         @mul float=2, @mul2 int
     AS
         UPDATE Employee SET salary=salary* @Mul* @mul2
     EXEC pUpdateSalary 0.5, 2       /* 모든 변수에 값을 대입 */
     EXEC pUpdateSalary @mul2=2      /* 원하는 변수에만 값을 대입 */
    3. 리턴값을 가지는 저장 프로시저
     CREATE PROC pToday
         @Today varchar(4) OUTPUT
     AS
         SELECT @Today=CONVERT(varchar(2), DATEPART(dd, GETDATE()))
         RETURN @Today
     DECLARE @answer varchar(4)
     EXEC pToday @answer OUTPUT
     SELECT @answer AS 오늘날짜
    4. 변수 선언과 대입, 출력
     ** @는 사용자 변수이고 @@는 시스템에서 사용하는 변수이다

     DECLARE @EmpNum int
     SET @EmpNum=10
     SELECT @EmpNum

  4. Trigger(트리거)
   ** 한 테이블의 데이타가 편집(INSERT/UPDATE/DELETE)된 경우에 자동으로 다른 테이블의
      데이타를 삽입, 수정, 삭제한다
   ** 트리거 내용을 보고 싶으면 SP_HELPTRIGGER 트리거명 을 사용한다

   CREATE TRIGGER 트리거명 ON 테이블명 FOR INSERT AS SQL문         /* INSERT 작업이 수행될때 */
   CREATE TRIGGER 트리거명 ON 테이블명 AFTER UPDATE AS SQL문       /* UPDATE 작업이 수행되고 난 후 */
   CREATE TRIGGER 트리거명 ON 테이블명 INSTEAD OF DELETE AS SQL문 
   DROP TRIGGER 트리거명

  5. Cursor(커서)
   ** SELECT로 가져온 결과들을 하나씩 읽어들여 처리하고 싶을때 사용한다
   ** 커서의 사용방법은 OPEN, FETCH, CLOSE, DEALLOCATE등 4단계를 거친다
   ** FETCH에는 NEXT, PRIOR, FIRST, LAST, ABSOLUTE {n / @nvar}, RELATIVE {n / @nvar}가 있다

   SET NOCOUNT ON      /* SQL문의 영향을 받은 행수를 나타내는 메시지를 숨긴다 */
   DECLARE cStatus SCROLL CURSOR    /* 앞뒤로 움직이는 커서 선언 */
   FOR
       SELECT ID, Year, City FROM aPlane
   FOR READ ONLY
   OPEN cStatus      /* 커서를 연다 */
   DECLARE @ID varchar(50), @Year int, @City varchar(50), @Status char(1)
   FETCH FROM cStatus INTO @ID, @Year, @City /* 커서에서 데이타를 하나씩 가져온다 */
   WHILE @@FETCH_STATUS=0                    /* 커서가 가르키는 결과의 끝까지 */
   BEGIN
       IF      @Year <= 5              SET @Status='A'
       ELSE IF @Year> 6 AND @Year <= 9 SET @Status='B'
       ELSE                            SET @Status='C'
       INSERT INTO aPlane(ID, City, Status) VALUES(@ID, @Year, @Status)
       FETCH FROM cStatus INTO @ID, @Year, @City /* 커서에서 데이타를 하나씩 가져온다 */
   END
   CLOSE cStaus                              /* 커서를 닫는다 */
   DEALLOCATE cStatus                        /* 커서를 해제한다 */

 보안과 사용자 권한
  ** 보안의 설정 방법은 크게 WINDOWS 보안과 SQL 보안으로 나뉘어 진다
  ** 사용자에게 역할을 부여하는데는 서버롤과 데이타베이스롤이 있다

  1. SA(System Administrator)
   ** 가장 상위의 권한으로 SQL 서버에 관한 전체 권한을 가지고 모든 오브젝트를 만들거나
      수정, 삭제할 수 있다

  2. DBO(Database Owner)
   ** 해당 데이타베이스에 관한 모든 권한을 가지며 SA로 로그인해서 데이타베이스에서 테이블을
      만들어도 사용자는 DBO로 매핑된다
   ** 테이블이름의 구조는 서버이름.데이타베이스이름.DBO.테이블이름이다

  3. DBOO(Database Object Owner)
   ** 테이블, 인덱스, 뷰, 트리거, 함수, 스토어드 프로시저등의 오브젝트를 만드는 권한을 가지며
      SA나 DBO가 권한을 부여한다

  4. USER(일반 사용자)
   ** DBO나 DBOO가 해당 오브젝트에 대한 사용 권한을 부여한다



MySql

 ** COMMAND LINE에서의 실행을 기준으로 한다

 시작하기, 끝내기  
  MYSQL -u 사용자명 -p      /* 관리자 계정은 디폴트로 ROOT */
  MYSQL -u 사용자명 -p 데이타베이스명    /* 시작할때 데이타베이스를 선택한다 */
  MYSQL -u 사용자명 데이타베이스명    /* 암호가 지정되어 있지 않을 경우 */
  USE 데이타베이스명      /* 데이타베이스 선택 */
  SELECT VERSION(), CURRENT_DATE;                                 /* 버전과 오늘 날짜 */
  SELECT USER();                                                  /* 사용자 */
  STATUS        /* 서버 정보 */
  SHOW CHARACTER SET;      /* 캐릭터 셋 리스트 */
  SHOW COLLATION;       /* 사용할 수 있는 문자 리스트 */
  SHOW PROCESSLIST;      /* 실행 프로세스 리스트 */
  QUIT                                                            /* 끝내기 */

 패스워드 설정 및 변경
  USE MYSQL       /* MYSQL 데이타베이스를 선택 */
  UPDATE USER SET PASSSWORD=PASSWORD('패스워드') WHERE USER='사용자명';
  FLUSH PRIVILEGES;      /* 변경 패스워드를 적용 */

 데이타베이스 생성 및 선택
  SHOW DATABASES;       /* 데이타베이스 리스트 */
  SHOW CREATE DATABASE 데이타베이스명;                           
  CREATE DATABASE 데이타베이스명;     /* 새 데이타베이스 만들기 */
  ALTER DATABASE 데이타베이스명 DEFAULT CHARACTER SET 문자셋;     /* 문자셋 지정. 4.1버전 이상 */
  DROP DATABASE 데이타베이스명;     /* 데이타베이스 삭제 */
  USE 데이타베이스명;      /* 데이타베이스 선택 */
  
 사용자 생성 및 권한
  ** ROOT 관리자 계정으로 접속해서 아래 2가지 방법중에 하나를 실행하면 된다

  1. USE MYSQL      /* MYSQL 데이타베이스 선택 */
     5.0 버전 이전
   INSERT INTO USER (HOST, USER, PASSWORD) VALUES('localhost', '사용자명', PASSWORD('패스워드'));
     5.0 버전 이후
   INSERT INTO USER    /* USER 테이블에 사용자 등록 */
    (HOST, USER, PASSWORD, ...
   VALUES('localhost', '사용자명', PASSWORD('패스워드'),
           'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y',
    'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y',
    '', '', '', '', 0, 0, 0, 0);
    ** USER 테이블의 HOST, USER, PASSWORD 이외의 나머지 칼럼 갯수만큼 처리
       위의 조건은 관리자에 해당하므로 권한에 제약을 두고 싶다면 각 칼럼별 'Y', 'N'를
       구분해 주어야 한다      
     FLUSH PRIVILEGES;     /* 사용자 등록 적용 */

  2. GRANT ALL ON *.*                                     /* 모든 데이타베이스에 접근 허용 */
   TO 사용자명@LOCALHOST IDENTIFIED BY '패스워드' 
     GRANT ALL ON 데이타베이스명.*                        /* 패스워드없이 지정한 데이타베이스에 접근 허용 */
      TO 사용자명@LOCALHOST  
     GRANT ALL ON 데이타베이스명.*                        /* 지정한 데이타베이스에 접근 허용 */
    TO 사용자명@LOCALHOST IDENTIFIED BY '패스워드' 
     GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP ON 테이타베이스명.*   /* LOCALHOST의 데이타베이스에 접근 허용 */
   TO 사용자명@LOCALHOST IDENTIFIED BY '패스워드';
     GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP ON 테이타베이스명.*   /* LOCALHOST가 아닌 다른 곳에서의 접속 허용 */
   TO 사용자명@'%' IDENTIFIED BY '패스워드';      

  SELECT HOST, USER, PASSWORD FROM USER;                          /* 사용자 리스트 */
  DELETE FROM USER WHERE USER='사용자명' AND HOST= '호스트명';    /* 사용자 삭제 */
  SHOW GRANTS FOR 사용자명@localhost;                             /* 사용자의 권한 상태 */
  SHOW GRANTS FOR CURRENT_USER;                                   /* 현재 사용자의 권한 상태 */
  SHOW GRANTS FOR 사용자명@LOCALHOST;                             /* 사용자 권한 */
  SHOW PRIVILEGES;      /* 시스템 권한 */

 테이블  
  CREATE TABLE 테이블명 (칼럼 데이타형 NOT NULL AUTO_INCREMENT);  /* 자동 증가값 만들기 */
  CREATE TABLE 테이블명 (칼럼 데이타형 제약, ...                  /* 기본 키 설정 */
                         PRIMARY KEY (칼럼));  
  CREATE TABLE 테이블명 (칼럼 데이타형 제약, ...                  /* 외래 키 설정 */
           FOREIGN KEY(칼럼) REFERENCES 부모테이블명 (부모칼럼));
  ALTER TABLE 테이블명 RENAME 새테이블명;                         /* 테이블명 변경 */
  ALTER TABLE 테이블명 MODIFY 칼럼 데이타형 제약;                 /* 칼럼의 형식 변경 */
  ALTER TABLE 테이블명 CHANGE 칼럼 새칼럼 데이타형;               /* 칼럼명과 형식 변경 */
  ALTER TABLE 테이블명 ADD 칼럼 데이타형 제약;                    /* 칼럼 추가 */
  ALTER TABLE 테이블명 ADD INDEX (칼럼);    /* 인덱스 칼럼 만들기 */ 
  ALTER TABLE 테이블명 DROP COLUMN 칼럼;                          /* 칼럼 삭제 */
  LOAD DATA INFILE 'TXT파일' INTO TABLE EXPORT FIELDS TERMINATED BY ' ';  /* TXT파일을 DB에 읽어오기 */
  SELECT * FROM EXPORT INTO OUTFILE 'txt파일' FILEDS TERMINATED BY ' ';   /* DB를 TXT파일로 내보내기 */
   ** FIELDS TERMINATED BY는 '\t', ',', ';'등 원하는 구분자를 지정하면 된다
  DROP TABLE 테이블명;                                            /* 테이블 삭제 */
  SHOW TABLES;       /* 테이블 리스트 */
  SHOW TABLES FROM 데이타베이스명;
  SHOW TABLE STATUS FROM 데이타베이스명;
  SHOW OPEN TABLES FROM 데이타베이스명;    /* 현재 열린 테이블 목록 */
  SHOW CREATE TABLE 테이블명;     /* 테이블의 create table문 내용 */
  SHOW COLUMNS FROM 테이블명 FROM 데이타베이스명;   /* 테이블의 칼럼 */
  DESC 테이블명;       /* 테이블 구조 */

 인덱스
  ** 적절한 인덱스 사용은 SELECT문의 성능을 크게 향상 시킨다
     최대 16개까지 지정할 수 있다
     최대 인덱스는 256바이트까지 가능하다
     CAHR, VARCHART에 대해서 앞 문자열로 인덱스 할 수 있다
     인덱스는 테이블에서 MUL 로 표시된다.

  CREATE TABLE 테이블명 (칼럼 데이타형 제약, ...                  /* 인덱스 만들기 */
           INDEX 인덱스명(칼럼));
   ** INDEX (칼럼), KEY 인덱스명 (칼럼)으로 해도 된다
  SHOW KEYS FROM 테이블명;     /* 인덱스 리스트 */
  SHOW INDEX FROM 테이블명 FROM 데이타베이스명;   

 저장 프로시저
  ** IN    프로시저로 값 전달
     OUT   프로시저에서 값 리턴
     INOUT IN과 OUT 속성을 다 가지고 있다
  ** REPLACE 명령을 사용하면 만들거나 수정할때마다 다시 컴파일을 한다
  ** MySql 5.0 이후 부터 지원한다

  CREATE PROCEDURE 프로시저명    /* 프로시저 생성 */
   (IN 파라미터1 데이타타입, OUT 파라미터2 데이타타입, INOUT 파라미터3 데이타타입)
  BEGIN
      프로그램; 
  END;
  DROP PROCEDURE 프로시저명;    /* 프로시저 삭제 */

출처 : http://okjsp.pe.kr/seq/151426

'DEVELOPMENT' 카테고리의 다른 글

Git  (0) 2013.12.30
dxf file format  (0) 2012.08.16
XSLT 빠른 가이드  (0) 2012.01.13
Oracle, MSSQL, MySql 요약 설명서  (0) 2010.05.18
Maven 빌드 라이프 사이클(Lifecycle)  (0) 2009.11.19
ServerVariables 콜렉션  (0) 2009.03.10

Comment +0


--//SQL Database documentation script
--//Description: T-SQL script to generate the database document for SQL server 2000/2005

Declare @i Int, @maxi Int
Declare @j Int, @maxj Int
Declare @sr int
Declare @Output varchar(4000)
--Declare @tmpOutput varchar(max)
Declare @SqlVersion varchar(5)
Declare @last varchar(155), @current varchar(255), @typ varchar(255), @description varchar(4000)

create Table #Tables  (id int identity(1, 1), Object_id int, Name varchar(155), Type varchar(20), [description] varchar(4000))
create Table #Columns (id int identity(1,1), Name varchar(155), Type Varchar(155), Nullable varchar(2), [description] varchar(4000))
create Table #Fk(id int identity(1,1), Name varchar(155), col Varchar(155), refObj varchar(155), refCol varchar(155))
create Table #Constraint(id int identity(1,1), Name varchar(155), col Varchar(155), definition varchar(1000))
create Table #Indexes(id int identity(1,1), Name varchar(155), Type Varchar(25), cols varchar(1000))

 If (substring(@@VERSION, 1, 25 ) = 'Microsoft SQL Server 2005')
   set @SqlVersion = '2005'
else if (substring(@@VERSION, 1, 26 ) = 'Microsoft SQL Server  2000')
   set @SqlVersion = '2000'
else
   set @SqlVersion = '2005'


Print '<head>'
Print '<title>::' + DB_name() + '::</title>'
Print '<style>'
   
Print '      body {'
Print '      font-family:verdana;'
Print '      font-size:9pt;'
Print '      }'
     
Print '      td {'
Print '      font-family:verdana;'
Print '      font-size:9pt;'
Print '      }'
     
Print '      th {'
Print '      font-family:verdana;'
Print '      font-size:9pt;'
Print '      background:#d3d3d3;'
Print '      }'
Print '      table'
Print '      {'
Print '      background:#d3d3d3;'
Print '      }'
Print '      tr'
Print '      {'
Print '      background:#ffffff;'
Print '      }'
Print '   </style>'
Print '</head>'
Print '<body>'

set nocount on
   if @SqlVersion = '2000'
      begin
      insert into #Tables (Object_id, Name, Type, [description])
         --FOR 2000
         select object_id(table_name),  '[' + table_schema + '].[' + table_name + ']', 
         case when table_type = 'BASE TABLE'  then 'Table'   else 'View' end,
         cast(p.value as varchar(4000))
         from information_schema.tables t
         left outer join sysproperties p on p.id = object_id(t.table_name) and smallid = 0 and p.name = 'MS_Description'
         order by table_type, table_schema, table_name
      end
   else if @SqlVersion = '2005'
      begin
      insert into #Tables (Object_id, Name, Type, [description])
      --FOR 2005
      Select o.object_id,  '[' + s.name + '].[' + o.name + ']',
            case when type = 'V' then 'View' when type = 'U' then 'Table' end, 
            cast(p.value as varchar(4000))
            from sys.objects o
               left outer join sys.schemas s on s.schema_id = o.schema_id
               left outer join sys.extended_properties p on p.major_id = o.object_id and minor_id = 0 and p.name = 'MS_Description'
            where type in ('U', 'V')
            order by type, s.name, o.name
      end
Set @maxi = @@rowcount
set @i = 1

print '<table border="0" cellspacing="0" cellpadding="0" width="550px" align="center"><tr><td colspan="3" style="height:50;font-size:14pt;text-align:center;"><a name="index"></a><b>Index</b></td></tr></table>'
print '<table border="0" cellspacing="1" cellpadding="0" width="550px" align="center"><tr><th>Sr</th><th>Object</th><th>Type</th></tr>'
While(@i <= @maxi)
begin
   select @Output =  '<tr><td align="center">' + Cast((@i) as varchar) + '</td><td><a href="#' + Type + ':' + name + '">' + name + '</a></td><td>' + Type + '</td></tr>'
         from #Tables where id = @i
  
   print @Output
   set @i = @i + 1
end
print '</table><br />'

set @i = 1
While(@i <= @maxi)
begin
   --table header
   select @Output =  '<tr><th align="left"><a name="' + Type + ':' + name + '"></a><b>' + Type + ':' + name + '</b></th></tr>',  @description = [description]
         from #Tables where id = @i
  
   print '<br /><br /><br /><table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td align="right"><a href="#index">Index</a></td></tr>'
   print @Output
   print '</table><br />'
   print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Description</b></td></tr><tr><td>' + isnull(@description, '') + '</td></tr></table><br />'

   --table columns
   truncate table #Columns
   if @SqlVersion = '2000'
      begin
      insert into #Columns  (Name, Type, Nullable, [description])
      --FOR 2000
      Select c.name,
               type_name(xtype) + (
               case when (type_name(xtype) = 'varchar' or type_name(xtype) = 'nvarchar' or type_name(xtype) ='char' or type_name(xtype) ='nchar')
                  then '(' + cast(length as varchar) + ')'
                when type_name(xtype) = 'decimal' 
                     then '(' + cast(prec as varchar) + ',' + cast(scale as varchar)   + ')'
               else ''
               end           
               ),
               case when isnullable = 1 then 'Y' else 'N'  end,
               cast(p.value as varchar(8000))
            from syscolumns c
               inner join #Tables t on t.object_id = c.id
               left outer join sysproperties p on p.id = c.id and p.smallid = c.colid and p.name = 'MS_Description'
            where t.id = @i
            order by c.colorder
      end
   else if @SqlVersion = '2005'
      begin
      insert into #Columns  (Name, Type, Nullable, [description])
      --FOR 2005  
      Select c.name,
               type_name(user_type_id) + (
               case when (type_name(user_type_id) = 'varchar' or type_name(user_type_id) = 'nvarchar' or type_name(user_type_id) ='char' or type_name(user_type_id) ='nchar')
                  then '(' + cast(max_length as varchar) + ')'
                when type_name(user_type_id) = 'decimal' 
                     then '(' + cast([precision] as varchar) + ',' + cast(scale as varchar)   + ')'
               else ''
               end           
               ),
               case when is_nullable = 1 then 'Y' else 'N'  end,
               cast(p.value as varchar(4000))
      from sys.columns c
            inner join #Tables t on t.object_id = c.object_id
            left outer join sys.extended_properties p on p.major_id = c.object_id and p.minor_id  = c.column_id and p.name = 'MS_Description'
      where t.id = @i
      order by c.column_id
      end
   Set @maxj =   @@rowcount
   set @j = 1

   print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Table Columns</b></td></tr></table>'
   print '<table border="0" cellspacing="1" cellpadding="0" width="750px"><tr><th>Sr.</th><th>Name</th><th>Datatype</th><th>Nullable</th><th>Description</th></tr>'
  
   While(@j <= @maxj)
   begin
      select @Output = '<tr><td width="20px" align="center">' + Cast((@j) as varchar) + '</td><td width="150px">' + isnull(name,'')  + '</td><td width="150px">' +  upper(isnull(Type,'')) + '</td><td width="50px" align="center">' + isnull(Nullable,'N') + '</td><td>' + isnull([description],'') + '</td></tr>'
         from #Columns  where id = @j
     
      print    @Output   
      Set @j = @j + 1;
   end

   print '</table><br />'

   --reference key
   truncate table #FK
   if @SqlVersion = '2000'
      begin
      insert into #FK  (Name, col, refObj, refCol)
   --      FOR 2000
      select object_name(constid), s.name,  object_name(rkeyid) ,  s1.name 
            from sysforeignkeys f
               inner join sysobjects o on o.id = f.constid
               inner join syscolumns s on s.id = f.fkeyid and s.colorder = f.fkey
               inner join syscolumns s1 on s1.id = f.rkeyid and s1.colorder = f.rkey
               inner join #Tables t on t.object_id = f.fkeyid
            where t.id = @i
            order by 1
      end  
   else if @SqlVersion = '2005'
      begin
      insert into #FK  (Name, col, refObj, refCol)
--      FOR 2005
      select f.name, COL_NAME (fc.parent_object_id, fc.parent_column_id) , object_name(fc.referenced_object_id) , COL_NAME (fc.referenced_object_id, fc.referenced_column_id)    
      from sys.foreign_keys f
         inner  join  sys.foreign_key_columns  fc  on f.object_id = fc.constraint_object_id  
         inner join #Tables t on t.object_id = f.parent_object_id
      where t.id = @i
      order by f.name
      end
  
   Set @maxj =   @@rowcount
   set @j = 1
   if (@maxj >0)
   begin

      print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Refrence Keys</b></td></tr></table>'
      print '<table border="0" cellspacing="1" cellpadding="0" width="750px"><tr><th>Sr.</th><th>Name</th><th>Column</th><th>Reference To</th></tr>'

      While(@j <= @maxj)
      begin

         select @Output = '<tr><td width="20px" align="center">' + Cast((@j) as varchar) + '</td><td width="150px">' + isnull(name,'')  + '</td><td width="150px">' +  isnull(col,'') + '</td><td>[' + isnull(refObj,'N') + '].[' +  isnull(refCol,'N') + ']</td></tr>'
            from #FK  where id = @j

         print @Output
         Set @j = @j + 1;
      end

      print '</table><br />'
   end

   --Default Constraints
   truncate table #Constraint
   if @SqlVersion = '2000'
      begin
      insert into #Constraint  (Name, col, definition)
      select object_name(c.constid), col_name(c.id, c.colid), s.text
            from sysconstraints c
               inner join #Tables t on t.object_id = c.id
               left outer join syscomments s on s.id = c.constid
            where t.id = @i
            and
            convert(varchar,+ (c.status & 1)/1)
            + convert(varchar,(c.status & 2)/2)
            + convert(varchar,(c.status & 4)/4)
            + convert(varchar,(c.status & 8)/8)
            + convert(varchar,(c.status & 16)/16)
            + convert(varchar,(c.status & 32)/32)
            + convert(varchar,(c.status & 64)/64)
            + convert(varchar,(c.status & 128)/128) = '10101000'
      end
   else if @SqlVersion = '2005'
      begin
      insert into #Constraint  (Name, col, definition)
      select c.name,  col_name(parent_object_id, parent_column_id), c.definition
      from sys.default_constraints c
         inner join #Tables t on t.object_id = c.parent_object_id
      where t.id = @i
      order by c.name
      end
   Set @maxj =   @@rowcount
   set @j = 1
   if (@maxj >0)
   begin

      print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Default Constraints</b></td></tr></table>'
      print '<table border="0" cellspacing="1" cellpadding="0" width="750px"><tr><th>Sr.</th><th>Name</th><th>Column</th><th>Value</th></tr>'

      While(@j <= @maxj)
      begin

         select @Output = '<tr><td width="20px" align="center">' + Cast((@j) as varchar) + '</td><td width="250px">' + isnull(name,'')  + '</td><td width="150px">' +  isnull(col,'') + '</td><td>' +  isnull(definition,'') + '</td></tr>'
            from #Constraint  where id = @j

         print @Output
         Set @j = @j + 1;
      end

   print '</table><br />'
   end


   --Check  Constraints
   truncate table #Constraint
   if @SqlVersion = '2000'
      begin
      insert into #Constraint  (Name, col, definition)
         select object_name(c.constid), col_name(c.id, c.colid), s.text
            from sysconstraints c
               inner join #Tables t on t.object_id = c.id
               left outer join syscomments s on s.id = c.constid
            where t.id = @i
            and ( convert(varchar,+ (c.status & 1)/1)
               + convert(varchar,(c.status & 2)/2)
               + convert(varchar,(c.status & 4)/4)
               + convert(varchar,(c.status & 8)/8)
               + convert(varchar,(c.status & 16)/16)
               + convert(varchar,(c.status & 32)/32)
               + convert(varchar,(c.status & 64)/64)
               + convert(varchar,(c.status & 128)/128) = '00101000'
            or convert(varchar,+ (c.status & 1)/1)
               + convert(varchar,(c.status & 2)/2)
               + convert(varchar,(c.status & 4)/4)
               + convert(varchar,(c.status & 8)/8)
               + convert(varchar,(c.status & 16)/16)
               + convert(varchar,(c.status & 32)/32)
               + convert(varchar,(c.status & 64)/64)
               + convert(varchar,(c.status & 128)/128) = '00100100')

      end
   else if @SqlVersion = '2005'
      begin
      insert into #Constraint  (Name, col, definition)
         select c.name,  col_name(parent_object_id, parent_column_id), definition
         from sys.check_constraints c
            inner join #Tables t on t.object_id = c.parent_object_id
         where t.id = @i
         order by c.name
      end
   Set @maxj =   @@rowcount
  
   set @j = 1
   if (@maxj >0)
   begin

      print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Check  Constraints</b></td></tr></table>'
      print '<table border="0" cellspacing="1" cellpadding="0" width="750px"><tr><th>Sr.</th><th>Name</th><th>Column</th><th>Definition</th></tr>'

      While(@j <= @maxj)
      begin

         select @Output = '<tr><td width="20px" align="center">' + Cast((@j) as varchar) + '</td><td width="250px">' + isnull(name,'')  + '</td><td width="150px">' +  isnull(col,'') + '</td><td>' +  isnull(definition,'') + '</td></tr>'
            from #Constraint  where id = @j
         print @Output
         Set @j = @j + 1;
      end

      print '</table><br />'
   end


   --Triggers
   truncate table #Constraint
   if @SqlVersion = '2000'
      begin
      insert into #Constraint  (Name)
         select tr.name
         FROM sysobjects tr
            inner join #Tables t on t.object_id = tr.parent_obj
         where t.id = @i and tr.type = 'TR'
         order by tr.name
      end
   else if @SqlVersion = '2005'
      begin
      insert into #Constraint  (Name)
         SELECT tr.name
         FROM sys.triggers tr
            inner join #Tables t on t.object_id = tr.parent_id
         where t.id = @i
         order by tr.name
      end
   Set @maxj =   @@rowcount
  
   set @j = 1
   if (@maxj >0)
   begin

      print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Triggers</b></td></tr></table>'
      print '<table border="0" cellspacing="1" cellpadding="0" width="750px"><tr><th>Sr.</th><th>Name</th><th>Description</th></tr>'

      While(@j <= @maxj)
      begin
         select @Output = '<tr><td width="20px" align="center">' + Cast((@j) as varchar) + '</td><td width="150px">' + isnull(name,'')  + '</td><td></td></tr>'
            from #Constraint  where id = @j
         print @Output
         Set @j = @j + 1;
      end

      print '</table><br />'
   end

   --Indexes
   truncate table #Indexes
   if @SqlVersion = '2000'
      begin
      insert into #Indexes  (Name, type, cols)
         select i.name, case when i.indid = 0 then 'Heap' when i.indid = 1 then 'Clustered' else 'Nonclustered' end , c.name
         from sysindexes i
            inner join sysindexkeys k  on k.indid = i.indid  and k.id = i.id
            inner join syscolumns c on c.id = k.id and c.colorder = k.colid
            inner join #Tables t on t.object_id = i.id
         where t.id = @i and i.name not like '_WA%'
         order by i.name, i.keycnt
      end
   else if @SqlVersion = '2005'
      begin
      insert into #Indexes  (Name, type, cols)
         select i.name, case when i.type = 0 then 'Heap' when i.type = 1 then 'Clustered' else 'Nonclustered' end,  col_name(i.object_id, c.column_id)
            from sys.indexes i
               inner join sys.index_columns c on i.index_id = c.index_id and c.object_id = i.object_id
               inner join #Tables t on t.object_id = i.object_id
            where t.id = @i
            order by i.name, c.column_id
      end

   Set @maxj =   @@rowcount
  
   set @j = 1
   set @sr = 1
   if (@maxj >0)
   begin

      print '<table border="0" cellspacing="0" cellpadding="0" width="750px"><tr><td><b>Indexes</b></td></tr></table>'
      print '<table border="0" cellspacing="1" cellpadding="0" width="750px"><tr><th>Sr.</th><th>Name</th><th>Type</th><th>Columns</th></tr>'
      set @Output = ''
      set @last = ''
      set @current = ''
      While(@j <= @maxj)
      begin
         select @current = isnull(name,'') from #Indexes  where id = @j
               
         if @last <> @current  and @last <> ''
            begin  
            print '<tr><td width="20px" align="center">' + Cast((@sr) as varchar) + '</td><td width="150px">' + @last + '</td><td width="150px">' + @typ + '</td><td>' + @Output  + '</td></tr>'
            set @Output  = ''
            set @sr = @sr + 1
            end
        
           
         select @Output = @Output + cols + '<br />' , @typ = type
               from #Indexes  where id = @j
        
         set @last = @current   
         Set @j = @j + 1;
      end
      if @Output <> ''
            begin  
            print '<tr><td width="20px" align="center">' + Cast((@sr) as varchar) + '</td><td width="150px">' + @last + '</td><td width="150px">' + @typ + '</td><td>' + @Output  + '</td></tr>'
            end

      print '</table><br />'
   end

    Set @i = @i + 1;
   --Print @Output
end


Print '</body>'
Print '</html>'

drop table #Tables
drop table #Columns
drop table #FK
drop table #Constraint
drop table #Indexes
set nocount off

Comment +0

3주 동안 고인물로 지내다가 다시 새로운 물을 가득 넣기로 마음 굳게 먹었다.
요즘 별다르게 배운게 없고 공부한게 없었는데 이게 다 모 사이트 운영때문이다.. 결국은 핑계다 ㅡ,.-^

운영업무를 하다보면 고객의 요청에 의해서 각종 데이터들을 산출해야 한다.
회원정보라던지 매출액등 월말, 분기별로 아주 바쁘게 데이터를 뽑아서 엑셀로 이쁘게 포장해서
고객에게 주면 참 좋아 하신다..^^;

그런데 이런 데이터들을 산출하다 보면 SELECT 된 값들을 다른 테이블에 그 데이터만을 담아서 사용하고 싶은 경우가 있다. 그 중에 또 다른 값을 가져오거나  그 값들로 인해서 또 다른 테이블과 조인을 한다던가 해야 하는 일 말이다.  이런 테이블을 만들지 않으면 쿼리도 늘어나고 속도도 느려지니 헷갈리고 속도도 느려진다.

그래서 이 때  사용할수 있는게 SELECT INTO 이다.
SELECT INTO는 현재 있는 테이블에 있는 내용 전체나 일부를 가져와서 새로운 테이블로 만들 때 사용한다.
기존에 있던 테이블에는 INSERT 시킬수가 없다. 기존 테이블에 INSERT를 시킬려면 SELECT INSERT를 사용하면 된다.

사용법
SELECT * FROM tableName
SELECT * INTO  temp_tableName(새로만들 테이블) FROM tableName

위에 사용법으로 테이블을 만들게 되면 영구적으로 테이블이 생기게 된다.
물론 DROP 명령으로 지워주면 되긴 하지만 잠시만 쓰고 지울 것이라면 굳이 영구 테이블을 만들지 않고 임시테이블을 만들어 사용하면 된다.

임시 테이블은 전역임시 테이블, 세션 임시 테이블 두개로 나뉜다.

만드는방법 사용할 수 있는 범위 삭제되는 시기
일반 테이블 CREATE TABLE 다른 세션에서도 DROP TABLE
세션 임시 테이블
#tablename
해당 세션에서만
세션이 끊어질 때
전역 임시 테이블
##tablename
다른 세션에서도
세션이 끊어질 때
tempdb의 일반 테이블
CREATE TABLE
다른 세션에서도
SQL 서버가 시작 될 때

사용법
SELECT * INTO #tablename FROM table
SELECT * INTO ##tablename FROM table
SELECT * FROM #tablename
SELECT * FROM ##tablename

이렇게 생성 된 테이블은 해당 데이터베이스에 생성되는 것이 아니라 tempdb에 만들어 지며 logout 할 때 자동으로 삭제가 된다.

실무에서는 많이 사용하는지는 모르지만 개인적으로는 정말 많이 사용한다.

참고::
오라클에서는 사용법이 다르다.

CREATE TABLE tableName_temp
AS SELECT * FROM tableName


'DEVELOPMENT > Database' 카테고리의 다른 글

oracle 시작과 종료  (0) 2009.05.07
Toad 단축키  (0) 2009.04.18
[oracle] decode 함수  (1) 2009.01.16
[ORACLE] 테이블 관련 정보 쿼리  (0) 2008.07.26
[MS-SQL] SELECT INTO  (0) 2008.05.20
[oracle] 오라클 중복제거 하면서 전체 값 가져오기  (0) 2008.03.27

Comment +0