Skema, kueri, dan mutasi Data Connect

Firebase Data Connect memungkinkan Anda membuat konektor untuk instance PostgreSQL yang dikelola dengan Google Cloud SQL. Konektor ini adalah kombinasi skema, kueri, dan mutasi untuk menggunakan data Anda.

Panduan memulai memperkenalkan skema aplikasi ulasan film untuk PostgreSQL, dan panduan ini membahas lebih dalam cara mendesain skema Data Connect untuk PostgreSQL.

Panduan ini memasangkan kueri dan mutasi Data Connect dengan contoh skema. Mengapa membahas kueri (dan mutasi) dalam panduan tentang skema Data Connect? Seperti platform berbasis GraphQL lainnya, Firebase Data Connect adalah platform pengembangan kueri-terlebih-dahulu, sehingga sebagai developer, dalam pemodelan data, Anda akan memikirkan data yang dibutuhkan klien, yang akan sangat memengaruhi skema data yang Anda kembangkan untuk project Anda.

Panduan ini dimulai dengan skema baru untuk ulasan film, lalu membahas kueri dan mutasi yang berasal dari skema tersebut, dan terakhir memberikan listingan SQL yang setara dengan skema Data Connect inti.

Skema untuk aplikasi ulasan film

Bayangkan Anda ingin membuat layanan yang memungkinkan pengguna mengirimkan dan melihat ulasan film.

Anda memerlukan skema awal untuk aplikasi tersebut. Anda akan memperluas skema ini nanti untuk membuat kueri relasional yang kompleks.

Tabel film

Skema untuk Film berisi perintah inti seperti:

  • @table, yang memungkinkan kita menetapkan nama operasi menggunakan argumen singular dan plural
  • @col untuk menetapkan nama kolom secara eksplisit
  • @default untuk mengizinkan setelan default.
# Movies
type Movie
  @table(name: "Movies", singular: "movie", plural: "movies", key: ["id"]) {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int @col(name: "release_year")
  genre: String
  rating: Int @col(name: "rating")
  description: String @col(name: "description")
}

Nilai server dan skalar kunci

Sebelum melihat aplikasi ulasan film, mari kita perkenalkan Data Connect nilai server dan skalar kunci.

Dengan menggunakan nilai server, Anda dapat secara efektif mengizinkan server mengisi kolom di tabel secara dinamis menggunakan nilai yang disimpan atau mudah dihitung sesuai dengan ekspresi sisi server tertentu. Misalnya, Anda dapat menentukan kolom dengan stempel waktu yang diterapkan saat kolom diakses menggunakan ekspresi updatedAt: Timestamp! @default(expr: "request.time").

Skalar kunci adalah ID objek ringkas yang otomatis dibuat oleh Data Connect dari kolom kunci dalam skema Anda. Skalar kunci berkaitan dengan efisiensi, sehingga Anda dapat menemukan informasi tentang identitas dan struktur data dalam satu panggilan. Parameter ini sangat berguna saat Anda ingin melakukan tindakan berurutan pada data baru dan memerlukan ID unik untuk diteruskan ke operasi mendatang, dan juga saat Anda ingin mengakses kunci relasional untuk melakukan operasi tambahan yang lebih kompleks.

Tabel metadata film

Sekarang, mari kita lacak sutradara film, serta siapkan hubungan satu-satu dengan Movie.

Tambahkan perintah @ref untuk menentukan hubungan.

# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata
  @table(
    name: "MovieMetadata"
  ) {
  # @ref creates a field in the current table (MovieMetadata) that holds the
  # primary key of the referenced type
  # In this case, @ref(fields: "id") is implied
  movie: Movie! @ref
  # movieId: UUID <- this is created by the above @ref
  director: String @col(name: "director")
}

Actor dan MovieActor

Selanjutnya, Anda ingin aktor membintangi film Anda, dan karena Anda memiliki hubungan banyak-ke-banyak antara film dan aktor, buat tabel join.

