원본 출처 : http://home.bcline.com/hoya1/
 
1.1 Pro*C란-
 
ORACLE RDBMS에 준비된 Pro*C툴은, SQL문을 포함한 C 프로그램을, ORACLE 데이터베이스내에 있는 데이터에 접근과, 조작을 할 수 있는 C 프로그램으로 변환하기 위한 것이다. Pro*C는 프리컴파일러이기 때문에, 입력 파일 내에 있는 EXEC SQL 문을 적당한 ORACLE 콜로 변환해서 출력 파일을 작성한다. 그 다음 이 출력 파일을 C 프로그램에 대한 통상의 방법으로 컴파일하고 링크해서 실행모듈을 작성한다.
 
 
1.2 개요
 
Pro*C 툴을 사용하면 프로그램머는 통상의 프로그래밍 과정에 덧붙여서 별도의 처리를 수행 할 필요가 생긴다. 그러나 별도의 처리를 추가함으로써, 프로그램머에 도움이 되는 상당량의 작업을 Pro*C 툴이 수행하게 된다.
 C 프로그램을 작성해서 기동할 때의 통상의 작업 순서는 다음과 같다.
       1. C 프로그램을 작성한다.
       2. 프로그램을 컴파일해서 오브젝트 파일을 작성한다.
       3. 오브젝트 파일을 링크해서 실행 가능한 파일을 작성한다.
       4. 프로그램을 실행한다.

  프로그래머가 소스프로그램에 Pro*C 문을 짜넣는 경우는, 위에서 기술한 순서에
   한가지 처리가 더 추가된다.
       1. Pro*C 프로그램을 작성한다.
       2. Pro*C를 이용해서 프로그램을 프리컴파일 한다.
       3. 프로그램를 컴파일해서 오브젝트 파일을 작성한다.
       4. 오브젝트 파일을 링크해서 실행 가능한 파일을 작성한다.
       5. 프로그램을 실행한다.
 
1.2.1 C 커맨드 및 SQL 문의 혼합
올바른 SQL 문이면 C 프로그램에서 실행할 수 있다. Pro*C 프로그램에서는 필수의 구성요소나 문장이 몇 개정도 있는 것 외에 기본적인 "지정순서"가 있지만, C 프로그램내의 어디에 배치해도 좋다
 
1.2.2 커맨드의 접두사 EXEC SQL
SQL 문을 호스트 언어에 포함시킴으로써, 발생할 수 있는 언어상의 장애를 최소화하기 위해서, 모든 SQL 문에는 EXEC SQL 이라고 하는 접두사를 붙인다.
 
1.2.3 커맨드의 접두사 EXEC ORACLE
대부분의 Pro*C 문에는 EXEC SQL 이라는 접두사를 붙이지만 EXEC ORACLE 이라는 접두사를 붙인문도 있다. 이들의 문은 SQL과는 호환성이 없고, ORACLE 프리컴파일러 특유의 것이다.
 
1.2.4 SQL 실행문 및 선언문
Pro*C 프로그램에 포함되어 있는 SQL 문은, 실행문 혹은 선언문중의 하나로 분류할 수 있다. 실행문 혹은 선언문에 관계없이 문에는 모두 EXEC SQL 이라는 접두사가 붙는다.
 
- 실행문
 
실제로 데이터베이스에 대한 콜을 행성하는 SQL 문이다. 데이터조작문(DML), 데이터정의문(DDL), 데이터제어문(DCL) 등이 있다. SQL 실행문을 실행한 후, SQLCA(SQL 통신영역)에는 일련의 리턴코드가 저장된다.
논리적인 작업단위는, 최초의 SQL 실행문을 실행함으로써 시작된다. 그러므로 CONNECT, COMMIT, ROLLBACK WORK 문의 다음에 첫 번째로 나타나는 SQL 실행문부터 논리적인 작업단위가 새롭게 시작된다.
 
- 선언문
 
코드를 생성하지 않기 때문에 논리적인 작업단위에 영향은 없다.
 
1.2.5 Pro*C 프로그램의 구성
Pro*C 프로그램은 2개의 부분으로 구성되어 있고, Pro*C의 처리에는 양자가 모두 필요하다.
 
- 어플리케이션 프롤로그
 
변수를 정의하고, Pro*C 프로그램을 위한 일반적인 준비를 수행한다.
 
- 어플리케이션 본체
 
ORACLE 데이터를 조작하기 위한 INSERT나 UPDATE 등의 SQL 문을 포함한다. Pro*C가 처리시 필요로 하는 코드의 전후에 어떠한 C 코드를 지정해도 상관없다.
 
2.1 어플리케이션 프롤로그
 
** 선언절
** INCLUDE SQLCA 문
- ** CONNECT 문
 
2.1.1 선언절 ( 2.0 버젼 이후 없어도 상관 없음 )
C 프로그램내에서 사용된 모든 호스트 변수를 선언한다. 선언절은 아래의 문으로 시작한다.
 
EXEC SQL BEGIN DECLARE SECTION;
아래의 문으로 종료한다.
EXEC SQL END DECLARE SECTION;
위 두 개의 문 사이에 허용되는 문은 호스트 변수 또는 표지 변수를 선언하는 문 뿐이다.
 
**호스트 변수
SQL 문 및 프로그램 문의 양쪽으로부터 참조되는 모든 값에 대해서 선언해야 한다. 호스트 변수의 데이터타입은 선언절에서 호스트 언어를 사용해서 선언해야 하며, 이 때 이 데이터타입은 테이블을 정의할 때에 사용되는 ORACLE 데이터타입과 일치할 필요는 없다.
 
EXEC SQL BEGIN DECLARE SECTION;
int pempno; /* 사번 */
char pname[11]; /* 성명 */
int pdeptno; /* 부서 */
EXEC SQL END DECLARE SECTION;
 
EXEC SQL SELECT deptno, ename
INTO :pdeptno, :pname
FROM emp
WHERE empno = :pempno;
 
호스트 변수의 조건
~선언절에서 명시적으로 선언한다.
~선언한 대로 영어 대문자/소문자의 포맷을 사용한다.
~SQL 문에서는 앞에 콜론(:)을 붙인다.
~C 문에서는 앞에 콜론을 붙이지 않는다.
~SQL의 예약어를 사용해서는 안된다.
~상수를 사용할 수 있는 곳에서만 사용한다.
~표지 변수가 붙어 있어도 상관없다.
 
**표지 변수
선언절에서 선언된 호스트 변수에 1대 1로 대응되는 임의 선택 변수이다. 표지 변수는 주로 널 값을 취급하는데 유효하다
표지 변수의 조건
~선언한 대로 영어 대문자/소문자의 포맷을 사용한다.
~2바이트 정수로써 선언해야 한다.
~SQL 문에서는 앞에 콜론(:)을 붙인다.
~C 문에서는 앞에 콜론을 붙이지 않는다.
~SQL의 예약어를 사용해서는 안된다.
~SQL 문 내에서는 대응하는 입력 호스트 변수를 앞에 붙여 사용한다.
 
호스트 변수로서의 포인터 선언
포인터 변수는 C에서 통상적으로 행하는 방법으로 선언함으로써, 선언절내에서 사용할 수 있다.
EXEC SQL BEGIN DECLARE SECTION;
int I, j, *intptr;
char *cp;
EXEC SQL END DECLARE SECTION;
 
SQL 문에서 사용하는 경우는 별표가 아닌 콜론(:)을 변수명 앞에 붙인다.
SELECT intfield INTO :intptr FROM…;
 
VARCHAR 의사타입의 선언
Proc*C에서는 VARCHAR 의사타입을 사용할 수 있으므로, 가변 길이의 문자열을 처리할 수 있다. VARCHAR 의사타입은 선언절에서 참조할 뿐이고, 확장된 C 타입 또는 사전에 선언된 구조라고 생각할 수 있다.
EXEC SQL BEGIN DECLARE SECTION;
VARCHAR jobDesc[40];
EXEC SQL END DECLARE SECTION;
 
이 선언은 다음의 구조체로 확장할 수 있다.
struct {
    unsigned short int len;
    unsigned char arr[40];
} jobDesc;
 
2.1.2 SQL 통신영역의 선언
 
어플리케이션 프로롤로그내에서 SQL 통신영역(SQLCA)에 대한 참조를 포함시킴으로써 각 Pro*C 프로그램에서 발생하는 상황처리를 가능하게 하는데, 유저는 다음의 문을 지정하면 된다.
 
EXEC SQL INCLUDE SQLCA;
 
