Data Connect क्वेरी लागू करना

Firebase Data Connect की मदद से, Google Cloud SQL से मैनेज किए जा रहे PostgreSQL इंस्टेंस के लिए कनेक्टर बनाए जा सकते हैं. ये कनेक्टर, आपके स्कीमा से डेटा का इस्तेमाल करने के लिए, क्वेरी और म्यूटेशन के कॉम्बिनेशन होते हैं.

शुरू करने के लिए गाइड में, PostgreSQL के लिए, फ़िल्म की समीक्षा करने वाले ऐप्लिकेशन का स्कीमा जोड़ा गया है.

उस गाइड में, डिप्लॉय किए जा सकने वाले और ad hoc एडमिनिस्ट्रेशन ऑपरेशन, दोनों के बारे में बताया गया है. इनमें क्वेरी भी शामिल हैं.

  • डिप्लॉय की जा सकने वाली क्वेरी, वे क्वेरी होती हैं जिन्हें आपने क्लाइंट ऐप्लिकेशन से कॉल करने के लिए लागू किया है. ये क्वेरी, आपके तय किए गए एपीआई एंडपॉइंट के साथ काम करती हैं. इन्हें सर्वर पर डिप्लॉय किए गए कनेक्टर में बंडल किया जाता है. Data Connect टूल, आपके एपीआई के आधार पर क्लाइंट SDK जनरेट करता है. डिप्लॉय की गई क्वेरी, आईएएम नीति के तहत सुरक्षित नहीं होती हैं. इसलिए, Data Connect @auth डायरेक्टिव का इस्तेमाल करके, उन्हें सुरक्षित करना न भूलें.
  • एड-हॉक एडमिन क्वेरी, डेटा पढ़ने के लिए, विशेषाधिकार वाले एनवायरमेंट से चलाई जाती हैं. इन्हें Firebase कंसोल या स्थानीय डेवलपमेंट एनवायरमेंट में बनाया और चलाया जा सकता है. इसके लिए, Data Connect VS Code एक्सटेंशन का इस्तेमाल करें.

इस गाइड में, डिप्लॉय की जा सकने वाली क्वेरी के बारे में ज़्यादा जानकारी दी गई है.

Data Connect क्वेरी की सुविधाएं

Data Connect की मदद से, PostgreSQL डेटाबेस में सभी तरह की बुनियादी क्वेरी की जा सकती हैं.

हालांकि, Data Connect के GraphQL एक्सटेंशन की मदद से, तेज़ और ज़्यादा असरदार ऐप्लिकेशन के लिए बेहतर क्वेरी लागू की जा सकती हैं:

  • रिकॉर्ड पर बार-बार की जाने वाली कार्रवाइयों को आसान बनाने के लिए, कई कार्रवाइयों से मिले की स्केलर का इस्तेमाल करें
  • डेटा को खोजने के लिए, कई चरणों वाले म्यूटेशन ऑपरेशन के दौरान क्वेरी करें. इससे कोड की लाइनें सेव होती हैं और सर्वर पर राउंड ट्रिप की संख्या कम होती है.

क्वेरी बनाने के लिए, जनरेट किए गए फ़ील्ड का इस्तेमाल करना

आपके Data Connect ऑपरेशन, आपके स्कीमा में मौजूद टाइप और टाइप के रिलेशनशिप के आधार पर, अपने-आप जनरेट हुए Data Connect फ़ील्ड के सेट को बड़ा करेंगे. जब भी स्कीमा में बदलाव किया जाता है, तो ये फ़ील्ड स्थानीय टूल से जनरेट होते हैं.

जनरेट किए गए फ़ील्ड का इस्तेमाल करके, ज़्यादा कॉम्प्लेक्स क्वेरी लागू की जा सकती हैं. जैसे, किसी एक टेबल से अलग-अलग रिकॉर्ड या कई रिकॉर्ड हासिल करना या मिलती-जुलती टेबल से कई रिकॉर्ड हासिल करना.

