Data Connect-Schemas entwerfen

Mit Firebase Data Connect können Sie ein GraphQL-Schema entwerfen, das das für Ihre Anwendung erforderliche Datenmodell darstellt. Data Connect konvertiert dieses Schema in die Cloud SQL for PostgreSQL-Instanz, die Ihre App unterstützt. Anschließend erstellen Sie Abfragen und Mutationen für die Interaktion mit dem Backend und bündeln diese Vorgänge in Connectors, um Ihre Daten aus dem Clientcode zu verwenden.

Data Connect bietet KI-Tools, mit denen Sie Ihre Schemas entwerfen und implementieren können. In diesem Leitfaden werden wichtige Konzepte für das Schemadesign vorgestellt, die Ihre Standard- und KI-gestützten Workflows unterstützen und ergänzen, wenn Sie mit der Entwicklung einer App beginnen und darüber hinaus.

In der Anleitung für die ersten Schritte wurde ein Schema für eine Filmbewertungs-App für PostgreSQL vorgestellt.

In diesem Leitfaden wird das Schema weiterentwickelt und eine SQL-Auflistung bereitgestellt, die dem endgültigen Schema der Filmrezensions-App entspricht.

Das Schema für eine Filmrezensions-App

Angenommen, Sie möchten einen Dienst entwickeln, mit dem Nutzer Filmrezensionen einreichen und ansehen können.

Für eine solche App benötigen Sie ein anfängliches Schema, um grundlegende Anfragen zu unterstützen. Sie erweitern dieses Schema später, um komplexe relationale Abfragen zu erstellen.

In Data Connect definieren Sie GraphQL-Typen, um die Form der Daten zu definieren, die Ihre Clients abfragen und bearbeiten können. Wenn Sie Ihr Schema schreiben, werden Ihre Typen in Cloud SQL for PostgreSQL-Tabellen übersetzt. Meistens gibt es eine direkte Beziehung zwischen GraphQL-Typen und Datenbanktabellen, aber auch andere Zuordnungen sind möglich. In diesem Leitfaden finden Sie einige Beispiele, die von einfach bis komplex reichen.

Einen einfachen Movie-Typ definieren

Sie können mit einem Movie-Typ beginnen.

Das Schema für Movie enthält wichtige Direktiven wie:

  • @table(name) und @col(name) zum Anpassen der SQL-Tabellen- und ‑Spaltennamen. Wenn keine Namen angegeben sind, werden von Data Connect Namen im snake_case-Format generiert.
  • @col(dataType) zum Anpassen von SQL-Spaltentypen.
  • @default zum Konfigurieren von SQL-Spaltenstandardwerten beim Einfügen.

Weitere Informationen finden Sie in der Referenzdokumentation zu @table, @col und @default.

# Movies
type Movie @table(name: "movie", key: "id") {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int
  genre: String @col(dataType: "varchar(20)")
  rating: Int
  description: String
}

Wichtige Nutzerdaten automatisch in einem User-Typ speichern

Ihre App muss Nutzer im Blick behalten. Daher benötigen Sie den Typ User.

Die @default-Anweisung ist in diesem Fall besonders nützlich. Im Feld id kann die ID des Nutzers automatisch aus der Authentifizierung abgerufen werden. Beachten Sie die Verwendung von @default(expr: "auth.uid") im folgenden Beispiel.

# Users
# Suppose a user can leave reviews for movies
type User @table {
  id: String! @default(expr: "auth.uid")
  username: String! @col(dataType: "varchar(50)")
}

Wichtige Skalare und Serverwerte

Bevor wir uns die App für Filmrezensionen genauer ansehen, ist es wichtig, die Data Connect-Skalare key und server vorzustellen.

Schlüssel-Skalare sind prägnante Objekt-IDs, die Data Connect automatisch aus Schlüsselfeldern in Ihren Schemas zusammenstellt. Bei wichtigen Skalaren geht es um Effizienz. Sie können mit einem einzigen Aufruf Informationen zur Identität und Struktur Ihrer Daten abrufen. Sie sind besonders nützlich, wenn Sie sequenzielle Aktionen für neue Datensätze ausführen möchten und eine eindeutige Kennung für nachfolgende Vorgänge benötigen. Außerdem können Sie damit auf relationale Schlüssel zugreifen, um zusätzliche komplexere Vorgänge auszuführen.