Pro*C는 프리컴파일시에 SQLCA 파일의 위치를 알아야 한다. 때문에 유저는 다음의 3가지중 하나를 선택해야 한다.
- ~~"INCLUDE = " 커맨드 라인 옵션을 사용한다.
- ~~Pro*C가 파일을 SYS$ORACLE:SQLCA(VMS의 경우)처럼 공동의 OS영역에서 발견할 수 있도록 파일의 정식 명칭을 지정한다.
- ~~PCC를 호출할 디렉토리 또는 디스크에 SQLCA를 카피한다.
 
SQLCA는 다음과 같은 정보를 포함하고 있다.
- 경고 플래그와 처리상황에 관한 정보
- 에러 코드
- 진단 정보
디폴드 값으로서, Pro*C는 가능한한 에러를 무시하고 처리를 속행시킨다. SQLCA내에 포함된 변수를 사용함으로써, 프로그래머는 각각의 환경에서 실행해야 할 처리를 제어할 수 있다.
 
2.1.3 ORACA(SQLCA에 대한 확장)
 
ORACA를 사용하기 위해서는 EXEC SQL INCLUDE을 사용해서 ORACA의 정의를 참조하거나 커맨드라인 옵션 또는 EXEC ORACLE OPTION에서 ORACA = YES 옵션을 선택하여야 한다.
 
2.1.4 ORACA 내의 정보
 - 현재의 SQL 문의 텍스트(orastxt)
  ORACLE RDBMS가 해석한 문의 내용을 조사할 수 있다. (CONNECT, FETCH, COMMIT등 은 제외)
 - ~에러가 있는 파일의 이름(orasfnm)
 - ~에러가 있는 행의 번호(oraslnr)
 - ~SQL 문 보존 플래그(orastxtf)
        이 플래그를 설정함으로써 어느 조건으로 문을 보존할 지를 선택할 수 있다.
          0. 디폴트값. SQL 문을 보존하지 않는다.
          1. SQLERROR가 있는 SQL 문 만을 보존한다.
          2. SQLERROR 및 SQLWARN이 있는 문을 보존한다.
          3. SQL 문을 전부 보존한다.

    ~DEBUG 처리의 사용 허가 플래그
         이 플래그는 0이나 1을 설정할 수 있다.
         1을 설정한 경우는 모든 DEBUG 처리를 사용할 수 있다.
     - 커서 캐쉬 검사(orahchf)
2.1.5 ORACLE에의 접속
 
EXEC SQL CONNECT :oracleid IDENTIFIED BY :oraclepassword;
 
- CONNECT 문은 Pro*C 프로그램 내에서 실행된 최초의 SQL 실행문이어야 한다. 선언문과 C 코드만을 논리적으로 CONNECT 문 앞에 놓을 수 있다. 패스워드를 따로 지정하는 경우는 ORACLE의 유정명과 ORACLE의 패스워드의 양쪽에 대해 호스트 변수를 사용해야 한다.
- 양쪽의 호스트 변수를 고정길이 문자열 또는 가변길이 문자열 중의 하나로 선언해야 한다.
- CONNECT 문을 수행하기 전에 양쪽의 호스트 변수를 초기화켜 놓아야 한다.
- CONNECT는 프로그램의 최초의 실행문이지만 논리적인 작업단위의 시작은 아니다.
 
 
2.2 어플리케이션 본체
 
어플리케이션 본체에는 ORACLE 데이터베이스 내에 보존된 데이터를 쿼리하고 조작하기 위한 SQL 문이 들어 있다. 이러한 문은 데이터 조작문이라고 한다. 또한 어플리케이션 본체에는 데이터 정의문이 포함되며 이것은 테이블, 뷰, 인덱스등의 데이터 구조를 작성하거나 정의하기 위해 사용한다.
- ~DECLARE STATEMENT 문
- ~DECLARE DATABASE 문
- ~EXEC ORACLE 옵션
 
 
2.3 Pro*C 예제 프로그램
/* 예제 #1 */
ORACLE의 로그온과 로그오프

#include
/***************************************************************
This is sample Pro*C program which will log onto a database as
scott/tiger.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;

    printf("Connected to ORACLE user : %sn", uid.arr);
    EXEC SQL COMMIT WORK RELEASE;            /* log off database */
    exit(0);
}

/* 예제 #2 */
    테이블의 작성

#include

/***************************************************************
This is is a sample Pro*C program which will create a table.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %sn", uid.arr);
    EXEC SQL CREATE TABLE Emp_TEST
        (empno     number
        ,ename     char(15)
        ,job        char(10)
        ,mgr       number
        ,hiredate    date
        ,sal         number
        ,deptno     number);
    printf("Table emp_test created. n");
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
}

/* 예제 #3 */
      행을 삽입하기 위한 값의 입력지시

#include
/***************************************************************
This is is a sample Pro*C program which will insert records
into the EMP table by prompting the user for values to be entered.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int empno;
    VARCHAR ename[15];
    VARCHAR job[10];
    float sal;
    int deptno;
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    int sret;                                   /* return code from scanf */

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;

    printf("Connected to ORACLE user : %snnn", uid.arr);
    while(1)
    {
        printf("Enter employee number(or 0 to end) : ");
        sret = scanf("%d", &empno);
        if( sret == EOF !! sret == 0 !! empno == 0 )
            break;                                      /* terminate loop */
        printf("Enter employee name : ");
        scanf("%s", ename.arr);
        ename.len = strlen(ename.arr);                /* set the name size */
        printf("Enter employee's job : ");
        scanf("%s", job.arr);
        job.len = strlen(job.arr);                     /* set the job size */
        printf("Enter employee salary : ");
        scanf("%f", &sal);
        printf("Enter employee deptno : ");
        scanf("%d", &deptno);

        EXEC SQL INSERT INTO EMP
                  (empno
                  ,ename
                  ,job
                  ,sal
                  ,deptno)
        VALUES (:empno
                  ,:ename
                  ,:job
                  ,:sal
                  ,:deptno);
        EXEC SQl COMMIT WORK;
        printf("Employee %s added. nn", ename.arr);
    }
    EXEC SQL COMMIT WORK RELEASE;            /* log off database */
    exit(0);
}

/* 예제 #4 */
    배열을 이용한 삽입

#include
/***************************************************************
This is is a sample Pro*C program which uses the FOR option
by inserting records into the EMP table.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int empno[100];
    VARCHAR ename[100][15];
    VARCHAR job[100][10];
    VARCHAR hiredate[100][9];
    float sal[100];
    int deptno[100];
    int loop;
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

FILE *fp;

void main(void)
{
    int i;
    int fsret;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                        /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                        /* copy the password */
    pwd.len = strlen(pwd.arr);
    EXEC SQL WHENEVER SQLERROR GOTO errrpt;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %snnn", uid.arr);
    if((fp = fopen("test.dat", "r")) == NULL)
    {
        printf("Error opening file test.dat n");
        exit(1);
    }
    while(1)
    {
        for(i = 0; i < 100 ; i++)
        {
            fsret = fscanf(fp, "%d %s %s %s %f %d",
                        &empno[i ], ename[i ].arr, job[i ].arr, hiredate[i ].arr,
                        &sal[i ], &deptno[i ]);
            if(fsret == EOF)
                break;
            if(fsret == 0)
            {
                printf("Incompatible field on the line. n");
                exit(1);
            }
            ename[i ].len = strlen(ename[i ].arr);
            job[i ].len = strlen(job[i ].arr);
            hiredate[i ].len = strlen(hiredate[i ].arr);
        }
        loop = i;
        EXEC SQL FOR :loop
            INSERT INTO EMP(empno, ename, job, hiredate, sal, deptno)
            VALUES(:empno, :ename, :job, :hiredate, :sal, :deptno);
        EXEC SQL COMMIT WORK;
        printf("%d rows inserted. n", sqlca.sqlerrd[2]);
        if(loop < 100)
            break;
    }
    printf("File test.dat loaded. n");
    EXEC SQL WHENEVER SQLERROR CONTINUE;
    EXEC SQL COMMIT work RELEASE;
    exit(0);

    errrpt:
        printf("n %70s n", sqlca.sqlerrm.sqlerrmc);
        EXEC SQL ROLLBACK WORK RELEASE;
        exit(1);
}

   /* 예제 #5 */
         갱신에 사용하기 위한 값의 입력지시

#include