मान लें कि आपके स्कीमा में Movie टाइप और उससे जुड़ा Actor टाइप है. Data Connect, movie, movies, actors_on_movies फ़ील्ड वगैरह जनरेट करता है.


movie फ़ील्ड की मदद से क्वेरी करना

movie फ़ील्ड, Movie टेबल में एक रिकॉर्ड दिखाता है.

इस फ़ील्ड का इस्तेमाल करके, किसी एक फ़िल्म की कुंजी से क्वेरी करें.

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


movies फ़ील्ड की मदद से क्वेरी करना

movies फ़ील्ड, Movie टेबल में रिकॉर्ड की सूची दिखाता है.

एक से ज़्यादा फ़िल्मों के बारे में क्वेरी करने के लिए, इस फ़ील्ड का इस्तेमाल करें. उदाहरण के लिए, किसी साल की सभी फ़िल्में.

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


actors_on_movies फ़ील्ड की मदद से क्वेरी करना

actors_on_movies फ़ील्ड, Actor और Movie टेबल को जोड़ने वाले रिकॉर्ड की सूची दिखाता है. किसी फ़िल्म से जुड़े सभी कलाकारों के बारे में जानकारी पाने के लिए, इस फ़ील्ड का इस्तेमाल करें.

किसी फ़िल्म से जुड़े सभी कलाकारों के बारे में जानकारी पाने के लिए, इस फ़ील्ड का इस्तेमाल करें.

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

क्वेरी के ज़रूरी एलिमेंट

Data Connect क्वेरी, Data Connect एक्सटेंशन वाली GraphQL क्वेरी होती हैं. सामान्य GraphQL क्वेरी की तरह ही, आपके पास ऑपरेशन का नाम और GraphQL वैरिएबल की सूची तय करने का विकल्प होता है.

Data Connect, @auth जैसे पसंद के मुताबिक बनाए गए डायरेक्टिव की मदद से, GraphQL क्वेरी को बेहतर बनाता है.

इसलिए, इस क्वेरी में:

  • query टाइप की परिभाषा
  • ListMoviesByGenre ऑपरेशन (क्वेरी) का नाम
  • एक क्वेरी आर्ग्युमेंट, यहां String टाइप का $genre वैरिएबल
  • एक डायरेक्टिव, @auth.
  • एक फ़ील्ड, movies.
query ListMoviesByGenre($genre: String!) @auth(level: PUBLIC) {
  movies(where: { genre: { eq: $genre } }) {
    id
    title
  }
}

हर क्वेरी आर्ग्युमेंट के लिए, टाइप का एलान करना ज़रूरी है. यह String जैसा कोई बिल्ट-इन टाइप हो सकता है या Movie जैसा स्कीमा से तय किया गया कस्टम टाइप हो सकता है.

इस गाइड में, ज़्यादा से ज़्यादा जटिल क्वेरी के सिग्नेचर पर ध्यान दिया जाएगा. आखिर में, आपको रिलेशनशिप एक्सप्रेशन के बारे में जानकारी मिलेगी. इनका इस्तेमाल, डिप्लॉय की जा सकने वाली क्वेरी बनाने के लिए किया जा सकता है.

क्वेरी में मुख्य स्केलर

हालांकि, सबसे पहले मुख्य स्केलर के बारे में जानकारी दें.

Data Connect, हर टेबल की मुख्य कुंजियों को दिखाने के लिए एक खास की स्केलर तय करता है. इन कुंजियों की पहचान {TableType}_Key से की जाती है. यह प्राइमरी की वैल्यू का JSON ऑब्जेक्ट है.

अपने-आप जनरेट होने वाले ज़्यादातर रीड फ़ील्ड से मिले जवाब के तौर पर, मुख्य स्केलर को वापस पाया जाता है. इसके अलावा, स्केलर कुंजी बनाने के लिए ज़रूरी सभी फ़ील्ड को वापस पाने वाली क्वेरी से भी मुख्य स्केलर को वापस पाया जा सकता है.

