Python - Database

Python - Database

몽고DB(MongoDB)는 NoSQL 데이터베이스 중 하나로, 데이터를 문서(document) 형식으로 저장하는 문서 지향형 데이터베이스입니다. 관계형 데이터베이스와는 다른 구조와 기능을 가지고 있으며, 데이터를 유연하게 저장하고 처리할 수 있는 특성을 가지고 있습니다. 주요 특징과 기본 개념을 중심으로 MongoDB를 설명하겠습니다.

1. MongoDB의 특징

• 문서 지향(Document-Oriented) 저장: MongoDB는 데이터를 BSON (Binary JSON) 형식으로 저장합니다. BSON은 JSON과 유사한 구조를 가지며, 이는 데이터의 유연한 구조를 가능하게 합니다. 각 문서(Document)는 JSON-like 객체로 저장되며, 필드마다 다양한 데이터 타입을 가질 수 있습니다.
• 스키마리스(Schemaless): MongoDB는 관계형 데이터베이스처럼 미리 스키마(데이터 구조)를 정의하지 않아도 됩니다. 각 문서가 다른 필드를 가질 수 있어, 데이터 구조가 자주 변경되는 애플리케이션에 유리합니다.
• 수평적 확장(Sharding): MongoDB는 대량의 데이터를 처리할 수 있도록 샤딩(Sharding) 기능을 제공합니다. 데이터가 매우 커질 경우, 여러 서버에 분산 저장할 수 있어 대규모 데이터를 효율적으로 처리할 수 있습니다.
• 고성능: MongoDB는 자동 인덱스 생성, 인메모리 저장(캐시), 빠른 쿼리 처리 등을 통해 대용량 데이터에서도 빠른 성능을 제공합니다.
• 유연한 쿼리 언어: SQL을 사용하지 않고, JSON 형식의 쿼리를 사용합니다. MongoDB는 CRUD (Create, Read, Update, Delete) 작업을 쉽게 할 수 있는 다양한 쿼리 기능을 제공합니다.
• 복제(Replication): MongoDB는 Replica Set을 사용하여 고가용성을 제공합니다. Replica Set은 동일한 데이터를 여러 서버에 복제해 놓는 방식으로, 하나의 서버에 문제가 생기면 다른 서버가 데이터를 유지하고 서비스 가용성을 확보할 수 있습니다.

2. MongoDB의 주요 개념

• Database: MongoDB는 여러 데이터베이스를 가질 수 있습니다. 각 데이터베이스는 여러 컬렉션(collection)으로 구성됩니다.
• Collection: MongoDB에서 컬렉션(collection)은 SQL의 테이블과 유사합니다. 하지만 컬렉션 안에 저장되는 문서는 서로 다른 구조를 가질 수 있습니다. 즉, 테이블처럼 스키마에 고정되지 않습니다.
• Document: 문서는 MongoDB의 기본 데이터 단위로, JSON 객체와 유사한 형식입니다. 각 문서는 키-값 쌍으로 이루어져 있으며, 해당 문서에 저장된 데이터의 구조는 자유롭습니다.
• Field: 문서 내에서 데이터를 저장하는 키-값 쌍의 각 항목을 필드(field)라고 합니다. 필드의 데이터는 다양한 자료형을 가질 수 있습니다 (숫자, 문자열, 배열, 객체 등).
• Index: MongoDB는 특정 필드에 인덱스를 생성할 수 있습니다. 인덱스를 사용하면 쿼리 성능을 대폭 향상시킬 수 있습니다.
• Replica Set: MongoDB에서 데이터를 복제하는 방법입니다. 하나의 주(primary) 서버와 여러 개의 보조(secondary) 서버로 구성됩니다. 주 서버가 쓰기 작업을 처리하고, 보조 서버는 읽기 작업을 보조하며 주 서버의 데이터를 복제합니다.
• Sharding: 큰 데이터를 여러 서버에 나누어 저장하는 방식입니다. 이를 통해 단일 서버가 처리할 수 없는 대규모 데이터를 여러 서버에서 분산 처리할 수 있습니다.

3. MongoDB의 CRUD 작업 예시

• Create (삽입):
• db.collection.insert_one({"name": "Alice", "age": 25, "city": "New York"})
• Read (조회):
• db.collection.find({"name": "Alice"})
• Update (수정):
• db.collection.update_one({"name": "Alice"}, {"$set": {"age": 26}})
• Delete (삭제):
• db.collection.delete_one({"name": "Alice"})

4. MongoDB의 장점

• 유연한 데이터 모델: 정해진 스키마 없이도 다양한 형식의 데이터를 저장할 수 있어, 데이터 구조의 유연성이 큽니다.
• 빠른 개발 속도: 스키마가 없으므로 개발자가 데이터 구조 변경에 자유로우며, 빠르게 데이터를 처리하고 새로운 기능을 추가할 수 있습니다.
• 확장성: 데이터를 쉽게 분산 저장할 수 있어, 대규모 데이터를 처리하는 시스템에서 매우 효율적입니다.

5. MongoDB의 단점

• 트랜잭션 처리의 제약: 관계형 데이터베이스에서 제공하는 복잡한 트랜잭션 관리가 상대적으로 제한적입니다. 하지만 최근 MongoDB는 트랜잭션을 지원하기 시작했습니다.
• 메모리 사용: MongoDB는 메모리 사용량이 클 수 있으며, 적절한 메모리 관리가 필요합니다.
• 관계 데이터 처리의 복잡성: 여러 테이블을 연결하여 처리하는 JOIN 연산이 없거나 제한적이어서, 복잡한 관계 데이터를 처리하는 경우에는 비효율적일 수 있습니다.

6. MongoDB 사용 사례

MongoDB는 유연한 데이터 구조 덕분에 여러 분야에서 많이 사용됩니다:

• 소셜 미디어: 사용자의 활동 로그, 프로필, 메시지 데이터를 처리할 때 적합.
• 전자상거래: 상품 목록, 재고 관리, 주문 데이터를 효율적으로 처리.
• 빅데이터 분석: 수많은 데이터를 빠르게 저장하고 분석할 수 있음.

MongoDB는 대규모 데이터 처리와 빠른 개발 속도가 필요한 곳에서 많이 사용되며, 특히 클라우드 기반 애플리케이션, 실시간 웹 애플리케이션, 모바일 앱 백엔드 등에 유용하게 활용됩니다.

pip install pymysql

import pymysql

conn = pymysql.connect(host="10.100.204.83",user='db7',
                       password='1234', db='db7', charset='utf8')

print(conn)
class DaoSet:
  def connect(self):
    self.con =  pymysql.connect(host="10.100.204.83",user='db7',
                       password='1234', db='db7', charset='utf8')
    return self.con
  def disconnect(self):
    try:
      if self.con != None:
        self.con.close()
      if self.cursor != None:
        self.cursor.close();
    except Exception as e:
      print(e)

---

from analysisVisualization.database.dao.DaoSet import DaoSet

con = DaoSet().connect()
if con != None:
  print('Succeeded Connection!')
else:
  print('Connection Failed!')

import pymysql

class DaoSet:
  def connect(self):
    self.con = pymysql.connect(host='10.100.204.26', user='db7', password='1234',
                               db="db7", charset='utf8')
    return self.con

  def disconnect(self):
    try:
      if self.con != None:
        self.con.close()
      if self.cursor != None:
        self.cursor.close();
    except Exception as e:
      print(e)

class Member:
  @property
  def memno(self): return self.__memno

  @memno.setter
  def memno(self, memno): self.__memno = memno

  @memno.getter
  def memno(self): return self.__memno

  @property
  def name(self): return self.__name

  @name.setter
  def name(self, name): self.__name = name

  @name.getter
  def name(self): return self.__name

  @property
  def id(self): return self.__id

  @id.setter
  def id(self, id): self.__id = id

  @id.getter
  def id(self): return self.__id

  @property
  def pw(self): return self.__pw

  @pw.setter
  def pw(self, pw): self.__pw = pw

  @pw.getter
  def pw(self): return self.__pw

  def __str__(self): return \
    f'{self.memno},{self.name},{self.id},{self.pw}'

  @classmethod # -> 해당 함수의 return 값의 타입
  def from_str(cls, member_from_str) -> 'Member':
    mem_list = member_from_str.spli('/')
    member = Member()
    member.memno = mem_list[0]
    member.name = mem_list[1]
    member.id = mem_list[2]
    member.id = mem_list[2]
    return member