/***************************************************************
This is is a sample Pro*C program which will prompt the user
for an employee name and will display thr current sal and comm
fields for that employee.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int empno[10];
    float sal, comm;
    short sali, commi;
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    int sret;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR STOP;
    EXEC SQL WHENEVER NOT FOUND STOP;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;

    printf("Connected to ORACLE user : %sn", uid.arr);
    printf("Enter employee name to update : ");
    scanf("%s", ename.arr);
    ename.len = strlen(ename.arr);

    EXEC SQL SELECT SAL, COMM
                  INTO  :sal, :comm
                  FROM EMP
                 WHERE ENAME = :ename;

    printf("Employee : %s   sal : %6.2f   comm : %6.2f n", ename.arr, sal,
            comm);
    printf("Enter new salary : ");
    sret = scanf("%f", &sal);
    sali = 0;
    if(sret == EOF !! sret == 0) sali = 0;
    printf("Enter new commision : ");
    sret = scanf("%f", &comm);
    commi = 0;
    if(sret == EOF !! sret == 0) commi = -1;

    EXEC SQL UPDATE EMP
                SET     SAL = :sal:sali,
                         COMM = :comm:commi
                WHERE ENAME = :ename;

    printf("Employee %s updateed. n", ename.arr);
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
}

   /* 예제 #6 */
       배열을 이용한 갱신

#include

/***************************************************************
This is is a sample Pro*C program which updates using host
variable arrays. The arrays will be loaded with values
from operator input.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int empno[100];
    float sal[100];
    int loop;
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    int i, sret;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR GOTO errrpt;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;

    printf("Connected to ORACLE user : %sn", uid.arr);

    while(1)
    {
        for(i = 0; i < 100; i++)
        {
            printf("Enter employee number (or 0 to end loop) : ");
            sret = scanf("%d", &empno[i ]);
            if(sret == EOF !! sret == 0 !! empno[i ] == 0) break;
            printf("Enter updated salary : ");
            sret = scanf("%f", &sal[i ]);
            if(sret == EOF !! sret == 0)
            {
                printf("Error in entry; terminating at this empno. n");
                break;
            }
        }
        if(i == 0) break;
        loop = i;
        EXEC SQL FOR :loop
            UPDATE EMP SET SAL = :sal
            WHERE EMPNO = :empno;
        EXEC SQL COMMIT WORK;
        printf("%d rows updated. n", sqlca.sqlerrd[2]);
    }
    printf("Update program complete. n");
    EXEC SQL WHENEVER SQLERROR CONTINUE;
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);

errrpt:
    printf("n %70s n", sqlca.sqlerrm.sqlerrmc);
    EXEC SQL ROLLBACK WORK RELEASE;
    exit(1);
}

/* 예제 #7 */
    배열을 이용한 선택

#include

/***************************************************************
This is is a sample Pro*C program which selects using host
variable arrays.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int empno[100];
    VARCHAR ename[100][15];
    float sal[100];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    long num_ret;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR GOTO errrpt;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;

    printf("Connected to ORACLE user : %sn", uid.arr);

     EXEC SQL DECLARE C1 CURSOR FOR
        SELECT  EMPNO, ENAME, SAL
          FROM   EMP;
    EXEC SQL OPEN C1;
    EXEC SQL WHENEVER NOT FOUND GOTO endloop;
    num_ret = 0;
    while(1)
    {
        EXEC SQL FETCH C1 INTO : empno, :ename, :sal;
        print_rows(sqlca.sqlerrd[2] - num_ret);
        num_ret = sqlca.sqlerrd[2];
    }
endloop:
    if(sqlca.sqlerrd[2] - num_ret > 0)
        print_rows(sqlca.sqlerrd[2] - num_ret);
    printf("nnProgram complete. n");
    EXEC SQL WHENEVER SQLERROR CONTINUE;
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
errrpt:
    printf("n %70s n", sqlca.sqlerrrm.sqlerrmc);
    EXEC SQL ROLLBACK WORK RELEASE;
    exit(1);
}

int print_rows(long n)
{
    long i;
    printf("nnEmployee numbertEmployee NametSalaryn");
    printf("nn---------------t-------------t------n");
    for(i = 1; i < n; i++)
        printf("%15dt%13st%6.2fn", empno[i ], ename[i ].arr, sal - i);
    return 0;
}
   

/* 예제 #8 */
기존의 테이블로부터 행의 삭제

#include

/***************************************************************
This is is a sample Pro*C program which will delete a row
from the emp table by prompting for an employee number.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int empno;
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR STOP;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %sn", uid.arr);
    scanf("%d", &empno);

    EXEC SQL DELETE FROM EMP WHERE EMPNO = :empno;
    EXEC SQL COMMIT WORK RELEASE;
    printf("Employee number %d dropped. n", empno);
    exit(0);
}
 
3.1 쿼리의 구성
 
Pro*C를 사용해서 작성하는 쿼리에는 다음에 나타낸 구를 지정한 어떠한 SELECT 문도 사용할 수 있다.
 
SELECT
INTO
FROM
WHERE
CONNECT
UNION
INTERSECT
MINUS
GROUP BY
HAVING
ORDER BY
 
3.1.1 입력 호스트 변수
WHERE 구 내의 호스트 변수는 입력 호스트 변수라고 부른다.
 
3.1.2 출력 호스트 변수
INTO 구 내의 호스트 변수는 출력 호스트 변수라고 부른다.
 
3.2 1개의 행 만을 리턴하는 쿼리
 
쿼리가 오직 1개의 행 만을 리턴하는 것을 알고 있는 경우는, SELECT 리스트 내의 항목과 같은 수의 출력 호스트 변수를 지정한 INTO 구를 사용한다.
 
3.3 복수의 행을 리턴하는 쿼리(커서의 사용법)
 
쿼리가 복수의 행을 리턴하는 경우, 혹은 몇 개의 행이 리턴됐는지 모를 경우는, SELECT 문과 함께 커서를 사용해야 한다.
커서는 ORACLE 및 Pro*C가 사용하는 작업 영역이고, 이 속에 쿼리의 결과가 포함된다. 커서는 1개의 SELECT문에 대응하고, 쿼리가 변화할 때마다 반복해서 실행된다. 커서는 선언되어야 하며, 데이터의 처리를 위해서 커서를 사용할 때는 아래의 4개의 커서 커맨드를 사용한다.
- DECLARE CURSOR
- OPEN CURSOR
- FETCH
- CLOSE CURSOR
커서를 "OPEN" 한 후 그 커서를 사용해서, 그것에 대응한 쿼리의 결과로서 얻어진 여러 행을 검색 할 수 있다. 쿼리 기준을 만족한 행은 모두 집합의 형식을 취하고, 이것을 커서의 실효집합이라고 부른다. 쿼리가 종료하면 커서를 "CLOSE" 한다.
 
3.3.1 DECLARE CURSOR 문
DECLARE CURSOR 문에서는 커서를 정의한다.
 
EXEC SQL DECLARE cursor_name CURSOR FOR
SELECT … FROM …
 
이 구문은 실제로 다음과 같이 사용한다.
 
EXEC SQL DECLARE C1 CURSOR FOR
SELECT ename, empno, job, sal
FROM emp
WHERE deptno = :deptno;
 
커서를 참조한는 SQL 문을 사용하기 전에 반드시 이커서에 대응하는 DECLARE CURSOR 문을 실행해야 하며, Pro*C는 선언되지 않은 커서에 대한 참조를 해석할 수 없다.
프로그램 내에는 복수의 커서를 사용할 수 있으며 동일 프로그램 내에서 같은 이름의 커서를 지정해서는 안된다.
 
 
3.3.2 OPEN CURSOR
커서를 OPEN 함으로써 쿼리가 판정되고, 행의 실효집합이 식별된다.
EXEC SQL OPEN cursor_name;
 
커서는 OPEN 상태에서 실효집합 최초의 행 직전에 위치된다. 그러나, 실제로 이 시점에서는 아직 어느 행의 검색도 행하지 않는다.
커서를 일단 OPEN 하면 다시 OPEN 하지 않는한, 이 커서의 입력 호스트 변수는 새로이 체크되지 않는다.
 
3.3.3 실효집합의 행의 검색(FETCH 문)
FETCH 문에서는 실효집합의 행을 읽어 들이고, 결과를 얻을 출력 호스트 변수의 이름을 지정한다.
EXEC SQL FETCH cursor_name INTO :hostvar1, :hostvat2 …;
 
이 구문은 실제로 다음과 같이 사용된다.
EXEC SQL FETCH C1 INTO :pename, :pempno, :pjob, :psal;
 
처음으로 커서를 실행하면, 커서는 실효집합의 이전 위치에서 실효집합의 첫째 행으로 이동하며 이 행이 현재의 행이 된다. 커서는 실효집합의 다음행으로만 진행하며 앞에 검색한 행으로 되돌아 가기 위해서는 커서를 CLOSE 하고 다시 오픈해야 한다.
 
3.3.4 CLOSE CURSOR 문
실효집합 행의 검색을 종료한 후 커서를 CLOSE 함으로써, 커서의 OPEN 상태를 유지하기 위해서 사용된 자원을 해제한다.
EXEC SQL CLOSE cursor_name;
 
CLOSE 한 커서에 대해서는 검색을 행할 수 없다.
 
3.4 예제 프로그램
 
/* 예제 #9 */
   WHERE 구에 의한 쿼리