# 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(name: "Actors", singular: "actor", plural: "actors") {
  id: UUID! @col(name: "actor_id") @default(expr: "uuidV4()")
  name: String! @col(name: "name", dataType: "varchar(30)")
}
# Join table for many-to-many relationship for movies and actors
# The 'key' param signifies the primary key(s) of this table
# In this case, the keys are [movieId, actorId], the generated fields of the reference types [movie, actor]
type MovieActor @table(key: ["movie", "actor"]) {
  # @ref creates a field in the current table (MovieActor) that holds the primary key of the referenced type
  # In this case, @ref(fields: "id") is implied
  movie: Movie! @ref
  # movieId: UUID! <- this is created by the above @ref, see: implicit.gql
  actor: Actor! @ref
  # actorId: UUID! <- this is created by the above @ref, see: implicit.gql
  role: String! @col(name: "role") # "main" or "supporting"
  # optional other fields
}

Pengguna

Terakhir, pengguna untuk aplikasi Anda.

# Users
# Suppose a user can leave reviews for movies
# user:reviews is a one to many relationship, movie:reviews is a one to many relationship, movie:user is a many to many relationship
type User
  @table(name: "Users", singular: "user", plural: "users", key: ["id"]) {
  id: UUID! @col(name: "user_id") @default(expr: "uuidV4()")
  auth: String @col(name: "user_auth") @default(expr: "auth.uid")
  username: String! @col(name: "username", dataType: "varchar(30)")
  # The following are generated from the @ref in the Review table
  # reviews_on_user
  # movies_via_Review
}

Jenis data yang didukung

Data Connect mendukung jenis data skalar berikut, dengan penetapan ke jenis PostgreSQL menggunakan @col(dataType:).

Jenis Data Connect Jenis bawaan GraphQL atau jenis kustom
Data Connect 		Jenis PostgreSQL default Jenis PostgreSQL yang didukung
(alias dalam tanda kurung)
String GraphQL teks text
bit(n), varbit(n)
char(n), varchar(n)
Int GraphQL int Int2 (smallint, smallserial),
int4 (integer, int, serial)
Float GraphQL float8 float4 (real)
float8 (double precision)
numeric (desimal)
Boolean GraphQL boolean boolean
UUID Kustom uuid uuid
Int64 Kustom bigint int8 (bigint, bigserial)
numerik (desimal)
Tanggal Kustom date date
Stempel waktu Kustom timestamptz

timestamptz

Catatan: Informasi zona waktu lokal tidak disimpan.
PostgreSQL mengonversi dan menyimpan stempel waktu tersebut sebagai UTC.
Vektor Kustom vector

vektor

Lihat Melakukan penelusuran kemiripan vektor dengan Vertex AI.
  • List GraphQL dipetakan ke array satu dimensi.
    • Misalnya, [Int] dipetakan ke int5[], [Any] dipetakan ke jsonb[].
    • Data Connect tidak mendukung array bertingkat.

Kueri dan mutasi implisit dan standar

Kueri dan mutasi Data Connect Anda akan memperluas kumpulan kueri implisit dan mutasi implisit yang dihasilkan oleh Data Connect berdasarkan jenis dan hubungan jenis dalam skema Anda. Kueri dan mutasi implisit dibuat oleh alat lokal setiap kali Anda mengedit skema.

Dalam proses pengembangan, Anda akan menerapkan kueri standar dan mutasi standar berdasarkan operasi implisit ini.

Penamaan kueri dan mutasi implisit

Data Connect menyimpulkan nama yang sesuai untuk kueri dan mutasi implisit dari deklarasi jenis skema Anda. Misalnya, saat menggunakan sumber PostgreSQL, jika Anda menentukan tabel bernama Movie, server akan menghasilkan:

  • Kueri untuk kasus penggunaan tabel tunggal dengan nama mudah movie (tunggal, untuk mengambil hasil individual yang meneruskan argumen seperti eq) dan movies (jamak, untuk mengambil daftar hasil yang meneruskan argumen seperti gt dan operasi seperti orderby). Data Connect juga menghasilkan kueri untuk operasi relasional multi-tabel dengan nama eksplisit seperti actors_on_movies atau actors_via_actormovie.
  • Mutasi bernama movie_insert, movie_upsert...

Bahasa definisi skema juga memungkinkan Anda menetapkan nama secara eksplisit untuk operasi menggunakan argumen perintah singular dan plural.

Perintah untuk kueri dan mutasi