from analysisVisualization.database.dao.DaoSet import DaoSet as dao

'''
CREATE TABLE member7(
    memno INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(20) NOT NULL,
    id VARCHAR(20) NOT NULL,
    pw VARCHAR(20) NOT NULL);
'''
class MemberDao(dao):
  def __init__(self):
    self.con = dao.connect(self)
    self.cursor = self.con.cursor()

  def __del__(self):
    try:
      self.disconnect()
    except Exception as e:
      print(e)

  def get_all(self):
    # cur = self.con.cursor()
    # sql = "select * from member7 "
    # cur.execute(sql)
    # return cur.fetchall()
    rs = self.cursor.execute("select * from member7 ")
    return rs.fetchall()

  def login_check(self, mem):
    rs = self.cursor.execute(f"select * from member7 "
                             f"where id='{mem.id}' and pw='{mem.pw}'")
  def insert_one(self, mem):
    self.cursor.execute(f"insert into member7 (id, name, pw) "
                        f"values('{mem.id}','{mem.name}','{mem.pw}') ")

  def modify_one(self, mem):
    self.cursor.execute(f"update member7 set name='' , pw='' "
                        f"where id='{mem.id}' ")
    self.con.commit()
    return self.cursor.rowcount

  def delete_one(self, mem):
    self.cursor.execute(f"delete from member7 where id='{mem.id}' ")
    self.con.commit()
    return self.cursor.rowcount

ui

def center_win(window, w, h) :
  x_pos = int(window.winfo_screenwidth() / 2 - w / 2)
  y_pos = int(window.winfo_screenwidth() /2 -h/2)
  window.geometry(f'{w}X{h}+{x_pos}+{y_pos}')

import tkinter.font
from tkinter import *
from tkinter import messagebox
from analysisVisualization.database.dao.DaoMember import MemberDao

class LoginWindow:
  def __init__(self):
    self.dao = MemberDao()
    self.window = Tk()
    self.id, self.pw = StringVar(), StringVar()

    font = tkinter.font.Font(family="맑은 고딕", size=12)
    # place() 절대 위치에 컴포넌트를 배치 할 수 있다.
    lbId = tkinter.Label(self.window, text="ID", font=font)
    lbPass = tkinter.Label(self.window, text="Pass", font=font)
    entryId = tkinter.Entry(self.window, relief="solid", borderwidth=1, font=font)
    entryPass = tkinter.Entry(self.window, relief="solid", borderwidth=1, font=font, show="*")

    lbId.place(x=10, y=8)
    entryId.place(x=50, y=10)
    lbPass.place(x=10, y=38)
    entryPass.place(x=50, y=40)

    btnLogin = Button(self.window, text="Login", width="10",
                      overrelief="groove", anchor="n", command=self.check_login)
    btnLogin.place(x=30, y=80)

    btnJoin = Button(self.window, text="Join", width="10",
                     overrelief="groove", anchor="n")
    btnJoin.place(x=130, y=80)

    entryId.focus()
    self.window.mainloop()

  def check_login(self):
    if str(self.entryId.get()) == "":
      messagebox.showinfo("알림", "ID를 확인하여 주세요")
      self.entryId.focus()
      return

    if str(self.entryPass.get()) == "":
      messagebox.showinfo("알림", "Password를 확인하여 주세요")
      self.entryPass.focus()
      return

class MemberController(object):

    #싱글톤 패턴
  def __new__(cls, *args, **kwargs):
    if not hasattr(cls, 'instance'):
      cls.instance = super(MemberController, cls).__new__(cls)
      print("Singleton 주소 :",cls.instance)
    return cls.instance