हमारे मौजूदा उदाहरण में movie जैसी सिंगल ऑटोमैटिक क्वेरी, एक मुख्य आर्ग्युमेंट के साथ काम करती हैं. यह आर्ग्युमेंट, मुख्य स्केलर को स्वीकार करता है.

किसी मुख्य स्केलर को लिटरल के तौर पर पास किया जा सकता है. हालांकि, इनपुट के तौर पर मुख्य स्केलर पास करने के लिए, वैरिएबल तय किए जा सकते हैं.

क्वेरी

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

जवाब

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

इन्हें अनुरोध के JSON फ़ॉर्मैट में इस तरह या सीरियलाइज़ेशन के अन्य फ़ॉर्मैट में दिया जा सकता है:

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

कस्टम स्केलर पार्सिंग की मदद से, ऑब्जेक्ट सिंटैक्स का इस्तेमाल करके भी Movie_Key बनाया जा सकता है. इसमें वैरिएबल शामिल हो सकते हैं. यह सुविधा तब ज़्यादा काम की होती है, जब आपको किसी वजह से अलग-अलग कॉम्पोनेंट को अलग-अलग वैरिएबल में बांटना हो.

बुनियादी क्वेरी लिखना

अपने डेटाबेस से अलग-अलग रिकॉर्ड पाने के लिए, क्वेरी लिखी जा सकती हैं. इसके अलावा, नतीजों को सीमित करने और क्रम से लगाने के विकल्प के साथ, टेबल से रिकॉर्ड की सूची बनाई जा सकती है.

अलग-अलग रिकॉर्ड वापस पाना

सबसे आसान क्वेरी से, आईडी के हिसाब से एक रिकॉर्ड मिलता है. आपकी क्वेरी में, अपने-आप जनरेट हुए movie फ़ील्ड का इस्तेमाल किया जाएगा.

क्वेरी

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

जवाब

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

टेबल में मौजूद सभी रिकॉर्ड वापस पाना

Movies टेबल से, फ़िल्मों की पूरी सूची के लिए फ़ील्ड का सबसेट पाने के लिए, आपकी क्वेरी में अपने-आप जनरेट हुए movies फ़ील्ड का इस्तेमाल किया जाएगा. साथ ही, लागू करने का तरीका कुछ ऐसा दिख सकता है.

क्वेरी

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

जवाब