Mit Serverwerten können Sie Felder in Ihren Tabellen dynamisch mit gespeicherten oder leicht berechenbaren Werten gemäß bestimmten serverseitigen CEL-Ausdrücken im expr-Argument füllen lassen. Sie können beispielsweise ein Feld mit einem Zeitstempel definieren, der angewendet wird, wenn auf das Feld mit der in einer Vorgangsanfrage gespeicherten Zeit updatedAt: Timestamp! @default(expr: "request.time") zugegriffen wird.

N-zu-N-Beziehungen in Actor- und MovieActor-Typen verarbeiten

Nachdem Sie die Nutzer behandelt haben, können Sie mit der Modellierung von Filmdaten fortfahren.

Als Nächstes brauchst du Schauspieler für deine Filme.

Die Tabelle Actor ist recht einfach.

# Actors
# Suppose an actor can participate in multiple movies and movies can have multiple actors
# Movie - Actors (or vice versa) is a many to many relationship
type Actor @table {
  id: UUID! @default(expr: "uuidV4()")
  name: String! @col(dataType: "varchar(30)")
}

Wenn Sie möchten, dass Schauspieler in mehreren Filmen mitspielen und Filme mehrere Schauspieler haben, benötigen Sie eine „Join-Tabelle“.

In der Tabelle MovieActor wird die m:n-Beziehung verarbeitet. Der Primärschlüssel ist eine Kombination aus [movie, actor] (den Fremdschlüsselfeldern aus movie und actor).

# Join table for many-to-many relationship for movies and actors
# The 'key' param signifies the primary keys of this table
# In this case, the keys are [movieId, actorId], the foreign key fields of the reference fields [movie, actor]
type MovieActor @table(key: ["movie", "actor"]) {
  movie: Movie!
  # movieId: UUID! <- implicitly added foreign key field
  actor: Actor!
  # actorId: UUID! <- implicitly added foreign key field
  role: String! # "main" or "supporting"
  # optional other fields
}

Wenn Sie eine SQL-Beziehung für die Tabelle mit einer Fremdschlüsseleinschränkung definieren, generiert Data Connect automatisch das entsprechende Feld auf der anderen Seite. Sie müssen das Feld für die umgekehrte Zuordnung nicht definieren (z.B. von Actor zurück zu MovieActor).

1-zu-1-Beziehungen in einem MovieMetadata-Typ verarbeiten

Jetzt können Sie den Überblick über Filmregisseure behalten und eine 1:1-Beziehung mit Movie einrichten.

Mit der Direktive @ref können Sie Fremdschlüsseleinschränkungen anpassen:

  • @ref(fields) gibt an, welche Fremdschlüsselfelder verwendet werden sollen.
  • Mit @ref(references) werden die Felder angegeben, auf die in der Zieltabelle verwiesen wird. Standardmäßig ist das der Primärschlüssel, aber auch @unique-Felder sind möglich. Dies ist eine erweiterte Option. Data Connect kann dies oft für Sie ableiten.

Weitere Informationen finden Sie in der Referenzdokumentation zu @ref.

# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata @table {
  # @unique ensures that each Movie only has one MovieMetadata.
  movie: Movie! @unique
  # Since it references to another table type, it adds a foreign key constraint.
  #  movie: Movie! @unique @ref(fields: "movieId", references: "id")
  #  movieId: UUID! <- implicitly added foreign key field
  director: String
}

Mit Feldern, die aus Ihrem Schema generiert wurden, Vorgänge erstellen

Ihre Data Connect-Vorgänge erweitern automatisch eine Reihe von Feldern, die auf Grundlage der Typen und Typbeziehungen in Ihrem Schema automatisch generiert werden.Data Connect Diese Felder werden von lokalen Tools generiert, wenn Sie Ihr Schema bearbeiten.

Angenommen, Ihr Schema enthält einen Typ Movie und einen zugehörigen Typ Actor. Data Connect generiert die Felder movie, movies, actors_on_movies und weitere.

Mit dem Feld
movie abfragen

Das Feld movie stellt einen einzelnen Datensatz in der Tabelle Movie dar.

Mit diesem Feld können Sie einen einzelnen Film anhand seines Schlüssels abfragen.

query GetMovie($myKey: Movie_Key!) {
  movie(key: $myKey) { title }
}

Mit dem Feld
movies abfragen

Das Feld movies stellt eine Liste von Datensätzen in der Tabelle Movie dar.

Mit diesem Feld können Sie mehrere Filme abfragen, z. B. alle Filme eines bestimmten Jahres.