#include

/***************************************************************
This is is a sample Pro*C program which will display all the
salesman in the employee table.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    float sal, comm;
    char ename[11];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR STOP;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %sn", uid.arr);

    EXEC SQL DECLARE C1 CURSOR FOR
        SELECT ENAME, SAL, COMM
          FROM EMP
        WHERE JOB = 'SALESMAN';
    EXEC OPEN C1;

    EXEC SQL WHENEVER NOT FOUND STOP;
    printf("SALESMAN NAMEttSALARYttCOMMISSIONnn");
    for( ; ; )
    {
        EXEC SQL FETCH C1 INTO :ename, :sal, :comm;
        printf("%-10stt%6.2ftt%6.2f n", ename, sal, comm);
    }
    EXEC SQL CLOSE C1;
    EXEC SQL WHENEVER SQLERROR CONTINUE;   /* don't trap errors */
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
}
 
 
 
------------------------------------------------------------------------------------
ORACLE의 기능에 의하여, 유저의 작업 모두가 실행하면 바로 COMMIT되는 것이 아니다. 다시말해서 ORACLE에서는 COMMIT 을 행하기 전에 모든 트랜잭션이 완료되어 있는지를 유저 자신이 확인하도록 되어 있다.
ORACLE은 BEFORE 이미지 파일을 사용하여, 데이터베이스의 일관성을 보호하고 있다. BEFORE 이미지 파일에는 트랜잭션이 시작하기 전의 상태로 데이터베이스의 블록이 보존된다. 상황에 따라 이들의 블록이 데이터베이스 파일에 다시 기록되어, 트랜잭션에 의해 변경된 부분이 변경 전의 상태로 되돌려 진다. 이 같은 처리는 다음과 같은 경우 발생한다.
 - 유저에 의한 ROLLBACK WORK
 - 유저 프로세스 내의 ORACLE로부터의 이상 종료
 - 프로세스간의 데드록
 - 시스템 장애(H/W OR S/W)
4.1 COMMIT WORK
 
COMMIT WORK 문은 현재 진행 중인 논리적인 작업단위를 종료하게 하고, 이 작업단위 내에서 행해진 변경을 모두 확정한다.
EXEC SQL COMMIT WORK [RELEASE];
 
RELEASE 옵션 파라미터는 프로그램이 소유하고 있는 자원을 모두 리턴하고, 데이터베이스에서 로그로프한다.
 
4.2 ROLLBACK WORK
 
ROLLBACK WORK 문은 현재 진행 중인 논리적인 작업단위를 종료하게 하고, 이 작업단위에서 행한 변경을 취소한다.
EXEC SQL ROLLBACK WORK [RELEASE];
 
유저는 RELEASE 옵션을 사용해서 최후의 작업단위를 반드시 명시적으로 COMMIT 또는 ROLLBACK해야 한다.
 
5.1 표지 변수에 리턴된 값의 사용
 
어느 호스트 변수에도 임의 선택 변수인 표지 변수를 대응시킬 수 있다. 이 표지 변수를 사용하면 각각의 필드 값이 어떤 경우인지 알 수 있다.
값      의미
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 0    리턴되는 값은 호스트 변수에 보존된다. 이것은 널도 아니고,
      절사도 되지 않는다.
-1   리턴된 값은 널이다. 호스트 변수의 값은 정의되지 않는다.
20   리턴된 값은 절사되어 있다. 호스트 변수의 폭이 충분하지 않다.
      표지 변수에 설정된 값은 절사되기 전의 폭이다
5.2 SQLCA의 구조
 
SQLCA 는 프로그램의 실행에 관한 정보를 교환하기 위해, 모든 Pro*C 프로그램에서 사용한다. SQLCA는 각각의 트랜잭션에 대해서 널 값의 무시여부, 쿼리를 시작하고 나서 데이터의 변경 여부등을 표시하므로, 프로그래머는 각각의 데이터 상태를 확인할 수 있다.
 
5.2.1 SQLCA를 참조하는 타이밍
SQLCA는 각 SQL 실행문의 실행 때마다 갱신된다. 따라서 프로그래머는 각 실행문 뒤에서 SQLCA를 검색해야 한다. 특히 각 DML 문 뒤에서는 SQLCA를 검색할 필요가 있다. 이는 테이블 속의 일부의 행만을 처리한 뒤에 INSERT 및 UPDATE 문이 실패한다면, 유저는 데이터베이스을 어떤 일관성 있는 상태로 회복하기 위해 ROLLBACK WORK 커맨드를 실행해야 하기 때문이다.
WHENEVER 문을 사용하면 이상 상태를 검출하고 그 상태에 따라 적절히 동작을 지정할 수 있다. 다음은 WHENEVER 문의 디폴트 값이다.
EXEC SQL WHENEVER anyerror CONTINUE;
 
5.2.2 SQLCA의 각 요소의 의미
struct sqlca {
      char sqlcaid[8];
      long sqlcabc;
      long sqlcode;
      struct {
             unsigned short sqlerrml;
             char   sqlerrmc[70];
       } sqlerrm;
      char sqlerrp[8];
      long sqlerrd[6];
      char sqlwarn[8];
      char sqlext[8];
};

struct sqlca sqlca;

 - *sqlca.sqlcode   4바이트 2진 정수이고, SQL 문의 실행결과를 나타낸다.
                        0  실행이 정상 종료
                        1403  NOT FOUND
                         음수  프로그램 또는 시스템 장애
     *sqlca.sqlerrm.sqlerrml sqlca.sqlerrm.sqlerrmc의 텍스트의 길이
 - *sqlca.sqlerrm.sqlerrmc 가변 길이의 문자열이고, sqlca.sqlcode 내에
                                              표시된 에러번호에 대응하는 에러메세지
 - *sqlca.sqlerrd   4바이트 2진 정수 배열 ORACLE RDBMS의 내부상황을
                               파악하기 위해 사용. sqlca.sqlerrd[2]는 INSERT나 UPDATE
                               처럼 DML 처리에 대해서 몇 개의 행이 처리 됐는지를 나타냄
 - *sqlca.sqlwarn   프리컴파일 중에 발생한 여러가지 상황에 대한 경고
 -       sqlca.sqlwarn[0]  "W"가 설정된 경우 1개 이상의 경고가 설정되어 있음
5.3 WHENEVER 문
  에러를 검출할 때 어떤 처리를 취해야 할 지를 결정한다.
   EXEC SQL WHENEVER [SQLERROR | SQLWARNING | NOT FOUND]
                         [STOP | CONTINUE | GOTO stmt-label];

 - SQLERROR      sqlca.sqlcode가 -1인 경우에 설정
 - SQLWARNING  sqlca.sqlwarn[0]에 "W"가 설정되어 있는 경우에 설정
 - NOT FOUND    sqlca.sqlcode가 1403인 경우에 설정
 - STOP             프로그램을 종료시키고 논리적인 작업단위는 ROLLBACK 된다.
 - CONTINUE      sqlca의 상태를 무시하고 프로그램을 계속 진행한다.
 - GOTO             지정한 라벨이 붙은 문으로 제어를 옮긴다.
 
6. 동적 정의문
 
6.1 동적 정의문의 정의
 
동적 정의문이란, 컴파일시에 정의되지 않는 SQL 문이다. 다시 말해서, 동적 정의문은 각각의 실행 때마다 변경이 가능하고, 실제로 많은 경우에 변경된다.
 
6.2 동적 정의문의 종류
방법 1 : EXECUTE IMMEDIATE 문의 사용
  모든 SQL 문(SELECT 문 제외)을 프리컴파일해서 이것을 실행한다.
  SQL 문은 상수 또는 호스트 변수 중 어느 것이라도 상관없다.
  SQL 문에는 호스트 변수를 포함하지 않는다.

방법 2 : PREPARE 문 및 EXECUTE 문의 사용
  모든 SQL 문(SELECT 문 제외)을 받아들여 이것을 수행한다.
  SQL 문 중에 호스트 변수를 포함할 수 있다.
 
방법 3 : PREPARE 문 및 FETCH 문의 사용
  선택을 행할 수 있다. SQL 문 중에 호스트 변수를 포함할 수 있다.
  이 방법은 PREPARE, DECLARE, OPEN, FETCH의 순서로 행한다.

방법 4 : 바인드 및 정의 기술자의 사용
  1행의 SELECT 및 여러 행의 SELECT를 포함하는 모든 SQL 문을
  사용할 수 있다.
