Data Connect şemaları, sorguları ve mutasyonları

Firebase Data Connect, Google Cloud SQL ile yönetilen PostgreSQL örnekleriniz için bağlayıcılar oluşturmanıza olanak tanır. Bu bağlayıcılar, verilerinizi kullanmak için bir şemanın, sorguların ve mutasyonların bir kombinasyonudur.

Başlangıç kılavuzunda, PostgreSQL için bir film yorumu uygulaması şeması tanıtıldı. Bu kılavuzda, PostgreSQL için Data Connect şemalarının nasıl tasarlanacağına daha ayrıntılı bir şekilde değinilmektedir.

Bu kılavuzda, Data Connect sorguları ve mutasyonları şema örnekleriyle eşleştirilir. Data Connect şemaları hakkındaki bir kılavuzda neden sorgular (ve mutasyonlar) ele alınıyor? Diğer GraphQL tabanlı platformlar gibi Firebase Data Connect de sorgu öncelikli bir geliştirme platformudur. Bu nedenle, geliştirici olarak veri modellemenizde müşterilerinizin ihtiyaç duyduğu verileri düşünürsünüz. Bu veriler, projeniz için geliştirdiğiniz veri şemasını büyük ölçüde etkiler.

Bu kılavuzda, yeni bir film yorumları şemasıyla başlanır, ardından bu şemadan türetilen sorgular ve mutasyonlar ele alınır ve son olarak temel Data Connect şemasına eşdeğer bir SQL listesi sağlanır.

Film yorumu uygulamasının şeması

Kullanıcıların film yorumları gönderip görüntülemesine olanak tanıyan bir hizmet oluşturmak istediğinizi varsayalım.

Bu tür bir uygulama için ilk bir şemaya ihtiyacınız vardır. Daha sonra karmaşık ilişkisel sorgular oluşturmak için bu şemayı genişleteceksiniz.

Film tablosu

Filmler şemasında aşağıdaki gibi temel yönergeler bulunur:

• @table, singular ve plural bağımsız değişkenlerini kullanarak işlem adları belirlememize olanak tanır.
• @col sütun adlarını açıkça ayarlamak için
• @default değerini seçerek varsayılan ayarların ayarlanmasına izin verin.

# 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")
}

Sunucu değerleri ve anahtar skalerleri

Film yorumu uygulamasına bakmadan önce Data Connect sunucu değerleri ve anahtar skalerlerini tanıtalım.

Sunucu değerlerini kullanarak, sunucunun belirli sunucu tarafı ifadelerine göre depolanan veya kolayca hesaplanabilen değerleri kullanarak tablolarınızdaki alanları dinamik olarak doldurmasına izin verebilirsiniz. Örneğin, updatedAt: Timestamp! @default(expr: "request.time") ifadesi kullanılarak alana erişildiğinde zaman damgası uygulanmış bir alan tanımlayabilirsiniz.

Anahtar skalerler, Data Connect'in şemalarınızdaki anahtar alanlardan otomatik olarak derlediği kısa nesne tanımlayıcılardır. Anahtar skalerler verimlilikle ilgilidir ve verilerinizin kimliği ve yapısı hakkındaki bilgileri tek bir çağrıda bulmanızı sağlar. Bu anahtarlar özellikle yeni kayıtlarda sıralı işlemler yapmak istediğinizde ve yaklaşan işlemlere iletilecek benzersiz bir tanımlayıcıya ihtiyaç duyduğunuzda ve ayrıca daha karmaşık işlemler yapmak için ilişkisel anahtarlara erişmek istediğinizde kullanışlıdır.

Film meta verileri tablosu

Şimdi film yönetmenlerini takip edip Movie ile bire bir ilişki oluşturalım.

İlişkileri tanımlamak için @ref yönergesini ekleyin.

# 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 ve MovieActor

Ardından, filmlerinizde rol alacak aktörler istiyorsunuz. Filmler ile aktörler arasında çoklu ilişki olduğundan bir birleştirme tablosu oluşturun.

# 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
}

Kullanıcı

Son olarak, uygulamanızın kullanıcıları.

# 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
}

Desteklenen veri türleri

Data Connect, @col(dataType:) kullanılarak PostgreSQL türlerine atamalarla aşağıdaki skaler veri türlerini destekler.

• GraphQL List, tek boyutlu bir diziyle eşlenir.
  • Örneğin, [Int] int5[] ile, [Any] ise jsonb[] ile eşlenir.
  • Data Connect iç içe dizileri desteklemez.

Örtük ve önceden tanımlanmış sorgular ve mutasyonlar

Data Connect sorgularınız ve mutasyonlarınız, şemanızdaki türlere ve tür ilişkilerine göre Data Connect tarafından oluşturulan bir dizi örtülü sorgu ve örtülü mutasyon ile genişletilir. Örtük sorgular ve mutasyonlar, şemanızı her düzenlediğinizde yerel araçlar tarafından oluşturulur.

Geliştirme sürecinizde, bu gizli işlemlere dayalı önceden tanımlanmış sorgular ve önceden tanımlanmış mutasyonlar uygularsınız.

Örtük sorgu ve mutasyon adlandırma

Data Connect, şema türü beyanlarınızdan örtülü sorgular ve mutasyonlar için uygun adlar çıkarır. Örneğin, PostgreSQL kaynağıyla çalışırken Movie adlı bir tablo tanımlarsanız sunucu aşağıdakileri oluşturur:

• movie (tekil, eq gibi bağımsız değişkenler göndererek tek tek sonuçları almak için) ve movies (çoğul, gt gibi bağımsız değişkenler ve orderby gibi işlemler göndererek sonuç listelerini almak için) gibi kullanıcı dostu adlara sahip tek tablolu kullanım alanları için sorgular. Data Connect, actors_on_movies veya actors_via_actormovie gibi açık adlara sahip çok tablolu, ilişkisel işlemler için de sorgular oluşturur.
• movie_insert, movie_upsert adlı mutasyonlar...

Şema tanımı dili, singular ve plural yönerge bağımsız değişkenlerini kullanarak işlemler için adları açıkça belirlemenize de olanak tanır.

Sorgular ve mutasyonlar için talimatlar

Data Connect, türleri ve tabloları tanımlarken kullandığınız yönergelere ek olarak sorguların ve mutasyonların davranışını geliştirmek için @auth, @check, @redact ve @transaction yönergelerini sağlar.

Film yorumu veritabanı sorguları

Sorgu işlemi türü beyanı, işlem adı, sıfır veya daha fazla işlem bağımsız değişkeni ve bağımsız değişken içeren sıfır veya daha fazla yönergeyle bir Data Connect sorgusu tanımlarsınız.

Hızlı başlangıç kılavuzundaki örnek listEmails sorgusunda parametre yoktu. Elbette, sorgu alanlarına iletilen veriler çoğu durumda dinamik olacaktır. Sorgu tanımının bileşenlerinden biri olarak değişkenlerle çalışmak için $variableName söz dizimini kullanabilirsiniz.

Dolayısıyla aşağıdaki sorguda:

• query türü tanımı
• ListMoviesByGenre işlemi (sorgu) adı
• Tek değişkenli $genre işlem bağımsız değişkeni
• Tek bir yönerge (@auth).

query ListMoviesByGenre($genre: String!) @auth(level: USER)

Her sorgu bağımsız değişkeni için bir tür beyanı, String gibi yerleşik bir tür veya Movie gibi şemada tanımlanmış özel bir tür gerekir.

Giderek daha karmaşık hale gelen sorguların imzasını inceleyelim. Son olarak, önceden tanımlanmış sorgularınızda kullanabileceğiniz, dolaylı sorgularda bulunan güçlü ve kısa ilişki ifadelerini tanıtın.

Sorgulardaki temel skalerler

Ancak öncelikle, temel skalerlerle ilgili bir not paylaşmak isterim.

Data Connect, _Key ile tanımlanan anahtar skalerler için özel bir tür tanımlar. Örneğin, Movie tablomuzdaki bir anahtar skalerinin türü Movie_Key'dur.

Anahtar skalerleri, çoğu dolaylı mutasyon tarafından döndürülen bir yanıt olarak veya tabii ki skaler anahtarı oluşturmak için gereken tüm alanları aldığınız sorgulardan alırsınız.

Çalışan örneğimizdeki movie gibi tekil otomatik sorgular, bir anahtar skaler kabul eden bir anahtar bağımsız değişkenini destekler.

Bir anahtar skalerini değişmez değer olarak iletebilirsiniz. Ancak, giriş olarak temel skalerlerin iletileceği değişkenler tanımlayabilirsiniz.

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

Bunlar, istek JSON'unda aşağıdaki gibi (veya diğer serileştirme biçimlerinde) sağlanabilir:

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

Özel skaler ayrıştırma sayesinde, Movie_Key değişken içerebilen nesne söz dizimi kullanılarak da oluşturulabilir. Bu yöntem, genellikle bir nedenle tek tek bileşenleri farklı değişkenlere bölmek istediğinizde yararlıdır.

Sorgularda takma adlandırma

Data Connect, sorgularda GraphQL takma adlandırmasını destekler. Takma adlar sayesinde, bir sorgunun sonuçlarında döndürülen verileri yeniden adlandırabilirsiniz. Tek bir Data Connect sorgusu, sunucuya tek bir verimli istek göndererek birden fazla filtre veya başka sorgu işlemleri uygulayabilir ve aynı anda birkaç "alt sorgu" yayınlayabilir. Döndürülen veri kümesinde ad çakışmalarını önlemek için alt sorguları ayırt etmek üzere takma adlar kullanırsınız.

Aşağıda, bir ifadenin mostPopular takma adını kullandığı bir sorgu verilmiştir.

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

Filtre içeren basit sorgular

Data Connect sorguları, tüm yaygın SQL filtreleriyle ve sıralama işlemleriyle eşlenir.

where ve orderBy operatörleri (tekil, çoğul sorgular)

Tablodaki eşleşen tüm satırları (ve iç içe geçmiş ilişkilendirmeleri) döndürür. Filtreyle eşleşen bir kayıt yoksa boş bir dizi döndürür.

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}]) { … }
}

limit ve offset operatörleri (tekil, çoğul sorgular)

Sonuçlarda sayfalandırma yapabilirsiniz. Bu bağımsız değişkenler kabul edilir ancak sonuçlarda döndürülmez.

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

Dizi alanları için içerir

Bir dizi alanının belirtilen bir öğeyi içerip içermediğini test edebilirsiniz.

# 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
  }
}

Dize işlemleri ve normal ifadeler

Sorgularınızda normal ifadeler de dahil olmak üzere normal dize arama ve karşılaştırma işlemleri kullanılabilir. Verimliliği artırmak için burada birkaç işlemi bir araya getirdiğinizi ve bunları takma adlarla açıklığa kavuşturduğunuzu unutmayın.

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}}}) {...}
}

Oluşturulan filtreler için or ve and

Daha karmaşık mantık için or ve and kullanın.

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
  }
}

Karmaşık sorgular

Data Connect sorguları, tablolar arasındaki ilişkilere göre verilere erişebilir. İç içe yerleştirilmiş sorgular oluşturmak (ör. iç içe yerleştirilmiş veya ilgili bir türden veri ile birlikte bir tür için veri almak) amacıyla şemanızda tanımlanan nesne (bire bir) veya dizi (bir çok) ilişkilerini kullanabilirsiniz.

Bu tür sorgular, oluşturulan örtülü sorgularda sihirli Data Connect _on_ ve _via söz dizimini kullanır.

İlk sürümümüzdeki şemada değişiklikler yapacaksınız.

Çoka-tek

Uygulamamıza yorumlar ekleyelim. Bunun için Review tablosu ve User'da değişiklikler yapalım.

# 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")
}

Bire çok sorgu

Şimdi _via_ söz dizimini açıklamak için takma ad içeren bir sorguya bakalım.

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
    }
  }
}

Bire bir

Bu durumu görebilirsiniz. Aşağıda, şemada açıklama amaçlı bir değişiklik yapılmıştır.

# 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
}

Bire bir sorgu

_on_ söz dizimini kullanarak sorgu oluşturabilirsiniz.

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

Çoka çok

Filmler oyunculara, oyuncular da filmlere ihtiyaç duyar. Bu iki tablo arasında MovieActors birleştirme tablosuyla modelleyebileceğiniz çoklu-çoklu bir ilişki vardır.

# 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!]!
}

Çoka çok sorgu

_via_ söz dizimini açıklamak için takma ad içeren bir sorguya bakalım.

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
    }
  }
}

Film eleştirisi veritabanı için mutasyonlar

Daha önce de belirtildiği gibi, şemanızda bir tablo tanımladığınızda Data Connect, her tablo için temel, gizli mutasyonlar oluşturur.

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!
}

Bu sayede, giderek daha karmaşık temel CRUD işlemlerini uygulayabilirsiniz. Bunu hızlıca beş kez söyle.

@transaction yönergesi

Bu yönerge, bir mutasyonun her zaman bir veritabanı işleminde çalıştırılmasını zorunlu kılar.

@transaction içeren mutasyonların tamamen başarılı veya tamamen başarısız olacağı garanti edilir. İşlemdeki alanlardan herhangi biri başarısız olursa tüm işlem geri alınır. İstemci açısından, tüm istek bir istek hatasıyla başarısız olmuş ve yürütme işlemi başlamamış gibi davranır.

@transaction içermeyen mutasyonlar, her bir kök alanı sırayla birbiri ardına yürütür. Tüm hataları kısmi alan hataları olarak gösterir ancak sonraki yürütmelerin etkilerini göstermez.

Oluştur

Temel oluşturma işlemlerini yapalım.

# 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
  })
}

Veya bir 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"
  })
}

Güncelleme yapma

Güncellemeleri aşağıda bulabilirsiniz. Yapımcılar ve yönetmenler, bu ortalama puanların trende uygun olmasını ister.

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

Silme işlemleri gerçekleştirme

Film verilerini silebilirsiniz. Film koruma uzmanları, fiziksel filmlerin mümkün olduğunca uzun süre korunmasını ister.

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

Burada _deleteMany kullanabilirsiniz.

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

İlişkilerde mutasyon yazma

Bir ilişkide örtülü _upsert mutasyonunun nasıl kullanıldığını gözlemleyin.

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

Yetkilendirme verisi arama sorguları

Data Connect mutasyonları, önce veritabanını sorgulayarak ve sorgunun sonuçlarını CEL ifadeleriyle doğrulayarak yetkilendirilebilir. Bu, bir tabloya yazarken başka bir tablodaki satırın içeriğini kontrol etmeniz gerektiğinde kullanışlıdır.

Bu özellik şunları destekler:

• Alanların içeriğini değerlendirmenize ve bu değerlendirmenin sonuçlarına göre işlem yapmanıza olanak tanıyan @check yönergesi:
  • Mutasyon tarafından tanımlanan oluşturma, güncelleme ve silme işlemlerine devam edin
  • İstemcilerinizde farklı mantıklar gerçekleştirmek için sorgu tarafından istemcilere döndürülen değerleri kullanın
• Sorgu sonuçlarını kablo protokolü sonuçlarından çıkarmanıza olanak tanıyan @redact yönergesi.

Bu özellikler yetkilendirme akışları için yararlıdır.

Eşdeğer SQL şeması

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

Sırada ne var?

• Yetkilendirme ve doğrulama ile sorgularınızı ve mutasyonlarınızı nasıl güvenli hale getireceğinizi öğrenin.
• Sorgularınızı ve mutasyonlarınızı otomatik olarak oluşturulan web SDK'sından, Android SDK'sından, iOS SDK'sından ve Flutter SDK'sından nasıl çağıracağınızı öğrenin.