gnuykob_sw

수업 출처) 숙명여자대학교 소프트웨어학부 수업 "자료구조", 유석종 교수님

1. Computer System

- 알고리즘 : 문제를 풀기 위한 명령어들의 모음 (데이터 처리 방법)

- 데이터 : 측정된 값들의 모음

- 자료구조 : 데이터를 효과적으로 저장, 관리, 처리하기 위한 구조체, 방법론

2. Algorithm

- 문제 해결에 필요한 명령어들의 집합

- 조건

    - input : 명시적 입력은 없어도 된다. (하지만, 묵시적 입력은 필요하다.)

    - output: 하나 이상의 출력이 필요하다.

    - definiteness 명확성 : 명령문은 모호하지 않고 명확해야 한다.

    - finiteness 유한성 : 명령어의 수는 유한해야 한다.

    - effectiveness 유효성 : 명령어는 실행 가능해야 한다.

- 표현 방법 : 수도코드, 자연어, flow chart, 프로그래밍 언어 ..

- 종류 : search, sort, compute, decision ..

- (ex) Prime Numbers

1) n이 소수인지 

int prime (int n)
{
    if (n < 2) return 0;
    for (i = 2; i < n; i++)
        if (n % i == 0) return 0;
        
    return 1;
}

2) 2와 n 사이의 모든 소수

int prime2 (int n)
{
    if (n < 2) return 0;
    
    for (i = 2; i < n; i++) {
        prime = 1;
        for (j = 2; j < i; j++) {
            if (i % j == 0) {
                prime = 0;
                break;
            }
        }
        if (prime) printf("%d", i);
    }
}

3. Huffman Coding Tree

- 빈도수에 따른 문자 압축 (요약) 방법

- (ex) "time and tide wait for no man"

- 방법

빈도수 순서로 문자들을 나열하고 빈도수의 합이 증가되는 방향으로 계속 더한다. 

더할 땐 값이 같거나 작은 것과 더한다.

각각의 연결 선에 0과 1의 label을 붙여준다. 왼쪽이 0, 오른쪽이 1이다.

가장 위에서부터 각각의 문자까지 내려오면서 label을 읽는다.

예를 들어 e는 29 - 17 - 7- 4- 2 순서대로 내려오기 때문에 0011 의 값을 갖는다.

10101010110 을 읽으면 101 / 0101 / 0110 → not 이 된다.

각 문자가 갖는 이진수 값을 '허프만 코드' 라고 부른다.

허프만 코딩 방법으로 저장한 문자의 저장 공간은 Sum(Freq * bits) 비트가 필요하다.

원래 문자를 저장할 때 필요한 공간은 '문자 수 x 비트(8)' 인데, 허프만 코드를 이용하면 데이터의 비트 수가 줄어들기 때문에 공간 복잡도를 57%나 낮출 수 있다. 

4. System Life Cycle

: Requirement → Analysis → Design → Inplementation → Verification → Release (+ improve)

4-1. Requirement

- 프로젝트의 목표를 정의하는 일련의 설계 명세서

- functions, platforms, input, output, constraints, users 등을 정의한다.

- (ex) Reservation system (flight ticket), Billing system (mobile phone, utility), Recruitment agency

4-2. Analysis

- 프로젝트를 여러개의 작은 서브 모듈로 세분화하는 전략이다.

- (ex) ticket reservation system → clients, contents, payment .. 

- top-down approach :  주 목표에서 구성 요소까지 계층을 만든다.

    - program → subroutines → instructions

    - 가장 많이 쓰는 방식이다.

- bottom-up approach : 구성요소들로부터 전체 시스템을 구성하는 방식이다.

4-3. Design

- 각 모듈에 대한 객체와 함수들을 정의한다.

- (ex) clinets → sign up/in, history, contents

4-4. Implementation

- 객체와 알고리즘에 대한 실행 가능한 코드를 작성한다.

- 플랫폼 : Web, Mobile App, Package, Embedded

4-5. Verification

- 알고리즘의 정확성 증명

- testing

    - black box test : 오직 input과 output 으로만 테스트

    - white box test : black box test + 내부 코드까지 확인

- Debugging

5. Data types

- 객체와 그 객체에 작용하는 관련된 연산자들의 모음

- (ex) Integer data type 

    - objects : {INT_MIN, ..., -2, -1, 0, 1, 2, ... INT_MAX}

    - operations : {+, -, *, /, %, ...}

        - INT MAX (4bytes) = 2^31 - 1 = 2,147,483,647

-Built-in data types

    - Basic type : char, int, float

    - Composite type : array, structure

    - Pointer type

    - User-defined data type : object type

    - sizeof() 함수로 크기 알 수 있다.

- (ex) Factorial

#include <stdio.h>
void factorial (int n);

void main() 
{
    factorial(20);
}

void factorial (int n);
{
    int i, j;
    int total;
    
    for(i = 2; i <= n; i++) {
        total = 1;
        for (j = 2; j <= i; j++) {
            total = total * j;
        }
        printf("%d! = %d\n", i, total);
    }
}

이 코드를 실행하면 12! 까지는 정확한 결과가 나오지만, 그 뒤로는 틀린 결과가 나온다. 

total 변수의 자료형인 intrk chleo 2,147,483,647까지만 저장 가능하기 때문이다. 

이러한 현상을 오버플로우라고 부르며, 더 큰 자료형을 사용함으로써 해결할 수 있다. 

6. Abstract Data Type 추상 자료형 (ADT)

- 사용자 정의 자료형이다. 

- 새로운 객체의 속성과 연산자를 정의한다.

- 공통적인 속성과 행동을 갖는 객체들을 자료형으로 정의 → 자료 추상화

- 명세부와 구현부로 이루어진다.

    - 명세부 : 객체를 자료형으로 정의 (객체의 속성 선언)

    - 구현부 : 객체에 적용 가능한 연산자 함수 정의

- 연산자

    - 생성자 : 새로운 객체 생성

    - 변형자 : 기존의 객체를 이용하여 새로운 객체 생성

    - 참조자 : 기존 객체의 속성값 참조

- 파이썬, C++, 자바에서 추상 자료형인 클래스 지원

- C는 지원하지 않는다.

- (ex) BankAccount 추상 자료형 수도코드

class BankAccount
{
    int account_id;
    int account_type;    // 0: checking, 1: saving
    char owner_name[20];
    float balance = 0;
    
    deposit(amount) {
        balance = balance + amount;
    }
    
    withdraw(amount) {
        balance = balance - amount;
    }
    
    init(name, type, money) {
        owner_name = name;
        account_type = type;
        deposit(money);
    }
}

BankAccount myaccount("Kim", 0, 10000);

- (ex) Natural number 추상 자료형

structure NaturalNum is

    Objects : an ordered subrange of integers [0, INT_MAX]
    
    Functions : for all x, y ∈ NaturalNum, TRUE, FLASE ∈ Boolean and 
                where +, -, <, = are integer operations
    
    NaturalNum Zero() ::= 0
    
    Boolean Is_Zero(x) ::= if (x) return FALSE else return TRUE
    
    NaturalNum add (x, y) ::= if((x + y) <= INT_MAX) return x + y else return INT_MAX
    
    NaturalNum Subtract(x, y) ::= if(x < y) return 0 else return x - y
    
    Boolean Equal(x, y) ::= if(x == y) return TRUE else return FALSE
    
    NaturalNum Successor(x) ::= if(x == INT_MAX) return x else return x + 1
    
end NaturalNum

www.acmicpc.net/problem/1259

문제

코드

#include <stdio.h>
#include <string.h>

int main() {
    char num[6];
    int len = 0;

    while(1) {
        scanf("%s", &num);

        if (num[0] == '0')
            break;

        if (strlen(num) == 1)
            printf("yes\n");
            len = 0;
            break;

        while (num[len] != '\0') {
            len = strlen(num);
            
            for (int i = 0; i < len/2 ; i++) {
                if (num[i] != num[len - 1 - i]) {
                    printf("no\n");
                    len = 0;
                    break;
                }
                    
                else {
                    if (num[i + 1] == num[len - i - 2]) {
                        printf("yes\n");
                        len = 0;
                        break;
                    }

                    else {
                        printf("no\n");
                        len = 0;
                        break;
                    }
                }
            break;
            }
        break;
        }
    }
    return 0;
}

1. SQL 파싱 (PARSING)

SQL 파싱은

1) SQL 문장에 문법적 오류가 없는지 검사 (Syntax 검사)

2) 의미상 오류가 없는지 검사 (Semantic 검사)

3) 사용자가 발생한 SQL과 그 실행계획시 라이브러리캐시(프로시저캐시)에 캐싱되어 있는지 확인

4) 캐싱되어 있다면 소프트파싱, 캐싱되어있지 않다면 하드파싱

으로 구성된다.

* 소프트파싱: SQL과 실행계획을 캐시에서 찾아 곧바로 실행단계로 넘어가는 경우

* 하드파싱: SQL과 실행계획을 캐시에서 찾지 못해 최적화 과정을 거치고나서 실행단계로 넘어가는 경우

* 라이브러리캐시는 해시구조로 엔진에서 관리된다. SQL마다 해시값에 따라 여러 해시 버킷으로 나뉘며 저장되고, SQL을 찾을 때는 SQL 문장을 해시 함수에 적용하여 반환되는 해시값을 이용해서 해시 버킷을 탐색한다.

2. 규칙기반 옵티마이저 (RBO)

실행계획을 정해진 룰에 따라 만든다.

룰은 데이터베이스 엔진마다 여러 가지가 있다.

예를 들어서 오라클의 RBO는 다음과 같다.

자세한 과정은 잘 모르겠지만, 크게 보면 엑세스를 할 때에 인덱스를 이용하느냐, 전체 테이블을 스캔하느냐 등으로 나눌 수 있다. 1번부터 순서대로 맞는 경우에 진행하며, 아래로 갈수록 data가 흐트러져서 저장되기 때문에 비용이 많이 든다.

그리고 요즘에는 대부분 RBO보다 CBO를 이용한다.

3. 비용기반 옵티마이저 (CBO)

비용을 기반으로 최적화를 수행하는 방식이다. 이때 비용이란 쿼리를 수행하는데 소요되는 일의 양 또는 시간 예상치이다.

딕셔너리에서 테이블과 인덱스를 통해 레코드 개수, 블록 개수, 평균 행 길이, 칼럼 값의 수, 칼럼 값 분포, 인덱스 높이, 클러스터링 팩터 등의 통계값을 기반으로 비용을 예측하는 방식이다. 이 예측된 비용에 따라 최적의 실행 계획을 도출한다. 최근에는 추가적으로 하드웨어적 특성을 반영한 시스템 통계정보 (CPU 속도, 디스크 I/O 속도 등)까지 이용한다.

4. SQL 실행계획

실행 계획은 SQL에서 요구한 사항을 처리하기 위한 절차와 방법을 의미한다. 즉, SQL을 어떤 순서로 어떻게 진행할 지 결정한다는 것이다.

실행 계획의 구성요소는 다음 다섯 가지가 있다.

• 조인 순서 (Join Order) : JOIN 수행에서 어떤 테이블이 먼저 조회되는가
• 조인 기법 (Join Method) : loop, merge, sorting 등
• 액세스 기법 (Access Method) : Index / Full table 등
• 최적화 정보 (Optimization Information) : 알고리즘
• 연산 (Operation) : 크다, 작다, 함수, MAX, MIN 등

5. INDEX

INDEX는 데이터베이스 분야에 있어서 테이블에 대한 동작의 속도를 높여주는 자료 구조이다.

CREATE INDEX IDX_### ON db, table (column);

ALTER TABLE db.table ADD INDEX IDX_###;

두 코드 모두 column에 대한 INDEX를 생성하는 코드이다.

ALTER TABLE db.table DROP INDEX IDX_###;

테이블에 있는 인덱스를 삭제하는 코드이다.

EXPLAIN SELECT * FROM db.table;

실행 계획을 확인하는 코드이다.

예제) 

DESC kaggle.titanic;

EXPLAIN SELECT * FROM kaggle.titanic WHERE `Age` = 23;

>> Age가 23인 데이터를 찾기 위해 418개의 rows를 모두 검색하는 것이 플랜임을 알 수 있다.

[INDEX 생성 후]

DESC kaggle.titanic;

Age에 인덱스가 생성된 것을 확인할 수 있다.

EXPLAIN SELECT * FROM kaggle.titanic WHERE `Age` = 23;

>> IDX_AGE를 사용해서 reference를 통해서 쿼리를 실행하는 것이 플랜임을 알 수 있다.

>> 데이터를 얻기 위해서 11개의 row만 검색하면 된다.

1. 계정 생성

CREATE USER ' ----- '@' host ' IDENTIFIED BY 'password';

host에게 password로 접근할 수 있는 계정을 생성해주는 것이다.

% 은 '모든 값'을 의미한다.

2. 계정 생성 확인

SELECT HOST, USER FROM MYSQL.USER;

STUDENT를 포함한 이름을 가진 유저를 호출한다는 의미이고, 위와 같이 세 개의 계정이 생성 되어있음을 알 수 있다.

3. 권한 부여

GRANT ALL ON database.* TO ' ----- '@' host ';

해당 계정에게 어떤 데이터베이스의 특정 클래스에 대한 권한을 부여하는 것이다. 

GRANT ALL 은 "모든" 권한을 부여한다는 의미이고, university.* 은 university 데이터베이스의 모든 테이블에 권한을 부여한다는 의미이다.

GRANT SELECT는 SELECT 함수만 실행할 수 있도록 권한을 부여한다는 의미이고, university.addresses는 university데이터베이스의 addresses 컬럼에만 접근할 수 있도록 권한을 부여한다는 의미이다.

4. 권한 확인

SHOW GRANTS FOR ' ----- '@' host ';

계정에 부여된 권한을 확인하는 코드이다.

5. 권한 취소

REVOKE functions ON class.table FROM ' ----- '@' host ';

해당 계정에 부여되었던 권한을 취소하는 코드이다. 모든 권한을 취소할 수도 있고, 일부 함수에 대한 권한만 취소할 수도 있다.

그런데 이 부분은 계속 오류가 떠서 더 알아보고 시도해봐야겠다.

6. 계정 삭제

DROP USER ' ----- '@' host ';

'STUDENT'@'localhost' 계정이 삭제되었음을 알 수 있다.

조건 1) 자바 클래스 파일명을 Calc.java로 하고 package명은 calc로 한다.

조건 2) 자바 클래스 파일명을 CalcTest.java로 하고 package명은 calc로 한다.

조건 3) Calc 클래스 파일에 정수형 멤버변수로 a, b를 선언한다.

조건 4) Calc 클래스에 기본생성자 함수를 정의하고 a, b 값은 0으로 설정한다.

조건 5) Calc 클래스에 정수형 인자 a, b를 인자(파라메터)로 생성자 함수를 정의하고 멤버 변수에 인자로 전달된 값을 대입한다.

조건 6) Calc 클래스에 멤버 함수 void add(), void sub(), void mul(), void div(), void mod() 함수를 정의한다.

조건 7) 6에서 정의한 함수를 아래와 같이 결과가 나오게 구현한다.

          a = 10, b = 2

          add() -> 10 + 2 = 12

          sub() -> 10 - 2 = 8

          mul() -> 10 * 2 = 20

          div() -> 10 / 2 = 5

          mod() -> 10 % 2 = 0  

조건 8) CalcTest 클래스 메인 함수에서 Calc 클래스 객체를 생성할 때 값으로 10, 2를 전달하여 객체를 생성하고 생성된 객체를 이용하여 6에서 정의된 함수를 호출하여 조건 7과 같이 나오는지 확인한다.

package calc;

public class Calc {
    private int a;
    private int b;
    
    public void add() {
        System.out.println(a + " + " + b + " = " + (a+b));
    }
    
    public void sub() {
        System.out.println(a + " - " + b + " = " + (a-b));
    }
	
    public void mul() {
        System.out.println(a + " * " + b + " = " + (a*b));
    }
	
    public void div() {
        System.out.println(a + " / " + b + " = " + (a/b));
    }
	
    public void mod() {
        System.out.println(a + " % " + b + " = " + (a%b));
    }
    
    public Calc() {            //기본생성자
        a = 0;
        b = 0;
    }
    
    public Calc (int cA, int cB) {
        a = cA;
        b = cB;
    }
}

pakage calc.test;
import calc.Calc;

public class CalcTest {
    
    public static void main(String[] args) {
        Calc calc1 = new Calc(10, 2);
        
        calc1.add();
        calc1.sub();
        calc1.mul();
        calc1.div();
        calc1.mod();
    }
}

결과 

조건 1) 자바 클래스 파일명을 Exam2.java 로 한다.
조건 2) main()을 만든다.
조건 3) for 루프를 이용하여 1에서부터 100까지 3의 배수의 전체 합을 구하는 프로그램을 작성한다.

package exam2;

public class Exam2 {
    public static void main(String[] args) {
        int total = 0;
        
        for (int i = 0; i <= 100; i++) {
            if (i % 3 == 0)
                total += i;
            else continue;
            
            System.out.println("sum = " + total + ", i = " + i);
        }
        
        System.out.println("total = " + total);
    }
}

결과

create database kaggle;

use kaggle;

CREATE TABLE `org_test_import` (
  `PassengerId` int NULL,
  `Pclass` int NULL,
  `Name` text,
  `Sex` text,
  `Age` text,
  `SibSp` int  NULL,
  `Parch` int  NULL,
  `Ticket` text,
  `Fare` text,
  `Cabin` text,
  `Embarked` text
) ENGINE=InnoDB ; 

SELECT @@sql_mode;

set @@sql_mode = "";    

CREATE TABLE `test` (
  `PassengerId` int NULL,
  `Pclass` int NULL,
  `Name` text,
  `Sex` text,
  `Age` double,
  `SibSp` int  NULL,
  `Parch` int  NULL,
  `Ticket` text,
  `Fare` double,
  `Cabin` text,
  `Embarked` text
) ENGINE=InnoDB ;

INSERT INTO `kaggle`.`test` (
  `PassengerId`,
  `Pclass`,
  `Name`,
  `Sex`,
  `Age`,
  `SibSp`,
  `Parch`,
  `Ticket`,
  `Fare`,
  `Cabin`,
  `Embarked` )
SELECT `org_test_import`.`PassengerId`,
    `org_test_import`.`Pclass`,
    `org_test_import`.`Name`,
    `org_test_import`.`Sex`,
    `org_test_import`.`Age`,
    `org_test_import`.`SibSp`,
    `org_test_import`.`Parch`,
    `org_test_import`.`Ticket`,
    `org_test_import`.`Fare`,
    `org_test_import`.`Cabin`,
    `org_test_import`.`Embarked`
FROM `kaggle`.`org_test_import`;

select age from `org_test_import`;  

select age from `kaggle`.`test`;   

SELECT * FROM `gender_submission`;

ALTER TABLE `test` ADD PRIMARY KEY (`PassengerId`);

ALTER TABLE `gender_submission` ADD PRIMARY KEY (`PassengerId`);

ALTER TABLE `gender_submission` ADD FOREIGN KEY (`PassengerId`) REFERENCES `test` (`PassengerId`);

SELECT COUNT (*) FROM `gender_submission`;
SELECT COUNT (*) FROM `test`;
SELECT COUNT (*) FROM test A JOIN gender_submission B ON A.PassengerId = B.PassengerId;

CREATE TABLE `titanic` (
  `PassengerId` int not NULL,
  `Pclass` int NULL,
  `Name` text,
  `Sex` text,
  `Age` double,
  `SibSp` int  NULL,
  `Parch` int  NULL,
  `Ticket` text,
  `Fare` double,
  `Cabin` text,
  `Embarked` text,             
  `Survived` int ,             
  primary key (`PassengerId` )
) ENGINE=InnoDB ; 

INSERT INTO `kaggle`.`titanic` (
  `PassengerId`,
  `Pclass`,
  `Name`,
  `Sex`,
  `Age`,
  `SibSp`,
  `Parch`,
  `Ticket`,
  `Fare`,
  `Cabin`,
  `Embarked`,
  `Survived`) 
SELECT 
A.`PassengerId`,
  `Pclass`,
  `Name`,
  `Sex`,
  `Age`,
  `SibSp`,
  `Parch`,
  `Ticket`,
  `Fare`,
  `Cabin`,
  `Embarked`, 
B.`Survived`
FROM test A JOIN gender_submission B ON A.PassengerId = B.PassengerId ; 

SELECT COUNT(*) FROM `kaggle`.`titanic` ; 

SELECT * FROM `kaggle`.`titanic` ; 

SELECT MAX(`Age`) FROM `kaggle`.`titanic`;

SELECT MIN(`Age`) FROM `kaggle`.`titanic` WHERE `Age` > 0;

SELECT AVG(`Age`), COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0;

SELECT sum(`Fare`) FROM `kaggle`.`titanic`;

SELECT `Name`, `Pclass`, `Sex`, `Age` FROM `kaggle`.`titanic` ORDER BY 1 ;  ##첫번째 컬럼 기준으로 오름차순 (Name)

SELECT `Name`, `Pclass`, `Sex`, `Age` FROM `kaggle`.`titanic` ORDER BY 3 ;

SELECT `Name`, `Pclass`, `Sex`, `Age` FROM `kaggle`.`titanic` ORDER BY `Name` DESC ;

#10개 제한된 행 조회
SELECT * FROM `kaggle`.`titaic` WHERE `Name` LIKE 'A%' LIMIT 10;   #이름이 A로 시작하는 row 10개

##`PassengerId` 유일한 값만 조회
SELECT DISTINCT `PassengerId` FROM `kaggle`.`titanic`;

SELECT DISTINCT `Sex` FROM `kaggle`.`titanic`;

SELECT `Sex`, COUNT(*) FROM `kaggle`.`titanic` GROUP BY 1;    #첫번째 컬럼을 그룹화해서 카운트

SELECT `Sex`, COUNT(*) CNT FROM `kaggle`.`titanic` GROUP BY `Sex` HAVING CNT > 200;  #count = cnt, cnt가 200이상인 그룹의 카운트 수

SELECT `Sex`, `survived`, COUNT(*) FROM `kaggle`.`titanic` GROUP BY `Sex`, `Survived` ;

##floor = 반올림
#연령 밴드별 조회
SELECT floor(`Age`/10) * 10 + 10, COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0 group by 1; #~대 미만 승객 수

SELECT floor(`Age`/10) * 10 + 10, COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0 group by 1 order by 1;

SELECT floor(`Age`/10) * 10 + 10, COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0 group by 1 order by 1 desc;

SELECT floor(`Age`/10) * 10 + 10, `survived`, COUNT(*) CNT FROM `kaggle`.`titanic` 
WHERE `Age` > 0 group by 1, 1 HAVING CNT > 40 order by 1 desc, 2 desc;


#서브쿼리
SELECT * FROM `kaggle`.`titanic`
WHERE `PassengerId` IN (SELECT `PassengerId` FROM `test` WHERE `Age` = 0);  # NULL 값이었던 passengerId(age=0)를 titanic table에서 조회해라

UPDATE `kaggle`.`titanic`
SET `Age` = 30.272590361445783
WHERE `PassengerId` IN (SELECT `PassengerId` FROM `test` WHERE `Age` = 0) ;

이번 예제는 csv 파일을 import하여 타이타닉 데이터를 활용해보는 예제이다.

이번에 사용할 2개의 예제 데이터는 https://www.kaggle.com/c/titanic/ 에서 받을 수 있다.

(gender_submission, test)

kaggle 테이블을 만들고, 스키마에서 Tables -> Table Data Import Wizard를 누르면 csv파일을 import할 수 있다.

첫번째로 'gender_submission.csv' 파일을 import해주었다.

이때, 현재 sql모드가 data타입을 strict하게 설정하도록 되어있기 때문에,

Wizard로 import한 데이터파일에 NULL값이 있으면 그 값은 truncate (삭제) 된다.

두번째로 import할 'test.csv' 파일에 NULL값이 있기 때문에

이걸 고치기 위해 sql 모드를 strict하지 않게 바꿔주고, 데이터타입을 바꿔주는 테이블을 생성할 것이다.

코드를 살펴보겠다.

create database kaggle; 
use kaggle;

kaggle database를 생성하고, 이용하겠다는 뜻이다.

이후 위에 있는 사진처럼 이 데이터베이스에 'gender_submission.csv'파일을 import 했다.

import할 때에 'gender_submission'이라는 테이블을 함께 형성해서 저장했다.

CREATE TABLE `org_test_import` (
`PassengerId` int NULL,   
`Pclass` int NULL,   
`Name` text,   
`Sex` text,   
`Age` text,   
`SibSp` int  NULL,   
`Parch` int  NULL,   
`Ticket` text,   
`Fare` text,   
`Cabin` text,   
`Embarked` text ) ENGINE=InnoDB ; 

이 테이블은 두번째로 import할 'test.csv'파일의 값을 저장할 테이블이다. 

현재 sql모드가 데이터를 strict하게 저장하도록 설정되어있기 때문에, 'text.csv' 파일에서 double타입의 'age' 값에 NULL값이 있으면 Wizard로 import 할 때 테이블이 truncate된다. (삭제된다)

따라서, 우선 'age'와 'fare'의 데이터타입을 text로 변경한 테이블 'org_test_import'에 파일을 import하고, 

이후 다시 원래대로 데이터 타입을 바꾼 테이블('test')에 값을 저장해주도록 하겠다.

SELECT @@sql_mode;  

현재 sql_mode를 알려준다.

set @@sql_mode = "" ;

또한, sql_mode를 strict하지 않게 바꿔주었다.

CREATE TABLE `test` (
  `PassengerId` int NULL,
  `Pclass` int NULL,
  `Name` text,
  `Sex` text,
  `Age` double,
  `SibSp` int  NULL,
  `Parch` int  NULL,
  `Ticket` text,
  `Fare` double,
  `Cabin` text,
  `Embarked` text
) ENGINE=InnoDB ; 

이 테이블이 import한 'test.csv'파일을 옮겨 담을 테이블이다.

'age'와 'fare'의 도메인을 원래처럼 double로 바꿔주었다.

INSERT INTO `kaggle`.`test`
(`PassengerId`,
`Pclass`,
`Name`,
`Sex`,
`Age`,
`SibSp`,
`Parch`,
`Ticket`,
`Fare`,
`Cabin`,
`Embarked`)
SELECT `org_test_import`.`PassengerId`,
    `org_test_import`.`Pclass`,
    `org_test_import`.`Name`,
    `org_test_import`.`Sex`,
    `org_test_import`.`Age`,
    `org_test_import`.`SibSp`,
    `org_test_import`.`Parch`,
    `org_test_import`.`Ticket`,
    `org_test_import`.`Fare`,
    `org_test_import`.`Cabin`,
    `org_test_import`.`Embarked`
FROM `kaggle`.`org_test_import`;

'org_test_import'에 저장된 모든 값을 'test'테이블에 삽입하는 코드이다.

이제 NULL값이 있던 'age'값을 각각의 테이블에서 select해보겠다.

select age from `org_test_import` ;       #NULL값이 있음  (text이기 때문)

select age from `kaggle`.`test` ;          #NULL -> 0   (double이기 때문)

test파일에 저장된 'age' 값에는 NULL값이 없고 그 값들이 모두 0으로 바뀐 것을 볼 수 있다.

NULL값이 있는 데이터 파일을 wizard로 import할 때에는 위와 같이 도메인을 text로 바꾼 테이블을 만들어서 import한 뒤, 다시 옮겨주는 방법을 사용하면 된다.

SELECT * FROM `gender_submission` ;

'gender_submission' 테이블의 값을 보여준다.

AlTER TABLE `test` ADD PRIMARY KEY ( `PassengerId` ) ; 

'test' 테이블의 기본키를 'PassengerId'로 바꿔주는 코드이다.

AlTER TABLE `gender_submission` ADD PRIMARY KEY ( `PassengerId` ) ; 

'gender_submission' 테이블의 기본키를 'PassengerId'로 설정하는 코드이다.

AlTER TABLE `gender_submission` ADD FOREIGN KEY ( `PassengerId` ) REFERENCES `test` ( `PassengerId` ) ; 

'gender_submission' 테이블의 외래키를 'PassengerId'로 설정하며, 'test' 테이블의 'PassengerId' 값을 참조하겠다는 코드이다.

SELECT COUNT(*) FROM `gender_submission` ; 
SELECT COUNT(*) FROM `test` ;

count( ) 는 투플의 개수를 세는 함수이다. FROM - 뒤에 WHERE - 을 붙여 조건을 걸 수 있다.

정확한 표현인지는 모르겠지만..

예제에 나온 SELECT COUNT(*) FROM 'gender_submission'; 은 'gender_submission' 테이블에 있는 전체 투플 수 (rows)를 count해준다.

SELECT  COUNT(*) FROM test A JOIN gender_submission B ON A.PassengerId = B.PassengerId ;

'test' 테이블의 'PassengerId'와 'gender_submission'테이블의 'PassengerId'가 같을 경우에, 'test'테이블과 'gender_submission'테이블을 결합한다는 의미이다. 그리고, 그 결합한 것의 투플 수 (row 수)를 세는 코드이다. 

두 테이블 다 418개의 투플을 갖고 있기 때문에, 이 결과도 418이 나온다.

CREATE TABLE `titanic` (
  `PassengerId` int not NULL,
  `Pclass` int NULL,
  `Name` text,
  `Sex` text,
  `Age` double,
  `SibSp` int  NULL,
  `Parch` int  NULL,
  `Ticket` text,
  `Fare` double,
  `Cabin` text,
  `Embarked` text,                   

  `Survived` int ,                       
  primary key (`PassengerId` )
) ENGINE=InnoDB; 

'titanic'이라는 테이블을 생성했다. 이 테이블에는 'test'테이블과 'gender_submission'테이블을 결합하여 저장할 것이다.

INSERT INTO `kaggle`.`titanic`

(`PassengerId`,
 `Pclass`,
 `Name`,
 `Sex`,
 `Age`,
 `SibSp`,
 `Parch`,
 `Ticket`,
 `Fare`,
 `Cabin`,
 `Embarked`,
 `Survived`) 
SELECT 
A.`PassengerId`,
   `Pclass`,
   `Name`,
   `Sex`,
   `Age`,
   `SibSp`,
   `Parch`,
   `Ticket`,
   `Fare`,
   `Cabin`,
   `Embarked`, 
B.`Survived`
FROM test A JOIN gender_submission B ON A.PassengerId = B.PassengerId ;

insert into, select, from join on 함수를 이용하여,

'test'테이블의 PassengerId값과 'gender_submission'테이블의 PassengerId값이 같을 경우,

두 테이블을 결합하여 각각의 값들을 'titanic' 테이블에 저장해 하나의 테이블로 만드는 것이다.

SELECT COUNT(*) FROM `kaggle`.`titanic` ; 

'titanic' 테이블의 투플 수를 보여준다.

'gender_submission'의 'PassengerId'값은 외래키로, 'test' 테이블의 값을 참조한 것이기 때문에 모든 값이 같다.

따라서 모든 투플이 결합하여 저장되었기 때문에 count 수는 동일하게 418이다.

SELECT * FROM `kaggle`.`titanic` ; 

'titanic' 테이블의 모든 값을 보여준다.

SELECT MAX(`Age`) FROM `kaggle`.`titanic`;

MAX함수는 이 속성에서 가장 큰 값을 보여준다.

SELECT MIN(`Age`) FROM `kaggle`.`titanic` WHERE `Age` > 0;

MIN함수는 반대로 이 속성에서 가장 크기가 작은 값을 보여준다.

WHERE은 조건문 느낌으로, 'Age'값이 0보다 큰 범위에서 가장 작은 값을 보여달라는 의미이다.

NULL값이 0으로 변환되었기 때문에 이 조건을 추가한 것이다.

SELECT AVG(`Age`), COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0;

AVG는 평균을 보여주는 값이다. 

COUNT는 뒤에 WHERE `Age` > 0 의 조건이 붙었기 때문에 'Age' 값이 0보다 큰 투플의 개수를 알려준다.

SELECT sum(`Fare`) FROM `kaggle`.`titanic`;

sum은 해당 속성의 투플 값들을 모두 더한 값을 반환한다.

SELECT `Name`, `Pclass`, `Sex`, `Age` FROM `kaggle`.`titanic` ORDER BY 1 ;  

ORDER BY 1은 SELECT 뒤에 나열된 4개의 속성들 중 첫번째 속성을 기준으로 오름차순 정렬하여 반환하라는 의미이다.

SELECT `Name`, `Pclass`, `Sex`, `Age` FROM `kaggle`.`titanic` ORDER BY 3 ;

마찬가지로 3번째 속성인 'Sex'를 기준으로 오름차순 정렬하라는 의미이다.

SELECT `Name`, `Pclass`, `Sex`, `Age` FROM `kaggle`.`titanic` ORDER BY `Name` DESC ;

ORDER BY - DESC는 해당 속성 기준으로 내림차순 정렬하라는 의미이다.

그리고 ORDER BY 뒤에 숫자보다는 이와 같이 속성명을 직접 써주는 것이 더욱 직관적이다.

SELECT * FROM `kaggle`.`titanic` WHERE `Name` LIKE 'A%' LIMIT 10; 

LIKE 'A%' 은 'Name' 값들 중에서 A로 시작하는 값을 반환하라는 조건이다.

LIMIT 10은 그 중에서 상위 10개만 반환하라는 조건이다. 아마 조건에 대한 오름차순 정렬 후 10개인 것 같다.

SELECT DISTINCT `PassengerId` FROM `kaggle`.`titanic`;

DISTINCT 는 해당 속성의 값들 중 유일한 값만 조회하는 함수이다.

'PassengerId'의 경우 기본키로, 모든 투플이 유일하게 갖는 값이기 때문에 모든 값이 반환된다.

SELECT DISTINCT `Sex` FROM `kaggle`.`titanic`;

마찬가지로 'Sex' 의 값들 중 유일한 값들만 반환한다. 

이 경우 투플 값이 male과 female 두 가지로 나뉘기 때문에 두개의 값만 반환된다.

SELECT `Sex`, COUNT(*) FROM `kaggle`.`titanic` GROUP BY 1;  

GROUP BY는 해당 속성 값들을 그룹화하는 함수이다. 이 경우 'Sex'는 male과 female의 두개의 그룹으로 나뉠 것이다.

여기에 COUNT함수를 적용하면, 각각의 그룹에 속하는 투플 수를 보여준다.

SELECT `Sex`, COUNT(*) CNT FROM `kaggle`.`titanic` GROUP BY `Sex` HAVING CNT > 200;  

위의 코드처럼 'Sex' 속성을 그룹화하여 count한 뒤, HAVING (조건) 을 이용해서 count값이 200보다 큰 값만 출력되도록 하는 코드이다.

count값을 CNT로 지정해서 HAVING 조건을 이용한 것이 특징이다.

위의 결과를 보면 male은 count값이 266, female은 152이기 때문에 male의 값만 출력되었다.

SELECT `Sex`, `survived`, COUNT(*) FROM `kaggle`.`titanic` GROUP BY `Sex`, `Survived` ;

'Sex' 속성과 'survived' 속성을 각각 그룹화하여 count값을 출력하는 코드이다.

이 값을 보면 남자는 모두 생존하지 못했고, 여자는 모두 생존했음을 알 수 있다. 

SELECT floor(`Age`/10) * 10 + 10, COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0 group by 1; 

floor는 반올림을 해주는 함수이다. 연령대별로 몇 명의 사람이 있는지 알아보기 위해서 'Age'를 10으로 나눈 값을 반올림하고, 10을 곱한 뒤, 0~9의 값이 있기 때문에 10을 더해준다. 그러면 이 값 미만의 사람들이 몇 명있는지 알아볼 수 있다.

SELECT floor(`Age`/10) * 10 + 10, COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0 group by 1 order by 1;

위의 값들을 오름차순으로 정렬하는 코드이다.

SELECT floor(`Age`/10) * 10 + 10, COUNT(*) FROM `kaggle`.`titanic` WHERE `Age` > 0 group by 1 order by 1 desc;

위의 값들을 내림차순으로 정렬하는 코드이다.

SELECT floor(`Age`/10) * 10 + 10, `survived`, COUNT(*) CNT FROM `kaggle`.`titanic` 
WHERE `Age` > 0 group by 1, 1 HAVING CNT > 40 order by 1 desc, 2 desc;

위의 코드처럼 'Age'를 연령대 별로 나누고, 그 중 count값이 40보다 큰 값에 대해 'Age' 값과 'survived' 값을 각각 내림차순으로 정렬하는 코드이다.

#서브쿼리: 하나의 SQL문 안에 들어있는 또 다른 SQL문(쿼리)! 괄호( )로 나타낸다.

#서브쿼리가 조건절이 됨. 결과에 해당하는 데이터를 조건으로 해서 메인쿼리 실행.

SELECT * FROM `kaggle`.`titanic`
WHERE `PassengerId` IN (SELECT `PassengerId` FROM `test` WHERE `Age` = 0); 

서브쿼리// 'test' 테이블에서 'Age'값이 0인 'PassengerId'를 찾는다.

메인쿼리// 그 'PassengerId'를 가진 값의 모든 데이터를 출력한다. ('PassengerId'가 JOIN으로 연결되어있기 때문에 같은 값임)

UPDATE `kaggle`.`titanic`
SET `Age` = 30.272590361445783
WHERE `PassengerId` IN (SELECT `PassengerId` FROM `test` WHERE `Age` = 0) ;

위의 코드대로 'Age' 값이 0인 데이터를 찾아서 그 값들의 'Age' 값을 평균인 30.272590361445783로 업데이트하는 코드이다.

업데이트한 후 위의 코드를 다시 실행시켜보면 'Age' 값이 모두 변경된 것을 볼 수 있다.

위의 코드는 'test' 테이블에서 'Age' 값이 0인 투플을 찾은 것이기 때문에 'titanic' 테이블에서 값을 변경한 뒤 다시 확인하기에 좋았다.

CREATE DATABASE `university`;

SHOW databases;

USE `university`;

#DROP TABLE `university`.`student`;
CREATE TABLE `university`.`student`(           # ` ` 은 해도 되고 안해도 되는 것 같다. 속성도.
  `student_id` int unsigned NOT NULL ,
  `name` varchar(20) NOT NULL ,
  `address` varchar(100) NULL ,
  `birth_date` char(8) NULL ,
  `major_id` smallint NULL ,
  `enterance_year` smallint NULL ,
  `leave_yn` bit NULL default 0;
  `last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`student_id`)
) ENGINE=InnoDB;

INSERT INTO `university`.`student`
(student_id, name, address, birth_date, major_id, enterance_year, leave_yn)
VALUES
(2016001, '정소정', '서울시 서초구 방배동 911-1', '19971101', 111, 2016, 0),
(2017053,'성민경','경상북도 대구 수성구 삼익 1-1','19980412',111,2017,1),
(2018111,'노규희','충청남도','19991204',130,2018,1),
(2017105,'박성희','강원도','19980908',130,2017,0);

select * from `university`.`student`;

select * from `university`.`student`
where student_id = 2016001;

select student_id, name from `university`.`student`
where major_id = 111;

UPDATE `university`.`student`
SET
address = '부산특별시 해운대 비치333-3',
leave_yn = 1
WHERE student_id = 2016001;

select * from university.student
where student_id = 2016001;

DELETE FROM university.student
WHERE student_id = 2016001;

select * from university.student 
where student_id = 2016001;

select * from university.student;

CREATE TABLE `university`.`class` (
  `class_id` int unsigned NOT NULL ,
  `name` varchar(20) NOT NULL , 
  `professor_id` int NOT NULL , 
  `major_id` smallint NULL ,
  `duration` smallint NULL ,
  `type` tinyint NULL ,
  `start_time` char(2) NULL,
  `last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (class_id)
  ) ENGINE = InnoDB;
  
SHOW TABLES;

SHOW CREATE TABLE `university`.`class`;

select * from `university`.`class`;

DESC `university`.`class`;

INSERT INTO `university`.`class`
(class_id, name, professor_id, major_id, duration, type, start_time)
VALUES
(10000, '데이터베이스', 10001, 111, 3, 1, '13'),
(20001, '물리기초1', 20011, 111, 1, 2, '09'),
(30002, '사회학개요', 30001, 120, 2, 3, '15'),
(50003, '통계학1', 50001, 130, 3, 4, '10');

CREATE TABLE `university`.`registerClass` (
  student_id int unsigned NOT NULL ,
  class_id int unsigned NOT NULL ,
  last_update timestamp NOT NULL DEFAULT CURRNET_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP ,
  PRIMARY KEY (student_id, class_id) ,
  FOREIGN KEY (student_id) REFERENCES `university`.`student` (student_id) ,
  FOREIGN KEY (class_id) REFERENCES `university`.`class` (class_id)
  ) ENGINE=InnoDB;
  
INSERT INTO `university`.`registerClass`
(student_id, class_id)
VALUES
(2018111, 10000), (2018111, 5003), (2018111, 30002);

INSERT INTO `university`.`registerClass`
(student_id, class_id)
VALUES
(2017105, 20001), (2017105, 30002), (2017105, 50003);

SELECT * FROM `university`.`registerClass`;

INSERT INTO `university`.`registerClass`
(student_id, class_id)
VALUES
(2017053, 10000), (2017053, 50003);

  #INSERT INTO `university`.`registerClass`
  #(student_id, class_id)
  #VALUES
  #(2017053, 45003);

SELECT S.NAME, C.NAME, R.last_update
FROM student S join registerClass R on S.student_id = R.student_id
join class C on R.class_id = C.class_id
where S.student_id = 2017053;

SELECT S.NAME, C.NAME, R.last_update
FROM student S join registerClass R on S.student_id = R.student_id
join class C on R.class_id = C.class_id
where S.student_id = 2018111;

SELECT S.NAME, C.NAME, R.last_update
FROM student S join registerClass R on S.student_id = R.student_id
join class C on R.class_id = C.class_id
where S.student_id = 2017105;

CREATE DATABASE `university`;

`university`라는 데이터베이스를 생성한다.

SHOW databases;

현재 생성되어있는 데이터베이스들을 보여준다.

USE `university`;

`university` 데이터베이스를 이용할 것임을 선언한다.

#DROP TABLE `university`.`student`;

DROP TABLE은 이미 존재하는 이 테이블을 삭제하겠다는 의미이다.

CREATE TABLE `university`.`student`(          
  `student_id` int unsigned NOT NULL ,
  `name` varchar(20) NOT NULL ,
  `address` varchar(100) NULL ,
  `birth_date` char(8) NULL ,
  `major_id` smallint NULL ,
  `enterance_year` smallint NULL ,
  `leave_yn` bit NULL default 0;
  `last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`student_id`)
) ENGINE=InnoDB;

university DB 안에 'student'라는 테이블을 생성한 것이다.

student_id, name, address, birth_date, major_id, enterance_year, leave_yn, last_update가 속성이다.

속성 이름 뒤에 도메인을 적어준다. 도메인은 속성의 특성에 맞는 자료형이다.

unsigned는 부호가 없다는 뜻이다. 예를 들어 tinyint의 경우, (signed) tinyint의 범위는 -128~127이며, 

unsigned tinyint의 범위는 0~255이다.

NULL, NOT NULL은 NULL값이 될 수 있냐 없냐를 정해주는 것이다. 예제의 경우 학번과 이름은 NULL값이 될 수 없도록 했다.

varchar( )의 괄호 속 숫자는 최대로 들어갈 수 있는 byte 값이다.

`leave_yn`는 휴학여부 속성으로 0과 1로 구분되고, 투플값이 없을 경우 default 값은 0이 들어가도록 했다.

`last_update`는 업데이트 시각으로, 직접 적는 것이 아니라 CURRNET_TIMESTAMP를 이용하여 자동으로 저장된다.

이 테이블의 기본키는 `student_id`로, 학번만 가지고도 투플들을 구분할 수 있다는 뜻이다.

MySQL의 스토리지 엔진으로 주로 MyISAM과 InnoDB가 사용된다.

스토리지 엔진은 데이터베이스 엔진이라고도 불리며, RDBMS가 데이터베이스에 대해 데이터를 삽입, 추출, 업데이트, 삭제하는 데 사용하는 기본 소프트웨어 컴포넌트이다. 

MyISAM은 항상 테이블에 ROW COUNT를 가지고 있기 때문에 SELECT 명령 시 속도가 빠르고, '풀텍스트 인덱스'를 지원하는데, 이는 자연 언어를 이용해 검색할 수 있는 특별한 인덱스로 모든 데이터 문자열의 단어를 저장한다는 것이다. 이때문에 Read only 기능이 많은 서비스일수록 효율적으로 사용할 수 있는 엔진이다. 단점으로는, row level locking을 지원하지 못해서 select, insert, update, delete 명령 시 해당 테이블 전체에 locking이 걸린다는 것이다. 그래서 갱신이 많이 필요한 경우에는 유용하지 못하다.

InnoDB는 MyISAM과 대조적인 엔진으로, 우선 row level locking이 지원된다는 장점이 있고, 트랜잭션 처리가 필요한 대용량 데이터를 다룰 때 효율적이다. 데이터의 변화가 많은 서비스에 적합하다. 또한, 유일하게 외래키를 지원하는 표준적인 스토리지 엔진이다.단점으로는, 풀텍스트 인덱스를 지원하지 않는다는 것이 있다.

주로 InnoDB를 많이 사용한다고 하고, 이번 예제에서도 InnoDB를 사용하였다. 

INSERT INTO `university`.`student`
(student_id, name, address, birth_date, major_id, enterance_year, leave_yn)
VALUES
(2016001, '정소정', '서울시 서초구 방배동 911-1', '19971101', 111, 2016, 0),
(2017053,'성민경','경상북도 대구 수성구 삼익 1-1','19980412',111,2017,1),
(2018111,'노규희','충청남도','19991204',130,2018,1),
(2017105,'박성희','강원도','19980908',130,2017,0);

student 테이블에 투플들을 삽입하는 코드이다. 

INSERT INTO로 속성을 한 번 나열하고, VALUES를 통해 각각의 개체들을 추가한다.

select * from `university`.`student`;

select from은 테이블에서 정보를 가져온다는 뜻이고, *은 테이블에 있는 모든 데이터를 가져온다는 뜻이다.

따라서 이 코드를 실행하면 university.student에 있는 4개의 투플들을 보여준다.

select * from `university`.`student`
where student_id = 2016001;

where은 조건의 개념으로, 이 경우에는 학번이 2016001인 투플의 모든 데이터를 가져온다는 뜻이 된다.

select student_id, name from `university`.`student`
where major_id = 111;

이 경우에는 selcet student_id, name 이므로, 전공번호가 111인 투플의 학번과 이름을 가져온다.

UPDATE `university`.`student`
SET
address = '부산특별시 해운대 비치333-3',
leave_yn = 1
WHERE student_id = 2016001;

update는 말 그대로 테이블을 새로운 정보로 업데이트한다는 뜻이다.

이 경우, 학번이 2016001인 투플의 주소와 휴학여부 정보를 변경하게 된다.

select * from university.student
where student_id = 2016001;

DELETE FROM university.student
WHERE student_id = 2016001;

select * from university.student 
where student_id = 2016001;

select * from university.student;

select문은 마찬가지로 정보를 가져오는 코드이고,

DELETE문은 university DB의 student 테이블에서 student_id가 2016001인 투플을 삭제하는 코드이다.

CREATE TABLE `university`.`class` (
  `class_id` int unsigned NOT NULL ,
  `name` varchar(20) NOT NULL , 
  `professor_id` int NOT NULL , 
  `major_id` smallint NULL ,
  `duration` smallint NULL ,
  `type` tinyint NULL ,
  `start_time` char(2) NULL,
  `last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (class_id)
  ) ENGINE = InnoDB;

두번째로 universityDB 안에 'class'라는 테이블을 생성한 것이다.

속성으로는 class_id, name, professor_id, major_id, duratin, type, start_time, last_update가 있고 각각의 도메인이 달려있다.

투플을 구분할 수 있는 기본키는 class_id이다.

SHOW CREATE TABLE `university`.`class`;

class 테이블에 대한 정보를 알려준다.

select * from `university`.`class`;

DESC `university`.`class`;

테이블의 속성과 도메인, NULL 여부 등의 모든 정보를 알려주는 DESC문이다.

INSERT INTO `university`.`class`
(class_id, name, professor_id, major_id, duration, type, start_time)
VALUES
(10000, '데이터베이스', 10001, 111, 3, 1, '13'),
(20001, '물리기초1', 20011, 111, 1, 2, '09'),
(30002, '사회학개요', 30001, 120, 2, 3, '15'),
(50003, '통계학1', 50001, 130, 3, 4, '10');

class테이블에 4개의 투플을 생성하는 코드이다. 위의 INSERT구문과 같다.

CREATE TABLE `university`.`registerClass` (
  `student_id` int unsigned NOT NULL ,
  `class_id` int unsigned NOT NULL ,
  `last_update` timestamp NOT NULL DEFAULT CURRNET_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP ,
  PRIMARY KEY (student_id, class_id) ,
  FOREIGN KEY (student_id) REFERENCES `university`.`student` (student_id) ,
  FOREIGN KEY (class_id) REFERENCES `university`.`class` (class_id)
  ) ENGINE=InnoDB;

세번째로 registerClass 테이블을 생성하는 코드이다. 

속성으로는 student_id, class_id, last_update가 있고, 기본키는 student_id와 class_id이다.

이 테이블에서는 외래키를 사용하였는데, 외래키는 다른 테이블의 속성을 참조하는 속성이다.

student_id는 student 테이블의 student_id를 참조하였고,

class_id는 class 테이블의 class_id를 참조하였다. 그곳에서 값을 가져올 수 있다고 생각하면 될 것 같다.

INSERT INTO `university`.`registerClass`
(student_id, class_id)
VALUES
(2018111, 10000), (2018111, 5003), (2018111, 30002);

INSERT INTO `university`.`registerClass`
(student_id, class_id)
VALUES
(2017105, 20001), (2017105, 30002), (2017105, 50003);

SELECT * FROM `university`.`registerClass`;

INSERT INTO `university`.`registerClass`
(student_id, class_id)
VALUES
(2017053, 10000), (2017053, 50003);

resigterClass 테이블에 투플들을 생성하는 코드들이다.

코드를 보면 student_id와 class_id 투플값이 모두 student테이블의 student_id와 class테이블의 class_id에 있는 값들인 것을 확인할 수 있다. 외래키를 사용했기 때문이다.

  #INSERT INTO `university`.`registerClass`
  #(student_id, class_id)
  #VALUES
  #(2017053, 45003);

이처럼 만약 참조되는 테이블에 없는 값을 value로 입력하면 오류가 뜬다.

SELECT S.NAME, C.NAME, R.last_update                        #조회할 것 -> 결합할 것
FROM student S join registerClass R on S.student_id = R.student_id         #조건
join class C on R.class_id = C.class_id
where S.student_id = 2017053;

SELECT S.NAME, C.NAME, R.last_update
FROM student S join registerClass R on S.student_id = R.student_id
join class C on R.class_id = C.class_id
where S.student_id = 2018111;

SELECT S.NAME, C.NAME, R.last_update
FROM student S join registerClass R on S.student_id = R.student_id
join class C on R.class_id = C.class_id
where S.student_id = 2017105;

join은 릴레이션 간의 조합을 검색하는 키워드이다.

예를 들어, 첫번째 예시는 학번이 2017053인 학생의 이름(from S)과 수강한 과목(C), 수강신청시간(R)을 조회하는 코드이다.

우선 join 다음에 나오는 on은 두 테이블이 결합할 조건을 의미한다.

이 예제에서는 student테이블의 student_id와 registerClass테이블의 student_id가 같을 경우, 

student테이블의 name과 class테이블의 name과 registerClass테이블의 last_update를 결합한다는 의미이다.

결과는 다음과 같이 나온다.

두번째, 세번째 예제도 같은 코드이고 학번만 바꾼 예제이다.

1. 객체 지향 프로그래밍

객체 지향 프로그래밍이란 객체를 기반으로 하는 프로그래밍이다. 

객체는 사람, 자동차, 건물, 주문, 생산, 관리 등 눈에 보이거나 어떠한 행동을 나타내는 단어를 예로 들 수 있다.

반대의 개념은 절차 프로그래밍이 있는데,

이것은 순서대로 일어나는 일을 시간 순으로 프로그래밍하는 것으로, C언어가 대표적이다.

2. 클래스

클래스란 객체에 대한 속성과 기능을 코드로 구현한 것으로, 사용자 정의 자료형이라고 말할 수 있다.

클래스는 데이터와 함수로 정의된다.

예를 들어 "학생"이라는 클래스가 있다면,

데이터는 학번, 이름, 학년, 주소 등이 있고,

함수로는 수강신청, 수업 듣기, 시험 보기 등이 있을 것이다.

속성은 객체의 특성을 정의하는 것으로, 변수 또는 데이터, 멤버 변수라고도 부른다.    (명사)

위의 예에서 학번, 이름, 학년, 주소 등이 해당된다.

함수는 메서드라고도 불리며, 객체가 하는 기능들을 구현하는 것이다.  (동사)

3. 클래스 정의하기

(접근 제어자) class 클래스이름 {

    멤버 변수;

    메서드;

}

/* 클래스 이름은 대문자로 시작하며, 하나의 자바 파일에 하나의 클래스를 두는 것이 기본이다.

여러 개의 클래스가 같이 있는 경우, public 클래스는 단 하나이며, public 클래스와 자바 파일의 이름은 동일해야 한다.

자바의 모든 코드는 class 내부에 위치한다. */

<학생 클래스 만들기>

package classpart;

public class Student {
    int studentId;
    String studentName;
    int grade;
    String address;
    
    public void showStudentInfo() {
        Sysstem.out.println(studentName + ", " + address);
    }
}

studentId부터 address까지가 멤버 변수이고, 

public void showStudentInfo()가 학생 정보를 보여주는 기능을 하는 메서드(함수)이다.

4. 패키지

패키지란 클래스 파일의 묶음이다. 패키지를 만들면 프로젝트 하위에 물리적으로 디렉토리가 생성된다.

패키지는 계층 구조로 구성되며, ( . ) 온점으로 계층을 구분한다.

패키지명은 소문자로 적는다.

package 패키지명;

5. 메서드

메서드는 함수의 일종으로, 객체의 기능을 제공하기 위해 클래스 내부에 구현되는 함수이다.

함수란 하나의 기능을 수행하는 일련의 코드로, 중복되는 기능은 함수로 구현하여 함수를 호출하여 사용한다.

//함수 선언
int add (int num1, int num2) {
    return num1 + num2;
}

//함수 사용
public void static main(String[] args) {
    int sum = add(10, 20);
    System.out.println("10 + 20 = " + sum);
}

<함수의 장점>

1) 기능을 나누어 코드를 효율적으로 구현할 수 있다.

2) 기능별로 함수를 구현해 놓으면 같은 기능을 매번 코드로 만들 필요가 없다.

3) 프로그램을 실행할 때 생긴 오류를 수정하는 디버깅 작업을 할 때도 편리하다.

**가능하면 하나의 함수에 하나의 기능만 구현하는 것이 좋다.

6. 객체 생성하기

클래스를 사용하기 위해서는 "객체"를 생성해야 한다.

new 예약어를 이용해 객체를 생성한다.

    클래스명 변수이름 = new 생성자();

ex) Student studentA = new Student();

7. 생성자

생성자란 객체가 생성될 때 멤버 변수의 값을 초기화하기 위해 사용되는 특별한 함수를 말한다.

생성자 이름은 클래스명과 같다.

생성자는 메서드가 아니고, 상속되지 않으며, 리턴 값이 없지만 앞에 void를 적지 않는다.

디폴트 생성자는 객체가 생성될 때 컴파일러가 자동으로 생성하는 코드이다.

클래스에 생성자를 추가하면 디폴트 생성자는 제공되지 않는다.

8. 생성자 재정의 (오버로드)

함수명은 같고 전달되는 인자의 자료형이 다른 함수를 정의하면 이를 메서드 오버로드라고 부른다. 즉, 다른 함수로 취급된다.

이를 이용해 생성자의 초기화 함수를 여러 개 정의할 수 있다. 이때, 전달되는 인자의 자료형과 개수를 달리 해야한다.

public class Person {
    String name;
    float height;
    float weight;
    
    public Person() {}    //디폴트 생성자
    
    public Person(String pName) {    //이름이 인자로 전달되는 생성자, 
        name = pName;                //pName을 전달하여 멤버변수 name을 초기화할 수 있다.
    } 
}

9. 참조 자료형

변수의 자료형에는 기본 자료형과 참조 자료형이 있다.

ㅇ기본 자료형에는 앞서 포스팅한 것과 같이 boolean, char, short, int, long, float, double이 있으며,

참조 자료형에는 String, Student, Person 등이 있다.

참조 자료형은 클래스 형으로 선언하는 자료형을 의미한다.

예를 들어, 학생 클래스에 (학번, 이름, 국어 성적, 수학 성적, 수강 과목 이름)이 있다고 하자.

이때 수업에 대한 각 속성을 학생 클래스에 정의하지 않고, 수업이라는 클래스로 분리해서 사용하는 것이다.

그럼 과목은 참조 자료형으로 선언되어서 학생 클래스에서 사용될 수 있다.

10. 정보 은닉

클래스의 외부에서 클래스 내부의 멤버 변수나 메서드에 접근하지 못하게 하는 경우에 사용된다.

이를 통해 오류를 줄일 수 있다.

일반적인 경우에 멤버 변수는 private을 선언하여 외부에서 접근하지 못하게 하고,

메서드는 public으로 선언하여 외부에서도 사용할 수 있도록 한다.

그래서 멤버 변수를 외부에서 접근하지 않고 객체를 생성할 수 있도록 생성자를 사용한다.

또한, 생성자를 이용하면 객체를 한번에 초기화 할 수 있다.

package exercise.domain;

public class Student {
    private int    studentId;
    private String name;
    private int    grade;
    private String address;
    
    public void courseRegistration() {
        System.out.println("수강신청");
    }
    public void takeAClass() {
        System.out.println("수업듣기");
    }
    public void takeATest() {
        System.out.println("시험보기");
    }
    
    public void showStudentInfo() {
        System.out.println(name + ", " + address);
        System.out.println(studentId + ", " + grade);
    }
    
    //생성자
    public Student (int pStudentId, String pName, int pGrade, String pAddress) {
        studentId = pStudentId;
        name = pName;
        grade = pGrade;
        address = pAddress;
    }
}     

package exercise.test;
import exercise.domain.Student;

public class StudentTest {

    public static void main(String[] args) {
        Student stu1 = new Student(1224, "홍길동", 1, "서울특별시");  //생성자 함수 호출 
        Student stu2 = new Student(1225, "이순신", 2, "충무로");      //-> 객체 한번에 초기화
        //함수에서만 멤버 변수 접근하도록
        
        stu1.showStudentInfo();
        stu2.showStudentInfo();     //메서드 호출

**private 멤버 변수를 클래스 외부에서 접근할 때에는 get() / set() 메서드를 제공한다.

1. 조건문

1) if 문

• if, if - else

주로 조건식이 범위와 관련된 경우에 사용한다.

if (조건식1) {    
수행문1;
} else if (조건식2) { 
    수행문2;
} else {    
    수행문3;

(예제) 

int age = 9;
int charge = 0;

if (age < 8) {
    charge = 1000;
    System.out.println("미취학 아동입니다.");
} else if (age < 14) {
    charge = 2000;
    System.out.println("초등학생입니다.");
} else if (age < 20) {
    charge = 2400;
    System.out.println("중고등학생입니다.");
} else {
    charge = 3000;
    System.out.println("성인입니다.");
}

System.out.prinln("요금은 " + charge + "원 입니다.");

• 조건 연산자 (삼항 연산자)

간단한 if - else 조건문을 조건 연산자로 구현할 수 있다. 

2) switch - case 문

조건식의 결과가 특정 정수 값 또는 특정 문자열 값과 같을 경우 사용한다.

case문에서 수행문이 끝나면 반드시 break; 를 써줘야 한다. 그렇지 않으면 break;를 만날 때까지 계속 아래의 수행문을 수행한다. 

다음과 같이 여러 case를 한 번에 묶을 수도 있다.

(예제)

int month = 1;
int day = 0;

switch(month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
    day = 31;
    break;
case 2: 
    day = 28;
    break;
case 4:
case 6:
case 9:
case 11:
    day = 30;
    break;
}

System.out.println("day = " + day);

final int Gold = 1;
final int Silver = 2;
final int Bronze = 3;
int medal = 1;

switch(medal) {
case Gold:
    System.out.println("금메달입니다.");
    break;
case Silver:
    System.out.println("은메달입니다.");
	break;
case Bronze:
    System.out.println("동메달입니다.");
    break;
default:
    System.out.println("금메달입니다.");
}

위와 같이 마지막에 default를 써줄 수도 있다. 위의 case를 모두 만족하지 않으면 default의 수행문이 실행된다.

JAVA 버전 7부터는 case 값에 문자열을 사용할 수 있지만, 위의 예제처럼 웬만하면 숫자로 비교하는 것이 좋다.

2. 반복문

1) while 문

조건이 "참"인 동안 수행문을 반복해서 수행한다.

주로 조건식이 true, false로 나타난다.

while (조건식) {

    수행문 1;

    ...

}

수행문2;

(예제)

int i = 0;
final int count = 10;
int sum = 0;

while (i <= count) {
    sum += i;
    ++i;
}

System.out.println("1부터 " + count + "까지의 합 = " + sum);

2) do - while 문

먼저 수행문을 한 번 수행하고 조건식을 체크한다.

수행문이 반드시 한 번 수행되어야 하는 경우에 사용한다.

do {

    수행문1;

    ...

} while (조건식); 

수행문2;

(예제)

int i = 2;

do {
    System.out.println(i);
    ++i;
} while (i < 1);

이 예제는 조건식이 처음부터 만족되지 않았지만, do 안에 있는 수행문은 한 번 실행된다.

3) for 문

가장 많이 사용되는 반복문으로, 주로 조건이 횟수인 경우에 사용한다.

for문 안에 초기식, 조건식, 증감식을 모두 쓰기 때문에 코드가 간결해질 수 있다.

for문 안에서만 쓰이는 변수는 초기식에서 선언과 초기화를 한번에 해주는 것이 좋다.

for (초기식 ; 조건식 ; 증감식) {

    수행문1;

    ...

}

수행문2;

(예제)

for (int num = 1; num <= 5; num++) {
    System.out.println(num);
}

for (int i = 1; i <= 9; i++) {
    System.out.println(i + "단");
    for (int j = 1; j <= 9; j++) {
        System.out.println(i + "x" + j + "=" + i*j);
    }
}

구구단 예제 코드이다.

int total = 0;
for (int i = 1; i <0 100; i++) {
    if (i % 2 ==0) continue;
    total += i;
    System.out.println(total + "i = " i);
}


total = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 1) {
        total += i;
        System.out.println(total + "i = " i);
    }
}

위의 예제에서 continue; 는 아래의 실행문을 실행하지 않고 증감식으로 넘어가라는 의미이다.

위의 for문과 아래의 for문은 100 이하의 홀수끼리만 더하라는 의미로 결과가 같은 코드이다.

int total = 0;
for (int i = 1; i <= 100; i++) { 
    if (i == 50) break;
    total += i;
    System.out.println(total + " i = " + i);
}

System.out.println("total = " + total);

위의 예제와 같이 for문에서 break; 를 쓰면 loop를 벗어난다. 즉, i가 50이 되면 그 이상 증가하지 않고 loop를 빠져나와서 아래의 print문을 실행하는 것이다.