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

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

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

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

• डप्लॉय की जा सकने वाली क्वेरी वे होती हैं जिन्हें क्लाइंट ऐप्लिकेशन से कॉल करने के लिए लागू किया जाता है. इनमें आपके तय किए गए एपीआई एंडपॉइंट होते हैं. इन्हें सर्वर पर डिप्लॉय किए गए कनेक्टर में बंडल किया जाता है. Data Connect टूलिंग, आपके एपीआई के आधार पर क्लाइंट एसडीके जनरेट करती है. डिप्लॉय की गई क्वेरी, आईएएम नीति के तहत सुरक्षित नहीं होती हैं. इसलिए, उन्हें 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 फ़ील्ड और अन्य फ़ील्ड जनरेट करता है.

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

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

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

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

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

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

इसलिए, इस क्वेरी में ये शामिल हैं:

• 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 for all fields

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

query CountProducts {
  products {
    _count
  }
}

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

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

query CountProductsWithExpirationDate {
  products {
    expirationDate_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
  }
}

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

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

अलग-अलग

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

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

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

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

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

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

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

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

query MostExpensiveProductByManufacturer {
  products {
  manufacturer
  price_max
  }
}

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

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

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

क्वेरी के लिए गिनती वाले फ़ील्ड

अपने स्कीमा में मौजूद एन्यूमरेशन फ़ील्ड के बारे में क्वेरी की जा सकती है.

मान लें कि हमारी गिनती इस तरह लागू की गई है:

enum AspectRatio {
   ACADEMY
   WIDESCREEN
   ANAMORPHIC
   IMAX
   "No information available on aspect ratio"
   UNAVAILABLE
}

उदाहरण के लिए, अपनी पसंद के आसपेक्ट रेशियो में फ़ॉर्मैट की गई सभी फ़िल्मों की सूची बनाई जा सकती है.

query ListMoviesByAspectRatio($aspectRatio: AspectRatio!) @auth(level: PUBLIC) {
  movies(where:
    {originalAspectRatio: {eq: $aspectRatio}}
) {
    id
    title
    imageUrl
    releaseYear
    genre
    rating
    tags
    description
    otherAspectRatios
  }
}

गिनती वाले फ़ील्ड को फ़िल्टर करना

इनम के लिए, फ़िल्टर करने की ये स्टैंडर्ड कार्रवाइयां उपलब्ध हैं: eq, ne, ge, gt, lt, le, in nin. साथ ही, सूचियों के लिए includes, excludes, includesAll, और excludesAll कार्रवाइयां उपलब्ध हैं.

order में, ग्रेटर और लेस दैन ऑपरेटर, एनम वैल्यू के क्रम का इस्तेमाल करते हैं, ताकि उन्हें सही तरीके से लागू किया जा सके. एनम की शुरुआत में मौजूद वैल्यू, एनम की परिभाषा के आखिर में मौजूद वैल्यू से छोटी होती हैं.

उदाहरण के लिए, यहां दिया गया where क्लॉज़, इनपुट आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) से कम ratio वाली सभी फ़िल्में दिखाएगा.

• पहले उदाहरण में, अगर $aspectRatio IMAX होता, तो ACADEMY, WIDESCREEN, और ANAMORPHIC से मेल खाने वाली फ़िल्में चुनी जातीं.ratio
• दूसरे उदाहरण में, सिर्फ़ वे फ़िल्में दिखाई जाएंगी जो ACADEMY और WIDESCREEN, दोनों में उपलब्ध हैं.

  movies(where: {originalAspectRatio: {lt: $aspectRatio}})

  movies(where: {otherAspectRatios: {includesAll: [ACADEMY, WIDESCREEN]}})

गिनती वाले फ़ील्ड पर एग्रीगेशन क्वेरी चलाना

इनम के लिए, सिर्फ़ _count का इस्तेमाल किया जा सकता है.

नीचे दी गई क्वेरी में, हर आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) वाली फ़िल्मों की कुल संख्या का हिसाब लगाया गया है.

query MovieCountByOriginalAspectRatio @auth(level: PUBLIC) {
  movies {
    _count
    originalAspectRatio
  }
}

क्लाइंट कोड से कॉल की गिनती करने वाली क्वेरी

क्लाइंट से गिनती करने के लिए क्वेरी इस्तेमाल करने का तरीका जानें. साथ ही, गिनती को मैनेज करने के लिए, क्लाइंट कॉल को इस तरह से डिज़ाइन करने का तरीका जानें कि आपको ज़्यादा से ज़्यादा फ़ायदा मिल सके. इसके लिए, iOS, Android, वेब, और Flutter के लिए एसडीके टूल की गाइड देखें.

ऐडवांस क्वेरी लिखना: एक से ज़्यादा चरणों वाली कार्रवाइयों में डेटा पढ़ने के लिए, query फ़ील्ड का इस्तेमाल करना

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

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

अगले चरण

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

• एआई की मदद से काम करने वाले टूल का इस्तेमाल करके, अपने ऐप्लिकेशन के लिए क्वेरी जनरेट करना
• अनुमति से जुड़ी गाइड के मुताबिक, आपकी क्वेरी को अनुमति देना
• वेब, iOS, Android, और Flutter के लिए, क्लाइंट कोड से क्वेरी कॉल करना.