Zum Inhalt springen
BlogDatenbankenWie Django die Schwerstarbeit für SQL übernimmt

Wie Django die Schwerstarbeit für SQL übernimmt

Wie Django das schwere Heben übernimmt - Blog Header

Pythonund vor allem Django sind unerlässlich, um effizientere Anwendungen mit weniger Code zu erstellen, die mit einer hochskalierbaren Datenbank verbunden sind. Ich bin hier, um mit Ihnen über die Verringerung der alltäglichen Reibung zu sprechen, die mit der Erstellung und Unterstützung moderner Anwendungen einhergeht, indem ich SQL und Python verwende, um die Komplexität zu abstrahieren und unsere Arbeit und unser Leben ein wenig einfacher zu machen.

Ohne in die Tiefe zu gehen, können wir davon ausgehen:

  • SQL ist für SQL-Datenbanken optimiert
  • Python ist nicht für SQL-Datenbanken optimiert

Diese Übung unterstützt direkt das E-Book "Understanding Databases " und meine neue Linode LIVE! Schulungsreihe, in der ich Python und Pythonic-Tools verwende, um Befehle in Roh-SQL auszuführen, ohne tatsächlich SQL schreiben zu müssen. Ich verwende die Datenmodellierung von Django, aber die Syntax ist dem SQLAlchemy-Paket in Python sehr ähnlich.

Fangen wir an!
Hier
ist ein Beispiel für ein Django-Datenmodell:

class BlogArticle(models.Model):
    user = models.ForeignKey(User, default=1, on_delete=models.SET_DEFAULT)
    title = models.CharField(max_length=120)
    slug = models.SlugField(blank=True, null=True)
    content = models.TextField(blank=True, null=True)
    publish_timestamp = models.DateTimeField(
        auto_now_add=False,
        auto_now=False,
        blank=True,
        null=True,
    )

Nehmen wir an, dieses Modell befindet sich in einer Django-App namens Articles (Django-Apps sind im Wesentlichen Komponenten, die die Gesamtheit eines Django-Projekts ausmachen).

Wir haben jetzt also zwei Namen, mit denen wir arbeiten können:

  • Articles (Name der Anwendung)
  • BlogArticle (Modellname)

In Kombination ergeben sie den SQL-Tabellennamen:

articles_blog_article

Django erledigt diesen Zauber für uns.

Wenn wir die MySQL-Shell verwenden würden, würden wir sehen:

mysql> SHOW TABLES;
+------------------------------+
| Tables_in_cfe_django_blog_db |
+------------------------------+
| articles_blog_article        |
| auth_group                   |
| auth_group_permissions       |
| auth_permission              |
| auth_user                    |
| auth_user_groups             |
| auth_user_user_permissions   |
| django_admin_log             |
| django_content_type          |
| django_migrations            |
| django_session               |
+------------------------------+
11 rows in set (0.01 sec)

Schauen wir uns nun die Spalten in unserem Django-Modell an:

mysql> DESCRIBE articles_blog_article;
+------------------------+--------------+------+-----+---------+----------------+
| Field                  | Type         | Null | Key | Default | Extra          |
+------------------------+--------------+------+-----+---------+----------------+
| id                     | bigint       | NO   | PRI | NULL    | auto_increment |
| title                  | varchar(120) | NO   |     | NULL    |                |
| slug                   | varchar(50)  | YES  | MUL | NULL    |                |
| content                | longtext     | YES  |     | NULL    |                |
| publish_timestamp      | datetime(6)  | YES  |     | NULL    |                |
| user_id                | int          | NO   | MUL | NULL    |                |
+------------------------+--------------+------+-----+---------+----------------+
12 rows in set (0.00 sec)

Abgesehen von der Erstellung einer grundlegenden Konfiguration hat Django die gesamte SQL-Arbeit in dieser MySQL-Datenbank für uns erledigt - und dabei hat Django nichts Beeindruckendes geleistet. Tatsächlich ist der größte Teil dieser Übung nicht dazu gedacht, Django oder Python als SQL-Ersatz hervorzuheben, sondern um Sie daran zu erinnern, dass Abstraktionen funktionieren.

Der Aufstieg von Python und die Kosten der Reibung

Lassen Sie uns über den Weg des geringsten Widerstands sprechen und darüber, warum ich glaube, dass Python eine der besten Möglichkeiten zur Nutzung von SQL ist.

