Heim > Artikel > Backend-Entwicklung > 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.
Für die Installation des Datenbank-Frameworks können Sie es mit pip installieren. Der Befehl lautet wie folgt:
pip install databases==0.4.*
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.
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.
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!