{
  "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, और offset ऑपरेटर का इस्तेमाल करना

किसी टेबल के सभी रिकॉर्ड की सूची बनाने का फ़ायदा सीमित होता है.

नतीजों को क्रम से लगाया जा सकता है और पेजेशन किया जा सकता है. इन आर्ग्युमेंट को स्वीकार किया जाता है, लेकिन नतीजों में नहीं दिखाया जाता.

यहां, क्वेरी में रेटिंग के हिसाब से टॉप 10 फ़िल्मों के टाइटल मिलते हैं.

क्वेरी

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

जवाब

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

हो सकता है कि आपके पास किसी ऑफ़सेट से पंक्तियां फ़ेच करने का कोई इस्तेमाल का उदाहरण हो, जैसे कि रेटिंग के हिसाब से 11 से 20 वाली फ़िल्में.

क्वेरी

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

जवाब

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

क्वेरी में अन्य नामों का इस्तेमाल करना

Data Connect क्वेरी में GraphQL के लिए, किसी एलिमेंट को दूसरा नाम देने की सुविधा के साथ काम करता है. किसी क्वेरी के नतीजों में दिखने वाले डेटा का नाम बदलने के लिए, बदलाव के नाम का इस्तेमाल किया जाता है. एक Data Connect क्वेरी, सर्वर पर एक ही अनुरोध में कई फ़िल्टर या क्वेरी के अन्य ऑपरेशन लागू कर सकती है. साथ ही, एक साथ कई "सब-क्वेरी" जारी कर सकती है. दिखाए गए डेटासेट में नामों के मेल खाने से बचने के लिए, सब-क्वेरी को अलग-अलग दिखाने के लिए, वैकल्पिक नामों का इस्तेमाल किया जाता है.

यहां एक क्वेरी दी गई है, जिसमें एक्सप्रेशन में mostPopular और leastPopular के उपनाम इस्तेमाल किए गए हैं.

क्वेरी

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

जवाब

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

क्वेरी फ़िल्टर का इस्तेमाल करना

Data Connect क्वेरी, सभी सामान्य एसक्यूएल फ़िल्टर और ऑर्डर ऑपरेशन से मैप होती हैं.

orderBy ऑपरेटर के साथ where का इस्तेमाल करके फ़िल्टर करना

टेबल और नेस्ट किए गए असोसिएशन से मैच होने वाली सभी पंक्तियां दिखाता है. अगर कोई रिकॉर्ड फ़िल्टर से मैच नहीं करता है, तो यह एक खाली कलेक्शन दिखाता है.

क्वेरी

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

जवाब

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

शून्य वैल्यू की जांच करके फ़िल्टर करना

isNull ऑपरेटर का इस्तेमाल करके, null वैल्यू की जांच की जा सकती है.

क्वेरी

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

जवाब

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

ज़्यादा ऑपरेटर के लिए, इनपुट ऑब्जेक्ट टाइप की रेफ़रंस गाइड देखें.

वैल्यू की तुलना करके फ़िल्टर करना

अपनी क्वेरी में वैल्यू की तुलना करने के लिए, lt (कम) और ge (ज़्यादा या उसके बराबर) जैसे ऑपरेटर का इस्तेमाल किया जा सकता है.

क्वेरी

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

जवाब

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

ऐरे फ़ील्ड के लिए, includes और excludes ऑपरेटर की मदद से फ़िल्टर करना

यह जांच की जा सकती है कि किसी ऐरे फ़ील्ड में कोई खास आइटम शामिल है या नहीं.

यहां दिए गए उदाहरण में, includes ऑपरेटर के बारे में बताया गया है.

Data Connect में includesAll, excludes, excludesAll वगैरह का इस्तेमाल किया जा सकता है. रेफ़रंस दस्तावेज़ के _ListFilter हेडिंग में, पूर्णांक, स्ट्रिंग, तारीखों, और अन्य डेटा टाइप के लिए, ऐसे सभी ऑपरेटर की समीक्षा करें.

क्वेरी

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

जवाब

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

स्ट्रिंग ऑपरेशन और रेगुलर एक्सप्रेशन की मदद से फ़िल्टर करना

आपकी क्वेरी में, रेगुलर एक्सप्रेशन के साथ-साथ सामान्य स्ट्रिंग खोज और तुलना करने वाले ऑपरेशन का इस्तेमाल किया जा सकता है. ध्यान दें कि बेहतर परफ़ॉर्मेंस के लिए, यहां कई कार्रवाइयों को एक साथ किया जा रहा है और उन्हें अलग-अलग नामों से दिखाया जा रहा है.

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 ऑपरेटर लॉजिक की मदद से फ़िल्टर करना

ज़्यादा जटिल लॉजिक के लिए, _or का इस्तेमाल करें. Data Connect में _and और _not ऑपरेटर भी काम करते हैं.

क्वेरी

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

जवाब

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

रिलेशनल क्वेरी लिखना

Data Connect क्वेरी, टेबल के बीच के संबंधों के आधार पर डेटा ऐक्सेस कर सकती हैं. नेस्ट की गई क्वेरी बनाने के लिए, अपने स्कीमा में तय किए गए ऑब्जेक्ट (वन-टू-वन) या कलेक्शन (वन-टू-मेनी) रिलेशनशिप का इस्तेमाल किया जा सकता है. इसका मतलब है कि नेस्ट किए गए या मिलते-जुलते टाइप के डेटा के साथ-साथ, एक टाइप का डेटा भी फ़ेच किया जा सकता है.

ऐसी क्वेरी, जनरेट किए गए रीड फ़ील्ड में मैजिक Data Connect _on_ और _via सिंटैक्स का इस्तेमाल करती हैं.

सैंपल स्कीमा की समीक्षा करना न भूलें.

कई से एक

अब _on_ सिंटैक्स को दिखाने के लिए, एक क्वेरी देखें.

क्वेरी

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

जवाब

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

वन-टू-वन

_on_ सिंटैक्स का इस्तेमाल करके, एक-से-एक क्वेरी लिखी जा सकती है.

क्वेरी

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

जवाब

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

कई-से-कई

कई-से-कई क्वेरी में _via_ सिंटैक्स का इस्तेमाल किया जाता है. कई-से-कई क्वेरी से, किसी खास फ़िल्म के लिए कलाकारों की जानकारी मिल सकती है.

क्वेरी

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

जवाब

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

हालांकि, हम role के आधार पर फ़िल्टर करने के लिए, बदलावों का इस्तेमाल करके ज़्यादा जटिल क्वेरी लिख सकते हैं, ताकि mainActors और supportingActors के नतीजों में कलाकारों और उनसे जुड़ी फ़िल्मों को वापस पाया जा सके. यह कई-से-कई वाला संबंध है, इसलिए _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
    }
  }
}

जवाब

{
  "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"
        }
      ]
    }
  }
}

एग्रीगेशन क्वेरी

एग्रीगेट क्या होते हैं और इनका इस्तेमाल क्यों किया जाता है?

एग्रीगेट किए गए फ़ील्ड की मदद से, नतीजों की सूची पर कैलकुलेशन की जा सकती है. एग्रीगेट फ़ील्ड की मदद से, ये काम किए जा सकते हैं:

  • समीक्षा का औसत स्कोर देखना
  • शॉपिंग कार्ट में मौजूद आइटम की कुल कीमत देखना
  • सबसे अच्छी या सबसे खराब रेटिंग वाला प्रॉडक्ट ढूंढना
  • अपने स्टोर में मौजूद प्रॉडक्ट की संख्या देखना

एग्रीगेट, सर्वर पर किए जाते हैं. इससे क्लाइंट साइड पर एग्रीगेट करने के मुकाबले कई फ़ायदे मिलते हैं:

  • ऐप्लिकेशन की तेज़ परफ़ॉर्मेंस (क्लाइंट साइड पर कैलकुलेशन की ज़रूरत नहीं पड़ती)
  • डेटा एक्सग्रेस की लागत कम हो जाती है. ऐसा इसलिए होता है, क्योंकि सभी इनपुट के बजाय सिर्फ़ एग्रीगेट किए गए नतीजे भेजे जाते हैं
  • बेहतर सुरक्षा (क्योंकि क्लाइंट को पूरे डेटा सेट के बजाय, इकट्ठा किए गए डेटा का ऐक्सेस दिया जा सकता है)

एग्रीगेट के लिए स्कीमा का उदाहरण

इस सेक्शन में, हम स्टोरफ़्रंट के उदाहरण वाले स्कीमा पर स्विच करेंगे. यह एग्रीगेट इस्तेमाल करने का तरीका बताने के लिए एक अच्छा उदाहरण है:

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

सामान्य एग्रीगेट

सभी फ़ील्ड के लिए _count

सबसे आसान एग्रीगेट फ़ील्ड _count है: यह दिखाता है कि आपकी क्वेरी से कितनी पंक्तियां मैच करती हैं. आपके टाइप के हर फ़ील्ड के लिए, Data Connect फ़ील्ड टाइप के आधार पर उससे जुड़े एग्रीगेट फ़ील्ड जनरेट करता है.

क्वेरी 

query CountProducts {
  products {
    _count
  }
}

जवाब 
one

उदाहरण के लिए, अगर आपके डेटाबेस में पांच प्रॉडक्ट हैं, तो नतीजा यह होगा:

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

सभी फ़ील्ड में एक <field>_count फ़ील्ड होता है. इससे यह पता चलता है कि कितनी पंक्तियों में उस फ़ील्ड में कोई वैल्यू मौजूद है.

क्वेरी 

query CountProductsWithExpirationDate {
  products {
    expirationDate_count
  }
}

जवाब
field_count

उदाहरण के लिए, अगर आपके पास ऐसे तीन प्रॉडक्ट हैं जिनकी समयसीमा खत्म होने वाली है, तो नतीजा यह होगा:

{
  "products": [
    {
    "expirationDate_count": 3
    }
  ]
}
संख्या वाले फ़ील्ड के लिए _min, _max, _sum, और _avg

संख्या वाले फ़ील्ड (int, float, int64) में भी <field>_min, <field>_max, <field>_sum, और <field>_avg होते हैं.

क्वेरी 

query NumericAggregates {
  products {
  quantityInStock_max
  price_min
  price_avg
  quantityInStock_sum
  }
}

जवाब
_min _max _sum _avg

उदाहरण के लिए, अगर आपके पास ये प्रॉडक्ट हैं:

  • प्रॉडक्ट A: quantityInStock: 10, price: 2.99
  • प्रॉडक्ट B: quantityInStock: 5, price: 5.99
  • प्रॉडक्ट C: quantityInStock: 20, price: 1.99

इसका नतीजा यह होगा:

{
  "products": [
    {
    "quantityInStock_max": 20,
    "price_min": 1.99,
    "price_avg": 3.6566666666666666,
    "quantityInStock_sum": 35
    }
  ]
}
तारीखों और टाइमस्टैंप के लिए _min और _max

तारीख और टाइमस्टैंप फ़ील्ड में <field>_min और <field>_max होते हैं.

क्वेरी 

query DateAndTimeAggregates {
  products {
  expirationDate_max
  expirationDate_min
  }
}

जवाब
_min _maxdatetime

उदाहरण के लिए, अगर आपके पास सदस्यता खत्म होने की ये तारीखें हैं:

  • प्रॉडक्ट A: 2024-01-01
  • प्रॉडक्ट B: 2024-03-01
  • प्रॉडक्ट C: 2024-02-01

इसका नतीजा यह होगा:

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

अलग-अलग

distinct आर्ग्युमेंट की मदद से, किसी फ़ील्ड (या फ़ील्ड के कॉम्बिनेशन) की सभी यूनीक वैल्यू देखी जा सकती हैं. उदाहरण के लिए:

क्वेरी 

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

जवाब
distinct

उदाहरण के लिए, अगर आपके पास ये मैन्युफ़ैक्चरर हैं:

  • प्रॉडक्ट A: manufacturer: "Acme"
  • प्रॉडक्ट B: manufacturer: "Beta"
  • प्रॉडक्ट C: manufacturer: "Acme"

इसका नतीजा यह होगा:

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

अलग-अलग वैल्यू को एग्रीगेट करने के लिए, एग्रीगेट फ़ील्ड पर distinct आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. उदाहरण के लिए:

क्वेरी 

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

जवाब
distinctonaggregate

उदाहरण के लिए, अगर आपके पास ये मैन्युफ़ैक्चरर हैं:

  • प्रॉडक्ट A: manufacturer: "Acme"
  • प्रॉडक्ट B: manufacturer: "Beta"
  • प्रॉडक्ट C: manufacturer: "Acme"

इसका नतीजा यह होगा:

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

ग्रुप किए गए एग्रीगेटर