6.3 EXECUTE IMMEDIATE 의 사용
/* 예제 #10 */
#include
/***************************************************************
This is is a sample Pro*C program which will prompt for a
WHERE clause to be used in an update statement. This is to be
used with EXECUTE IMMEDIATE.
***************************************************************/

EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    char select[132];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    char where[80];
    int scode;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR STOP;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %sn", uid.arr);

    strcpy(select, "UPDATE EMP SET COMM = 100 WHERE");
    printf("Please enter where clause for the following : n");
    printf("%s", select);
    scode = scanf("%s", where);
    if(scode == EOF !! scode == 0)
    {
        printf("Invalid entry. n");
        exit(1);
    }
    strcat(select, where);

    EXEC SQL EXECUTE IMMEDIATE :select;

    printf("%d records updated. n", sqlca.sqlerrd[2]);
    EXEC SQL WHENEVER SQLERROR CONTINUE;
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
}
6.4 PREPARE 및 EXECUTE 의 사용
/* 예제 #11 */
#include
/***************************************************************
This is is a sample Pro*C program which will prompt for a
WHERE clause to be used in an update statement. This is to be
used with PREPARE and EXECUTE.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    float comm;
    char select[132];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    char where[80];
    int scode;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR GOTO errrpt;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %sn", uid.arr);

    strcpy(select, "UPDATE EMP SET COMM = :comm WHERE");
    printf("Please enter where clause for the follwing : n");
    printf("%s", select);
    scode = scanf("%s", where);
    if(scode == EOF !! scode == 0)
    {
        printf("Invalid entry. n");
        exit(1);
    }
    strcat(select, where);

    EXEC SQL PREPARE S1 FROM :select;

    printf("Please enter commission : ");
    scanf("%f", &comm);
    EXEC SQL EXECUTE S1 USING :comm;

    printf("%d records updated. n", sqlca.sqlerrd[2]);
    EXEC SQL WHENEVER SQLERROR CONTINUE;
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);

errrpt:
    printf("n %70s n", sqlca.sqlerrm.sqlerrmc);
    EXEC SQL ROLLBACK WORK RELEASE;
    exit(1);
}       
 
6.5 PREPARE, DECLARE, OPEN, FETCH, CLOSE 의 사용
/* 예제 #12 */
#include

/***************************************************************
This is is a sample Pro*C program which will prompt for a
WHERE clause to be used in a select statement.
This sample uses PREPARE, DECLARE, OPEN, FETCH, CLOSE
since this may be a multi-row select and world require a cursor.
***************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
    VARCHAR uid[20];
    VARCHAR pwd[20];
    int deptno;
    float sal;
    char select[132];
EXEC SQL END DECLARE SECTION;
EXEC SQL INCLUDE SQLCA;

void main(void)
{
    char where[80];
    int i, scode;

    /* log into ORACLE */
    strcpy(uid.arr, "SCOTT");                       /* copy the user name */
    uid.len = strlen(uid.arr);
    strcpy(pwd.arr, "TIGER");                       /* copy the password */
    pwd.len = strlen(pwd.arr);

    EXEC SQL WHENEVER SQLERROR GOTO errrpt;
    EXEC SQL CONNECT :uid IDENTIFIED BY :pwd;
    printf("Connected to ORACLE user : %sn", uid.arr);
    strcpy(select, "SELECT ENAME, SAL FROM EMP ");
    printf("Please enter where clause for the following : n");
    printf("%s", select);
    scode = scanf("%s", where);
    if(scode == EOF !! scode == 0)
    {
        printf("Invalid entry. n");
        exit(1);
    }
    strcat(select, where);

    EXEC SQL PREPARE S1 FROM :select;
    EXEC SQL DECLARE C1 CURSOR FOR S1;
    EXEC SQL OPEN C1;
    printf("Employee       tSalary       n");
    printf("--------------t-----------n");

    EXEC SQL WHENEVER NOT FOUND GOTO endloop;
    for(i = 0; ; i++)
    {
        EXEC SQL FETCH C1 INTO :ename, :sal;
      printf("%10st%6.2fn", ename, sal);
    }

endloop:
    printf("nn%d records selected.n", i);
    EXEC SQL WHENEVER SQLERROR CONTINUE;
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
errrpt:
    printf("n %70s n", sqlca.sqlerrm.sqlerrmc);
    EXEC SQL ROLLBACK WORK RELEASE;
    exit(1);
}
 
7.1 STORED PROCEDURE 의 사용
 
/* calldemo.sql */
rem
Rem    calldemo.sql -
Rem    DESCRIPTION
Rem   
Rem    RETURNS
Rem

CREATE OR REPLACE PACKAGE calldemo AS
   TYPE name_array IS TABLE OF emp.ename%type
       INDEX BY BINARY_INTEGER;
   TYPE job_array IS TABLE OF emp.job%type
       INDEX BY BINARY_INTEGER;
   TYPE sal_array IS TABLE OF emp.sal%type
       INDEX BY BINARY_INTEGER;

   PROCEDURE get_employees(
     dept_number IN     number,    -- department to query
     batch_size  IN     INTEGER,   -- rows at a time
     found       IN OUT INTEGER,   -- rows actually returned
     done_fetch  OUT    INTEGER,   -- all done flag
     emp_name    OUT    name_array,
     job         OUT    job_array,
     sal         OUT    sal_array);
END calldemo;
/

CREATE OR REPLACE PACKAGE BODY calldemo AS
   CURSOR get_emp (dept_number IN number) IS
       SELECT ename, job, sal FROM emp
           WHERE deptno = dept_number;

   PROCEDURE get_employees(
     dept_number IN     number,
     batch_size  IN     INTEGER,
     found       IN OUT INTEGER,
     done_fetch  OUT    INTEGER,
     emp_name    OUT    name_array,
     job         OUT    job_array,
     sal         OUT    sal_array) IS

   BEGIN
       IF NOT get_emp%ISOPEN THEN      -- open the cursor if
           OPEN get_emp(dept_number);  -- not already open
       END IF;
       done_fetch := 0;  -- set the done flag FALSE
       found := 0;
       FOR i IN 1..batch_size LOOP
           FETCH get_emp INTO emp_name(i), job(i), sal(i);
           IF get_emp%NOTFOUND THEN    -- if no row was found
               CLOSE get_emp;
               done_fetch := 1;   -- indicate all done
               EXIT;
           ELSE
               found := found + 1;  -- count row
           END IF;
       END LOOP;
   END;
END;
/

 /* 예제 #13 */

#include
#include
/***************************************************************
This program connects to ORACLE using the SCOTT/TIGER account. 
The program declares several host arrays, then calls a PL/SQL
stored procedure (GET_EMPLOYEES in the CALLDEMO package)
that fills the table OUT parameters. The PL/SQL procedure returns
up to ASIZE values.
****************************************************************/
EXEC SQL INCLUDE sqlca.h;

typedef char asciz[20];
typedef char vc2_arr[11];

EXEC SQL BEGIN DECLARE SECTION;
    /* User-defined type for null-terminated strings */
    EXEC SQL TYPE asciz IS STRING(20) REFERENCE;
    /* User-defined type for a VARCHAR array element. */
    EXEC SQL TYPE vc2_arr IS VARCHAR2(11) REFERENCE;
    asciz     username;
    asciz     password;
    int       dept_no;                  /* which department to query- */
    vc2_arr   emp_name[10];            /* array of returned names */
    vc2_arr   job[10];
    float     salary[10];
    int       done_flag;
    int       array_size;
    int       num_ret;                 /* number of rows returned */
EXEC SQL END DECLARE SECTION;

long      SQLCODE;

void print_rows();            /* produces program output      */
void sql_error();             /* handles unrecoverable errors */

main()
{
    int   i;
    char  temp_buf[32];

    /* Connect to ORACLE. */
    EXEC SQL WHENEVER SQLERROR DO sql_error();
    strcpy(username, "scott");
    strcpy(password, "tiger");
    EXEC SQL CONNECT :username IDENTIFIED BY :password;
    printf("nConnected to ORACLE as user: %snn", username);

    printf("Enter department number: ");
    gets(temp_buf);
    dept_no = atoi(temp_buf);

    /* Print column headers. */
    printf("nn");
    printf("%-10.10s%-10.10s%sn", "Employee", "Job", "Salary");
    printf("%-10.10s%-10.10s%sn", "--------", "---", "------");

    /* Set the array size. */
    array_size = 10;
    done_flag = 0;
    num_ret = 0;
    /*  Array fetch loop.
     *  The loop continues until the OUT parameter done_flag is set.
     *  Pass in the department number, and the array size--
     *  get names, jobs, and salaries back. */
     for ( ; ; )
    {
        EXEC SQL EXECUTE
            BEGIN calldemo.get_employees
                (:dept_no, :array_size, :num_ret, :done_flag,
                 :emp_name, :job, :salary);
            END;
        END-EXEC;

        print_rows(num_ret);
        if(done_flag) break;
    }
    /* Disconnect from the database. */
    EXEC SQL COMMIT WORK RELEASE;
    exit(0);
}

void print_rows(int n)
{
    int i;

    if (n == 0)
    {
        printf("No rows retrieved.n");
        return;
    }
    for (i = 0; i < n; i++)
        printf("%10.10s%10.10s%6.2fn", emp_name[i ], job[i ], salary[i ]);
}

 /* Handle errors. Exit on any error. */
void sql_error()
{
    char msg[512];
    int buf_len, msg_len;

    EXEC SQL WHENEVER SQLERROR CONTINUE;

    buf_len = sizeof(msg);
    sqlglm(msg, &buf_len, &msg_len);

    printf("nORACLE error detected:");
    printf("n%.*s n", msg_len, msg);

    EXEC SQL ROLLBACK WORK RELEASE;
    exit(1);
}
 
8. Pro*C/C++의 사용
 
8.1 디렉토리 또는 경로의 설정
OS에서 디렉토리 또는 경로를 사용하고 있는 경우 경로 또는 디렉토리의 이름이 장치의 지정과 함께 올바른 지를 확인해야 한다.
 
8.2 커맨드 구문
 
일반적인 커맨드 구문은 다음과 같다.
PCC INAME = filename {option=value (option=value …)}
 
8.2.1 필수 인수
필수 인수는 "INAME = 파일명" 하나뿐이다. 파일의 확장자나 파일타입을 지정하지 않는 경우 "HOST = 언어"를 인수로서 지정해야 한다.
Pro*C에서 입력파일 및 출력파일에 대한 파일타입 및 확장자의 디폴트값은 다음과 같다.
OS          입력파일타입 또는 확장자      출력파일타입 또는 확장자
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
VAX/VMS               .pc                                  .c
IBM/VM/CMS         csql                                c
UNIX                      .pc                                  .c
 
8.2.2. Pro*C의 실행시 옵션
  실행시에는 복수의 옵션을 사용할 수 있다.
OPTION = value

 · AREASIZE
 · ASACC
 · ERRORS
 · HOLD_CURSOR/RELEASE_CURSOR
 · HOST
 · INCLUDE
 · IRECLEN
 · LNAME
 · LRECLEN
 · LTYPE
 · MAXLITERAL
 · MAXOPENCURSOR
 · ONAME
 · ORACA
 · ORECLEN
 · PAGELEN
 · REBIND
 · SELECT_ERROR
 · USERID
 · XREF

쉘 프로그래밍 강좌

참고서적 :  초보자용 리눅스 프로그래밍
            ( 대림출판사, 한동훈,이만용역, NEIL MATTHEW, RICHARD STONES 저 )

※ 넷츠고 리눅스 동호회 7월 제 5회 정기 공개강좌 자료
글쓴이 : 위경섭 ( powerhack@netsgo.com )

1. 변수
  . 쉘변수는 처음 사용될때 만들어진다. 즉 미리 선언할 필요가 없다.
  . 쉘변수는 유닉스 명령과 마찬가지로 대소문자에 구별이 있다.
  . 쉘변수는 기본적으로 데이터를 문자열로 저장한다. 수치를 대입해도 실제 수치
    가 아닌 문자열이 저장된다. 계산이 필요할 경우는 자동으로 수치로 변환하여 
    계산후 다시 문자열로저장된다.
  . 쉘변수의 값을 사용할 때는 변수명앞에 "$" 를 붙여서 사용한다.
  . 쉘변수에 값을 대입할때는 "$"를 사용하지 않는다.
  . 쉘변수는 타입이 없다. 즉 아무 값이나 다 넣을 수 있다.
	
1.1 환경변수
  쉘을 기동하고나면 기본적으로 셋팅되어있는 변수들이다. 유닉스/리눅스에는 많은
  환경변수들이 있고 필요한경우 이 변수들을 마치 일반변수처럼 값을 얻어오거나 셋
  팅할 수 있다. 여기서는 쉘과 직접적인 관련이 있는것만 설명한다. 
		
  $0 - 실행된 쉘 스크립트 이름
  $# - 스크립트에 넘겨진 인자의 갯수
  $$ - 쉘 스크립트의 프로세스 ID
		
1.2 인자 변수
  쉘스크립트에 인자를 넘겨줄때 그 인자들에 대한 정보를 가지고 있는 변수들.
		
  $1~ $nnn  : 넘겨진 인자들
  $*        : 스크립트에 전달된 인자들을 모아놓은 문자열. 하나의 변수에 저장되며
              IFS 환경변수의 첫번째 문자로 구분된다.
  $@        : $*과 같다. 다만 구분자가 IFS변수의 영향을 받지 않는다.
	
1.3 일반변수
  일반변수에 특별한 제약은 없다. 단 대소문자 구분만 정확하게 해주면 된다.

  예제 )

  #!/bin/sh
  echo "This Script Executable File : $0"
  echo "Argument Count : $#"
  echo "Process ID : $$"
  echo "Argument List \$* : $*"
  echo "Argument List \$@ : $@"
  echo "Argument 1 : $1"
  echo "Argument 2 : $2"
  echo "Argument 3 : $3"
  echo "Argument 4 : $4"	
  	
  실행 )
  $chmod 755 test1
  $./test1 a1 a2 a3 a4
  This Script Executable File : ./test1
  Argument Count : 4
  Process ID : 905
  Argument List $* : a1 a2 a3 a4
  Argument List $@ : a1 a2 a3 a4
  Argument 1 : a1
  Argument 2 : a2
  Argument 3 : a3
  Argument 4 : a4
	
1.4 연산
  변수의 산술연산은 생각하는것 처럼 쉽지않다. 위에서 언급했듯이 변수에는 모든것
  이 문자열로 저장되기 때문에 연산이 불가능하다. 연산을 위해서는 좀 복잡한 절차
  를 거쳐야 한다.

  변수 = $((산술식))
	
  이것이 가장 단순한 연산 규칙이다. 산술식내에는 변수( $1, $a 와 같은 ) 도 들어
  갈 수 있다. 산술식 내에 숫자가 아닌 문자열, 또는 문자열이 담겨있는 변수가 들어
  가면 그것들은 계산에서 제외된다.
  (정확히 말하면 0 으로 간주되어 연산이 이루어 지지 않는다.)
	