Selain perintah yang Anda gunakan dalam menentukan jenis dan tabel, Data Connect menyediakan perintah @auth, @check, @redact, dan @transaction untuk meningkatkan perilaku kueri dan mutasi.

Perintah Berlaku untuk Deskripsi
@auth Kueri dan mutasi Menentukan kebijakan autentikasi untuk kueri atau mutasi. Lihat panduan otorisasi dan pengesahan.
@check Kueri pencarian data otorisasi Memverifikasi bahwa kolom yang ditentukan ada dalam hasil kueri. Ekspresi Common Expression Language (CEL) digunakan untuk menguji nilai kolom. Lihat panduan otorisasi dan pengesahan.
@redact Kueri Menyamarkan bagian respons dari klien. Lihat panduan otorisasi dan pengesahan.
@transaction Mutasi Menerapkan bahwa mutasi selalu berjalan dalam transaksi database. Lihat contoh mutasi aplikasi film.

Kueri untuk database ulasan film

Anda menentukan kueri Data Connect dengan deklarasi jenis operasi kueri, nama operasi, nol argumen operasi atau lebih, dan nol atau lebih perintah dengan argumen.

Dalam panduan memulai, contoh kueri listEmails tidak memerlukan parameter. Tentu saja, dalam banyak kasus, data yang diteruskan ke kolom kueri akan bersifat dinamis. Anda dapat menggunakan sintaksis $variableName untuk menggunakan variabel sebagai salah satu komponen definisi kueri.

Jadi, kueri berikut memiliki:

  • Definisi jenis query
  • Nama operasi (kueri) ListMoviesByGenre
  • Argumen operasi $genre variabel tunggal
  • Satu perintah, @auth.
query ListMoviesByGenre($genre: String!) @auth(level: USER)

Setiap argumen kueri memerlukan deklarasi jenis, bawaan seperti String, atau jenis kustom yang ditentukan skema seperti Movie.

Mari kita lihat tanda tangan kueri yang semakin kompleks. Anda akan mengakhiri dengan memperkenalkan ekspresi hubungan yang efektif dan ringkas yang tersedia dalam kueri implisit yang dapat Anda buat dalam kueri standar.

Skalar kunci dalam kueri

Namun, pertama-tama, catatan tentang skalar kunci.

Data Connect menentukan jenis khusus untuk skalar kunci, yang diidentifikasi oleh _Key. Misalnya, jenis skalar kunci untuk tabel Movie kita adalah Movie_Key.

Anda mengambil skalar kunci sebagai respons yang ditampilkan oleh sebagian besar mutasi implisit, atau tentunya dari kueri tempat Anda mengambil semua kolom yang diperlukan untuk membuat kunci skalar.

Kueri otomatis tunggal, seperti movie dalam contoh yang sedang berjalan, mendukung argumen kunci yang menerima skalar kunci.

Anda dapat meneruskan skalar kunci sebagai literal. Namun, Anda dapat menentukan variabel untuk meneruskan skalar kunci sebagai input.

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

Ini dapat diberikan dalam JSON permintaan seperti ini (atau format serialisasi lainnya):

{
  # …
  "variables": {
    "myKey": {"foo": "some-string-value", "bar": 42}
  }
}

Berkat penguraian skalar kustom, Movie_Key juga dapat dibuat menggunakan sintaksis objek, yang dapat berisi variabel. Hal ini sangat berguna saat Anda ingin membagi setiap komponen menjadi variabel yang berbeda karena alasan tertentu.

Alias dalam kueri

Data Connect mendukung alias GraphQL dalam kueri. Dengan alias, Anda dapat mengganti nama data yang ditampilkan dalam hasil kueri. Satu kueri Data Connect dapat menerapkan beberapa filter atau operasi kueri lainnya dalam satu permintaan yang efisien ke server, sehingga secara efektif mengeluarkan beberapa "sub-kueri" sekaligus. Untuk menghindari konflik nama dalam set data yang ditampilkan, Anda menggunakan alias untuk membedakan subkueri.

Berikut adalah kueri yang ekspresinya menggunakan alias mostPopular.

query ReviewTopPopularity($genre: String) {
  mostPopular: review(first: {
    where: {genre: {eq: $genre}},
    orderBy: {popularity: DESC}
  }) { … }
}

Kueri sederhana dengan filter

Kueri Data Connect dipetakan ke semua filter SQL umum dan operasi urutan.

Operator where dan orderBy (kueri tunggal, jamak)

Menampilkan semua baris yang cocok dari tabel (dan pengaitan bertingkat). Menampilkan array kosong jika tidak ada data yang cocok dengan filter.

query MovieByTopRating($genre: String) {
  mostPopular: movies(
     where: { genre: { eq: $genre } }, orderBy: { rating: DESC }
  ) {
    # graphql: list the fields from the results to return
    id
    title
    genre
    description
  }
}

query MoviesByReleaseYear($min: Int, $max: Int) {
  movies(where: {releaseYear: {le: $max, ge: $min}}, orderBy: [{releaseYear: ASC}]) { … }
}

Operator limit dan offset (kueri tunggal, jamak)

Anda dapat melakukan penomoran halaman pada hasil. Argumen ini diterima, tetapi tidak ditampilkan dalam hasil.

query MoviesTop10 {
  movies(orderBy: [{ rating: DESC }], limit: 10) {
    # graphql: list the fields from the results to return
    title
  }
}

mencakup untuk kolom array

Anda dapat menguji apakah kolom array menyertakan item yang ditentukan.

# Filter using arrays and embedded fields.
query ListMoviesByTag($tag: String!) {
  movies(where: { tags: { includes: $tag }}) {
    # graphql: list the fields from the results to return
    id
    title
  }
}

Operasi string dan ekspresi reguler

Kueri Anda dapat menggunakan operasi perbandingan dan penelusuran string standar, termasuk ekspresi reguler. Perhatikan bahwa untuk efisiensi, Anda menggabungkan beberapa operasi di sini dan membedakannya dengan alias.

query MoviesTitleSearch($prefix: String, $suffix: String, $contained: String, $regex: String) {
  prefixed: movies(where: {title: {startsWith: $prefix}}) {...}
  suffixed: movies(where: {title: {endsWith: $suffix}}) {...}
  contained: movies(where: {title: {contains: $contained}}) {...}
  matchRegex: movies(where: {title: {pattern: {regex: $regex}}}) {...}
}

or dan and untuk filter gabungan

Gunakan or dan and untuk logika yang lebih kompleks.

query ListMoviesByGenreAndGenre($minRating: Int!, $genre: String) {
  movies(
    where: { _or: [{ rating: { ge: $minRating } }, { genre: { eq: $genre } }] }
  ) {
    # graphql: list the fields from the results to return
    title
  }
}

Kueri kompleks

Kueri Data Connect dapat mengakses data berdasarkan hubungan antar-tabel. Anda dapat menggunakan hubungan objek (one-to-one) atau array (one-to-many) yang ditentukan dalam skema untuk membuat kueri bertingkat, yaitu mengambil data untuk satu jenis beserta data dari jenis bertingkat atau terkait.

Kueri tersebut menggunakan sintaksis Data Connect _on_ dan _via magic dalam kueri implisit yang dihasilkan.

Anda akan melakukan modifikasi pada skema dari versi awal kami.

Many to one

Mari kita tambahkan ulasan ke aplikasi, dengan tabel Review dan modifikasi pada User.

# Users
# Suppose a user can leave reviews for movies
# user:reviews is a one to many relationship,
# movie:reviews is a one to many relationship,
# movie:user is a many to many relationship
type User
  @table(name: "Users", singular: "user", plural: "users", key: ["id"]) {
  id: UUID! @col(name: "user_id") @default(expr: "uuidV4()")
  auth: String @col(name: "user_auth") @default(expr: "auth.uid")
  username: String! @col(name: "username", dataType: "varchar(30)")
  # The following are generated from the @ref in the Review table
  # reviews_on_user
  # movies_via_Review
}
# Reviews
type Review @table(name: "Reviews", key: ["movie", "user"]) {
  id: UUID! @col(name: "review_id") @default(expr: "uuidV4()")
  user: User! @ref
  movie: Movie! @ref
  rating: Int
  reviewText: String
  reviewDate: Date! @default(expr: "request.time")
}

Membuat kueri many-to-one

Sekarang, mari kita lihat kueri, dengan alias, untuk mengilustrasikan sintaksis _via_.

query UserMoviePreferences($username: String!) @auth(level: USER) {
  users(where: { username: { eq: $username } }) {
    likedMovies: movies_via_review(where: { rating: { ge: 4 } }) {
      title
      genre
      description
    }
    dislikedMovies: movies_via_review(where: { rating: { le: 2 } }) {
      title
      genre
      description
    }
  }
}

Satu lawan satu

Anda dapat melihat polanya. Di bawah ini, skema diubah untuk ilustrasi.

# Movies
type Movie
  @table(name: "Movies", singular: "movie", plural: "movies", key: ["id"]) {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int @col(name: "release_year")
  genre: String
  rating: Int @col(name: "rating")
  description: String @col(name: "description")
  tags: [String] @col(name: "tags")
}
# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata
  @table(
    name: "MovieMetadata"
  ) {
  # @ref creates a field in the current table (MovieMetadata) that holds the primary key of the referenced type
  # In this case, @ref(fields: "id") is implied
  movie: Movie! @ref
  # movieId: UUID <- this is created by the above @ref
  director: String @col(name: "director")
}


extend type MovieMetadata {
  movieId: UUID! # matches primary key of referenced type
...
}

extend type Movie {
  movieMetadata: MovieMetadata # can only be non-nullable on ref side
  # conflict-free name, always generated
  movieMetadatas_on_movie: MovieMetadata
}

Kueri untuk one to one

Anda dapat membuat kueri menggunakan sintaksis _on_.

# One to one
query GetMovieMetadata($id: UUID!) @auth(level: PUBLIC) {
  movie(id: $id) {
    movieMetadatas_on_movie {
      director
    }
  }
}

Many-to-many

Film membutuhkan aktor, dan aktor membutuhkan film. Keduanya memiliki hubungan banyak ke banyak yang dapat Anda buat modelnya dengan tabel join MovieActors.

# MovieActors Join Table Definition
type MovieActors @table(
  key: ["movie", "actor"] # join key triggers many-to-many generation
) {
  movie: Movie!
  actor: Actor!
}

# generated extensions for the MovieActors join table
extend type MovieActors {
  movieId: UUID!
  actorId: UUID!
}

# Extensions for Actor and Movie to handle many-to-many relationships
extend type Movie {
  movieActors: [MovieActors!]! # standard many-to-one relation to join table
  actors: [Actor!]! # many-to-many via join table

  movieActors_on_actor: [MovieActors!]!
  # since MovieActors joins distinct types, type name alone is sufficiently precise
  actors_via_MovieActors: [Actor!]!
}

extend type Actor {
  movieActors: [MovieActors!]! # standard many-to-one relation to join table
  movies: [Movie!]! # many-to-many via join table

  movieActors_on_movie: [MovieActors!]!
  movies_via_MovieActors: [Movie!]!
}

Membuat kueri banyak ke banyak

Mari kita lihat kueri, dengan alias, untuk mengilustrasikan sintaksis _via_.

query GetMovieCast($movieId: UUID!, $actorId: UUID!) @auth(level: PUBLIC) {
  movie(id: $movieId) {
    mainActors: actors_via_MovieActor(where: { role: { eq: "main" } }) {
      name
    }
    supportingActors: actors_via_MovieActor(
      where: { role: { eq: "supporting" } }
    ) {
      name
    }
  }
  actor(id: $actorId) {
    mainRoles: movies_via_MovieActor(where: { role: { eq: "main" } }) {
      title
    }
    supportingRoles: movies_via_MovieActor(
      where: { role: { eq: "supporting" } }
    ) {
      title
    }
  }
}

Mutasi untuk database ulasan film

Seperti yang disebutkan, saat Anda menentukan tabel dalam skema, Data Connect akan menghasilkan mutasi implisit dasar untuk setiap tabel.

type Movie @table { ... }

extend type Mutation {
  # Insert a row into the movie table.
  movie_insert(...): Movie_Key!
  # Upsert a row into movie."
  movie_upsert(...): Movie_Key!
  # Update a row in Movie. Returns null if a row with the specified id/key does not exist
  movie_update(...): Movie_Key
  # Update rows based on a filter in Movie.
  movie_updateMany(...): Int!
  # Delete a single row in Movie. Returns null if a row with the specified id/key does not exist
  movie_delete(...): Movie_Key
  # Delete rows based on a filter in Movie.
  movie_deleteMany(...): Int!
}