किसी टाइप पर एग्रीगेट और नॉन-एग्रीगेट फ़ील्ड का मिक्स चुनकर, ग्रुप किया गया एग्रीगेट किया जाता है. यह उन सभी मैच होने वाली पंक्तियों को एक साथ ग्रुप करता है जिनमें एग्रीगेट नहीं किए गए फ़ील्ड के लिए एक ही वैल्यू होती है. साथ ही, उस ग्रुप के लिए एग्रीगेट किए गए फ़ील्ड का हिसाब लगाता है. उदाहरण के लिए:

क्वेरी 

query MostExpensiveProductByManufacturer {
  products {
  manufacturer
  price_max
  }
}

जवाब
groupedaggregates

उदाहरण के लिए, अगर आपके पास ये प्रॉडक्ट हैं:

  • प्रॉडक्ट A: manufacturer: "Acme", price: 2.99
  • प्रॉडक्ट B: manufacturer: "Beta", price: 5.99
  • प्रॉडक्ट C: manufacturer: "Acme", price: 1.99

इसका नतीजा यह होगा:

{
  "products": [
    { "manufacturer": "Acme", "price_max": 2.99 },
    { "manufacturer": "Beta", "price_max": 5.99 }
  ]
}
ग्रुप किए गए एग्रीगेट के साथ having और where

having और where आर्ग्युमेंट का इस्तेमाल करके, सिर्फ़ उन ग्रुप को दिखाया जा सकता है जो दी गई शर्तों को पूरा करते हैं.

  • having की मदद से, एग्रीगेट किए गए फ़ील्ड के हिसाब से ग्रुप फ़िल्टर किए जा सकते हैं

  • where की मदद से, बिना एग्रीगेट किए गए फ़ील्ड के आधार पर लाइनों को फ़िल्टर किया जा सकता है.

क्वेरी 

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

जवाब
havingwhere

उदाहरण के लिए, अगर आपके पास ये प्रॉडक्ट हैं:

  • प्रॉडक्ट A: manufacturer: "Acme", price: 2.99
  • प्रॉडक्ट B: manufacturer: "Beta", price: 5.99
  • प्रॉडक्ट C: manufacturer: "Acme", price: 1.99

इसका नतीजा यह होगा:

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

सभी टेबल में एग्रीगेट

अपने डेटा के बारे में मुश्किल सवालों के जवाब देने के लिए, एग्रीगेट फ़ील्ड का इस्तेमाल, जनरेट किए गए एक-से-कई रिलेशनशिप फ़ील्ड के साथ किया जा सकता है. यहां बदला गया स्कीमा दिया गया है. इसमें एक अलग टेबल, Manufacturer है. इसका इस्तेमाल उदाहरणों में किया जा सकता है:

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

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

अब एग्रीगेट फ़ील्ड का इस्तेमाल करके, कई काम किए जा सकते हैं. जैसे, यह पता लगाना कि मैन्युफ़ैक्चरर कितने प्रॉडक्ट बनाता है:

क्वेरी 

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

जवाब 
aggregatesacrosstables

उदाहरण के लिए, अगर आपके पास ये मैन्युफ़ैक्चरर हैं:

  • मैन्युफ़ैक्चरर A: name: "Acme", products_on_manufacturer: 2
  • मैन्युफ़ैक्चरर B: name: "Beta", products_on_manufacturer: 1

इसका नतीजा यह होगा:

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

बेहतर क्वेरी लिखना: कई चरणों वाले ऑपरेशन में डेटा पढ़ने के लिए, query फ़ील्ड का इस्तेमाल करना

कई मामलों में, डेटा डालने या अपडेट करने से पहले, मौजूदा डेटा को लुकअप और पुष्टि करने के लिए, म्यूटेशन को लागू करने के दौरान डेटाबेस को पढ़ा जा सकता है. इन विकल्पों से, डेटा को एक से दूसरी जगह भेजने में लगने वाला समय और लागत कम हो जाती है.

Data Connect इस सुविधा के साथ काम करता है. एक से ज़्यादा चरणों वाले ऑपरेशन देखें.

अगले चरण

आपकी दिलचस्पी इनमें हो सकती है: