Data Connect sorgularını uygulama

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, şemanızdaki verilerinizi kullanmak için sorgular ve mutasyonların birleşimidir.

Not: Veri Bağlayıcı şemaları ve bağlayıcıları oluşturma ile ilgili tüm seriyi takip edin. Bu seride şu konular ele alınır:

• Şema geliştirme
• Sorgu geliştirme (bu kılavuz)
• Mutasyon geliştirme

Başlangıç kılavuzunda PostgreSQL için bir film inceleme uygulaması şeması tanıtıldı.

Bu kılavuzda, sorgular da dahil olmak üzere hem dağıtılabilir hem de geçici yönetim işlemleri tanıtılmıştı.

• Dağıtılabilir sorgular, tanımladığınız API uç noktalarıyla istemci uygulamalarından çağrı yapmak için uyguladığınız sorgulardır. Bunları sunucuya dağıtılan bir bağlayıcıda birleştirirsiniz. Data Connect aracı, API'nize göre istemci SDK'ları oluşturur. Dağıtılan sorgular IAM politikası tarafından korunmaz. Bu nedenle, Data Connect @auth yönergesini kullanarak bunları güvenli hale getirdiğinizden emin olun.
• Geçici yönetim sorguları, verileri okumak için ayrıcalıklı ortamlardan çalıştırılır. Bu görevleri Firebase konsolunda veya Data Connect VS Code uzantımızı kullanarak yerel geliştirme ortamlarında oluşturup yürütebilirsiniz.

Bu kılavuzda dağıtılabilir sorgular daha ayrıntılı olarak ele alınmaktadır.

Data Connect sorgularının özellikleri

Data Connect, PostgreSQL veritabanı göz önüne alındığında bekleyeceğiniz tüm yöntemlerle temel sorgular gerçekleştirmenize olanak tanır.

Ancak Data Connect'ın GraphQL'e yönelik uzantılarıyla daha hızlı ve verimli uygulamalar için gelişmiş sorgular uygulayabilirsiniz:

• Kayıtlarda tekrarlanan işlemleri basitleştirmek için birçok işlem tarafından döndürülen anahtar ölçeklendirme faktörlerini kullanın.
• Verileri aramak için çok adımlı mutasyon işlemleri sırasında sorgular gerçekleştirerek kod satırlarını ve sunucuya gidiş dönüşleri kaydedin.

Not: Bu kılavuzu kullanmadan önce film yorumu şemasını inceleyin.

Movie review app schema

      type User @table {
      id: String! @default(expr: "auth.uid")
      username: String! @col(dataType: "varchar(50)")
      }

      type Review @table(name: "Reviews", key: ["movie", "user"]) {
      user: User!
      movie: Movie!
      rating: Int
      reviewText: String
      reviewDate: Date! @default(expr: "request.time")
      }

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

      type MovieMetadata
      @table(
        name: "MovieMetadata"
      ) {
      movie: Movie! @ref
      director: String @col(name: "director")
      }

      extend type Movie {
      movieMetadata: MovieMetadata
      movieMetadatas_on_movie: MovieMetadata
      }

      type MovieActors @table(
      key: ["movie", "actor"]
      ) {
      movie: Movie!
      actor: Actor!
      }

      extend type MovieActors {
      movieId: UUID!
      actorId: UUID!
      }

      extend type Movie {
      movieActors: [MovieActors!]!
      actors: [Actor!]!
      actors_via_MovieActors: [Actor!]!
      }

      extend type Actor {
      movieActors: [MovieActors!]!
      movies: [Movie!]!
      movies_via_MovieActors: [Movie!]!
      }
    

Sorgu oluşturmak için oluşturulan alanları kullanma

Data Connect işlemleriniz, şemanızdaki türlere ve tür ilişkilerine göre otomatik olarak oluşturulan Data Connect bir dizi alanı genişletir. Bu alanlar, şemanızı her düzenlediğinizde yerel araçlar tarafından oluşturulur.

İpucu: İşlemleri oluştururken oluşturulan alanları keşfetmek için Firebase konsolundaki sorgu düzenleyiciyi veya Visual Studio Code uzantımızı kullanın.

Oluşturulan alanları kullanarak tek tablolardan tek kayıt veya birden çok kayıt almaktan ilgili tablolardan birden çok kayıt almaya kadar giderek karmaşıklaşan sorgular uygulayabilirsiniz.

Şemanızın bir Movie türü ve ilişkili bir Actor türü içerdiğini varsayalım. Data Connect, movie, movies, actors_on_movies alanlarını ve daha fazlasını oluşturur.

Not: Bu sorgu alanları, kayıtları tanımlamak için anahtar skaler türü (burada Movie_Key) iletmenize olanak tanır. Bunlar şemanıza göre oluşturulur.

movie alanı içeren sorgu

movie alanı, Movie tablosundaki tek bir kaydı temsil eder.

Bu alanı, tek bir filmi anahtarına göre sorgulamak için kullanın. query GetMovie($myKey: Movie_Key!) { movie(key: $myKey) { title } }

movies alanı içeren sorgu

movies alanı, Movie tablosundaki kayıtların listesini temsil eder.

Bu alanı, birden fazla filmi (ör. belirli bir yılda yayınlanan tüm filmler) sorgulamak için kullanın. query GetMovies($myYear: Int!) { movies(where: { year: { eq: $myYear } }) { title } }

actors_on_movies alanı içeren sorgu

actors_on_movies alanı, Actor ve Movie tablolarını bağlayan kayıtların listesini gösterir. Belirli bir filmle ilişkili tüm aktörleri sorgulamak için bu alanı kullanın.

Belirli bir filmle ilişkili tüm aktörleri sorgulamak için bu alanı kullanın. query GetActorsOnMovie($myKey: Movie_Key!) { actors_on_movies(where: { movie: { key: { eq: $myKey } } }) { actor { name } } }

İpucu: Şema tanım dili, @table yönergesi için singular ve plural bağımsız değişkenlerini kullanarak alanlar için adların nasıl oluşturulacağını açıkça kontrol etmenize de olanak tanır.

Sorgunun temel öğeleri

Data Connect sorguları, Data Connect uzantıları içeren GraphQL sorgularıdır. Normal bir GraphQL sorgusunda olduğu gibi, işlem adı ve GraphQL değişkenleri listesi tanımlayabilirsiniz.

Data Connect, GraphQL sorgularını @auth gibi özelleştirilmiş yönergelerle genişletir. @auth.

İpucu: Firebase konsolunda GraphQL sorguları oluşturup test etmenize yardımcı olması için Firebase'da Gemini'ı kullanabilirsiniz. Daha fazla bilgi için Sorgular ve mutasyonlar için yapay zeka yardımını kullanma başlıklı makaleyi inceleyin.

Bu nedenle, aşağıdaki sorguda:

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

query ListMoviesByGenre($genre: String!) @auth(level: PUBLIC) {
  movies(where: { genre: { eq: $genre } }) {
    id
    title
  }
}

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

Bu kılavuzda, giderek daha karmaşık hale gelen sorguların imzası incelenecektir. Dağıtılabilir sorgularınızı oluşturmak için kullanabileceğiniz güçlü ve kısa ilişki ifadelerini tanıtarak kursu tamamlayacaksınız.

Sorgulardaki temel skalerler

Ancak öncelikle temel ölçekler hakkında bir not.

Data Connect, {TableType}_Key ile tanımlanan her tablonun birincil anahtarlarını temsil etmek için özel bir anahtar skaler tanımlar. Birincil anahtar değerlerinin JSON nesnesidir.

Çoğu otomatik oluşturulmuş okuma alanının döndürdüğü yanıt olarak veya tabii ki skaler anahtar oluşturmak için gereken tüm alanları aldığınız sorgulardan temel skalerleri alırsınız.

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

Bir anahtar skalerini değişmez değer olarak iletiyor olabilirsiniz. Ancak, geçiş anahtarı skalerlerini giriş olarak iletmek için değişkenler tanımlayabilirsiniz.

Sorgu

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

Yanıt

{
  "data": {
    "movie": {
      "title": "Example Movie Title"
    }
  }
}
    

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

{
  # …
  "variables": {
    "myKey": {"id": "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"}
  }
}

Özel skaler ayrıştırma sayesinde, değişkenler içerebilen nesne söz dizimi kullanılarak da Movie_Key oluşturulabilir. Bu özellik, genellikle tek tek bileşenleri bir nedenden dolayı farklı değişkenlere ayırmak istediğinizde yararlıdır.

Temel sorgular yazma

Veritabanınızdan tek tek kayıtlar almak için sorgu yazmaya başlayabilir veya sonuçları sınırlama ve sıralama seçeneğiyle birlikte bir tablodaki kayıtları listeleyebilirsiniz.

İpucu: Firebase konsolunda GraphQL sorguları oluşturup çalıştırmanıza yardımcı olması için Firebase'da Gemini'ı kullanabilirsiniz. Daha fazla bilgi için Sorgular ve mutasyonlar için yapay zeka yardımını kullanma başlıklı makaleyi inceleyin.

Kayıtları tek tek alma

En basit sorgu, kimliğe göre tek bir kayıt alır. Sorgunuzda otomatik olarak oluşturulan movie alanı kullanılır.

Sorgu

query GetMovieById($id: UUID!) @auth(level: PUBLIC) {
  movie(id: $id) {
    id
    title
    imageUrl
    genre
  }
}
    

Yanıt

{
  "data": {
    "movie": {
      "id": "some-uuid",
      "title": "Example Movie Title",
      "imageUrl": "https://example.com/movie.jpg",
      "genre": "Action"
    }
  }
}
    

Tablodaki tüm kayıtları alma

Movies tablosundaki filmlerin tam listesi için bir alan alt kümesini almak üzere sorgunuzda otomatik olarak oluşturulan movies alanı kullanılır ve uygulamanız aşağıdaki gibi görünebilir.

Sorgu

query ListMovies @auth(level: PUBLIC) {
  movies {
    id
    title
    imageUrl
    genre
  }
}
    

Yanıt

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title",
        "imageUrl": "https://example.com/movie.jpg",
        "genre": "Action"
      },
      {
        "id": "another-uuid",
        "title": "Another Movie Title",
        "imageUrl": "https://example.com/another-movie.jpg",
        "genre": "Comedy"
      }
    ]
  }
}
    

orderBy, limit ve offset operatörlerini kullanma

Doğal olarak, bir tablodaki tüm kayıtları listelemek sınırlı bir kullanışlılığa sahiptir.

Sonuçları sıralayabilir ve sayfalandırabilirsiniz. Bu bağımsız değişkenler kabul edilir ancak sonuçlarda döndürülmez.

Burada sorgu, puanına göre en iyi 10 filmin başlığını alıyor.

Sorgu

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

Yanıt

{
  "data": {
    "movies": [
      { "title": "Top Movie 1" },
      { "title": "Top Movie 2" },
      { "title": "Top Movie 3" }
      // ... other 7 movies
    ]
  }
}
    

Derecelendirmeye göre sıralanmış 11-20. filmler gibi, satırları bir uzaklıktan getirme konusunda bir kullanım alanınız olabilir.

Sorgu

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

Yanıt

{
  "data": {
    "movies": [
      { "title": "Movie 11" },
      { "title": "Movie 12" },
      { "title": "Movie 13" }
      // ... other 7 movies
    ]
  }
}
    

Sorgularda takma ad kullanma

Data Connect, sorgularda GraphQL takma adını destekler. Diğer adlarla, bir sorgunun sonuçlarında döndürülen verileri yeniden adlandırabilirsiniz. Tek bir Data Connect sorgusu, sunucuya tek bir verimli istekte birden fazla filtre veya başka sorgu işlemi uygulayabilir. Bu sayede, aynı anda birden fazla "alt sorgu" gönderilmiş olur. 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 ve leastPopular takma adlarını kullandığı bir sorgu verilmiştir.

