რა მეთოდებს იცნობ მონაცემთა ბაზებთან მუშაობისთვის?

• შენახული მოდულები:
  sqlite3 - მსუბუქი SDB SQLite-ისთვის. მოსახერხებელია მცირე პროექტებისთვის ან როგორც ფაილური მონაცემთა ბაზა მომხმარებელზე.

  import sqlite3
  
  # მონაცემთა ბაზასთან დაკავშირება (ფაილი შექმნის, თუ არ არსებობს)
  conn = sqlite3.connect('mydatabase.db')
  cursor = conn.cursor()
  
  # ცხრილის შექმნა
  cursor.execute('''
      CREATE TABLE IF NOT EXISTS users (
          id INTEGER PRIMARY KEY,
          name TEXT NOT NULL,
          age INTEGER
      )
  ''')
  
  # მონაცემების შეტანა
  cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
  
  # ცვლილებების დადასტურება
  conn.commit()
  
  # მონაცემების მიღება
  cursor.execute("SELECT name, age FROM users")
  rows = cursor.fetchall()
  for row in rows:
      print(row)
  
  # კავშირის დახურვა
  conn.close()
  

• Python DB API (PEP-249):
  სტანდარტული ინტერფეისი, რომელიც განსაზღვრავს უმეტესწილად მესამე მხარის დრაივერებს სხვადასხვა მონაცემთა ბაზებისთვის (PostgreSQL, MySQL, Oracle და სხვა). საშუალებას აძლევს დაწეროთ კოდი, რომელიც არ არის კონკრეტული SDB-ზე დამოკიდებული.

• სპეციალიზებული დრაივერები/კონექტორები:
  ბიბლიოთეკები, რომლებიც ახორციელებენ Python DB API-ს კონკრეტული SDB-ებისთვის:

  • psycopg2 - PostgreSQL-ისთვის.
  • mysql-connector-python ან PyMySQL - MySQL-ისთვის.
  • cx_Oracle - Oracle-ისთვის.
  • pymssql - Microsoft SQL Server-ისთვის:

  import psycopg2
  
  # დაკავშირება PostgreSQL-სთან
  try:
      conn = psycopg2.connect(
          host="localhost",
          database="mydatabase",
          user="myuser",
          password="mypassword"
      )
      cursor = conn.cursor()
  
      # SQL შეკვეთა
      cursor.execute("SELECT * FROM products;")
      results = cursor.fetchall()
      for row in results:
          print(row)
  
      conn.close()
  except psycopg2.Error as e:
      print(f"დატვირთვის შეცდომა მონაცემთა ბაზასთან: {e}")
  

• ORM (ობიექტ-რელაციური რუკა):
  ჩარჩოები, რომლებიც საშუალებას აძლევენ მუშაობას მონაცემთა ბაზებთან Python ობიექტების გამოყენებით, არა პირდაპირ SQL შეკვეთებით. ამარტივებს ურთიერთქმედებას მონაცემთა ბაზასთან, უზრუნველყოფს აბსტრაქციას, ეხმარება SQL ინექციების თავიდან აცილებაში.

  • SQLAlchemy - ერთ-ერთი ყველაზე ძლიერი და მოქნილი ORM Python-ში. მხარს უჭერს მრავალი SDB-ს, უზრუნველყოფს როგორც "Core" (საკონტექსტო SQL-ის დონეზე მუშაობა), ასევე "ORM" (ობიექტური მიდგომა).
  • Django ORM - Django-ის შიდა ORM, ძალიან მოსახერხებელია Django-ის ვებ-პროექტებში მონაცემთა ბაზებთან მუშაობისთვის.
  • Peewee - მარტივი და მსუბუქი ORM:

  მაგალითი SQLAlchemy Core-ით:

  from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, select
  
  # დაკავშირება მონაცემთა ბაზასთან (მაგ., SQLite)
  engine = create_engine('sqlite:///mydatabase.db')
  
  # MetaData ობიექტი მონაცემთა ბაზის მეტადატებისთვის
  metadata = MetaData()
  
  # ცხრილის განსაზღვრა
  users_table = Table(
      'users',
      metadata,
      Column('id', Integer, primary_key=True),
      Column('name', String),
      Column('age', Integer)
  )
  
  # ცხრილის შექმნა მონაცემთა ბაზაში (თუ არ არსებობს)
  metadata.create_all(engine)
  
  # დაკავშირება
  with engine.connect() as connection:
      # მონაცემების შეტანა
      connection.execute(
          users_table.insert().values(name='Bob', age=25)
      )
  
      # მონაცემების კითხვა
      select_query = select(users_table)
      result = connection.execute(select_query)
  
      for row in result:
          print(row)
  

  მაგალითი ORM-ით:

  from sqlalchemy import create_engine, Column, Integer, String
  from sqlalchemy.ext.declarative import declarative_base
  from sqlalchemy.orm import sessionmaker
  
  # მონაცემთა ბაზასთან დაკავშირება
  engine = create_engine('sqlite:///mydatabase_orm.db')
  
  # ORM მოდელების ძირითადი კლასი
  Base = declarative_base()
  
  # ORM მოდელის განსაზღვრა
  class User(Base):
      __tablename__ = 'users_orm'
      id = Column(Integer, primary_key=True)
      name = Column(String)
      age = Column(Integer)
  
      def __repr__(self):
          return f"<User(name='{self.name}', age={self.age})>"
  
  # ცხრილის შექმნა (თუ არ არსებობს)
  Base.metadata.create_all(engine)
  
  # სესიის ფაბრიკის შექმნა
  Session = sessionmaker(bind=engine)
  session = Session()
  
  # ობიექტის შექმნა და დამატება
  new_user = User(name='Charlie', age=40)
  session.add(new_user)
  
  # ტრანზაქციის დადასტურება
  session.commit()
  
  # ობიექტის მიღება
  user = session.query(User).filter_by(name='Charlie').first()
  print(user)
  
  # სესიის დახურვა
  session.close()
  

• NoSQL მონაცემთა ბაზები:
  NoSQL ბაზებთან მუშაობისთვის გამოიყენება სპეციალიზებული ბიბლიოთეკები, მაგალითად:

  • pymongo - MongoDB-ისთვის.
  • redis - Redis-ისთვის.
  • cassandra-driver - Cassandra-ისთვის:

მოდელის არჩევა დამოკიდებულია პროექტის მოთხოვნებზე, გამოყენებული SDB ტიპზე, ORM-ის საჭიროებაზე და პროექტის სირთულეზე.