Es ist sehr einfach, Python zu schreiben, zu lesen, auszuführen UND zu versenden. Ändern Sie "Python" in fast jedes andere Programmierparadigma und es ist fast unmöglich, die gleiche Aussage zu treffen. JavaScriptist auch ein Anwärter, aber es wird auch ständig mit Java verwechselt. Ich weiß, dass dies Verallgemeinerungen sind und nicht immer zutreffen, aber es sind häufige Probleme, die bei der Entwicklung Ihrer Anwendung auftauchen.

Ich glaube, dass diese Verallgemeinerungen aufgrund der an das Englische angelehnten Syntax, mit der PythonDinge tut, eher zutreffen.

Vergleichen wir eine SQL-Anweisung mit einer Python und Django-Anweisung:

  • SQL: SELECT * from articles_blog_article;
  • Python und Django: items = BlogArticle.objects.all()

Beide Anweisungen liefern genau die gleichen Daten. Die Anweisung Python liefert jedoch eine Liste von Python Objekten (items), die fast jeder Python Entwickler mit unterschiedlicher Erfahrung verwenden kann. Die rohen SQL-Ergebnisse müssten vor der Verwendung in einer Python -Anwendung konvertiert werden.

Feldbeschreibungen
Schauen wir uns diese SQL-Feldbeschreibung genauer an:

+------------------------+--------------+------+-----+---------+----------------+
| Field                  | Type         | Null | Key | Default | Extra          |
+------------------------+--------------+------+-----+---------+----------------+
| title                  | varchar(120) | NO   |     | NULL    |                |
+------------------------+--------------+------+-----+---------+----------------+

Im Gegensatz zu dieser Django-Feldbeschreibung:

title = models.CharField(max_length=120)

  • Welche hat mehr Reibung?
  • Welches von beiden ist leichter zu verstehen?

Die gerade genug Informationen liefert?

Wenn Sie kein Programmierer sind und sehen varchar(120)was würden Sie davon halten? Ich bin mir ziemlich sicher, dass Sie zumindest erraten können, was max_length=120 means. Das Tolle daran ist, dass sie genau das Gleiche bedeuten: Begrenzen Sie dieses Feld auf höchstens 120 Zeichen.

Hinzufügen von Daten zur Datenbank

Mit Django:

BlogArticle.objects.create(
    title="Hello World",
    content="Coming Soon",
    slug="hello-world",
    publish_timestamp=None,
)

Mit SQL:

INSERT INTO `articles_blog_article` (`user_id`, `title`, `slug`, `content`, `publish_timestamp`) 
VALUES (1, 'Hello World', 'hello-world', 'Coming Soon', NULL);

Wenn es um Einfachheit und Klarheit geht, sind Django und Python meiner Meinung nach eindeutig die Gewinner. title = "Hello World" ist einfacher, als herauszufinden, was mit dem entsprechenden Spalten- (Feld-) Wert in SQL los ist. Machen Sie keinen Fehler, die Art und Weise, wie dies in SQL geschrieben ist, ist sehr effektiv, wenn Sie wissen, was Sie tun.

Hinzufügen mehrerer Zeilen
mit Django:

items = [
    BlogArticle(title='Hello Again 0', slug='hello-again-0', content="Coming Soon"),
    BlogArticle(title='Hello Again 1', slug='hello-again-1', content="Coming Soon"),
    BlogArticle(title='Hello Again 2', slug='hello-again-2', content="Coming Soon"),
    BlogArticle(title='Hello Again 3', slug='hello-again-3', content="Coming Soon"),
    BlogArticle(title='Hello Again 4', slug='hello-again-4', content="Coming Soon"),
]
BlogArticle.objects.bulk_create(items)

Mit SQL:

INSERT INTO `articles_blog_article` (`user_id`, `title`, `slug`, `content`, `publish_timestamp`) 
VALUES (1, 'Hello Again 0', 'hello-again-0', 'Coming Soon', NULL),
    (1, 'Hello Again 1', 'hello-again-1', 'Coming Soon', NULL),
    (1, 'Hello Again 2', 'hello-again-2', 'Coming Soon', NULL),
    (1, 'Hello Again 3', 'hello-again-3', 'Coming Soon', NULL),
    (1, 'Hello Again 4', 'hello-again-4', 'Coming Soon', NULL);

Auch hier ist der Code von Python besser lesbar, während der SQL-Code mehr Einblick in die tatsächlichen Daten gibt. Und wieder einmal schreibt Python diesen SQL-Code für uns unter Verwendung des obigen Django-Codes. Ziemlich klasse, oder?

Der Grund, warum ich mich in diesen Vergleich vertieft habe, ist nicht, um herauszufinden, welcher Weg der beste ist, um SQL-Datenbanken zu nutzen, sondern um die Fähigkeit von Pythonhervorzuheben, den Aufwand für das Erlernen des direkten Schreibens von Roh-SQL zu reduzieren.

Es gibt mehrere Python Pakete, die im Wesentlichen das rohe SQL für Sie schreiben, hier sind ein paar von ihnen:

  • Django
  • Pandas
  • SQLAlchemy
  • Polare
  • Dask
  • Vaex
  • Pythoneingebautes CSV-Modul
  • Schildkröte ORM
  • Pony ORM
  • SQLObject

Django erledigt die Schwerstarbeit
Objektrelationale Mapping-Pakete (gemeinhin als ORMs bezeichnet) sind die geheime Soße dafür, wie Python SQL-Datenbanken nutzen kann. Ich betrachte ein ORM als einen Mittelsmann, der dabei hilft, Daten in der nativen Syntax einer bestimmten Programmiersprache zu bewegen.

Zu Beginn dieser Übung haben wir bereits gesehen, wie sich dies auf Django übertragen lässt, aber lassen Sie uns das jetzt vertiefen.

Angenommen, wir haben Daten in unserer Datenbank, können wir einen Befehl wie diesen schreiben:

my_post = BlogArticle.objects.first()
Diese Anweisung fragt unsere Datenbank ab, extrahiert die Daten, lädt sie in eine Instanz einer Python Classund weisen Sie es dann der Variablen my_post.

Von hier aus können wir nun etwa so vorgehen:

# using a django-managed python shell
# via python manage.py shell
>>> print(my_post.title)
Hello World

In diesem Fall haben wir die Punktnotation verwendet, um auf die title Feld, das in der Datei BlogPost Django-Modell aus dem vorherigen Abschnitt. Dieses Feld entspricht einer Spalte in unserer SQL-Datenbanktabelle articles_blog_article.

Dank des ORM können wir dies tun:

>>> my_post.title = "some other title"

In diesem Beispiel der Python Shell-Sitzung wird die my_post.title wird nun immer sein "some other title". Die zugrundeliegende SQL-Datenbank erkennt jedoch immer noch genau diese Daten als Hello World. Die Datenbank behält die ursprünglichen Daten bei, bis Python schließlich einen Commit ausführt (aka .save()) diese Datenänderung in der Datenbank. Wenn Python diese Daten nie festschreibt, werden sie auch nie in der Datenbank aktualisiert, was ein Teil der Magie des ORM ist. Wir können verwenden. und ändern die Daten, ohne die tatsächlich gespeicherten Daten zu beeinflussen. Wenn wir ändern wollen, was tatsächlich in der Datenbank passiert, führen wir aus:

>>> my_post.title = "some other title again"
>>> my_post.save()

Nach der Ausführung .save() wird unsere Datenbank für diese bestimmte Zeile den Spaltentitel so aktualisieren, dass er genau dem entspricht, was oben als Zeichenfolge Python geschrieben wurde. Vergessen Sie nicht, dass die .save() Methode ist speziell für die Durchführung von Commits an die Datenbank in Django-Modellen. .save() bedeutet eigentlich nichts für einen Python Class ohne dass es zuerst eine Django Model-Klasse erbt.

Bauen mit Django, MySQL und Linode

Dies ist nur eines von vielen Beispielen dafür, wie Django die schwere Arbeit für Sie übernimmt. Wenn Sie an einem modernen Ansatz für die Bereitstellung von Django-Anwendungen auf Linode zusammen mit einer verwalteten MySQL-Datenbank, GitHub-Aktionen für CI/CD, Terraform und Ansible interessiert sind, sehen Sie sich die folgenden Inhalte an, die jetzt auf Linode verfügbar sind:

Um Ihnen den Einstieg zu erleichtern, finden Sie auf dem Coding for Entrepreneurs GitHub ein Repository mit Code, der zu jedem Schritt der Serie gehört. Viel Glück, und lassen Sie mich über Twitter @JustinMitchel wissen, wie es läuft.


Kommentare

Kommentar abgeben

Ihre E-Mail Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit *gekennzeichnet