1.5 매개변수 확장
  매개변수 확장이란 변수의 값을 문자열등으로 대체하는 것을 말한다. 단순한 대체뿐
  아니라 변수내의 문자열을 조작하여 원하는 문자열만을 추출할 수도 있다.

  형식
  ${parm:-default}	: parm이 존재하지 않으면 default로 대체된다.
  ${#parm}          : parm의 길이를 참조한다.(가져온다)
  ${parm%word}      : 끝에서부터 word와 일치하는 parm의 최소부분(첫번째 일치) 을
                      제거하고 나머지를 반환한다.
  ${parm%%word}     : 끝에서부터 word와 일치하는 parm의 최대부분(마지막 일치) 을
                      제거하고 나머지를 반환한다.
  ${parm#word}      : 처음부터 word와 맞는 parm의 최소부분(첫번째 일치)을 제거하
                      고 나머지 부분을 반환한다.
  ${parm##word}     : 처음부터 word와 맞는 parm의 최대부분(마지막 일치)을 제거하
                      고 나머지를 반환한다.
		
  * word에는 와일드 카드를 사용할 수 있다.
		
  예를 보자.
  		
  1 #!/bin/sh
  2
  3 p="/usr/X11R6/bin/startx"
  4
  5 unset p
  6 a=${p:-"Variable p Not found"}
  7 echo $a
  8
  9 p="/usr/X11R6/bin/startx"
  10 a=${p:-"Variable parm Not found"}
  11 echo $a
  12
  13 a=${#p}
  14 echo $a
  15
  16 a=${p%/*}
  17 echo $a
  18
  19 a=${p%%/*}
  20 echo $a
  21
  22 a=${p#*/}
  23 echo $a
  24
  25 a=${p##*/}
  26 echo $a
  27                    
		
  위 스크립트의 결과는 다음과 같다.
  ---------------------------------
  Variable p Not found
  /usr/X11R6/bin/startx
  21
  /usr/X11R6/bin
  
  usr/X11R6/bin/startx
  startx              
  ----------------------------------
   6행 : 변수 p 가 제거 되었으므로 "Variable p Not found" 가 a에 들어간다.
  10행 : 변수 p 가 있으므로 그대로 a에 들어간다.
  13행 : a에는 변수 p의 길이가 들어간다.
  16행 : p 에서 가장 오른쪽의 "/"부터 끝까지 지우고 나머지를 a에 넣는다.
  19행 : p 에서 가장 왼쪽의 "/" 부터 끝까지 지우고 나머지를 a에 넣는다.
         (아무것도 없다)
  22행 : p 의 처음부터 가장왼쪽의 "/" 까지 지우고 나머지를 a에 넣는다.
  25행 : p 의 처음부터 가장 오른쪽의 "/"까지 지우고 나머지를 a에 넣는다.
		
2. 조건 판단
  쉘 스크립트에서 조건판단은 if 와 test 명령을 혼합하여 사용한다.
  일반적인 예는 다음과 같다.
	
  if test -f test1
  then
  	...
  fi
  
  -f 는 주어진 인자가 일반파일 일때 참이된다.
  
  
  test 명령은  [] 로 대체될 수 있다.
  
  if [ -f test1 ]
  then
  	...
  fi
  
  -----------------------------
  
  if [ -f test1 ]; then
  	...
  fi
	
  2.1 test 명령
  
  test 명령의 조건은 다음과 같이 세 부류로 나누어진다.
	
  문자열비교
    [ string ]             : string이 빈 문자열이 아니라면 참
    [ string1 = string2 ]  : 두 문자열이 같다면 참
    [ string1 != string2 ] : 두 문자열이 다르면 참
    [ -n string ]          : 문자열이 null(빈 문자열) 이 아니라면 참
    [ -z string ]          : 문자열이 null(빈 문자열) 이라면 참
		
  산술비교
    [ expr1 -eq expr2 ]	: 두 표현식 값이 같다면 참 ( EQual )
    [ expr1 -ne expr2 ]	: 두 표현식 갑이 같지 않다면 참 ( Not Equal )
    [ expr1 -gt expr2 ]	: expr1 > expr2 이면 참 ( Greater Then )
    [ expr1 -ge expr2 ]	: expr1 >= expr2 이면 참 ( Greater Equal )
    [ expr1 -lt expr2 ]	: expr1 < expr2 이면 참 ( Less Then )
    [ expr1 -le expr2 ]	: expr1 <= expr2 이면 참 ( Less Equal )
    [ ! expr ]          : expr 이 참이면 거짓, 거짓이면 참
    [ expr1 -a expr2 ]  : expr1 AND expr2 의 결과 ( 둘다 참이면 참 )
    [ expr1 -o expr2 ]  : expr1 OR expr2 의 결과 ( 둘중 하나만 참이면 참 )
		
  파일조건

    [ -b FILE ]           : FILE 이 블럭 디바이스 이면 참
    [ -c FILE ]           : FILE 이 문자 디바이스 이면 참.
    [ -d FILE ]           : FILE 이 디렉토리이면 참
    [ -e FILE ]           : FILE 이 존재하면 참
    [ -f FILE ]           : FILE 이 존재하고 정규파일이면 참
    [ -g FILE ]           : FILE 이 set-group-id 파일이면 참
    [ -h FILE ]           : FILE 이 심볼릭 링크이면 참
    [ -L FILE ]           : FILE 이 심볼릭 링크이면 참
    [ -k FILE ]           : FILE 이 Sticky bit 가 셋팅되어 있으면 참
    [ -p FILE ]           : True if file is a named pipe.
    [ -r FILE ]           : 현재 사용자가 읽을 수 있는 파일이면 참
    [ -s FILE ]           : 파일이 비어있지 않으면 참
    [ -S FILE ]           : 소켓 디바이스이면 참
    [ -t FD   ]           : FD 가 열려진 터미널이면 참
    [ -u FILE ]           : FILE 이 set-user-id 파일이면 참
    [ -w FILE ]           : 현재 사용자가 쓸 수 있는 파일(writable file) 이면 참
    [ -x FILE ]           : 현재사용자가 실행할 수 있는 파일(Executable file) 이면 참
    [ -O FILE ]           : FILE 의 소유자가 현재 사용자이면 참
    [ -G FILE ]           : FILE 의 그룹이 현재 사용자의 그룹과 같으면 참
    [ FILE1 -nt FILE2 ]   : FILE1이 FILE2 보다 새로운 파일이면 ( 최근파일이면 ) 참
    [ FILE1 -ot FILE2 ]   : FILE1이 FILE2 보다 오래된 파일이면 참
    [ FILE1 -ef FILE2 ]   : FILE1 이 FILE2의 하드링크 파일이면 참
		
  2.2 if 구문
    if 문은 조건을 판단하여 주어진 문장을 수행한다.
		
    1. 형식 1  ( 단일 if 문 )
    형식 :
      if [ 조건 ]
      then
        문장1
        문장2
      fi
				
    2. 형식 2  ( if~else 문 )
    형식 :
      if [ 조건 ]
      then
        문장3
        문장4
      fi
				
    3. 형식 3  ( if~elif 문 )
    형식 :
      if [ 조건 ]
      then
        문장1
        문장2
      elif
        문장3
        문장4
      else
        문장5
        문장6
      fi
				
  2.3 case 구문
  ※ 패턴에는 * 문자, 즉 와일드카드를 사용할 수 있다.
  형식 :
      case 변수 in
        패턴 [ | 패턴 ] ... ) 문장 ;;
        패턴 [ | 패턴 ] ... ) 문장 ;;
        ....
        * ) 문장 ;;
      easc
		
  2.4 목록
    여려명령을 실행할때 앞의 명령의 결과에 의해서 다음행동이 결정되어야 할 경우
    가 있다. 이런경우에 AND나 OR조건을 사용해서 한번에 처리할 수 있다. 이것은 쉘
    스크립트 뿐 아니라 명령행에서도 사용 가능하다. 물론 if 문을 이용해서 반환값
    을 검사하여 처리할 수 있지만 문장이 길어지고 복잡해진다.
		
    AND 목록
	
        statment1 && statment2 && statmentN && .....

        위의 명령들은 각 명령이 거짓이 될 때 까지 명령을 수행해 나간다. 수행도중
        결과가 거짓이 되면 그이후의 명령은 수행되지 않는다.
	
    OR  목록
	
        statment1 || statment2 || statmentN || .....
	
        위의 명령들은 각 명령이 거짓이 나오는 동안 계속된다. 즉 참이 나오면 실행
        을 멈춘다.
	
    AND와 OR목록은 혼용이 가능하다.
	
        [ 조건 ] && 문장1 || 문장2

        위의 예는 조건이 참이면 문장1을 수행하고 거짓이면 문장2를 수행한다.

        또한 위의 문장1이나 문장2에서 여러개의 문장을 수행 하고 싶을 때는 {}를
        사용하면 된다.

        [조건] && {
                    문장1
                    문장2
                    문장3
                          } || {
                                 문장4
                                 문장5
                                 문장6
                               }
	
3. 제어문
  3.1 for
  for 문은 지정된 범위안에서 루프를 수행한다. 범위는 어떤 집합도 가능하다.
  형식 :
         for 변수 in 값1, 값2, ...
         do
             문장
         done

  매 루프를 돌때마다 변수의 값은 in 이후의 값으로 대체된다.
  예)
      for str in "test1", "test2", "test3", "test4"
      do
         echo @str
      done

  출력 )

      test1
      test2
      test3
      test4
		
  값에는 와일드 카드 확장을 사용할 수 있다.

    for file in $(ls -a | grep "^.")
    do
      echo "$file is Hidden File"
    done

  위 예의 출력 결과는 현재디렉토리에서 처음이 "." 으로시작하는 파일(히든파일) 만
  을 출력한다.

  for file in $(ls chap[345].txt); do
      echo "--- $file ---" >> Books.txt
      cat $file >> Books.txt
  done

  위의예는 chap3.txt, chap4.txt, chap5.txt 파일을 Books.txt 라는 파일에 붙여 넣
  는다.

  다음의 예를 보고 결과를 예측해보자

  echo "\$* output"

  for fvar in $*
  do
    echo $fvar
  done

  echo "\$@ output"
  for fvar in $@
  do
    echo $fvar
  done
				
  3.2 while
    for 명령의 경우는 횟수를 지정해서 루프를 수행하는데는 문제가 있다.
    while 문은 실행횟수가 지정되지 않았을때 편리하다.
		
    형식 :
           while 조건문
           do
                문장
           done
			
    예제를 보자. 패스워드를 입력받고 맞는지 확인하는 프로그램이다.

    echo "Enter Password : "
    read password1

    echo "Retype Password : "
    read password2

    while [ "$password1" != "$password2" ]
    do
         echo "Password miss match Try again "

         echo "Retype Password : "
         read password2
    done

    echo "OK Password Match complete"
		


    어떻게 동작하는가 ?
				
  3.3 until
    until은 while문과 동일한 효과를 내지만 조건이 반대이다. 즉, while문은 조건이
    참 일동안 루프를 수행하지만 until은 조건이 거짓일 동안 루프를 수행한다.
    
    형식 :
      until 조건문
      do
      	문장
      done
    
    다음 예를 보자. 이 예는 지정한 유저가 로그인 하면 알려준다.
    
    #!/bin/sh
    
    until who | grep "$1" > /dev/null
    do
        sleep 10
    done
    
    echo "User $1 just logged in ^_^"
		
	3.4 select
    select 문은 원하는 리스트를 출력하고 그중 선택된것을 돌려주는 구문이다. 주의
    할점은 select의 루프내에서는 자동적으로 루프를 벗어날 수 없다. 반드시 break
    문을 사용해서 루프를 벗어나야 한다.
		
    예) 간단한 퀴즈 ^_^

      #!/bin/sh
      
      echo "다음중 스크립트언어 프로그래밍에 속하는 것은 ?"
      select var in "쉘 프로그래밍" "C 프로그래밍" "자바 프로그래밍" "Exit"
      do
          if [ "$var" = "쉘 프로그래밍" ]
          then
                  echo "정답입니다."
                  exit 0
          elif [ "$var" = "Exit" ]
          then
                  echo "종료합니다."
                  exit 1
          else
                  echo "$var 을 선택하셨습니다. 오답입니다."
                  echo "다음중 스크립트언어 프로그래밍에 속하는 것은 ?"
          fi
      done

4. 함수
  쉘 스크립트 내부에 또는 다른 스크립트파일에 함수를 정의해 놓고 사용할 수 있다.
  함수를 사용하면 코드를 최적화 할 수 있고, 코딩이 간결해지며,재사용이 가능하다.
  그러나 다른 스크립트 파일을 호출해서 함수를 실행할 경우, 가능은 하지만 스크립
  트의 실행시간이 길어지고, 함수의 결과를 전달하는 것이 까다롭기 때문에 가급적이
  면 외부파일의 함수는 안쓰는 것이 좋다.
	
  형식 :
    정의 - 
    함수명 ()
    {
    	문장
    	return 값
    }
    
    사용
    
    함수명 인자1, 인자2, ...
    
    
    함수는 독립적으로 $#, $*, $0 등의 인자변수를 사용한다. 즉 함수내의 $#과 본체
    의 $#은 다를 수 있다는 것이다.
    
    다음의 예를 보자
    
    #!/bin/sh
		
    func()
    {
      echo ------ this is func --------
      echo "This Script Executable File : $0"
      echo "Argument Count : $#"
      echo "Process ID : $$"
      echo "Argument List \$* : $*"
      echo "Argument List \$@ : $@"
      echo "Argument 1 : $1"
      echo "Argument 2 : $2"
      echo "Argument 3 : $3"
    }
		
    echo ------ this is main --------
    echo "This Script Executable File : $0"
    echo "Argument Count : $#"
    echo "Process ID : $$"
    echo "Argument List \$* : $*"
    echo "Argument List \$@ : $@"
    echo "Argument 1 : $1"
    echo "Argument 2 : $2"
    echo "Argument 3 : $3"
    echo "Argument 4 : $4"
    func aa bb cc 


    본체와 함수에서 동일한 변수를 보여주지만 값은 틀린다는것을 알 수 있다.
    
    함수에서 값을 반환하기 - 함수에서 반환값은 반드시 정수값만을 반환할 수 있다.
    이 값을 if등으로 조건을 판단해서 사용할 수 있다. 반환값중 0은 참으로 나머지 
    숫자는 거짓으로 판별된다.
		
5. 명령어
  쉘에서 쓸 수 있는 명령어는 두가지로 나누어진다. 명프롬프트 상에서 실행 시킬 수
  있는 외부 명령어와 쉘 내부 명령이다. 내부명령은 보통 쉘 내부나 쉘 구문상에서
  쓰인다. 외부명령은 쉘에 관계없이 사용이 가능하다.
	
  break
    제어문이나 조건문의 루프를 빠져나갈때 사용한다.
    예)
    	while [ $a -eq 10 ]
    	do
    		if [ $a -eq 5 ]; then
    			break
    		fi
    	done
	
  :명령
    의미없는 명령. 논리값 true를 대신해 쓰기도 한다.
		
  continue
    제어문이나 조건문의 처음으로 돌아가서 다시수행한다.
    예)
    	while [ $a -eq 10 ]
    	do
    	    if [ $a -eq 5 ]; then
               continue
            fi
    	done
		
  . 명령
    . 명령을 사용하면 현재 쉘에서 명령을 실행시킨다 그러므로 실행된 명령의 결과
    를 본 프로그램에서 사용할 수 있다.
    
    예를 들면 A 라는 스크립트에서 B라는 스크립트를 그냥 실행할 경우 B에서의 변화
    (환경변수 등)는 A에게 아무런 영향도 미치지 않는다. 그러나 . 명령을 사용해서 
    실행하면 B에서의 변화가 A에도 영향을 미친다.
		
  echo
    문장을 출력한다. 자동으로 개행문자가 삽입된다. ( 다음줄로 넘어간다 )
	
  eval
    인자의 실제 값을 구하는데 사용한다.
		
    foo=10
    x=foo
    y='$'$x
    echo $y
		
    이 예를 실행해 보면 $foo가 출력된다
		
    foo=10
    x=foo
    eval y='$'$x
    echo $y
		
    이 예에서는 $foo의 값 즉 10 이 출력된다. eval명령은 원하는 문자열들을 조합해
    서 변수를 액세스 할 수 있다.
	
  exec
    현재쉘을 다른 프로그램으로 대체한다.
		
    예 ) exec csh
	
  exit n
    현재 쉘을 종료한다. 종료시 n 값을 리턴한다.
	
  export
    해당 쉘에서 파생된 자식 프로세스에서 export한 환경변수는 본래 쉘에서 관리한
    다.
	
  expr
    표현식의 값을 구한다.    ( x=`expr 1 + 2` )
    요즘은 expr보다는 $((계산식)) 구문을 많이 사용한다.
	
  printf
    C 언어의 printf명령과 흡사하다.
    
    형식 :  printf "Format String" arg1 arg2 arg3 ...
		
  return
    쉘함수에서 값을 반환 할 때 쓰인다.
    0은 성공을 1~125까지는 쉘 에러코드를 나타낸다.
	
  set
    쉘 내부에서 매개 인자를 설정한다.
    set의 인자로 쓰인 문자열은 공백에 의해 $1 부터 차례대로 대입된다.
    
    예)
    
    #!/bin/sh
    echo $#
    set $(ls)
    echo $# 
    
    결과는 
    
    0
    22
    
    이다..( 22는 필자의 ls 결과의 갯수이다. ). 첫번째 0는 이 스크립트에 인수가
    없으므로 0이고 set $(ls) 에 의해서 인수의 갯수가 22개로 늘었다.
	
  shift
    쉘의 인자를 한자리씩 아래로( n -> 1 로 ) 이동시킨다.
    
    예)
    #!/bin/sh
    
    echo $1
    shift
    echo $1
    shift 5
    echo $1
    
    #./myscript 1 2 3 4 5 6 7 8 9 0
    1
    2
    7
	
	trap
    쉘의 실행도중 시그널을 처리하는 시그널 처리기를 만드는 역할을 한다.
    
    형식 : trap command signal
    
    쉘 스크립트는 위에서 아래로 실행되므로 보호하려는 부분 이전에 trap명령을 사
    용해야 한다. trap조건을 기본으로 사용하려면 명령에 - 를 넣으면 된다.
    신호를 무시하려면 '' 빈 문자열을 준다.
	
  unset
  	변수나 함수를 제거한다.

6. 명령실행
  외부명령의 실행 결과를 변수에 집어넣어 변수의 값으로 사용할 수 있다.
  
  형식 : x = $(명령)
  
  이렇게 변수에 결과를 넣은 후에는 이 변수를 일반문자열로 생각하고 원하는 가공을
  해서 결과를 얻어낼 수 있다.
  위에서 보았던 매개변수 확장이나 set명령을 이용해서 원하는 부분을 추출해 내면
  그만이다.

7. 쉘 스크립트 내부에서 명령에 입력 전달하기 ( Here Documents )
  이 기능은 쉘 내부에서 명령어에 입력을 전달하는 방법이다. 전달된 입력은 마치 키
  보드에서 눌려진 것 처럼 반응한다.
  
  형식 :  명령 << 종료문자열
  		입력값.....
  		종료문자열
  예제 ) 자동으로 메일을 보내는 스크립트
  
  #!/bin/sh
  
  mail $1 << myscript
  This is Header
  This is Body
  .
  
  myscript