query GetMovies($myYear: Int!) {
  movies(where: { year: { eq: $myYear } }) { title }
}

Mit dem Feld
actors_on_movies abfragen

Das Feld actors_on_movies stellt eine Liste von Datensätzen dar, die die Tabellen Actor und Movie verbinden. Mit diesem Feld können Sie alle Schauspieler abfragen, die mit einem bestimmten Film in Verbindung stehen.

Mit diesem Feld können Sie alle Schauspieler abfragen, die mit einem bestimmten Film in Verbindung stehen.

  query GetActorsOnMovie($myKey: Movie_Key!) {
    actors_on_movies(where: { movie: { key: { eq: $myKey } } }) {
      actor { name }
    }
  }

Informationen zur Implementierung von Vorgängen mit diesen Feldern finden Sie in der Anleitung zum Implementieren von Abfragen und der Anleitung zum Implementieren von Mutationen.

Erweiterte Schemakonzepte

Wenn Sie über grundlegende, aber nützliche Typen und Beziehungen hinausgehen möchten, sehen Sie sich die Beispiele in der Referenzdokumentation an.

Unterstützte Datentypen

Data Connect unterstützt die folgenden skalaren Datentypen, wobei die Zuweisungen zu PostgreSQL-Typen mit @col(dataType:) erfolgen.

Data Connect type Integrierter GraphQL-Typ oder
Data Connect benutzerdefinierter Typ 		Standard-PostgreSQL-Typ Unterstützte PostgreSQL-Typen
(Alias in Klammern)
String GraphQL Text text
bit(n), varbit(n)
char(n), varchar(n)
Integer GraphQL int Int2 (smallint, smallserial),
int4 (integer, int, serial)
Float GraphQL float8 float4 (real)
float8 (double precision)
numeric (decimal)
Boolesch GraphQL boolean boolean
UUID Benutzerdefiniert uuid uuid
INT64 Benutzerdefiniert bigint int8 (bigint, bigserial)
numeric (decimal)
Datum Benutzerdefiniert date Datum
Zeitstempel Benutzerdefiniert timestamptz

timestamptz

Hinweis:Informationen zur lokalen Zeitzone werden nicht gespeichert.
PostgreSQL konvertiert und speichert solche Zeitstempel als UTC.
Vektor Benutzerdefiniert vector

Vektor

Weitere Informationen finden Sie unter Vektorähnlichkeitssuche mit Vertex AI durchführen.
  • GraphQL-List wird einem eindimensionalen Array zugeordnet.
    • Beispiel: [Int] wird int5[] zugeordnet, [Any] wird jsonb[] zugeordnet.
    • Data Connect unterstützt keine verschachtelten Arrays.

Entsprechendes SQL-Schema

-- Movies Table
CREATE TABLE Movies (
    movie_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    release_year INT,
    genre VARCHAR(30),
    rating INT,
    description TEXT,
    tags TEXT[]
);
-- Movie Metadata Table
CREATE TABLE MovieMetadata (
    movie_id UUID REFERENCES Movies(movie_id) UNIQUE,
    director VARCHAR(255) NOT NULL,
    PRIMARY KEY (movie_id)
);
-- Actors Table
CREATE TABLE Actors (
    actor_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    name VARCHAR(30) NOT NULL
);
-- MovieActor Join Table for Many-to-Many Relationship
CREATE TABLE MovieActor (
    movie_id UUID REFERENCES Movies(movie_id),
    actor_id UUID REFERENCES Actors(actor_id),
    role VARCHAR(50) NOT NULL, # "main" or "supporting"
    PRIMARY KEY (movie_id, actor_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id),
    FOREIGN KEY (actor_id) REFERENCES Actors(actor_id)
);
-- Users Table
CREATE TABLE Users (
    user_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_auth VARCHAR(255) NOT NULL
    username VARCHAR(30) NOT NULL
);
-- Reviews Table
CREATE TABLE Reviews (
    review_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_id UUID REFERENCES Users(user_id),
    movie_id UUID REFERENCES Movies(movie_id),
    rating INT,
    review_text TEXT,
    review_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE (movie_id, user_id)
    FOREIGN KEY (user_id) REFERENCES Users(user_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id)
);
-- Self Join Example for Movie Sequel Relationship
ALTER TABLE Movies
ADD COLUMN sequel_to UUID REFERENCES Movies(movie_id);

Nächste Schritte

Folgendes könnte Sie interessieren: