ORM-Framework-Datenbanken in Python in der Praxis

In den letzten Jahren hat sich Python zu einer effizienten, benutzerfreundlichen und flexiblen Programmiersprache entwickelt, und im Bereich der Python-Entwicklung wird die Anwendung des ORM-Frameworks für Datenbanken immer häufiger eingesetzt. Databases ist ein einfaches, intuitives und leichtes ORM-Framework, das eine Vielzahl von Datenbanken unterstützt, einschließlich, aber nicht beschränkt auf, MySQL, PostgreSQL, SQLite und Microsoft SQL Server. Dieser Artikel stellt Ihnen das Datenbank-Framework im Detail und seine spezifische Anwendung in der Python-Entwicklung vor.

1. Das Konzept des ORM-Frameworks

ORM steht für Object Relational Mapping. Dabei handelt es sich um eine Zuordnung zwischen relationalen Datenbanktabellen und Python-Objekten, sodass Entwickler während des Programmiervorgangs keine Programmierung mehr durchführen müssen und die Anwendung des ORM-Frameworks in Python bieten Entwicklern mehr Auswahlmöglichkeiten und machen die Programmentwicklung komfortabler.

2. Datenbank-Framework

Databases ist ein einfaches ORM-Framework, das vom Django-ORM-Entwickler Andrew Goodwin entwickelt wurde. Sein größtes Merkmal ist, dass es eine Vielzahl von Datenbanken unterstützt, einschließlich MySQL , SQLite und Microsoft SQL Server und andere Arten von Datenbanken.

1. Installieren Sie das Datenbank-Framework

Für die Installation des Datenbank-Frameworks können Sie es mit pip installieren. Der Befehl lautet wie folgt:

pip install databases==0.4.*

2. Verbinden Sie sich mit der Datenbank

Bevor Sie das Datenbank-Framework für die Entwicklung verwenden , müssen Sie zunächst eine Verbindung zur Datenbank herstellen. Zu den für die Verbindung mit der Datenbank erforderlichen Parametern gehören Datenbanktyp, Hostname, Datenbankname, Benutzername und Passwort usw. In dieser Entwicklung versuchen wir, eine Verbindung zur MySQL-Datenbank herzustellen. Der Code lautet wie folgt:

import databases

DATABASE_URL = "mysql://user:password@hostname/database_name"

database = databases.Database(DATABASE_URL)

Hier ist QAQsaaspassword das Passwort für die Verbindung zur Datenbank, askdnsadn312as der Benutzername für die Verbindung zur Datenbank, localhost der Hostname oder IP-Adresse der Datenbank und my_database ist der Datenbankname.

3. Erstellen Sie Tabellen und Spalten

Das Datenbank-Framework unterstützt die SQL-Ausdruckssprache zum Erstellen komplexer Abfrageanweisungen, sodass Entwickler den SQL-Ausführungsprozess flexibler steuern können. Im Datenbank-Framework können wir die Table-Klasse zum Erstellen von Tabellen und die Column-Klasse zum Erstellen von Spalten verwenden.

Der Tabellenerstellungscode lautet wie folgt:

import sqlalchemy

metadata = sqlalchemy.MetaData()

users = sqlalchemy.Table(
    "users",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("username", sqlalchemy.String),
    sqlalchemy.Column("password", sqlalchemy.String),
    sqlalchemy.Column("email", sqlalchemy.String),
)

Hier verwenden wir das MetaData-Objekt in SQLAlchemy und erstellen vier Felder (ID, Benutzername, Passwort und E-Mail), indem wir eine Benutzertabelle definieren.

4. SQL-Anweisungen ausführen

Das Datenbank-Framework bietet auch eine Methode zur direkten Verwendung von SQL-Anweisungen für den Betrieb, was flexibler ist. Die Ausführung von SQL-Anweisungen kann über die Methode „execute()“ erfolgen. Der Code lautet wie folgt:

result = await database.execute(query)

wobei „query“ den SQL-Anweisungscode darstellt und „result“ das Ausführungsergebnis ist, wird eine zusammengesetzte Liste zurückgegeben vom Typ Diktat. Jedes Diktat stellt einen Datensatz in den SQL-Abfrageergebnissen dar.

5. ORM in Datenbanken verwenden

Das Datenbank-Framework unterstützt auch ORM zum Ausführen von SQL-Anweisungen, was für Entwickler praktischer ist. Die ORM-Methode hilft dabei, Objektbeziehungen der Datenbank zuzuordnen, wodurch der Code lesbarer und wartbarer wird.