Dengan ini, Anda dapat menerapkan kasus CRUD inti yang semakin kompleks. Ucapkan itu lima kali dengan cepat.

Perintah @transaction

Perintah ini mewajibkan mutasi selalu berjalan dalam transaksi database.

Mutasi dengan @transaction dijamin akan berhasil sepenuhnya atau sepenuhnya gagal. Jika salah satu kolom dalam transaksi gagal, seluruh transaksi akan di-roll back. Dari sudut pandang klien, kegagalan apa pun berperilaku seolah-olah seluruh permintaan telah gagal dengan error permintaan dan eksekusi belum dimulai.

Mutasi tanpa @transaction akan mengeksekusi setiap kolom root satu per satu secara berurutan. Fungsi ini menampilkan error sebagai error kolom sebagian, tetapi tidak menampilkan dampak eksekusi berikutnya.

Buat

Mari kita buat dasar-dasarnya.

# Create a movie based on user input
mutation CreateMovie($title: String!, $releaseYear: Int!, $genre: String!, $rating: Int!) {
  movie_insert(data: {
    title: $title
    releaseYear: $releaseYear
    genre: $genre
    rating: $rating
  })
}

# Create a movie with default values
mutation CreateMovie2 {
  movie_insert(data: {
    title: "Sherlock Holmes"
    releaseYear: 2009
    genre: "Mystery"
    rating: 5
  })
}

Atau upsert.

# Movie upsert using combination of variables and literals
mutation UpsertMovie($title: String!) {
  movie_upsert(data: {
    title: $title
    releaseYear: 2009
    genre: "Mystery"
    rating: 5
    genre: "Mystery/Thriller"
  })
}

Melakukan update

Berikut adalah pembaruan. Produser dan sutradara tentu berharap rating rata-rata tersebut sesuai dengan tren.

mutation UpdateMovie(
  $id: UUID!,
  $genre: String!,
  $rating: Int!,
  $description: String!
) {
  movie_update(id: $id, data: {
    genre: $genre
    rating: $rating
    description: $description
  })
}

# Multiple updates (increase all ratings of a genre)
mutation IncreaseRatingForGenre($genre: String!, $ratingIncrement: Int!) {
  movie_updateMany(
    where: { genre: { eq: $genre } },
    update: { rating: { inc: $ratingIncrement } }
  )
}

Melakukan penghapusan

Anda tentu saja dapat menghapus data film. Para pelestarian film tentu saja ingin film fisik dipertahankan selama mungkin.

# Delete by key
mutation DeleteMovie($id: UUID!) {
  movie_delete(id: $id)
}

Di sini, Anda dapat menggunakan _deleteMany.

# Multiple deletes
mutation DeleteUnpopularMovies($minRating: Int!) {
  movie_deleteMany(where: { rating: { le: $minRating } })
}

Menulis mutasi pada relasi

Amati cara menggunakan mutasi _upsert implisit pada suatu relasi.

# Create or update a one to one relation
mutation MovieMetadataUpsert($movieId: UUID!, $director: String!) {
  movieMetadata_upsert(
    data: { movie: { id: $movieId }, director: $director }
  )
}

Kueri pencarian data otorisasi

Mutasi Data Connect dapat diotorisasi dengan membuat kueri database terlebih dahulu dan memverifikasi hasil kueri dengan ekspresi CEL. Hal ini berguna saat Anda menulis ke tabel, dan perlu memeriksa konten baris di tabel lain.

Fitur ini mendukung:

  • Perintah @check, yang memungkinkan Anda mengevaluasi konten kolom, dan berdasarkan hasil evaluasi tersebut:
    • Lanjutkan dengan membuat, memperbarui, dan menghapus yang ditentukan oleh mutasi
    • Gunakan nilai yang ditampilkan ke klien oleh kueri untuk menjalankan logika yang berbeda di klien Anda
  • Perintah @redact, yang memungkinkan Anda menghapus hasil kueri dari hasil wire protocol.

Fitur ini berguna untuk alur otorisasi.

Skema SQL yang setara

-- 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);

Apa langkah selanjutnya?