지나간 삶

=> nvl함수는 해당값이 null 이면 지정된 값을 리턴해주는 역할을 한다.
- emp 테이블에서 comm 이 0 또는 null 인 값을 출력하는데 null 인값은 0으로 출력해보자...
SELECT ename, nvl(comm,0) comm
FROM emp
 WHERE comm = 0 or comm is null;

=> 그룹을 지정하기 전에 조건을 줄수 있는 것은 Where에 조건을 명시해주게 된다.
=> 그룹을 한 후에 조건을 줄려면 HAVING에서 조건을 명시해 준다.
- 10번 20번 부서에 속한 사원들 대상으로 직종별 급여합이 5000이상인 직종에 대해 직종별 평균급여..
SELECT job, AVG(sal) PAYROLL
FROM emp
WHERE deptno IN(10, 20)
GROUP BY job
HAVING SUM(sal) > 5000
ORDER BY AVG(sal);

- 부서별로 2명 이상 근무하고 있는 직종 만을 출력하시오.
SELECT dept_id, title
FROM s_emp
GROUP BY dept_id, title
HAVING COUNT(*) > 1;

=> 서로 다른 테이블의 조인과 그룹화를 통한 정보 보여주기
- 'MANAGER' 직종에 속한 사원들의
부서별 급여합이 2500 이상인 부서의 부서번호, 부서별 평균 급여, 부서 이름 
SELECT   d.deptno, avg(e.sal) , d.dname  
FROM      emp e, dept d
WHERE    e.deptno = d.deptno and e.job='MANAGER'
GROUP BY d.deptno, d.dname 
HAVING      sum(sal) >= 2500;

=>Subquery 를 사용한 Nested, Inline View
- 직종별로 제일 적은 봉급을 받는 사람의 이름 표시

1) 각 정보를 비교하면서 출력하므로 성능이 떨어짐
SELECT  job, ename, sal
FROM  emp
WHERE (job, sal) in ( select job, min(sal)
                              from emp
                              group by job);

2) 새로운 테이블을 생성하여 거기서 부터 정보를 얻어온다.
SELECT  e.job, e.ename, e.sal
FROM emp e, (select job, min(sal) msal
                    from emp
                    group by job) g
WHERE e.job = g.job  and    e.sal = g.msal;
 

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
#include <shlobj.h>

// 바로가기 만들기
int main()
{
    CoInitialize( 0 );

    // 원하는 COM객체를 생성한다.
    // 클래스 팩토리가 없을때 사용한다.
    IShellLink* pLink;
    HRESULT ret = CoCreateInstance(
        CLSID_ShellLink,        // CLS ID
        0,                        // 포함(사용안함)
        CLSCTX_INPROC_SERVER,    // DLL에 있는 COM
        IID_IShellLink,            // 인터페이스 ID
        reinterpret_cast<void**>(&pLink) );

    if( FAILED( ret ) )
    {
        printf( "실패\n" );
        CoUninitialize();

        return 0;
    }
    //--------------------------------------------------------
    pLink->SetPath(_T("C:\\windows\\system32\\calc.exe"));    // 단축아이콘을 만들 화일
    pLink->SetDescription( _T("Calc Application") );        // 설명

    // IPersistFile 인터페이스가 필요하다.
    IPersistFile* pFile;
    ret = pLink->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&pFile) );

    if( FAILED( ret ) )
    {
        printf( "실패\n" );
        pLink->Release();
        CoUninitialize();

        return 0;
    }

    pFile->Save( _T("C:\\aaa.lnk"), FALSE );
   
    //--------------------------------------------------
    pLink->Release();
    pFile->Release();


    CoUninitialize();
}

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
#include <shlobj.h>

// Taskbar제어
// 1. SHAppBarMessage()    태스크바의 위치,크기
// 2. ITaskbarList        인터페이스

int main()
{
    CoInitialize( 0 );

    // TaskbarList 객체를 생성한다.
    ITaskbarList* pList;

    HRESULT ret = CoCreateInstance( CLSID_TaskbarList, 0, CLSCTX_INPROC_SERVER,
        IID_ITaskbarList, (void**)&pList );

    if( SUCCEEDED( ret ) )
    {
        printf( "성공\n" );

        HWND hwnd = FindWindow( 0, _T("계산기") );

        pList->DeleteTab( hwnd );

        getch();

        pList->Release();
    }
       
    CoUninitialize();
}

#include <stdio.h>
#include <stdlib.h>

typedef struct rb_node
{
        struct rb_node *rb_parent;
        int rb_color;
#define RB_RED          0
#define RB_BLACK        1
        struct rb_node *rb_right;
        struct rb_node *rb_left;
}rb_node_t;

typedef struct rb_root
{
        struct rb_node *rb_node;
}rb_root_t;

typedef struct
{
    int age;
    struct rb_node tree;
} AGE;

#define rb_entry(ptr, type, member)              \
  ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

void rb_link_node(struct rb_node * node,
                  struct rb_node * parent,  
                  struct rb_node ** rb_link);
AGE * rb_insert_age(struct rb_root * root,
                            int age,
                            rb_node_t * node);
void in_order( rb_node_t * p );
void __rb_rotate_left(rb_node_t * node, rb_root_t * root);
void __rb_rotate_right(rb_node_t * node, rb_root_t * root);
void rb_insert_color(rb_node_t * node, rb_root_t * root);
void display(struct rb_node  *p);
void rb_erase(rb_node_t * node, rb_root_t * root);
void __rb_erase_color(rb_node_t * node, rb_node_t * parent,
                             rb_root_t * root);

void rb_delete(  int age, struct rb_root *root);
int main()
{
    struct rb_root root={0};
    int i;

    AGE a[10];

    for(i=0; i<10; i++)
    {
        a[i].age = (i+1)*10;
        rb_insert_age( &root, a[i].age , &a[i].tree );
       
    display(root.rb_node);
    getchar();
    system("cls");
    }


    display(root.rb_node);
    getchar();
    system("cls");
    rb_delete(60 , &root);

    display(root.rb_node);
    //in_order( root.rb_node );
    return 0;
}

void rb_delete(  int age, struct rb_root *root){
        struct rb_node ** p = &root->rb_node;
        struct rb_node * parent = NULL;
        AGE *temp;

        while (*p) {
                parent = *p;
                temp = rb_entry(parent, AGE, tree);
                if ( age < temp->age )
                        p = &(*p)->rb_left;
                else if (age > temp->age )
                        p = &(*p)->rb_right;
                else
                        break;
        }
        if(!*p)  return;
       
        rb_erase( *p, root );
}





void display(struct rb_node  *p)
{
    int i;
    static int x = 0;
   
    if (p)
    {
        x += 2;
        display(p->rb_right);
        for (i = 2; i < x; i++)
            printf("   ");

        if( p->rb_color == 1 )
            printf("[%2d]\n", rb_entry(p, AGE, tree)->age);
        else
            printf("<%2d>\n", rb_entry(p, AGE, tree)->age);

        display(p->rb_left);
        x -= 2;
    }
}



void rb_link_node(struct rb_node * node,
                  struct rb_node * parent,  
                  struct rb_node ** rb_link)
{
    node->rb_parent = parent;
    node->rb_color = RB_RED;
    node->rb_left = node->rb_right = NULL;
   
    *rb_link = node;
}



AGE * rb_insert_age(struct rb_root * root,
                            int age,
                            rb_node_t * node)
{
    rb_node_t ** p = &root->rb_node;
    rb_node_t * parent = NULL;
    AGE *a;
   
    while (*p)
    {
        parent = *p;
        a = rb_entry(parent, AGE, tree);
       
        if (age < a->age)
            p = &(*p)->rb_left;
        else if (age > a->age)
            p = &(*p)->rb_right;
        else
            return 0;
    }
   
    rb_link_node(node, parent, p);
    rb_insert_color(node, root);
    return NULL;
}




//  root  ->   [ 25 ]


void in_order( rb_node_t * p )
{
    if(p==0) return;

    in_order( p->rb_left );
    printf("[%d]\n",rb_entry(p, AGE, tree)->age);
    in_order( p->rb_right );
}

void __rb_rotate_left(rb_node_t * node, rb_root_t * root)
{
    rb_node_t * right = node->rb_right;
   
    if ((node->rb_right = right->rb_left))
        right->rb_left->rb_parent = node;
    right->rb_left = node;
   
    if ((right->rb_parent = node->rb_parent))
    {
        if (node == node->rb_parent->rb_left)
            node->rb_parent->rb_left = right;
        else
            node->rb_parent->rb_right = right;
    }
    else
        root->rb_node = right;
    node->rb_parent = right;
}




void rb_insert_color(rb_node_t * node, rb_root_t * root)
{
    rb_node_t * parent, * gparent;
   
    while ((parent = node->rb_parent) && parent->rb_color == RB_RED)
    {
        gparent = parent->rb_parent;
       
        if (parent == gparent->rb_left)
        {
            {
                register rb_node_t * uncle = gparent->rb_right;
                if (uncle && uncle->rb_color == RB_RED)
                {
                    uncle->rb_color = RB_BLACK;
                    parent->rb_color = RB_BLACK;
                    gparent->rb_color = RB_RED;
                    node = gparent;
                    continue;
                }
            }
           
            if (parent->rb_right == node)
            {
                register rb_node_t * tmp;
                __rb_rotate_left(parent, root);
                tmp = parent;
                parent = node;
                node = tmp;
            }
           
            parent->rb_color = RB_BLACK;
            gparent->rb_color = RB_RED;
            __rb_rotate_right(gparent, root);
        } else {
            {
                register rb_node_t * uncle = gparent->rb_left;
                if (uncle && uncle->rb_color == RB_RED)
                {
                    uncle->rb_color = RB_BLACK;
                    parent->rb_color = RB_BLACK;
                    gparent->rb_color = RB_RED;
                    node = gparent;
                    continue;
                }
            }
           
            if (parent->rb_left == node)
            {
                register rb_node_t * tmp;
                __rb_rotate_right(parent, root);
                tmp = parent;
                parent = node;
                node = tmp;
            }
           
            parent->rb_color = RB_BLACK;
            gparent->rb_color = RB_RED;
            __rb_rotate_left(gparent, root);
        }
    }
   
    root->rb_node->rb_color = RB_BLACK;
}

void __rb_rotate_right(rb_node_t * node, rb_root_t * root)
{
    rb_node_t * left = node->rb_left;
   
    if ((node->rb_left = left->rb_right))
        left->rb_right->rb_parent = node;
    left->rb_right = node;
   
    if ((left->rb_parent = node->rb_parent))
    {
        if (node == node->rb_parent->rb_right)
            node->rb_parent->rb_right = left;
        else
            node->rb_parent->rb_left = left;
    }
    else
        root->rb_node = left;
    node->rb_parent = left;
}

void __rb_erase_color(rb_node_t * node, rb_node_t * parent,
                             rb_root_t * root)
{
    rb_node_t * other;
   
    while ((!node || node->rb_color == RB_BLACK) && node != root->rb_node)
    {
        if (parent->rb_left == node)
        {
            other = parent->rb_right;
            if (other->rb_color == RB_RED)
            {
                other->rb_color = RB_BLACK;
                parent->rb_color = RB_RED;
                __rb_rotate_left(parent, root);
                other = parent->rb_right;
            }
            if ((!other->rb_left ||
                other->rb_left->rb_color == RB_BLACK)
                && (!other->rb_right ||
                other->rb_right->rb_color == RB_BLACK))
            {
                other->rb_color = RB_RED;
                node = parent;
                parent = node->rb_parent;
            }
            else
            {
                if (!other->rb_right ||
                    other->rb_right->rb_color == RB_BLACK)
                {
                    register rb_node_t * o_left;
                    if ((o_left = other->rb_left))
                        o_left->rb_color = RB_BLACK;
                    other->rb_color = RB_RED;
                    __rb_rotate_right(other, root);
                    other = parent->rb_right;
                }
                other->rb_color = parent->rb_color;
                parent->rb_color = RB_BLACK;
                if (other->rb_right)
                    other->rb_right->rb_color = RB_BLACK;
                __rb_rotate_left(parent, root);
                node = root->rb_node;
                break;
            }
        }
        else
        {
            other = parent->rb_left;
            if (other->rb_color == RB_RED)
            {
                other->rb_color = RB_BLACK;
                parent->rb_color = RB_RED;
                __rb_rotate_right(parent, root);
                other = parent->rb_left;
            }
            if ((!other->rb_left ||
                other->rb_left->rb_color == RB_BLACK)
                && (!other->rb_right ||
                other->rb_right->rb_color == RB_BLACK))
            {
                other->rb_color = RB_RED;
                node = parent;
                parent = node->rb_parent;
            }
            else
            {
                if (!other->rb_left ||
                    other->rb_left->rb_color == RB_BLACK)
                {
                    register rb_node_t * o_right;
                    if ((o_right = other->rb_right))
                        o_right->rb_color = RB_BLACK;
                    other->rb_color = RB_RED;
                    __rb_rotate_left(other, root);
                    other = parent->rb_left;
                }
                other->rb_color = parent->rb_color;
                parent->rb_color = RB_BLACK;
                if (other->rb_left)
                    other->rb_left->rb_color = RB_BLACK;
                __rb_rotate_right(parent, root);
                node = root->rb_node;
                break;
            }
        }
    }
    if (node)
        node->rb_color = RB_BLACK;
}

void rb_erase(rb_node_t * node, rb_root_t * root)
{
    rb_node_t * child, * parent;
    int color;
   
    if (!node->rb_left)
        child = node->rb_right;
    else if (!node->rb_right)
        child = node->rb_left;
    else
    {
        rb_node_t * old = node, * left;
       
        node = node->rb_right;
        while ((left = node->rb_left))
            node = left;
        child = node->rb_right;
        parent = node->rb_parent;
        color = node->rb_color;
       
        if (child)
            child->rb_parent = parent;
        if (parent)
        {
            if (parent->rb_left == node)
                parent->rb_left = child;
            else
                parent->rb_right = child;
        }
        else
            root->rb_node = child;
       
        if (node->rb_parent == old)
            parent = node;
        node->rb_parent = old->rb_parent;
        node->rb_color = old->rb_color;
        node->rb_right = old->rb_right;
        node->rb_left = old->rb_left;
       
        if (old->rb_parent)
        {
            if (old->rb_parent->rb_left == old)
                old->rb_parent->rb_left = node;
            else
                old->rb_parent->rb_right = node;
        } else
            root->rb_node = node;
       
        old->rb_left->rb_parent = node;
        if (old->rb_right)
            old->rb_right->rb_parent = node;
        goto color;
    }
   
    parent = node->rb_parent;
    color = node->rb_color;
   
    if (child)
        child->rb_parent = parent;
    if (parent)
    {
        if (parent->rb_left == node)
            parent->rb_left = child;
        else
            parent->rb_right = child;
    }
    else
        root->rb_node = child;
   
color:
    if (color == RB_BLACK)
        __rb_erase_color(child, parent, root);
}