%{
#include <stdlib.h>
#include "y.tab.h"
%}
 
//declarations 토큰 선언 
digit   [0-9]
alpha   [a-zA-Z]
symbol  [-+*/%=]
 
%%
//translation rules 토큰 패턴 정의
{digit}+        { yylval.ival = atoi(yytext); return NUM; }
{alpha}+        { yylval.sval = strdup(yytext); return VAR; }
{symbol}        { yylval.sval = strdup(yytext); return SYM; }
.               { fprintf(stderr, "'%c' illegal\n", yytext[0]); exit(1); }
%%
//auxiliary procedures 추가적인 함수(유틸리티)
int yywrap() { return 1; }

%%
. ECHO;
%%
int main() {
yylex();
return 0;
}
int yywrap() {
return 1;
}

// declarations 선언부
%{
#include <stdio.h>
#include <ctype.h>
int yylex();
void yyerror(const char *s);
%}
%token NUM
 
%%
// translation rules 문법 규칙
Exp : Exp '+' Exp { puts("E -> E + N"); }
| NUM { puts("E -> N"); }
;
%%
 
// auxiliary procedures 추가적인 함수(유틸리티)
int main() { yyparse(); return 0; }
void yyerror(const char *msg) { fputs(msg, stderr); }
int yylex() { char c=getchar(); return (c=='\n')?0:isdigit(c)?NUM:c; }

// 괄호 깊이 구하는 yacc 예제 일부 Parenthesis depth
%%
Line : S { printf("max depth = %d \n", $1); }
;
S : '(' S ')' S { $$ = max($2 + 1, $4); }
| { $$ = 0; }
;
%%

S -> ID = E;
E -> E + T 
  | T;
T -> T * F
  | F;
F -> ID | NUM | (E);

S => ID = E;
  => ID = E + T;
  => ID = T + T;
  => ID = F + T;
  => ID = ID + T;
  => ID = ID + F;
  => ID = ID + (E);
  => ID = ID + (T);
  => ID = ID + (T * F);
  => ID = ID + (F * F);
  => ID = ID + (ID * F);
  => ID = ID + (ID * NUM);

S
├─ ID("sum")
├─ '='
├─ E
│  ├─ E
│  │  └─ T
│  │     └─ F
│  │        └─ ID("sum")
│  ├─ '+'
│  └─ T
│     └─ F
│        ├─ '('
│        ├─ E
│        │  └─ T
│        │     ├─ T
│        │     │  └─ F
│        │     │     └─ ID("a")
│        │     ├─ '*'
│        │     └─ F
│        │        └─ NUM("2")
│        └─ ')'
└─ ';'

sum = sum + (a * 2);
 
        =
       / \
    sum   +
         / \
      sum   *
           / \
          a   2

typedef struct _Node{
    NKind Kind; // 노드 종류 태그
    union {} val; // 노드 값 
    struct _node *bro, *son; // son은 자신 노드에 사용되는 operand들 bro는 자신의 윗 노드가 연산에 사용하는 operand
} *Tree;

// sum = sum + (a * 2);
-----
| = |
-----
  |
-------     -----
| sum |  -  | + |   
-------     -----
              |
            -------   -------
            | sum | - |  *  |
            -------   ------- 
                         |
                       -----     -------
                       | a |  -  |  2  |
                       -----     -------

// sum = sum + (a * 2);
(= . (sum . ((+ . (sum . ((* . (a . (2 . nil))) . nil))) . nil)))
=> 보기 편하게 하면
=> (= . (sum . (addNode . nil)))  sum은 첫 번째 피연산자, addNode는 두 번째 피연산자
addNode => (+ . (sum . (mulNode . nil)))  sum은 첫 번째 피연산자 mulNode는 두 번째 피연산자
mulNode => (* . (a . (2 . nil)))
// 트리 시각화
                           .
                         /   \
                        =     .
                             / \
                          sum   .
                               / \
                              .   nil
                            /   \
                           +     .
                                / \
                            sum    .
                                  / \
                                .   nil
                               / \
                              *   .
                                 / \
                                a   .
                                   / \
                                  2   nil
// 다른 시각화
.   -   .   -   .   -   nil
=       sum     |
                .   -   .   -   .   -   nil
                +       sum     |
                                .   -   .   -   .   -   nil
                                *       a       2                       

cursor(iterator)
tier system
conn, statement, Drivermanager, execQuery, getRsultSet(), result.next(), result.getstring(colname | colIndex), 
first, last, next, previous, absolute, // result(cursor, iterator) 탐색
prepare statement // 미리 SQL 작성해두고 내부에 ? 박아두고서 사용할 때 포맷
 
 
// 인덱스 구조 - 보통 B+ 트리
// 클러스티드 - B+ 트리 리프노드가 시퀀셜하게 배열 리스트로 돼 있음 -> 인덱스 기반으로 범위기반 접근이 빨라짐 
// 논클러스티드 - 트리 분류에 의해 범위기반으로 접근 자체는 되는데 마지막 리프노드 접근할 때 메모리를 띄엄띄엄 접근하게 됨 
 
// ER 모델