Sorgu

query ReviewPopularitySpread($genre: String) {
  mostPopular: review(
    first: {
      where: {genre: {eq: $genre}},
      orderBy: {popularity: DESC}
    }
  ),
  leastPopular: review(
    last: {
      where: {genre: {eq: $genre}},
      orderBy: {popularity: DESC}
    }
  )
}
    

Yanıt

{
  "data": {
    "mostPopular": [
      { "popularity": 9 }
    ],
    "leastPopular": [
      { "popularity": 1 }
    ]
  }
}
    

Sorgu filtrelerini kullanma

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

where ve orderBy operatörleriyle filtreleme

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

Sorgu

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

Yanıt

{
  "data": {
    "mostPopular": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title",
        "genre": "Action",
        "description": "A great movie"
      }
    ]
  }
}
    

Boş değerleri test ederek filtreleme

null değerlerini isNull operatörünü kullanarak test edebilirsiniz.

Sorgu

query ListMoviesWithoutDescription {
  movies(where: { description: { isNull: true }}) {
    id
    title
  }
}
    

Yanıt

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title"
      },
      {
        "id": "another-uuid",
        "title": "Another Movie Title"
      }
    ]
  }
}
    

Daha fazla operatör için giriş nesnesi türleri referans kılavuzuna bakın.

Değer karşılaştırmalarıyla filtreleme

Sorgularınızdaki değerleri karşılaştırmak için lt (küçüktür) ve ge (büyüktür veya eşittir) gibi operatörleri kullanabilirsiniz.

Sorgu

query ListMoviesByRating($minRating: Int!, $maxRating: Int!) {
  movies(where: { rating: { ge: $minRating, lt: $maxRating }}) {
    id
    title
  }
}
    

Yanıt

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title"
      },
      {
        "id": "another-uuid",
        "title": "Another Movie Title"
      }
    ]
  }
}
    

Dizi alanları için includes ve excludes operatörleriyle filtreleme

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

Aşağıdaki örnekte includes operatörü gösterilmektedir.

Data Connect, includesAll, excludes, excludesAll ve daha fazlasını destekler. Tam sayılar, dizeler, tarihler ve diğer veri türleri için bu tür tüm operatörleri _ListFilter referans dokümanının başlıklarında inceleyin.

Sorgu

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

Yanıt

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title"
      }
    ]
  }
}
    

Dize işlemleri ve normal ifadelerle filtreleme

Sorgularınızda normal ifadeler de dahil olmak üzere, normal dize arama ve karşılaştırma işlemleri kullanılabilir. Verimlilik için burada birkaç işlemi paketlediğinizi ve bunları takma adlarla netleştirdiğinizi 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}}) {...}
}

_or, _and, _not operatör mantığıyla filtreleme

Daha karmaşık mantık için _or kullanın. Data Connect, _and ve _not operatörlerini de destekler.

Sorgu

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

Yanıt

{
  "data": {
    "movies": [
      { "title": "Movie Title 1" },
      { "title": "Movie Title 2" }
    ]
  }
}
    

İpucu: Data Connect için GraphQL dil uzantılarının tam seti dil referans kılavuzunda belgelenmiştir.

İlişkisel sorgular yazma

Data Connect sorguları, tablolar arasındaki ilişkilere göre verilere erişebilir. Şemanızda tanımlanan nesne (bire bir) veya dizi (bire çok) ilişkilerini kullanarak iç içe yerleştirilmiş sorgular oluşturabilirsiniz. Yani, bir tür için verileri iç içe yerleştirilmiş veya ilgili bir türdeki verilerle birlikte getirebilirsiniz.

Bu tür sorgular, oluşturulan okuma alanlarında sihirli Data Connect _on_ ve _via söz dizimini kullanır.

Örnek şemayı incelemeyi unutmayın.

Çoktan bire

Şimdi _on_ söz dizimini açıklayan bir sorguya bakalım.

Sorgu

query MyReviews @auth(level: USER) {
  user(key: {id_expr: "auth.uid"}) {
    reviews: reviews_on_user {
      movie { name }
      rating
    }
  }
}
    

Yanıt

{
  "data": {
    "user": {
      "reviews": [
        {
          "movie": { "name": "Movie Title" },
          "rating": 5
        }
      ]
    }
  }
}
    

Bire bir

_on_ söz dizimini kullanarak bire bir sorgu yazabilirsiniz.

Sorgu

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

Yanıt

{
  "data": {
    "movie": {
      "movieMetadatas_on_movie": {
        "director": "Some Director"
      }
    }
  }
}
    

Çoka çok

Çoktan çoka sorgularında _via_ söz dizimi kullanılır. Çoktan çoğa sorgusu, belirtilen bir filmdeki oyuncuları alabilir.

Sorgu

query MoviesActors($id: UUID!) @auth(level: USER) {
  movie(id: $id) {
     actors: actors_via_MovieActors {
        name
     }
  }
}
    

Yanıt

{
  "data": {
    "movie": {
      "actors": [
        {
          "name": "Actor Name"
        }
      ]
    }
  }
}
    

Ancak role sonuçlarına göre filtrelemek için takma adlar kullanarak daha karmaşık bir sorgu yazabiliriz. Bu sorgu, mainActors ve supportingActors sonuçlarında oyuncuları ve ilişkili filmleri alır. Bu ilişki çoktan çoğa olduğundan _via_ söz dizimi kullanılır.

Sorgu

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

Yanıt

{
  "data": {
    "movie": {
      "mainActors": [
        {
          "name": "Main Actor Name"
        }
      ],
      "supportingActors": [
        {
          "name": "Supporting Actor Name"
        }
      ]
    },
    "actor": {
      "mainRoles": [
        {
          "title": "Main Role Movie Title"
        }
      ],
      "supportingRoles": [
        {
          "title": "Supporting Role Movie Title"
        }
      ]
    }
  }
}
    

İpucu: Data Connect için GraphQL dil uzantılarının tam seti dil referans kılavuzunda belgelenmiştir.

Toplama sorguları

Toplama nedir ve neden kullanılır?

Toplama alanları, sonuç listesinde hesaplamalar yapmanıza olanak tanır. Toplama alanlarıyla aşağıdakiler gibi işlemler yapabilirsiniz:

• Yorumun ortalama puanını bulma
• Alışveriş sepetindeki öğelerin toplam maliyetini bulma
• En yüksek veya en düşük puanlı ürünü bulma
• Mağazanızdaki ürünlerin sayısını belirleme

Toplama işlemleri sunucuda gerçekleştirilir. Bu durum, istemci tarafında hesaplamaya kıyasla çeşitli avantajlar sunar:

• Daha hızlı uygulama performansı (istemci tarafı hesaplamalarından kaçındığınız için)
• Veri çıkışı maliyetlerinde azalma (tüm girişleri göndermek yerine yalnızca toplu sonuçları gönderdiğiniz için)
• Gelişmiş güvenlik (çünkü müşterilere tüm veri kümesi yerine toplu verilere erişim izni verebilirsiniz)

Not: Toplama alanlarının tam listesi için Data Connect GraphQL referans belgelerine bakın.

Toplamalar için örnek şema

Bu bölümde, toplamları nasıl kullanacağımızı açıklamak için iyi bir örnek olan bir mağaza vitrini örnek şemasına geçeceğiz:

  type Product @table {
    name: String!
    manufacturer: String!
    quantityInStock: Int!
    price: Float!
    expirationDate: Date
  }

Basit toplamalar

Tüm alanlar için _count

En basit toplama alanı _count'dır: Sorgunuzla eşleşen satır sayısını döndürür. Türünüzdeki her alan için, Data Connect alan türüne bağlı olarak karşılık gelen toplama alanları oluşturur.

Sorgu

query CountProducts {
  products {
    _count
  }
}

Yanıt

one

Örneğin, veritabanınızda 5 ürün varsa sonuç şu şekilde olur:

{
  "products": [
    {
    "_count": 5
    }
  ]
}

Tüm alanlarda, söz konusu alanda kaç satırın boş olmayan bir değere sahip olduğunu sayan bir <field>_count alanı bulunur.

Sorgu

query CountProductsWithExpirationDate {
  products {
    expirationDate_count
  }
}

Yanıt

field_count

Örneğin, geçerlilik bitiş tarihi olan 3 ürününüz varsa sonuç şu şekilde olur:

{
  "products": [
    {
    "expirationDate_count": 3
    }
  ]
}

Sayısal alanlar için _min, _max, _sum ve _avg

Sayısal alanlarda (int, float, int64) <field>_min, <field>_max, <field>_sum ve <field>_avg da bulunur.

Sorgu

query NumericAggregates {
  products {
  quantityInStock_max
  price_min
  price_avg
  quantityInStock_sum
  }
}

Yanıt

_min _max _sum _avg

Örneğin, aşağıdaki ürünlere sahipseniz:

• A ürünü: quantityInStock: 10, price: 2.99
• B ürünü: quantityInStock: 5, price: 5.99
• C ürünü: quantityInStock: 20, price: 1.99

Sonuç şöyle olur:

{
  "products": [
    {
    "quantityInStock_max": 20,
    "price_min": 1.99,
    "price_avg": 3.6566666666666666,
    "quantityInStock_sum": 35
    }
  ]
}

Tarihler ve zaman damgaları için _min ve _max

Tarih ve zaman damgası alanlarında <field>_min ve <field>_max bulunur.

Sorgu

query DateAndTimeAggregates {
  products {
  expirationDate_max
  expirationDate_min
  }
}

Yanıt

_min _maxdatetime

Örneğin, aşağıdaki son kullanma tarihlerine sahipseniz:

• A ürünü: 2024-01-01
• B ürünü: 2024-03-01
• Ürün C: 2024-02-01

Sonuç şöyle olur:

{
  "products": [
    {
    "expirationDate_max": "2024-03-01",
    "expirationDate_min": "2024-01-01"
    }
  ]
}

Farklı

distinct bağımsız değişkeni, bir alanın (veya alan kombinasyonunun) tüm benzersiz değerlerini almanızı sağlar. Örneğin:

Sorgu

query ListDistinctManufacturers {
  products(distinct: true) {
    manufacturer
  }
}

Yanıt

distinct

Örneğin, aşağıdaki üreticilere sahipseniz:

• A ürünü: manufacturer: "Acme"
• B ürünü: manufacturer: "Beta"
• Ürün C: manufacturer: "Acme"

Sonuç şöyle olur:

{
  "products": [
    { "manufacturer": "Acme" },
    { "manufacturer": "Beta" }
  ]
}

Ayrıca, farklı değerleri toplamak için toplama alanlarında distinct bağımsız değişkenini de kullanabilirsiniz. Örneğin:

Sorgu

query CountDistinctManufacturers {
  products {
    manufacturer_count(distinct: true)
  }
}

Yanıt

distinctonaggregate

Örneğin, aşağıdaki üreticilere sahipseniz:

• A ürünü: manufacturer: "Acme"
• B ürünü: manufacturer: "Beta"
• Ürün C: manufacturer: "Acme"

Sonuç şöyle olur:

{
  "products": [
    {
    "manufacturer_count": 2
    }
  ]
}

Gruplandırılmış toplamalar

Bir türde toplama ve toplama dışı alanların bir karışımını seçerek gruplandırılmış toplama işlemi gerçekleştirirsiniz. Bu işlev, toplama içermeyen alanlar için aynı değere sahip olan tüm eşleşen satırları birlikte gruplandırır ve bu grup için toplama içeren alanları hesaplar. Örneğin:

Sorgu

query MostExpensiveProductByManufacturer {
  products {
  manufacturer
  price_max
  }
}

Yanıt

groupedaggregates

Örneğin, aşağıdaki ürünlere sahipseniz:

• A ürünü: manufacturer: "Acme", price: 2.99
• B ürünü: manufacturer: "Beta", price: 5.99
• C ürünü: manufacturer: "Acme", price: 1.99

Sonuç şöyle olur:

{
  "products": [
    { "manufacturer": "Acme", "price_max": 2.99 },
    { "manufacturer": "Beta", "price_max": 5.99 }
  ]
}

Gruplandırılmış toplamlar içeren having ve where

Ayrıca, yalnızca belirtilen ölçütleri karşılayan grupları döndürmek için having ve where bağımsız değişkenini de kullanabilirsiniz.

• having, grupları toplu alanlarına göre filtrelemenize olanak tanır.

• where, satırları toplama içermeyen alanlara göre filtrelemenizi sağlar.

Sorgu

query FilteredMostExpensiveProductByManufacturer {
  products(having: {price_max: {ge: 2.99}}) {
  manufacturer
  price_max
  }
}

Yanıt

havingwhere

Örneğin, aşağıdaki ürünlere sahipseniz:

• A ürünü: manufacturer: "Acme", price: 2.99
• B ürünü: manufacturer: "Beta", price: 5.99
• C ürünü: manufacturer: "Acme", price: 1.99

Sonuç şöyle olur:

{
  "products": [
    { "manufacturer": "Acme", "price_max": 2.99 },
    { "manufacturer": "Beta", "price_max": 5.99 }
  ]
}

Tablolar arasında toplama

Toplama alanları, verilerinizle ilgili karmaşık soruları yanıtlamak için oluşturulan bire çok ilişki alanlarıyla birlikte kullanılabilir. Aşağıda, örneklerde kullanabileceğimiz ayrı bir tablo olan Manufacturer ile değiştirilmiş bir şema yer almaktadır:

  type Product @table {
    name: String!
    manufacturer: Manufacturer!
    quantityInStock: Int!
    price: Float!
    expirationDate: Date
  }

  type Manufacturer @table {
    name: String!
    headquartersCountry: String!
  }

Artık toplama alanlarını kullanarak bir üreticinin kaç ürün ürettiğini bulma gibi işlemler yapabiliriz:

Sorgu

query GetProductCount($id: UUID) {
  manufacturers {
    name
    products_on_manufacturer {
      _count
    }
  }
}

Yanıt

aggregatesacrosstables

Örneğin, aşağıdaki üreticilere sahipseniz:

• A üreticisi: name: "Acme", products_on_manufacturer: 2
• B üreticisi: name: "Beta", products_on_manufacturer: 1

Sonuç şöyle olur:

{
  "manufacturers": [
    { "name": "Acme", "products_on_manufacturer": { "_count": 2 } },
    { "name": "Beta", "products_on_manufacturer": { "_count": 1 } }
  ]
}

Gelişmiş sorgular yazma: Çok adımlı işlemlerde verileri okumak için query alanlarını kullanın.

Mevcut verileri aramak ve doğrulamak için mutasyon yürütülürken veritabanınızı okumak isteyebileceğiniz birçok durum vardır. Örneğin, ekleme veya güncelleme işlemleri yapmadan önce bu işlemi gerçekleştirebilirsiniz. Bu seçenekler gidiş dönüş işlemleri ve dolayısıyla maliyetlerden tasarruf sağlar.

Data Connect bu işlevi destekler. Çok adımlı işlemleri inceleyin.

Sonraki adımlar

Not: Veri Bağlayıcı şemaları ve bağlayıcıları oluşturma ile ilgili tüm seriyi takip edin. Bu seride şu konular ele alınır:

• Şema geliştirme
• Sorgu geliştirme (bu kılavuz)
• Mutasyon geliştirme

İlginizi çekebilir:

• Yapay zeka yardım araçlarını kullanarak uygulamalarınız için sorgu oluşturma
• Sorgularınızı yetkilendirme kılavuzuna göre yetkilendirme
• Web, iOS, Android ve Flutter için istemci kodunuzdan sorgu çağırma.