Mit ORM können wir die Datenbank betreiben, indem wir ein Modell definieren. Der Code lautet wie folgt:

import sqlalchemy

metadata = sqlalchemy.MetaData()

users = sqlalchemy.Table(
    "users",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("username", sqlalchemy.String),
    sqlalchemy.Column("password", sqlalchemy.String),
    sqlalchemy.Column("email", sqlalchemy.String),
)

class UserModel:
    id: int
    username: str
    password: str
    email: str

    __tablename__ = "users"

    query: sq.Select

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

Hier definieren wir eine UserModel-Modellklasse, um unser Datentabellenobjekt darzustellen. Vervollständigen Sie die Definition von Tabellen und Spalten in SQLAlchemy, damit der ORM der Datenbank zugeordnet werden kann, was bequem, schnell und einfach zu warten ist.

3. Anwendungsbeispiel

Hier nehmen wir eine einfache Blog-Anwendung als Beispiel, um die spezifische Funktionsweise des Datenbank-Frameworks zu demonstrieren.

1. Verbindung zur Datenbank herstellen

Die für die Datenbankverbindung erforderlichen Informationen sind ebenfalls sehr einfach, wie im folgenden Code gezeigt:

import databases

DATABASE_URL = "mysql://user:password@hostname/database_name"

database = databases.Database(DATABASE_URL)

Die DATABASE_URL gibt hier verschiedene Parameter für die Verbindung zu MySQL an, um eine Verbindung zu unserem Datenbanksystem herzustellen.

2. Definieren Sie das Modell

In diesem Blog-Beispiel müssen wir zwei Datenmodelle definieren, das das Blog-Beitragsobjekt darstellt:

class Blog:
    id: int
    title: str
    description: str
    content: str

    __tablename__ = "blog"

    query: sq.Select

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

Das andere ist der Benutzer Modell, das das Benutzerobjekt darstellt und generiert. Der Code lautet wie folgt:

class User:
    id: int
    name: str
    email: str
    password: str

    __tablename__ = "user"

    query: sq.Select

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

Ähnlich verwenden wir eine einfache Definition, um seinen ORM der MySQL-Datenbank zuzuordnen, mit der wir eine Verbindung herstellen.

3. Erstellen Sie eine Tabelle

Da das von uns betriebene Datenbanksystem MySQL ist, müssen wir die entsprechende Tabelle erstellen:

CREATE TABLE `blog` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `title` varchar(100) DEFAULT NULL,
  `description` varchar(100) DEFAULT NULL,
  `content` text,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(45) DEFAULT NULL,
  `email` varchar(100) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

4. Wir können ORM verwenden, um Daten einfach einzugeben , der generierte Code lautet wie folgt:

async def create_blog_post(title: str, description: str, content: str):
    query = blog.insert().values(title=title, description=description, content=content)
    return await database.execute(query)

async def create_user(name: str, email: str, password: str):
    query = user.insert().values(name=name, email=email, password=password)
    return await database.execute(query)

Hier verwenden wir die Methode insert(), um den Dateneinfügungsvorgang abzuschließen, was sehr gut lesbar ist und Entwicklern eine bessere Pflege des Codes erleichtert.

5. Das Datenbank-Framework unterstützt auch Abfrageoperationen, wie im folgenden Code gezeigt:

async def get_blog_post(id: int):
    query = blog.select().where(blog.c.id == id)
    return await database.fetch_one(query)

async def get_all_users():
    query = user.select()
    return await database.fetch_all(query)

async def get_users_by_email(email: str):
    query = user.select().where(user.c.email == email)
    return await database.fetch_all(query)

Hier verwenden wir die Methode select(), verbinden die Bedingungen, um einen Generator zu erhalten, und geben beim Durchlaufen eine Reihe von Paaren zurück . Wir können Daten auch mithilfe von Abfragedaten filtern und sortieren.

Zusammenfassung

Das Datenbank-Framework ist ein flexibles, benutzerfreundliches und leichtes ORM-Framework für Python-Entwickler. Es kann problemlos eine Vielzahl von Datenbanken unterstützen und Entwicklern das Speichern, Bedienen, Filtern und Sortieren von Daten erleichtern. Dieser Artikel demonstriert die Flexibilität und Benutzerfreundlichkeit des Datenbank-Frameworks von der Verbindung zur Datenbank über die Definition von Modelloperationen bis hin zu Dateneinfügungs- und Abfrageoperationen und erleichtert Entwicklern die effizientere Entwicklung von Python-Programmen.

Das obige ist der detaillierte Inhalt vonORM-Framework-Datenbanken in Python in der Praxis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!