Post

반응형

MSSQL 기초 정리

mssql 책 보고 중요한 부분 정리한 것.


1. 기본적인 T-SQL 구문

  1) SELECT : 테이블 데이터 조회 할 때 사용

  2) WHERE : 조건을 줘서 결과를 조회.

  3) BETWEEN , AND : ~사이에 조건문.

      ex) Select Name, height From UserTb1 Where height Betwwen 180 AND 183

  

  4) ANY, ALL, SOME, 하위쿼리

     하위쿼리 ? 쿼리문안에 쿼리문이 들어있는 것

     ANY : 하위쿼리의 결과 중 하나만 만족시키면 됨.

     ALL : 하위쿼리의 결과를 모두 만족시켜야 함.

     SOME == ANY 동일한 의미


   5) ORDER BY 절 : 결과물의 출력순서

       오름차순 : ASCENDING            내림차순 : DESCENDING


   6) 중복된 데이터 한건만 보여준다.

       DISTINCT     ex) SELECT DISTINCT addr FROM userTb1


   7) Having 절 : where 과 비슷한 개념. 조건을 제한하되 집계함수에 대해서 제한

 

   8) JOIN : 두 개 이상의 테이블을 서로 묶어서 하나의 결과집합으로 만들어내는 것을 의미

      InnerJoin : 조건에 맞는 두개의 테이블 정보를 묶어서 보여줌

      ex ) SELECT <열목록>

            FROM <첫번째 테이블>

            INNER JOIN <두번째 테이블>

            ON <조인될 조건>

            WHERE <검색 조건>


      OuterJoin : 조건에 맞는 두개의 테이블 정보를 보여주는데, 없는 데이터를 NULL로 표시해서 보여줌(InnerJoin과 차이점)

      ex) SELECT <열목록>

           FROM <첫번째 테이블>

           ON <조인될 조건>

           WHERE <검색조건>


      CROSS JOIN : 모든 행을 조인시키는 기능

      SELF JOIN : 자체조인, 자기 자신과 조인 시킨다.


   2. 데이터베이스 생성과 관리

     1) mdf, ndf : 뎅터파일, 실제 데잍와 그행들이 저장됨

        ldf : 트랜잭션 로그파일

   

     2) SQL 작동 방식

        1. 사용자가 조회  OR 변경을 한다.

        2. 실제데이터

        3. 트랜잭션 로그로 남긴다.

        4. 결과를 사용자에게 보여준다.


     3) 데이터 파일

        데이터 파일(mdf or ndf) : 데이터가 순차적으로 저장되는 것x

        트랜잭션 로그파일(ldf) : 데이터가 순차적으로 저장됨.


     * SELECT addr FROM userTb1 =>실행결과

       1. 사용자는 1번처럼 논리적인 데이터베이스에 저장된 데이터를 조회

       2. 내부적으로 2번처럼 데이터 파일을 검색

       3. 4번 조회결과 응답

       select는 조회 결과가 남지 않는다.


     * Update userTb1 SET addr = '서울' where userid = 'js'

      1. 로그를 먼저 실행, 그리고 물리적인 데이터 변경

      로그파일 기록 이유 => 데이터 무결성 (성능이 감소하더라도)


    4) 트랜잭션의 개념과 작동원리

        트랜잭션 ? 하나의 논리적인 작업 단위로 수행되는 인력의 작업

        Update는 트랜잭션을 각각 하나씩 발생시킴

        Update를 세번 사용하면 3번 트랜잭션

        본래 자동 커밋모드이므로 묶어줘야 함


     5) Begin Tran 실행

        Begin Tran ~ Commit Tran

     

     6) 컴퓨터가 정전되었다면? 데이터가 일부로그에 남겨져 있다면 롤백. 다 있다면 작업 수행


     7) 시스템 데이터베이스와 예제 데이터베이스

        master DB : 가장 중요한 데이터베이스, 문제가 생긴다면 Server구동이 안될 수도 있다. 디스크 공간. 시스템 구성 설정 게정 정보 등이 있다.

        model DB : 사용자 DB 생성 시 기본 틀

        MS DB : 예약된 작업(백업, 복제) 등을 함

        tempDB : 임시 데이터베이스(내용이 시작할 때마다 사라짐)


     8) 데이터베이스 구조

        최소 다음 2개의 파일이 필요.

        주 데이터베이스 : 확장명 *.mdf 실제 데이터가 저장되는 곳

        트랜잭션 로그파일 : 확장명 .ldf , 복구에 사용

  

    9) 파일 그룹의 개념 : 물리적으로 독립되어야 의미가 있다. 같은 하드디스크에서 읽고 쓰면 느려진다.

  


 



반응형

Post

반응형

IOCP 소켓 종료 상황


소켓이 CloseSocket으로 안전하게 끊어졌는지, 아닌지에 따라

정상종료. 비정상종료로 나눌 수 있다.


정상종료는 GetQueuedCompletionStatus 완료된 바이트 수가 0일 때..


비정상 종료는 GetQueuedCompletionStatus 함수의 리턴값이 0이고 WSAGetLastError값이 64 이다.

그리고 IO도 NULL이 아니다.


나는 이렇게 사용하였다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    
            int err = WSAGetLastError();
            if(NULL == userInfo)
            {
                PrintColor(YELLOW, "userInfo는 NULL! h \n");
            }
            else if((!result && WSAGetLastError() == 64)&& ioInfo != NULL// 비정상 종료
            {
                printf("bytesTrans가 0이라 종료합니다 ID:%d \n", userInfo->id);
                closesocket(sock);
                int id = userInfo->id;
                EnterCriticalSection(&cs);
                UserList.RemoveKey(userInfo->id);
                SAFE_DELETE(userInfo);
                SAFE_DELETE(ioInfo);
                LeaveCriticalSection(&cs);
        
                printf("접속자 %d가 나갔습니다. \n", id);
                PrintColor(YELLOW, "접속자 나갔습니다. \n");
                continue;
            }
            else if(!bytesTrans)
            {
                PrintColor(YELLOW, "정상적인 종료! \n");
            }
cs


반응형

Post

반응형

1. #include <crtdbg.h>를 한다.

2. 소스 코드 처음에 _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); 을 추가한다.

3. 만약 누수가 있다면


Detected memory leaks!
Dumping objects ->
{62} normal block at 0x00C34C50, 24 bytes long.
 Data: <                > 03 00 18 00 00 00 00 00 00 00 00 00 00 00 00 00 
Object dump complete.


이런식으로 나온다.


그리고 A부모 클래스가 있고 B자식 클래스가 있을 때

A* pB = new B()했을 경우

delete(pB)를 해도 메모리 누수가 되지 않는다.


반응형

Post

반응형

MSSQL JOIN 정리


조인이란 두개 이상의 테이블을 조건에 맞게 합쳐서 새로운 테이블을 보여주는 것이다.

여러가지 join 방법이 있겠지만 INNER JOIN과 OUTER JOIN만 정리하였다.



사용법

SELECT A별칭.<행1>, B별칭.<행2>... FROM A A별칭 INNER JOIN B B별칭 ON 조건 



일단 테이블은 CharacterLv, CharacterItem 테이블이 있다.



     



INNER JOIN이란?

보여주겠다고 한 행과, 조건에 알맞은 데이터가 있을 시에 포함되는 것 만 보여주는 것이다.

예를 들어


1
2
3
4
5
6
7
8
USE ExEx
SELECT chLv.CharacterIndex,chLv.Lv,
 chItem.ItemIndex, chItem.ItemCount
FROM CharacterLv ChLv
    INNER JOIN
    CharacterItem ChItem
    ON ChLv.CharacterIndex = ChItem.CharacterIndex
 
cs


CharacterIndex, Lv, ItemIndex, ItemCount 행을 보여주면서 조건에 맞는 값만 보여줍니다.

마치 AND 같습니다.

(조건 값<CharacterIndex>이 맞다면 여러개 보여질 수 있습니다.)



<INNER JOIN 결과>


LEFT OUTER JOIN 이란?


LEFT OUTER JOIN 은 조건에 맞는 값만 보여주지만 조왼쪽에 있는 테이블은 전부 보여줍니다.

이 때 오른쪽 테이블에 해당하는 값이 없다면 null로 표기해줍니다.

그래서 어떤 테이블을 왼쪽에 놓는냐에 따라서 결과 값이 다릅니다.


<LEFT OUTER JOIN 결과>



위와 달리 CharacterItem 테이블을 왼쪽에 놓았을 경우.

CharacterItem 테이블 값이 전부 나옵니다.






반응형

'이전게시판 > MySQL MSSQL' 카테고리의 다른 글

MSSQL MYSQL 차이  (0) 2016.05.11
MSSQL 뷰, 인덱션, 트랜잭션, 저장 프로시저 정리  (0) 2016.05.11
MSSQL 기초 정리  (0) 2016.05.10

Post

반응형

옛날부터 다중상속을 하면 어떻게 되는지 헷갈렸다.

그래서 A, B를 동시에 상속받은 C가 Func를 호출하게 했다.

Func함수는 A, B 클래스에 동시에 있으므로

결론은 error C2385: 'Func' 액세스가 모호합니다.' 가 뜬다.

호출하려면 어떤 클래스인지 명확하게 지정해주고 사용한다.

그러므로 C클래스 안에서 Print 함수를 만들어서 부모를 지정해준 뒤 함수를 호출하면 된다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
#include <windows.h>
 
class A
{
public:
    int a;
    int b;
    A()
    {
        a = 100;
        b = 101;
    }
    
    void Func()
    {
        printf("A입니다 \n");
    }
};
 
class B
{
    
public:
    int a;
    int b;
    B()
    {
        a = 200;
        b = 201;
    }
    void Func()
    {
        printf("B입니다 \n");
    }
};
 
class C : public A, public B
{
public:
 
};
 
void main()
{
    C c;
    printf("%d %b \n", c.a(), c.b);
    getchar();
}
cs


반응형

Post

반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <stdio.h>
#include <windows.h>
#include <process.h>
 
#define NUM_THREAD 50
unsigned WINAPI threadInc(void* arg);
unsigned WINAPI threadDes(void* arg);
 
long long num = 0;
CRITICAL_SECTION cs;
 
int main(int argc, char* argv[])
{
    HANDLE tHandles[NUM_THREAD];
    int i = 0;
 
    InitializeCriticalSection(&cs);
    
    for(int j = 0; j < 2++j)
    {
        tHandles[i] = (HANDLE)_beginthreadex(NULL0, threadInc, NULL0NULL);
        ++i;
    }
    DWORD returnMessage = WaitForMultipleObjects(2, tHandles, TRUE, INFINITE);
    DeleteCriticalSection(&cs);
    printf("result:%d \n", num);
    return 0;
}
 
unsigned WINAPI threadInc(void* arg)
{
    int i;
    EnterCriticalSection(&cs);
    for(i = 0; i<1000++i)
    {
        num+=1;
        printf("num:%d i:%d \n", num, i); 
    }
    //LeaveCriticalSection(&cs);
    return 0;
}
 
unsigned WINAPI threadDes(void* arg)
{
    int i;
    EnterCriticalSection(&cs);
    for(i = 0; i<1000000++i)
        num-=1;
    //LeaveCriticalSection(&cs);
    return 0;
}
cs


윤성우의 TCP/IP책으로 공부를 하고 있다.

데드락에 대한 예제를 찾기가 어려웠다.

예전에는 데드락이 의도치 않게 잘 일어났었는데... 지금은 잘안됨 ㅋㅋ

일단 허접하게 LeaveCriticalSection을주석처리해서 다른 쓰레드가 접근하지 못하게 했다. 


내가 이해안가던게, 크리티컬 섹션에 접근을 못하는 건지, 해당 변수에 접근을 못해서

데드락이 걸리는건지 헷갈렸는데..

크리티컬 섹션을 꼼꼼히 안해주면 크리티컬 섹션 효과를 못보니까 크리티컬 섹션에 접근을 못해서 문제인 듯.



반응형

'이전게시판 > C, C++' 카테고리의 다른 글

C++ 11 람다식(Lamda)이란 - 1  (0) 2016.06.19
IOCP 소켓 종료 상황  (0) 2016.04.21
CRT 메모리 누수 체크  (0) 2016.04.15
C++ 다중상속 문제점?  (0) 2016.04.04
2의 보수 만드는 법  (0) 2016.04.01
구조체 패딩이란?  (0) 2016.03.31
C++ 스택(Stack) 예제  (0) 2016.03.20
C++ 간단한 원형 큐  (0) 2016.03.20

Post

반응형

2의 보수로 나타내는 법..

양수는 쉬운데 음수는 좀 어렵다.

4는 그대로 0000 0100 이다.

오른쪽부터 차례대로 1, 2, 4, 8, 16, 32..... 이렇게 나아간다.


만약 -4라면

1) 4 0000 0100 에서 반전 시킨다 -> 1111 1011

2) 1을 더해준다 -> 1111 1100

-4의 2의 보수(음수) 표현은 1111 1100 가 된다.



반응형

'이전게시판 > C, C++' 카테고리의 다른 글

IOCP 소켓 종료 상황  (0) 2016.04.21
CRT 메모리 누수 체크  (0) 2016.04.15
C++ 다중상속 문제점?  (0) 2016.04.04
C++ 데드락(DeadLock)  (0) 2016.04.04
구조체 패딩이란?  (0) 2016.03.31
C++ 스택(Stack) 예제  (0) 2016.03.20
C++ 간단한 원형 큐  (0) 2016.03.20
c++ 링크드리스트 만들기  (0) 2016.03.19

Post

반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
using namespace std;
 
struct Player
{
    char name;
    int level;
    short wClass;
};
 
#pragma pack(1)
struct Player2
{
    char name;
    int level;
    short wClass;
};
 
void main()
{
    Player player;
    Player2 player2;
 
    printf("name:%d level:%d class:%d AllSize:%d \n"sizeof(player.name),
        sizeof(player.level), sizeof(player.wClass), sizeof(player));
 
    printf("name:%d level:%d class:%d AllSize:%d \n"sizeof(player2.name),
        sizeof(player2.level), sizeof(player2.wClass), sizeof(player2));
 
    getchar();
}
cs

구조체 패딩은....
32비트 운영체제일 때는 4byte, 64비트 운영체제일 때는 8byte를 읽어온다.
그래서 빈공간이 있을 땐 딱 4byte, 8byte에 맞아 떨어지도록 구조체 패딩을한다.
그래서 Player의 사이즈는 7이 아니라 12이다. char도 4byte로 wClass도 4byte로 치환한다.
이것을 방지하기 위해선 pragma pack을 사용해 Player2 클래스처럼 만들어주면 된다.


반응형

'이전게시판 > C, C++' 카테고리의 다른 글

CRT 메모리 누수 체크  (0) 2016.04.15
C++ 다중상속 문제점?  (0) 2016.04.04
C++ 데드락(DeadLock)  (0) 2016.04.04
2의 보수 만드는 법  (0) 2016.04.01
C++ 스택(Stack) 예제  (0) 2016.03.20
C++ 간단한 원형 큐  (0) 2016.03.20
c++ 링크드리스트 만들기  (0) 2016.03.19
C++ 문자열 뒤집기, 한글 뒤집기  (0) 2016.03.18

Post

반응형

간단하게 C++ 스택 예제를 만들어보았습니다.

Stack은 먼저 들어온 애가 나중에 나가는 자료구조입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <iostream>
using namespace std;
 
#define MAX_STACK_COUNT 5
 
class Stack
{
    int m_StackData[MAX_STACK_COUNT];
    int m_Top;
public:
    Stack()
    {
        memset(m_StackData, 0sizeof(m_StackData));
        m_Top = 0;
    }
    
    bool Push(int value)
    {
        if(isPull())
            return false;
 
        m_StackData[m_Top] = value;
        ++m_Top;
 
        return true;
    }
    
    bool Pop(int& value)
    {
        if(isEmpty())
            return false;
        
        value = m_StackData[m_Top];
        m_StackData[m_Top] = 0;
        --m_Top;
 
        return true;
    }
    
    bool isEmpty()
    {
        if(0 == m_Top)
            return true;
        
        return false;
    }
 
    bool isPull()
    {
        if(MAX_STACK_COUNT == m_Top)
            return true;
        
        return false;
    }
 
    void Print()
    {
        if(isEmpty())
            return;
 
        for(int i = m_Top - 1; i >= 0--i)
        {
            cout<< m_StackData[i] << endl;    
        } 
    }
};
 
void main()
{
    int data = 0;
    Stack stackData;
    stackData.Push(1);
    stackData.Push(2);    
    stackData.Push(3);
    stackData.Pop(data);    
    stackData.Push(4);
    stackData.Push(5);
    stackData.Print();
    stackData.Push(6);
    stackData.Push(7);
    stackData.Print();
    getchar();
}
cs


반응형

Post

반응형

간단한 원형 큐를 만들어보았습니다.

빨리 간단하게 만든거라서 틀리거나 버그가 있을 수 있습니다.

추후에 수정하겠습니다.

제가 이해한대로 만든 거라서..

아무튼 이렇게 강제 공부를 하고 있네요 ㅋㅋㅋ

나름 장점이라면 장점인가 ㅋㅋ?


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
using namespace std;
 
#define MAX_QUEUE_COUNT 5
 
class CicleQueue
{
    int m_Queue[MAX_QUEUE_COUNT];
    int m_front;
    int m_end;
    int m_Count;
public:
    CicleQueue()
    {
        memset(m_Queue, 0sizeof(m_Queue));
        m_front        = 0;
        m_end        = 0;
        m_Count        = 0;
    }
 
    bool Push(int value)
    {
        if(isPull())
            return false;
 
        m_Queue[m_end] = value;
        m_end = (m_end+1) % MAX_QUEUE_COUNT;
        ++m_Count;
 
        if(MAX_QUEUE_COUNT == m_end)
            m_end = 0;
 
        return true;
    }
 
    int Pop()
    {
        int temp = m_Queue[m_front];
        m_Queue[m_front] = 0;
        
        m_front = (m_front + 1) % MAX_QUEUE_COUNT;
        --m_Count;
        return temp;
    }
 
    bool isPull()
    {
        if(m_Count == MAX_QUEUE_COUNT)
            return true;
        
        return false;
    }
 
    void Print()
    {
        if(m_end <= m_front)
        {
            for(int i = m_front, j = 0; j < MAX_QUEUE_COUNT; ++i, ++j)
            {
                cout<<m_Queue[i%MAX_QUEUE_COUNT]<<" ";
            }
        }
        else
        {
            for(int i = 0; i < MAX_QUEUE_COUNT; ++i)
                cout<< m_Queue[i]<<" ";
        }
 
        cout<<endl;
    }
};
 
void main()
{
    CicleQueue cicleQueue;
    cicleQueue.Push(1);
    cicleQueue.Push(2);
    cicleQueue.Push(3);
    cicleQueue.Print();
    cicleQueue.Pop();
    cicleQueue.Push(4);
    cicleQueue.Push(5);
    cicleQueue.Pop();
    cicleQueue.Print();
    cicleQueue.Push(6);
    cicleQueue.Push(7);
    cicleQueue.Print();
    cicleQueue.Push(8);    
    cicleQueue.Print();
}
cs


반응형
▲ top