Prisma ORM: Beginnen Sie mit dem Projekt mit JS

Was ist Prisma?

Prisma: ORM der nächsten Generation für Node.js und TypeScript

ORM: Object Relation Mapping ist eine Möglichkeit, mit Datenbanken mithilfe von OOP-Sprachen zu kommunizieren, ohne dass komplexe Abfragen geschrieben werden müssen.

• Prisma zielt darauf ab, Datenbanken für Entwickler einfach zu machen.
• Es bietet Typsicherheit, eine intuitive API und steigert die Entwicklerproduktivität.
• Konzentriert sich auf die Entwicklererfahrung.

Schlüsselkomponenten

• Prisma-Schema: Die einzige Quelle der Wahrheit für Ihr Datenbankschema. Definiert Modelle und ihre Beziehungen.
• Prisma Client: Automatisch generierter Abfrage-Builder, der auf Ihr Schema zugeschnitten ist. Bietet typsicheren Zugriff auf Ihre Datenbank.
• Prisma Migrate:Tool zum Verwalten von Datenbankschemamigrationen.

---

Warum Prisma?

1. Vereinfachung der Datenbankinteraktionen: Prisma ORM bietet intuitive Abfragen und Schemamigration.
2. Verbesserung der Codequalität: Prisma ORM generiert typsichere Abfragen und lässt sich in gängige IDEs integrieren.
3. Unterstützung mehrerer Datenbanken: Prisma ORM erleichtert die Anpassung und Erweiterung von Anwendungen. (z. B. MongoDB, MySQL, MariaDB, PostgreSQL, Microsoft SQL usw.)
4. Entschärfung der Probleme herkömmlicher ORMs: Prisma ORM behebt Probleme wie aufgeblähte Modellinstanzen und unvorhersehbare Abfragen.

Projekt-Setup

1. Projekteinrichtung

Erstellen Sie ein neues Projektverzeichnis

mkdir prisma-example
cd prisma-example

Initialisieren Sie ein Node.js-Projekt

npm init -y

Installieren Sie Prisma CLI

npm install prisma dotenv express --save-dev

Installieren Sie den Prisma-Client

npm install @prisma/client --save-dev

Dadurch wird der Prisma-Client für Ihre Datenbank installiert.

2. Prisma initialisieren

npx prisma init

Dadurch wird ein Prisma-Verzeichnis erstellt, das Folgendes enthält:

• schema.prisma: Ihre Prisma-Schemadatei.
• .env: Für Ihre Datenbankverbindungszeichenfolge.

3. Konfigurieren Sie die Datenbankverbindung

Wählen Sie eine Datenbank

Das Video verwendet wahrscheinlich PostgreSQL, aber Sie können dies an MySQL, SQLite oder andere anpassen. Für dieses Beispiel verwenden wir PostgreSQL.

Legen Sie die DATABASE_URL fest

Fügen Sie in Ihrer .env-Datei die Verbindungszeichenfolge hinzu. Beispiel für PostgreSQL:

DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"

Ersetzen Sie Ihren_Benutzer, Ihr_Passwort und Ihre_Datenbank durch Ihre tatsächlichen Anmeldeinformationen. Wenn Sie keinen lokalen PostgreSQL-Server haben, müssen Sie einen installieren und konfigurieren.

4. Definieren Sie die Datenmodelle (schema.prisma)

Ersetzen Sie den Inhalt von prisma/schema.prisma durch Folgendes:

mkdir prisma-example
cd prisma-example

5. Generieren Sie den Prisma-Client

npm init -y

Dadurch wird der typsichere Prisma-Client in node_modules/@prisma/client generiert.

6. Erstellen Sie eine Migration

npm install prisma dotenv express --save-dev

Dadurch wird eine neue Migrationsdatei im Verzeichnis prisma/migrations erstellt und auf Ihre Datenbank angewendet, wodurch die Tabellen erstellt werden. Der --name init gibt der Migration einen beschreibenden Namen.

7. Erstellen einer separaten Datei für Prisma Setup

Erstellen Sie eine db.config.js-Datei im Stammverzeichnis und fügen Sie den folgenden Code hinzu:

npm install @prisma/client --save-dev

Dadurch wird eine neue Instanz von PrismaClient erstellt und exportiert, sodass sie in anderen Dateien verwendet werden kann. Die Option log: ['query'] protokolliert alle Abfragen an der Konsole.

8. Erstellen einer einfachen Express-API, um die Funktionsweise von Prisma zu verstehen

1. Controller

Erstellen Sie eine Controllers.js-Datei im Stammverzeichnis des Projekts. Das Folgende ist der Code für CRUD-Operationen in der Datei „controllers.js“:

npx prisma init

2. Routen

Erstellen Sie eine Routes.js-Datei im Stammverzeichnis des Projekts. Das Folgende ist der Code für CRUD-Operationen in der Datei „routes.js“:

DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"

3. Server

Erstellen Sie eine server.js-Datei im Stammverzeichnis des Projekts. Das Folgende ist der Code für CRUD-Operationen in der Datei server.js:

generator client {
    provider = "prisma-client-js"
}

datasource db {
    provider = "postgresql" // Or "mysql", "sqlite", etc.
    url      = env("DATABASE_URL")
}

model Post {
    id        String   @id @default(uuid())
    title     String
    content   String?
    createdAt DateTime @default(now())
    author    User     @relation(fields: [user_id], references: [id])
    user_id   Int
}

model User {
    id    Int     @id @default(autoincrement())
    email String  @unique
    name  String?
    posts Post[]
}

9. Führen Sie das Skript aus

npx prisma generate

Dadurch wird das Skript ausgeführt, ein Benutzer und ein Beitrag in Ihrer Datenbank erstellt, dann der Benutzer aktualisiert und der Beitrag gelöscht.

Sie können Postman verwenden, um die API mit den folgenden Routen zu testen:

• POST: http://localhost:5000/api/users
• GET: http://localhost:5000/api/users
• GET: http://localhost:5000/api/users/1
• PUT: http://localhost:5000/api/users/1
• LÖSCHEN: http://localhost:5000/api/users/1

Legen Sie den Text in Postman für die POST-Anfrage als JSON mit den folgenden Daten fest:

npx prisma migrate dev --name init

Wichtige Punkte, die bei der Prisma-Syntax zu berücksichtigen sind

• findUnique/findFirst – um einen einzelnen Datensatz abzurufen, gibt kein Array zurück.
• findMany – um mehrere Datensätze abzurufen, gibt ein Array zurück.
• include – um die zugehörigen Daten einzuschließen.
• auswählen – um bestimmte Felder auszuwählen.
• Sie können nur eines der Attribute verwenden, entweder auswählen oder einschließen.

Beispiele für Prisma-Syntax

import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient({
    log: ["query"],
});

export default prisma;

Weitere Informationen zu Prisma-Aggregationen, Filterung, Reihenfolge und Beziehungen

1. Aggregationsfunktionen in Prisma

Prisma bietet mehrere Aggregationsfunktionen, mit denen Sie Berechnungen für Datensätze direkt in Ihren Datenbankabfragen durchführen können. Diese Funktionen sind nützlich, um Daten zusammenzufassen und Erkenntnisse zu gewinnen, ohne große Datenmengen in Ihre Anwendung abrufen zu müssen.

Allgemeine Aggregationsfunktionen

• _count: Zählt die Anzahl der Datensätze, die den angegebenen Kriterien entsprechen.
• _avg: Berechnet den Durchschnitt eines numerischen Feldes.
• _sum: Berechnet die Summe eines numerischen Feldes.
• _min: Ermittelt den Mindestwert eines Felds.
• _max: Ermittelt den Maximalwert eines Feldes.

Beispiele für Aggregation

Nehmen wir an, wir haben das folgende Produktmodell:

mkdir prisma-example
cd prisma-example

Zählen der Anzahl der Produkte in jeder Kategorie

npm init -y

Berechnung des Durchschnittspreises aller Produkte

npm install prisma dotenv express --save-dev

Ermitteln des Mindest- und Höchstpreises von Produkten in einer bestimmten Kategorie

npm install @prisma/client --save-dev

Summe der Preise für Produkte, die in der letzten Woche erstellt wurden

npx prisma init

2. Filterung in Prisma

Prisma bietet zahlreiche Filteroptionen, mit denen Sie Ihre Datenbank präzise abfragen können. Hier ist eine umfassende Übersicht mit Beispielen:

Grundlegende Filterung

• gleich (Standard):Prüft auf genaue Gleichheit.
  

  DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"
  

• nicht: Negiert eine Bedingung.
  

  generator client {
      provider = "prisma-client-js"
  }
  
  datasource db {
      provider = "postgresql" // Or "mysql", "sqlite", etc.
      url      = env("DATABASE_URL")
  }
  
  model Post {
      id        String   @id @default(uuid())
      title     String
      content   String?
      createdAt DateTime @default(now())
      author    User     @relation(fields: [user_id], references: [id])
      user_id   Int
  }
  
  model User {
      id    Int     @id @default(autoincrement())
      email String  @unique
      name  String?
      posts Post[]
  }
  

Vergleichsoperatoren

• gt (Größer als), gte (Größer als oder gleich), lt (Kleiner als), lte (Kleiner als oder gleich): Wird für numerische und Datums-/Uhrzeitvergleiche verwendet.
  

  npx prisma generate
  

String-Filter

• enthält:Überprüft, ob eine Zeichenfolge eine Teilzeichenfolge enthält.
  

  npx prisma migrate dev --name init
  

• startsWith:Überprüft, ob eine Zeichenfolge mit einem Präfix beginnt.
  

  import { PrismaClient } from "@prisma/client";
  
  const prisma = new PrismaClient({
      log: ["query"],
  });
  
  export default prisma;
  

• endsWith:Überprüft, ob eine Zeichenfolge mit einem Suffix endet.
  

  import prisma from "./db.config.js";
  
  // create user
  export const createUser = async (req, res) => {
      const { name, email } = req.body;
  
      const existing_user = await prisma.user.findUnique({
          where: {
              email,
          },
      });
  
      if (existing_user) {
          return res.status(400).json({ message: "User already exists" });
      }
  
      const user = await prisma.user.create({
          data: {
              email,
              name,
          },
      });
  
      return res.status(201).json(user);
  };
  
  // create post
  export const createPost = async (req, res) => {
      const { title, content, user_id } = req.body;
  
      const post = await prisma.post.create({
          data: {
              title,
              content,
              user_id,
          },
      });
  
      return res.status(201).json(post);
  };
  
  // get all users
  export const getUsers = async (req, res) => {
      const users = await prisma.user.findMany({
          include: {
              posts: true,
          },
      });
  
      return res.status(200).json(users);
  };
  
  // read specific user by id
  export const getUserById = async (req, res) => {
      const { id } = req.params;
  
      const user = await prisma.user.findUnique({
          where: {
              id: parseInt(id),
          },
          include: {
              posts: true,
          },
      });
  
      if (!user) {
          return res.status(404).json({ message: "User not found" });
      }
  
      return res.status(200).json(user);
  };
  
  // update user
  export const updateUser = async (req, res) => {
      const { id } = req.params;
      const { name, email } = req.body;
  
      const user = await prisma.user.update({
          where: {
              id: parseInt(id),
          },
          data: {
              name,
              email,
          },
      });
  
      return res.status(200).json(user);
  };
  
  // delete user
  export const deleteUser = async (req, res) => {
      const { id } = req.params;
  
      const user = await prisma.user.delete({
          where: {
              id: parseInt(id),
          },
      });
  
      return res.status(200).json(user);
  };
  
  // create similar for post
  

• Modus: ohne Berücksichtigung: Führt Suchvorgänge ohne Berücksichtigung der Groß- und Kleinschreibung durch.
  

  import express from "express";
  import {
      createUser,
      createPost,
      getUsers,
      getUserById,
      updateUser,
      deleteUser,
  } from "./controllers.js";
  
  const router = express.Router();
  
  router.post("/users", createUser);
  router.get("/users", getUsers);
  router.get("/users/:id", getUserById);
  router.put("/users/:id", updateUser);
  router.delete("/users/:id", deleteUser);
  // create similar for post
  router.post("/posts", createPost);
  // router.get('/posts', getPosts);
  // router.get('/posts/:id', getPostById);
  // router.put('/posts/:id', updatePost);
  // router.delete('/posts/:id', deletePost);
  
  export default router;
  

Filter auflisten

• in:Überprüft, ob ein Wert in einer Liste vorhanden ist.
  

  import express from "express";
  import dotenv from "dotenv";
  import router from "./routes.js";
  
  dotenv.config();
  
  const app = express();
  
  app.use(express.json());
  app.use("/api", router);
  
  const PORT = process.env.PORT || 5000;
  
  app.listen(PORT, () => {
      console.log(`Server running on port ${PORT}`);
  });
  

• notIn: Prüft, ob ein Wert nicht in einer Liste vorhanden ist.
  

  node index.js
  

Logische Operatoren

• UND: Kombiniert mehrere Bedingungen mit einem logischen UND.
  

  {
      "name": "John Doe",
      "email": "sample@example.com"
  }
  

• ODER: Kombiniert mehrere Bedingungen mit einem logischen ODER.
  

  // get all posts of a user with id
  const user = await prisma.user.findUnique({
      where: {
          id: parseInt(id),
      },
      include: {
          posts: true,
      },
  });
  
  // select specific fields of user with post details
  const user = await prisma.user.findUnique({
      where: {
          id: parseInt(id),
      },
      select: {
          name: true,
          posts: {
              select: {
                  title: true,
                  content: true,
              },
          },
      },
  });
  
  // get all users name with their posts count (Aggregation)
  const req_data = await prisma.user.findMany({
      select: {
          id: true,
          name: true,
          _count: {
              select: {
                  post: true,
              },
          },
      },
  });
  

• NICHT: Negiert eine Gruppe von Bedingungen.
  

  model Product {
      id        Int      @id @default(autoincrement())
      name      String
      price     Float
      category  String
      createdAt DateTime @default(now())
  }
  

Verschachtelte Filter (Filtern nach Beziehungen)

Sie können nach verwandten Modellen filtern.

mkdir prisma-example
cd prisma-example

Filtern nach optionalen Beziehungen

npm init -y

Filter kombinieren

Sie können diese Operatoren für eine komplexe Filterlogik kombinieren.

npm install prisma dotenv express --save-dev

Diese Beispiele decken die häufigsten Filterszenarien in Prisma ab. Durch die Kombination dieser Operatoren und verschachtelten Filter können Sie sehr präzise Abfragen erstellen, um genau die Daten abzurufen, die Sie benötigen. Denken Sie daran, für die aktuellsten und detailliertesten Informationen die offizielle Prisma-Dokumentation zu konsultieren.

Bestellen Sie Datensätze in Prisma

Mit der Option „orderBy“ von Prisma können Sie die Ergebnisse Ihrer Abfragen sortieren. Hier sind einige Beispiele, die seine Verwendung veranschaulichen:

Grundlegende Bestellung

• Aufsteigende Reihenfolge (Standard):
  

  npm install @prisma/client --save-dev
  

• Absteigende Reihenfolge:
  

  npx prisma init
  

Sortieren nach mehreren Feldern

Sie können mehrere Felder angeben, nach denen sortiert werden soll, mit jeweils unterschiedlichen Richtungen. Prisma sortiert zuerst nach dem ersten Feld, dann nach dem zweiten Feld innerhalb von Gruppen identischer Werte im ersten Feld und so weiter.

DATABASE_URL="postgresql://your_user:your_password@localhost:5432/your_database"

In diesem Beispiel werden die Beiträge hauptsächlich nach dem Namen des Autors in aufsteigender Reihenfolge sortiert. Wenn mehrere Beiträge denselben Autor haben, werden sie in absteigender Reihenfolge nach ihrem Titel sortiert.

Sortieren nach verschachtelten Feldern (Beziehungen)

Wie im vorherigen Beispiel gezeigt, können Sie nach Feldern für verwandte Modelle sortieren.

generator client {
    provider = "prisma-client-js"
}

datasource db {
    provider = "postgresql" // Or "mysql", "sqlite", etc.
    url      = env("DATABASE_URL")
}

model Post {
    id        String   @id @default(uuid())
    title     String
    content   String?
    createdAt DateTime @default(now())
    author    User     @relation(fields: [user_id], references: [id])
    user_id   Int
}

model User {
    id    Int     @id @default(autoincrement())
    email String  @unique
    name  String?
    posts Post[]
}

Dadurch werden Beiträge nach der E-Mail-Adresse ihrer Autoren sortiert.

Sortieren nach Datums-/Uhrzeitfeldern

Sie können auch nach Datums- und Uhrzeitfeldern sortieren.

npx prisma generate

Sortieren nach einem anderen Feld als dem Filterfeld

Sie können nach einem Feld filtern und nach einem anderen sortieren. Beispielsweise möchten Sie möglicherweise alle Benutzer finden, deren Name „test“ enthält, sie aber nach ihrer E-Mail-Adresse sortieren:

npx prisma migrate dev --name init

Verwenden der Nulls-Option

Sie können steuern, wie Nullwerte bei der Sortierung behandelt werden. Die Nulls-Option kann entweder auf „first“ oder „last“ gesetzt werden.

import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient({
    log: ["query"],
});

export default prisma;

Standardmäßig werden Nullwerte beim Sortieren in aufsteigender Reihenfolge an letzter Stelle und beim Sortieren in absteigender Reihenfolge an erster Stelle platziert. Mit der Nulls-Option können Sie dieses Standardverhalten überschreiben.

Beziehungsfunktionen in Prisma

Prisma zeichnet sich durch den eleganten Umgang mit Datenbankbeziehungen aus. Hier sind die wichtigsten Aspekte:

• Beziehungen im Schema definieren: Sie definieren Beziehungen zwischen Modellen direkt in Ihrer schema.prisma-Datei mit dem @relation-Attribut.

• Arten von Beziehungen: Prisma unterstützt:

  • Eins-zu-eins:Ein Datensatz in Modell A ist mit genau einem Datensatz in Modell B verknüpft.
  • One-to-Many:Ein Datensatz in Modell A ist mit mehreren Datensätzen in Modell B verknüpft.
  • Many-to-Many: Mehrere Datensätze in Modell A sind mit mehreren Datensätzen in Modell B verknüpft (erfordert eine Join-Tabelle).

Beispiele für Beziehungen

Verwenden wir die User- und Post-Modelle aus den vorherigen Beispielen:

mkdir prisma-example
cd prisma-example

Ich hoffe, dies hilft Ihnen, das Prisma ORM besser zu verstehen.
Geben Sie uns gerne Ihr Feedback und Ihre Vorschläge.

Danke fürs Lesen! ?

Das obige ist der detaillierte Inhalt vonPrisma ORM: Beginnen Sie mit dem Projekt mit JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!