T-Tiger

select name,value
from
v$pgastat
order by
value desc;

에서 일단 사이즈를 확인한다

SQL> alter system set pga_aggregate_target=20000000;
시스템이 변경되었습니다.
SQL> alter system set workarea_size_policy=AUTO;
시스템이 변경되었습니다.
SQL> show parameter pga;
NAME TYPE                                       VALUE
------------------------------------ -------------------------------- ------------------------------
pga_aggregate_target big integer           20000000


SQL> show parameter workarea
NAME TYPE                                      VALUE
------------------------------------ -------------------------------- ------------------------------
workarea_size_policy string                 AUTO


관련 뷰(View)
WORKAREA_SIZE_POLICY를 Auto로 사용할때 아래의 view가 유용할것이다.
1. V$SQL_WORKAREA
2. V$SQL_WORKAREA_ACTIVE
3. V$PROCESS contains new columns (PGA_USED_MEM, PGA_ALLOC_MEM AND PGA_MAX_MEM)
4. V$PGASTAT

Oracle 9.2 has also new views (see [NOTE:223730.1] for some explanation)
1. V$SQL_WORKAREA_HISTOGRAM
2. V$PGA_TARGET_ADVICE
3. V$PGA_TARGET_ADVICE_HISTOGRAM


v$pga_target_advice : PGA메모리 사용현황을 볼 수 있음
SQL> desc v$pga_target_advice
 이름                                                         널?         유형
 ----------------------------------------- -------- ----------------------------
 PGA_TARGET_FOR_ESTIMATE                                 NUMBER
 PGA_TARGET_FACTOR                                            NUMBER
 ADVICE_STATUS                                                     VARCHAR2(3)
 BYTES_PROCESSED                                               NUMBER
 ESTD_EXTRA_BYTES_RW                                        NUMBER
 ESTD_PGA_CACHE_HIT_PERCENTAGE                     NUMBER
 ESTD_OVERALLOC_COUNT                                     NUMBER 
v$pgastat : 모니터링 PGA_AGGREGATE_TARGET
SQL> SELECT * FROM V$PGASTAT;
NAME                                                    VALUE          UNIT
---------------------------------------- ------------ ------------
aggregate PGA target parameter                524,288,000 bytes
aggregate PGA auto target                       467,481,600 bytes
global memory bound                                26,214,400 bytes
total PGA inuse                                          4,714,496 bytes
total PGA allocated                                   16,799,744 bytes
maximum PGA allocated                            33,172,480 bytes
total freeable PGA memory                          1,114,112 bytes
PGA memory freed back to OS                  598,933,504 bytes
total PGA used for auto workareas                          0 bytes
maximum PGA used for auto workareas       12,239,872 bytes
total PGA used for manual workareas                      0 bytes
maximum PGA used for manual workareas               0 bytes
over allocation count                                             0
bytes processed                                ############ bytes
extra bytes read/written                                         0 bytes
cache hit percentage                                         100 percent
16 개의 행이 선택되었습니다.

SQL> connect /as sysdba
연결되었습니다.
SQL> recover database;
ORA-00283: 복구 세션이 오류로 인하여 취소되었습니다.
ORA-00264: 복구가 필요하지 않습니다.

SQL> recover database until cancel;
매체 복구가 완료되었습니다.
SQL> alter database open resetlogs;

데이타베이스가 변경되었습니다.

SQL> shutdown

 sqlplus 접속시 "ORA-00257: 아카이버 오류. 공간이 확보되기 전에는 내부 접속만 가능." 에러 발생

 - 아카이브 용량 확인
 C>sqlplus / as sysdba
 SQL> select * from v$recovery_file_dest;
 --------------------------------------------------------------------------------
 NAME            SPACE_LIMIT  SPACE_USED        SPACE_RECLAIMABLE NUMBER_OF_FILES
 --------------  ----------   ----------------- ---------------   ---------------
 D:\archivelog   2.1475E+11   2.1475E+11       0                 4193

 SQL> select dest_name,error from v$archive_dest;
 DEST_NAME             ERROR
 -------------------   --------------------------------------------
 LOG_ARCHIVE_DEST_1
 LOG_ARCHIVE_DEST_2
 LOG_ARCHIVE_DEST_3
 LOG_ARCHIVE_DEST_4
 LOG_ARCHIVE_DEST_5
 LOG_ARCHIVE_DEST_6
 LOG_ARCHIVE_DEST_7
 LOG_ARCHIVE_DEST_8
 LOG_ARCHIVE_DEST_9
 LOG_ARCHIVE_DEST_10   ORA-19809: 복구 파일에 대한 한계를 초과함

 SQL> recover database;
 ORA-00283: 복구 세션이 오류로 인하여 취소되었습니다
 ORA-01124: 1 데이터 파일을 복구할 수 없음 - 파일이 사용중이거나 복구중입니다
 ORA-01110: 1 데이터 파일: 'D:\ORADATA\ORADB\SYSTEM01.DBF'

------------------------------------------------------------------------------------------------

해결방법
1. 아카이브 로그를 삭제
 SQL> select * from v$recovery_file_dest;
 --------------------------------------------------------------------------------
 NAME            SPACE_LIMIT  SPACE_USED        SPACE_RECLAIMABLE NUMBER_OF_FILES
 --------------  ----------   ----------------- ---------------   ---------------
 D:\archivelog   2.1475E+11   2.1475E+11

 D:\archivelog 이 아래파일 모두삭제
db리스타트

2. 아카이브모드 해제

  SQL> startup mount
  SQL> alter database noarchivelog;
  SQL> archive log list
  SQL> alter database open;

 댓글 쓰기  

회사에서 사용중인 PL/SQL Developer
토드나 오렌지를 쓰다가 강제로 사용하게 되서 첨에는 불편했으나.. 금방 익숙해진다.

첨에 버벅 댈때 설정을 알려준 내용을
보내준 그대로 긁어 놓음..ㅋㅋㅋ
---------------------------------------------
-PL/SQL Developer

- Window Types

- SQL Window
- AutoSelect Statement : 이게 설정되어 있으면 여러 sql을 써놨을때 자동으로 선택되어 하나만 실행되.

쿼리가 많아지면...좀 멍청해 지기도 해...^^;;;

- Null value color : sql 결과창에 null value color 세팅...좀 눈에 띄는걸루 해 놓는게 보기편할꺼고...

- Record per page : sql 실행했을때 default로 뿌려지는 갯수인데

기본적으로 Automatically determined 인데...난 불편해서

All records 로 해놓고써.. sql 실행결과가 많을때 중간에 끊고싶으면 F7를 누르면 되거든..^^


 User Interface

- Options

- Autosave Desktop 활성화

: 이게 활성화되어있으면 plsql 을 다시 실행했을때, 직전 종료했던

sql file들이 자동으로 다 열려( 단, 그 파일들이 저장된 경우에만..)

- Editor

- Syntax Highlighting

- Keyword case : Uppercase - keyword면 자동으로 대문자화( default값인가? 모르겠다..)

- Other

- Highlight edit line : 말그대로...

■ 포인터 스터디 [1]■
    

■ 1. 포인터란…■
    
    ◐ 변수와 주소

      우리가 흔히 사용하는 변수. 변수를 이름 그대로 해석해 보면 「변할 수 있는 값」이라고 하네요.

      그렇지만 값이라고 하기에는 조금 무리가 있다. 하나의 값이 다른 값으로 그냥 바뀔 수 는 없으니.

     변수라는 것을  좀 더 구체적으로 말하자면 『값을 저장할 수 있는 메모리』라고 할 수 있다.

     이미 아실테지만, 변수는  메모리의 일부입니다.

     물론 모든 메모리가 변수가 되는건 아니지만  그 가능성은 가지고 있다.

    우리가 변수를 선언할 때 컴파일러는 자기가 알아서 비어있는 메모리를 찾아 그 메모리를 변수로 사용하게 되는 거다.
     그렇다면 컴파일러는 어떻게 각 메모리를 구분하면 우리가 집이나 사람을 구분할 때 바로 주소나 주민등록번호 같은 번호를 사용하
    지요. (주소는 일부만 번호이긴 하지만… 더 쉽게 아파트의 호수를 생각하면 된다.) 컴퓨터도 마찬가지 이다.

    각각의 메모리에 주소를  붙여 구별을 하는 것이다.

    그리고 컴퓨터의 메모리는 한줄로 이어져 있기 때문에(이를 「선형 메모리」라 한다) 연속된 값으로 주소값이 표시 한다.

    즉 컴퓨터의 메모리 크기가 100이라고 하면 0부터 시작해서 99까지의 주소가 존재하는  것이다.

   그런데 컴퓨터는 일반적으로 수백만 이상의 크기를 가지므로 그만큼 주소값의 범위도 커지게 된다.

    그래서 흔히  주소값은  4바이트의 long형으로  나타내는 것이다.

    ◐ 포인터 상수와 변수

      포인터 상수는 별게 아니다. (물론 포인터 변수도 별게 아니지만…) 포인터 상수는 바로 위에서 말씀드린 주소를 말하는 겁니다.

     당연히 크기도 4바이 트이다  컴퓨터의 가장 첫번째 메모리의  포인터는 0x00000000이 된다
      그 다음은 0x00000001…(앞에 0x를 붙인건 16진수라는거) 그렇다면 포인터 변수는  바로 「포인터 상수를  저장할 수

     있는 변수」이다.. 포인터 변수의 크기도 포인터 상수처럼 4바이트 이다.

      char *p; // 포인터 변수를 선언할 때 「*」를 붙이고

      이 p라는 포인터 변수는 포인터를 저장할 수 있다. char의  포인터형이 긴 하지만 포인터는 포인터 입니다.

     앞에 정해진 자료형이 무엇이든 상관없이  크기는 4바이트인 거다.

      char ch = 'A';  // 'A'의 코드 값은 65 이다
      char *pc = &ch; // 변수의 주소값을 알아낼 때는 「&」를 사용한다.
                      // ch의 주소값이 0x0000001A라고 가정한다.
    ┏━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
    ┃        ┃       ┏━━━━━━━━━━━━━━━━┓                                              ┃
    ┣━━┫       ▼                                                                ┃
    ┃주소   ┃   10  1A  1B  1C  1D  1E                21  22  23  24  25   ┃
    ┃        ┃ ┳━┳━┳━┳━┳━┳━┳━━━━━━┳━  ━━━━━━ ┳ ━┳┃
    ┃ 값    ┃ ┃    ┃65┃    ┃    ┃    ┃    ┃    …                ┃1A┃00┃00┃00┃    ┃┃
    ┃        ┃ ┻━┻━┻━┻━┻━┻━┻━━━━━━┻━━━━━━━┻━┻   ┃
    ┃이름  ┃       ch                                pc                                                                            ┃
    ┗━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

      컴퓨터가 수를 저장하는 방법은 좀 특이 하다.  바이트 별로 거꾸로 저장 하는 것.

     즉, 0x12345678을 첫번째 바이트에 78,  두번째 바이트에 56,세번째 바이트에 34,

    네번째 바이트에 12를 저장하는 것  이유는  난중에 한번더...

      한가지 더. 이 글에 사용되는 모든 주소값은 임의로 붙인 것이다. 컴파일 러가 마음대로 빈 공간을 찾아

    사용하기 때문에 특별히 정해진 값이 있을수가 없기 때문이다

      int ih = 0x13;
      int *pi = &ih;
    ┏━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
    ┃주소   ┃   41  42  43  44  45  46                5A  5B  5C  5D  5E                                       ┃
    ┃        ┃ ┳━┳━━━┳━┳━┳━┳━━━━━━┳━━━━━━━┳━┳   ┃
    ┃ 값    ┃ ┃    ┃13┃00┃   ┃    ┃   ┃    …                 ┃42┃00┃00┃00┃ ┃  ┃
    ┃        ┃ ┻━┻━━━┻━┻━┻━┻━━━━━━┻━━━━━━━┻━┻   ┃
    ┃이름  ┃       ih                                pi                                                                              ┃
    ┗━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

      long lh = 0x00781253;
      long *pl = &lh;
    ┏━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
    ┃주소   ┃   65  66  67  68  69  70                7A  7B  7C  7D  7E                                     ┃
    ┃        ┃ ┳━┳━━━━━━━┳━┳━━━━━━┳━━━━━━━┳━┳   ┃
    ┃ 값    ┃ ┃    ┃53┃12┃78┃00┃  ┃    …                ┃66┃00┃00┃00┃ ┃  ┃
    ┃        ┃ ┻━┻━━━━━━━┻━┻━━━━━━┻━━━━━━━┻━┻  ┃
    ┃이름  ┃       lh                                pl                                                                               ┃
    ┗━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

    ◐ *연산자의 쓰임새

      모든 연산자가 그렇듯이 *와 &도 여러가지 쓰임새를 가지고 있다. 우선 *는 곱을 구하기도 하고 위에서

     사용된 것 처럼 자료형에 붙어 포인터 변수임  을 나타내기도 한다.

      (이 경우는 연산자라고 보기는 좀 어렵지요)  그리고 또 한가지. 「주어진 주소의 값을 읽어내는」 일도 한다.

   
    ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
    ┃  #include <stdio.h>                                                ┃
    ┃                                                                    ┃
    ┃  void main(void) {                                                 ┃
    ┃      int i;                                                        ┃
    ┃      for (i = 0; i < 100; i++)                                     ┃
    ┃          printf("%c", *(char *)i);                                 ┃
    ┃  }                                                                 ┃
    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

      실행해 보면 화면이 이상한 문자들만 나온다.  이 문자들이  뜻하는게 무엇이나면  i 값이 0부터 99까지 증가할
       테고 printf 문에서 무언가를 출력하라 한다.. 그 부분만 뜯어보면,

      *(char *)i

      i가 0인 경우 위의 코드는 다음과 같게된다.

      *(char *)0

      우선 0이라는 수(상수)를 char *형으로 캐 스팅 했다. 이제 0은 그냥 수가 아닌 char 크기(1 바이트)의 메모리를 나타
     낼 수 있는 포인터 상수가 된다. 그리고 거기에 *연산자를 붙여 값을 읽어내고 있다. 이 소스 코드는  0번 메모리의 값을 읽어서 출력
     하는 것. 이렇게 99번째 메모리까지  모두 100개의 메모리의 내용을 보여주는 코드인 것. 물론 우리가 알아볼 수는 없는 글자들만 

     잔뜩   있지 만.

     만약에 (char *)로 캐스팅을 안하고 *0이라고만 쓰면  에러가 난다

    *연산자는  그 다음에 오는 내용을  포인터라고 가정을 하기는 하는데, 거기서 얼마만한 크기의 메모리를 읽어와야  하는지를 모르는
    일이다.. 즉 *앞의 자료형은 「그 포인터의 값을 *를 사용해서 읽어올 때 얼마만한 크기를 읽어와야 하는지를 정해주는 것」

     이라 할 수 있다.  
    ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
    ┃  #include <stdio.h>                                                ┃
    ┃                                                                    ┃
    ┃  void main() {                                                     ┃
    ┃      int ih = 0x0506;                                              ┃
    ┃      char *pp = (char *)&ih;                                       ┃
    ┃                                                                    ┃
    ┃      long lh = 0x01020304;                                         ┃
    ┃      char *pc = (char *)&lh;                                       ┃
    ┃      int *pi = (int *)&lh;                                         ┃
    ┃                                                                    ┃
    ┃      printf("- integer -\n");                                      ┃
    ┃      printf("ih=%X\n", ih);                                        ┃
    ┃      printf("(char)ih=%X, *(char *)=%X\n", (char)ih, *pp);  …①   ┃
    ┃                                                                    ┃
    ┃      printf("\n- long integer -\n");                               ┃
    ┃      printf("lh=%lX\n", lh);                                       ┃
    ┃      printf("(char)lh=%X, *(char *)=%X\n", (char)lh, *pc);  …②   ┃
    ┃      printf("(int)lh=%X, *(int *)=%X\n", (int)lh, *pi);     …③   ┃
    ┃  }                                                                 ┃
    ┃                                                                    ┃
    ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
    ┃  <결과>                                                            ┃
    ┃  - integer -                                                       ┃
    ┃  ih=506                                                            ┃
    ┃  (char)ih=6, *(char *)=6                                           ┃
    ┃                                                                    ┃
    ┃  - long integer -                                                  ┃
    ┃  lh=1020304                                                        ┃
    ┃  (char)lh=4, *(char *)=4                                           ┃
    ┃  (int)lh=304, *(int *)=304                                         ┃
    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

      ①의 첫번째 값은 int형 0x0506을 char형으로 캐스팅한 값이다. 당연하게 도 int는 2바이트,

      char형은 1바이트이므로 char형을 벗어나는 부분이 잘려나간 6이 결과가 된다.
      포인터를 사용한 연산도 마찬가지다. pp는  1바이트 크기의 변수를 포인트하는 포인터 변수이다.

     이 pp 변수를 사용해 그 메모리를  읽어오게 되 면 그 첫번째 바이트 한 바이트만을 읽어오게 되는 것이다.

    ┏━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
    ┃주소┃   41  42  43  44  45  46                5A  5B  5C  5D  5E   ┃
    ┃    ┃ ┳━┳━━━┳━┳━┳━┳━━━━━━┳━━━━━━━┳━┳ ┃
    ┃ 값 ┃ ┃  ┃06┃05┃  ┃  ┃  ┃    …      ┃42┃00┃00┃00┃  ┃ ┃
    ┃    ┃ ┻━┻━━━┻━┻━┻━┻━━━━━━┻━━━━━━━┻━┻ ┃
    ┃이름┃       ih                                pp                   ┃
    ┗━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

      pp는 char *형 변수이므로 *pp는 char 만큼(1바이트)만을  읽어오게 된다는것이다.

     ih를 char형으로 캐스팅한 결과와 같게 된다. 당연히  같아야 하는 거이다.

      만약 수를 거꾸로 저장하지 않고 순서대로 저장을 한다면 두 결과가 틀리게 나올 것이다

    . 포인터를 사용해 어떤 변수의 일정 크기만큼만을 읽어오려고 할 때 문제가 생기므로. 굉장히 복잡한 과정이 요구된다.

      이 때문에 컴퓨터는 수를 거꾸로 저장하는 것이다


    ◐ &연산자의 쓰임새

      연산자 &는 비트 연산자로써 AND 연산을 행하는 연산자이다. 그런데 여기서 address-of 연산자의 기능도 행하고 있습니다.

     이름 그대로 「어떤 변수 의 주소를 알아내는」 역할을 하는 연산자 이다.

     상수는 메모리에 위치하지 않으므로 주소가 있을 수 없고 당연히 &연산자도 사용하지 못하게 된다.

    ◐ *연산자와 &연산자의 관계

      *연산자는 어떤 주소의 값을 읽어오는 연산자라고 했고 &연산자는  어떤 변 수의 주소를 알아내는 연산자라고 했다.

      이 두 연산의  기능은 완전히 반 대라고 할 수 있다. 물론 변수에 대해 사용할 때 이다.  (상수에서는 *는 가능하지만 &는 아예 사용을

      하지 못한다

    ◐ 포인터 변수를 사용해 간접적으로 변수의 값 참조하기

      int ih = 0x1234;
      int *pi = &ih;
      *pi = 0x5678;

      pi는 ih의 주소를 가지고 있고 그  주소의 메모리를 *연산자를 통해 참조하고 있습니다. 그 메모리에 0x5678이라
    는 값을 넣고 있다. 한 문장으로 설명한다면 「pi의 값을 주소로 하는  2바이트 크기의 메모리에 0x5678를 대입하는」 것이다.

      int ih = 0x1234;
      char *pc = &ih;
      *pc = 0x56;

    ih 값중의 char형으로 참조 가능한 부분인 첫번째 바이트  만이 바뀌게 된다.

   결과적으로 ih는 0x1256이 되는 것이다.

    ◐ void형 포인터

      포인터 변수를 선언할 때 * 앞에는 자료형을 정해준다고 했다. 

      int ih = 0x1234;
      void *vc = (void *)&ih;

      물론 아무런 에러도 나지 않다. vc도 포인터 변수이므로 당연하게도 ih변수의 포인터를 저장할 수가 있는 것이다.

      *vc = 0x5678;

      이 코드도 에러가 나지 않을까요? 조금만 생각해 보면 알 수 있다.  당연 히 에러가 발생 한다.

      void형은 크기를 갖지 않기 때문에 얼마만한 크기 만큼의 메모리에 값을 넣어야 할지를 모르는 거이다.

      
      *(int *)vc = 0x5678;

      이렇듯 void형 포인터는 어떤 포인터 값도 가질 수 있지만,  직접적으로 참조를 할 수는 없고 반드시 캐스팅을

      해 주야 하는 포인터 이다.  별로 사용될 곳이 없어 보이기도 하지만 나중에 프로그래밍을 하다보면  의외로 쓰이
    는 곳이 많기도 하다.

    ◐ 참조에 의한 호출 (참조 호출, Call by reference)

        int i = 3;

      printf("%d", 3); //…①
      printf("%d", i); //…②

     컴파일러가 컴파일을 마친 이후에는 완전히 동일한 코드가 됩니다. 다시 말해서  ②번
    의 경우 i 대신에 i가 가진 값인 3을 대치시켜서 넘겨준다는 것이다.  바로 이것이 Call by value 이다.

    변수가 넘어가는 것이  아닌 변수가 가지고 있 는 「값」이 넘어가기 때문이다

      void swapA(int a1, int a2) {
          int ta;
          ta = a1;
          a1 = a2;
          a2 = ta;
      }

      void swapB(int *b1, int *b2) {
          int tb;
          tb = *b1;
          *b1 = *b2;
          *b2 = tb;
      }


      int i = 3, j = 4;
      swapA(i, j);   //…③
      swapB(&i, &j); //…④

      이후의 결과는 아시다시피 i와 j값이 바뀌어 있다.  그럼 내부적으로 어떤 과정을 통하길래 이런 것이 가능할까

포인터

들어가기 전에... C언어를 배울때 포인터만 알아도 70%는 성공한거다 라는 말이 있었다

그 만큼 포인터의 기능이 막강하다고한다. 우리는 그동안 골치 아프게 속 썩였던 포인터란 늠을 한번 파해쳐보자..

알고보면 쉬운 포인터, 그런데 그 개념을 알기까지는 그리 쉽지는 않은데요 

포인터?

변수는  값(value)을 저장하는 녀석이죠~

이 변수란 녀석은 선언된 형(type)에 따라서 값(value)을 저장하는 녀석이다~

이 말입니다. 너무 어렵게 설명했죠? 쉽게 말해서 i라는 변수가 있는데 이게 int형(type)로 선언되면

int가 표현할 수 있는 값(value), 즉 정수 값(value)만을 저장하는 녀석이다~

이 말입니다. (물론 형변환 어쩌구 저쩌구 해서 다른 값을 집어넣을 수도 있지만 저는 그렇게 복잡하게 생각하지 않습니다.!)

int i;

i = int형이 표현할 수 있는 값(value)을 집어넣습니다. 만약 int i; 라는 코드를 입력했다면 이건 무슨 뜻일까요

위에서 말했듯이 int형의 값을 저장하는 i라는 변수가 됩니다.

그렇다면!! 아래 코드는 어떤 내용일까요?

int i, j;

i = j;

뭐 이것도 간단하네요

int형의 값을 저장하는 i와 j라고 하는 변수를 선언하고i라는 변수에 j를 대입시킨다.

근데.. 이것 뿐입니까? 더 다른건 없나요?

없긴 왜 없습니까! i에 j를 대입한다고 하잖아요!

이때 컴파일러에서는 어떠한 작업을 수행하느냐~ 이 말입니다!

'뭐 당연히 j의 값을 i에 대입하겠지~'

라고 생각하신다면 아주아주 큰~~~~ 오산 입니다!

이렇게 생각하고 계신분들 지금부터 그 내용 머리속에서 싹 지워버리세요.

이제부터 개념적으로 설명 드리겠습니다.

메모리라고 아시나요?

모든 전역변수나 지역변수 정적변수 동적변수들은

죄다 이 메모리에 영역을 할당 받은 다음에 주소라는 것을 받게 됩니다.

그래서 다음에 이 변수를 참조(읽고 쓰는)할 일이 생기면

이 메모리의 이 주소로 찾아가서 값을 참조하는 것이죠

이 말은 다들 프로그래밍을 하면서 한번 쯤 들어 보셨을거라고 생각해요.

이게 아주 중요한 개념 입니다.

우리는 어떻게 메모리상에 저장된 변수를 참조(읽고 쓰는)를 할 수 있을까요?

위에서 잠깐 언급 했지만 그건 바로 주소(Address) 라는 개념때문에 가능합니다.

이게 포인터의 핵심입니다! 주소를 이해하지 못한채로 포인터를 때려잡는다는건

계란에 바위치기인 격이죠.

그럼 이제 주소란 녀석을 알아봐야 겠네요

우리가 어떠한 변수를 선언하던 모든 변수는

메모리상에서 주소를 할당받아서 존재할 수 있는 겁니다.

그 변수를 참조(읽고 쓰는)할땐 할당받은 그 메모리 주소로 찾아가서

값을 읽고 쓰는 것이죠.

너무 어렵죠? 압니다 그래서 좀 더 쉽게 표현해보도록 하죠

우리가 int i 라고 선언을 하면 이 i변수는

메모리한테 이렇게 말합니다

"변수 : 이~메모리. 나 추운데 입고 자고 먹을 집 하나 마련해 주시지?"

"메모리 : 그래? 그럼 마땅한 집이.. 어! 여깄다. 마침 [100]이라는 집이 비었는데

             거기서 한번 먹고 자고 해볼래?"

"변수 : 그러지 뭐~ 그럼 앞으로 내가 필요할땐 [100]이라는 곳으로 찾아와"

"메모리 : 알았어"

어때요? 개념이 잡히나요?

저 내용중에서 집을 주소라고 생각해 보세요. 개념이 잡히죠?

우리가 변수를 선언해서 그 변수가 [100]이라는 주소를 가졌다면

i = 10; 이 문장은 메모리상의 [100]이라는 주소로 찾아가 그 값에 10을 대입한다.

라는 뜻이 되는 겁니다 i는 실상 [100]이라는 주소를 편리하게 관리하도록

임시적으로 만든 변수일 뿐이죠.

아..참고로 여기선 [100]이라는 주소를 할당 받았는데 어떤 주소를 받게 될지는

아무도 모릅니다~ 며느리도 모르지요 ㅡ.ㅡ;

여기서 중요한 점이 있는데 주소(Address)와 값(Value)는 전혀 다른 것입니다.

우리가 변수를 선언하면 메모리상에서 "주소"와 "값"이 함께 할당되는 것입니다

이 "값"을 참조하기 위해선 "주소"를 이용해야 하는 거구요.

쉽게 말해서 i = 20 이란 문장은

i라는 변수의 메모리 "주소"에 20이라는 "값"을 대입한다.

라고 해석할 수 있는 겁니다. 이해 가시죠?

그렇다면 처음으로 돌아가서

i = j;

이 문장은 어떻게 해석을 해야 할까요?

i에 j의 값을 대입한다라고 말한건 아주 큰 오산이라고 했습니다.

아직 잘 모르시겠다구요?

모든 변수는 "주소"와 "값"이 함께 메모리에 할당된다고 했죠?

"값"을 참조하기 위해선 그 변수의 "주소"로 찾아가서 참조할 수 있다고 했구요

그럼 위는 이렇게 해석이 가능 하겠군요.

i라는 "주소"로 찾아가 그 주소의 "값"에

j라는 "주소"로 찾아가 그 주소의 "값"을 대입 시킨다.

다시 말하면 i라는 주소의 값에 j의 주소의 값을 대입 시킨다.

이렇게 해석하는 겁니다!

너무 길게 설명했네요 너무너무 간단한걸..

내용을 요약해서 가장 중요한걸 찝으라면 이겁니다

모든 변수는 메모리에 "주소"로 할당되고

이 변수를 참조할때에는 그 "메모리주소"를 찾아가 참조한다

다음 시간에는 본격적으로 포인터에 대해 알아볼겁니다

포인터는 변수가 메모리에 할당되는것과는 좀 달라요

근본적으론 같지만.. 왜 다른지 다음 시간에 알아보도록 하고 우선은 여기까지

저의 하드용량과 성능이 뻗기 시작하였네요..^^*

SELECT object_name(parent_id) [target], name
FROM sys.triggers
ORDER BY object_name(parent_id)