DATABASE-Constraint

in DATABASE, MYSQL, DDL

Constraint : 제약조건

데이터 베이스의 테이블을 생성할때 각 컬럼은 각각의 제약조건을 갖습니다.

  • NOT NULL

    NULL 값 (비어있는 값)을 저장할수 없습니다.

  • UNIQUE

    같은 값을 저장할수 없습니다.

  • PRIMARY KEY

    • NOT NULL과 UNIQUE 의 제약조건을 동시에 만족해야 합니다.

    • 그러므로 컬럼에 비어 있는 값과 동일한 값을 저장할수 없습니다.

    • 하나의 테이블에 하나의 컬럼만 조건을 설정할수 있습니다.

  • AUTO_INCREMENT

    주로 테이블의 PRIMARY KEY 데이터를 저장할때 자동으로 숫자를 1씩 증가시켜 주는 기능으로 사용합
    니다.

  • FOREIGN KEY

    다른 테이블과 연결되는 값이 저장됩니다.

    • 테이블 수정으로 FK 설정

      1
      2
      3
      4
      alter table money
      add constraint fk_user
      foreign key (user_id)       # money의 user_id
      references user (user_id);  # user의 user_id

    • 테이블 생성시 FK 설정

      1
      2
      3
      4
      5
      6
      create table money(
          money_id int primary key auto_increment,
          income int, 
          user_id int,
          foreign key (user_id) references user(user_id)
      );

  • ON DELETE, ON UPDATE 설정

    • 참조를 받는 데이터가 수정하거나 삭제될때 참조 하는 데이터를 설정(수정,삭제 등등)

    • CASECADE : 참조 받는 데이터가 수정, 삭제하면, 참조하는 데이터도 수정 삭제

    • SET NULL : 참조 받는 데이터가 수정 삭제하면, 참조하는 데이터는 NULL로 수정

  • DEFAULT

    데이터를 저장할때 해당 컬럼에 별도의 저장값이 없으면 DEFAULT로 설정된 값이 저장됩니다.

    1
    2
    3
    4
    5
    6
    7
    create table money(
        money_id int primary key auto_increment,
        income int, 
        user_id int,
        foreign key (user_id) references user(user_id)
        on update cascade on delete set null
    );

Comment and share

DATABASE-DATA TYPE

in DATABASE, DDL

DATA TYPE

데이터 베이스의 테이블을 생성할때 각 컬럼은 데이터 타입을 가집니다.

reference : https://dev.mysql.com/doc/refman/5.7/en/data-types.html

Numberic

reference : https://dev.mysql.com/doc/refman/5.7/en/numeric-types.html

  • 정수 타입 ( integer types )

    스크린샷 2020-10-26 오후 7 05 55

  • 실수 (floating-point types)

    소수점을 나타내기 위한 데이터 타입으로 아래의 두가지 데이터 타입이 있습니다.

    두가지의 데이터 타입은 데이터 저장공간의 차이가 있습니다.

    FLOAT (4byte), DOUBLE (8byte)

    또한 아래와 같이 고정 소수점 타입으로도 사용이 가능합니다.

    FLOAT(M,D), DOUBLE(M,D)

Date & Time

reference : https://dev.mysql.com/doc/refman/5.7/en/date-and-time-types.html

  • DATE

    DATE는 날짜를 저장하는 데이터 타입이며, 기본 포멧은 “년-월-일” 입니다.

  • DATETIME

    DATETIME은 날짜와 시간을 저장하는 데이터 타입이며, 기본 포멧은 “년-월-일 시:분:초” 입니다.

  • TIMESTAME

    TIMESTAME는 날짜와 시간을 저장하는 데이터 타입이며,

    DATETIME과 다른점은 날짜를 입력하지 않으면 현재 날짜와 시간을 자동으로 저장할수 있는 특징이 있습니다.

  • TIME

    TIME은 시간을 저장하는 데이터 타입이며, 기본 포멧은 “시:분:초” 입니다.

  • YEAR

    YEAR는 연도를 저장할수 있는 데이터 타입입니다.

    YEAR(2)는 2자리의 연도를 저장할수 있으며 YEAR(4)는 4자리의 연도를 저장할수 있습니다.

String

reference
https://dev.mysql.com/doc/refman/5.7/en/string-types.html

  • CHAR & VARCHAR

    스크린샷 2020-10-26 오후 7 06 06

  • TEXT

    • CHAR와 VARCHAR는 대체로 크기가 작은 문자열을 저장할때 사용되며 크기가 큰 문자열을 저장할 때는 TEXT를 사용합니다.

    • TEXT의 타입에 따라서 아래와 같이 크기를 가집니다.

      스크린샷 2020-10-26 오후 7 06 14

Comment and share

DATABASE-DDL

in DATABASE, DDL

CREATE USE ALTER DROP

USE

  • test 데이터 베이스 선택

    1
    USE test;

  • 현재 데이터 베이스 확인

    1
    SELECT DATABASE()

CREATE

  • 데이터 베이스 생성

    1
    CREATE DATABASE <database_name>;

  • test 데이터 베이스 생성

    1
    CREATE DATABASE test;

  • 테이블 생성

    1
    2
    3
    4
    5
    CREATE TABLE <table_name> (
        column_name_1 column_data_type_1 column_constraint_1,
        column_name_2 column_data_type_2 column_constraint_2,
        ...
    )

  • 제약조건이 없는 user1 테이블 생성

    1
    2
    3
    4
    5
    6
    7
    CREATE TABLE user1(
        user_id INT,
        name Varchar(20),
        email Varchar(30),
        age INT(3),
        rdate DATE
    )

  • 제약조건이 있는 user2 테이블 생성

    1
    2
    3
    4
    5
    6
    7
    CREATE TABLE user2(
        user_id INT PRIMARY KEY AUTO_INCREMENT,
        name Varchar(20) NOT NULL,
        email Varchar(30) UNIQUE NOT NULL,
        age INT(3) DEFAULT '30',
        rdate TIMESTAMP
    )

ALTER

Database

  • 사용중인 데이터베이스의 인코딩 방식 확인

    1
    SHOW VARIABLES LIKE "character_set_database"

  • test 데이터 베이스의 문자열 인코딩을 utf8으로 변경

    1
    2
    ALTER DATABASE world CHARACTER SET = ascii
    ALTER DATABASE world CHARACTER SET = utf8

Table

  • ALTER를 이용하여 Table의 컬럼을 추가하거나 삭제하거나 수정할수 있습니다.

  • ADD

    • user2 테이블에 TEXT 데이터 타입을 갖는 tmp 컬럼을 추가

      1
      ALTER TABLE user2 ADD tmp TEXT

  • MODIFY

    • user2 테이블에 INT 데이터 타입을 갖는 tmp 컬럼으로 수정

      1
      ALTER TABLE user2 MODIFY COLUMN tmp INT

  • DROP

    • user2 테이블의 tmp 컬럼을 삭제

      1
      ALTER TABLE user2 DROP tmp

DROP

  • DATABASE

    • tmp 데이터 베이스 생성

      1
      2
      CREATE DATABASE tmp;
      SHOW DATABASES;

    • tmp 데이터 베이스 삭제

      1
      2
      DROP DATABASE tmp;
      SHOW DATABASES;

  • TABLE

    • tmp 데이터 베이스 생성

      1
      CREATE DATABASE tmp;

    • tmp 데이터 베이스 선택

      1
      USE tmp;

    • tmp 테이블 생성

      1
      CREATE TABLE tmp( id INT );

    • tmp 테이블 삭제

      1
      DROP TABLE tmp;

Comment and share

성 지키기

in Algorithm, Search

백준 1236 : 문제링크

  • 문제유형 :

    • 탐색

  • 설명

    • 행 기준, 열 기준 중 더 큰 값을 출력한다.

  • 풀이

    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
    n, m = map(int, input().split())
    array = []

    for _ in range(n):
        array.append(input())

    row = [0] * n
    column = [0] * m

    for i in range(n):
        for j in range(m):
            if array[i][j] == 'X':
                row[i] = 1
                column[j] = 1

    row_count = 0
    for i in range(n):
        if row[i] == 0:
            row_count += 1

    column_count = 0
    for i in range(m):
        if column[j] == 0:
            column_count +=  1
        
    print(max(row_count, column_count))

Comment and share

트로피 진열

in Algorithm, Search

백준 1668 : 문제링크

  • 문제유형 :

    • 탐색

  • 설명

    • N의 최대값이 50이기 때문에 단순 구현

  • 풀이

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    def ascending(array):
        now = array[0]
        result += 1
        for i in range(1, len(array)):
            if now < array[i]:
                result += 1
                now = array[i]
        return result

    n = int(input())
    array = []

    for _ in range(n):
        array.append(int(input()))

    print(ascending(array))
    array.reverse()
    print(ascending(array))

Comment and share

베스트셀러

in Algorithm, Search

백준 1302 : 문제링크

  • 문제유형 :

    • 탐색

  • 설명

    • 파이썬 dictionary 자료형 사용(HashMap)

  • 풀이

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    n = int(input())

    books = {}

    for _ in range(n):
        book = input()
        if book not in books:
            books[book] = 1
        else:
            books[book] += 1

    target = max(books.values())
    array = []

    for book, number in books.items():
        if number == target:
            array.append(book)

    print(sorted(array)[0])

Comment and share

새

in Algorithm, Search

백준 1543 : 문제링크

  • 문제유형 :

    • 탐색

  • 설명

    • N이 최대 1000000000 이다

    • K가 반복적으로 증가하므로, 새의 마리 수는 빠르게 증가한다

    • 요구하는 대로 단순 구현하면 된다

  • 풀이

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    n = int(input())
    result = 0
    k = 1

    while n != 0:
        if k > n:
            k = 1
        n -= k
        k += 1
        result += 1
        
    print(result)

Comment and share

문서 검색

in Algorithm, Search

백준 1543 : 문제링크

  • 문제유형 :

    • 탐색

  • 설명

    • 단순히 모든 경우의 수를 계산하여 해결

    • 인덱스를 하나씩 올리면서 단어와 비교

    • 동일하면 결과값을 1 올리고 인덱스 위치를 단어의 길이만큼 늘린다

    • 다르면 인덱스를 1만 올린다

    • 단어의 길이보다 문서의 남은 인덱스의 길이가 짧을 때 종료한다

  • 풀이

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    document = input()
    word = input()

    index = 0
    result = 0

    while len(document) - index >= len(word):
        if document[index:index + len(word)] == word:
            result += 1
            index += len(word)
        else:
            index += 1

    print(result)

Comment and share

K번째 수

in Algorithm, Sorting

백준 11004 : 문제링크

  • 문제유형 : 정렬

  • 설명

    1. 데이터의 크기가 5000000이다

    2. 병합정렬, 퀵 정렬, 힙 정렬을 사용해야한다.

    3. python 기본 정렬 라이브러리로도 가능하다.

  • 풀이

    • 병합정렬 

      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
      def merge_sort(array):
          if len(array) == 1:
              return array
          left = array[:mid]
          right = array[mid:]
          i, j, k = 0
          while i < len(left) and j < len(right):
              if left[i] < right[j]
                  array[k] = left[i]
                  left += 1
              else:
                  array[k] = right[j]
                  right += 1
              k += 1

          if i == len(left):
              while j < len(right):
                  array[k] = right[j]
                  j += 1
                  k += 1
          elif j == len(right):
              while i < len(left):
                  array[k] = left[i]
                  i += 1
                  k += 1

          return array

      n, k = map(int, input().split(' '))
      array = list(map(int, input().split(' ')))

      array = merge_sort(array)

      print(array[k-1])

    • 정렬 라이브러리

      1
      2
      3
      4
      5
      6
      n, k = map(int, input().split(' '))
      array = list(map(int, input().split()))

      array = sorted(array)

      print(array[k-1])

Comment and share

수 정렬하기2

in Algorithm, Sorting

백준 2751 : 문제링크

  • 문제유형 : 정렬

  • 설명

    • 데이터의 개수가 1000000개

    • NlogN의 정렬 알고리즘을 이용해야한다. -> 병합, 퀵, 힙 정렬

    • 기본 정렬 알고리즘으로 해결가능

  • 풀이

    • 병합 정렬

      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
      def merge_sort(array):
          if len(array) <= 1:
              return array
          mid = len(array) // 2
          left = merge_sort(array[:mid])
          right = merge_sort(array[mid:])
          i, j, k = 0, 0, 0
          while i < len(left) and j < len(right):
              if left[i] < left[j]:
                  array[k] = left[i]
                  i + = 1
              else:
                  array[k] = right[j]
                  j += 1
              k += 1
          if i == len(left):
              while j < len(right):
                  array[k] = right[j]
                  j += 1
                  k += 1
          elif j == len(right):
              while i < len(left):
                  array[k] = left[i]
                  i += 1
                  k += 1
          return array

      n = int(input())
      array = []

      for _ in range(n):
          array.append(int(input()))

      array = merge_sort(array)

      for data in array:
          print(data)

    • 정렬 라이브러리

      1
      2
      3
      4
      5
      6
      7
      n = int(input())
      array = []

      for _ in range(n):
          array.append(int(input()))

      array = sorted(array)

Comment and share

Yechan Kim

author.bio


author.job