Firebase SQL Connect की मदद से, Cloud SQL से मैनेज किए जा रहे PostgreSQL इंस्टेंस के लिए कनेक्टर बनाए जा सकते हैं. ये कनेक्टर, क्वेरी और म्यूटेशन का कॉम्बिनेशन होते हैं. इनकी मदद से, आपके स्कीमा से डेटा का इस्तेमाल किया जाता है.
शुरुआती निर्देश में, PostgreSQL के लिए फ़िल्म की समीक्षा करने वाले ऐप्लिकेशन का स्कीमा बताया गया है.
उस गाइड में, डिप्लॉय किए जा सकने वाले और ऐड हॉक एडमिनिस्ट्रेटिव ऑपरेशन के बारे में भी बताया गया था. इनमें क्वेरी भी शामिल थीं.
- डिप्लॉय की जा सकने वाली क्वेरी वे होती हैं जिन्हें क्लाइंट ऐप्लिकेशन से कॉल करने के लिए लागू किया जाता है. इसके लिए, आपके तय किए गए एपीआई एंडपॉइंट का इस्तेमाल किया जाता है. आप उन्हें सर्वर पर डिप्लॉय किए गए कनेक्टर में बंडल करते हैं. SQL Connect टूल, आपके एपीआई के आधार पर क्लाइंट एसडीके जनरेट करता है. डिप्लॉय की गई क्वेरी, आईएएम नीति से सुरक्षित नहीं होती हैं. इसलिए, SQL Connect
@authडायरेक्टिव का इस्तेमाल करके उन्हें सुरक्षित करना न भूलें. - एड हॉक एडमिन क्वेरी, डेटा को पढ़ने के लिए खास अधिकार वाले एनवायरमेंट से चलाई जाती हैं. इन्हें Firebase कंसोल में या हमारे SQL Connect VS Code एक्सटेंशन का इस्तेमाल करके, लोकल डेवलपमेंट एनवायरमेंट में बनाया और लागू किया जा सकता है.
इस गाइड में, डिप्लॉय की जा सकने वाली क्वेरी के बारे में ज़्यादा जानकारी दी गई है.
SQL Connect क्वेरी की सुविधाएं
SQL Connect की मदद से, उन सभी तरीकों से बुनियादी क्वेरी की जा सकती हैं जिनकी उम्मीद PostgreSQL डेटाबेस से की जाती है.
GraphQL के लिए SQL Connect के एक्सटेंशन की मदद से, तेज़ी से और बेहतर तरीके से काम करने वाले ऐप्लिकेशन के लिए ऐडवांस क्वेरी लागू की जा सकती हैं:
- रिकॉर्ड पर बार-बार होने वाली कार्रवाइयों को आसान बनाने के लिए, कई कार्रवाइयों से मिले की स्केलर का इस्तेमाल करें
- डेटा खोजने के लिए, कई चरणों वाले म्यूटेशन ऑपरेशन के दौरान क्वेरी करें. इससे कोड की लाइनों और सर्वर पर बार-बार जाने की ज़रूरत नहीं पड़ती.
क्वेरी बनाने के लिए, जनरेट किए गए फ़ील्ड का इस्तेमाल करना
आपके SQL Connect ऑपरेशन, फ़ील्ड के उस सेट को बढ़ाएंगे जो आपके स्कीमा में टाइप और टाइप रिलेशनशिप के आधार पर, SQL Connect से अपने-आप जनरेट होता है. जब भी स्कीमा में बदलाव किया जाता है, तब ये फ़ील्ड लोकल टूल से जनरेट होते हैं.
जनरेट किए गए फ़ील्ड का इस्तेमाल करके, ज़्यादा जटिल क्वेरी लागू की जा सकती हैं. जैसे, किसी एक टेबल से अलग-अलग रिकॉर्ड या कई रिकॉर्ड हासिल करना या मिलती-जुलती टेबल से कई रिकॉर्ड हासिल करना.मान लें कि आपके स्कीमा में Movie टाइप और उससे जुड़ा Actor टाइप शामिल है.
SQL Connect, movie, movies, actors_on_movies फ़ील्ड वगैरह जनरेट करता है.
movie फ़ील्ड की मदद से क्वेरी करना
|
|
इस फ़ील्ड का इस्तेमाल करके, किसी फ़िल्म की कुंजी से उसे खोजें. query GetMovie($myKey: Movie_Key!) { movie(key: $myKey) { title } } |
movies फ़ील्ड की मदद से क्वेरी करना
|
|
इस फ़ील्ड का इस्तेमाल करके, एक से ज़्यादा फ़िल्मों के बारे में क्वेरी की जा सकती है. उदाहरण के लिए, किसी साल में रिलीज़ हुई सभी फ़िल्में. query GetMovies($myYear: Int!) { movies(where: { year: { eq: $myYear } }) { title } } |
actors_on_movies फ़ील्ड की मदद से क्वेरी करना
|
|
इस फ़ील्ड का इस्तेमाल करके, किसी फ़िल्म से जुड़े सभी कलाकारों के बारे में क्वेरी करें. query GetActorsOnMovie($myKey: Movie_Key!) { actors_on_movies(where: { movie: { key: { eq: $myKey } } }) { actor { name } } } |
क्वेरी के ज़रूरी एलिमेंट
SQL Connect क्वेरी, SQL Connect एक्सटेंशन वाली GraphQL क्वेरी हैं. सामान्य GraphQL क्वेरी की तरह ही, ऑपरेशन का नाम और GraphQL वैरिएबल की सूची तय की जा सकती है.
SQL 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.
इस गाइड में, मुश्किल क्वेरी के सिग्नेचर के बारे में बताया जाएगा. आखिर में, आपको रिलेशनशिप एक्सप्रेशन के बारे में बताया जाएगा. ये एक्सप्रेशन, कम शब्दों में ज़्यादा जानकारी देते हैं. इनका इस्तेमाल करके, डिप्लॉय की जा सकने वाली क्वेरी बनाई जा सकती हैं.
क्वेरी में मुख्य स्केलर
हालांकि, सबसे पहले मुख्य स्केलर के बारे में जानकारी.
SQL 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 ] } }
क्वेरी में उपनामों का इस्तेमाल करना
SQL Connect, क्वेरी में GraphQL के लिए उपनाम इस्तेमाल करने की सुविधा देता है. उपनामों की मदद से, क्वेरी के नतीजों में मिलने वाले डेटा का नाम बदला जा सकता है. एक SQL 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 } ] } }
क्वेरी फ़िल्टर इस्तेमाल करना
SQL 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 ऑपरेटर के बारे में बताया गया है.
SQL 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 का इस्तेमाल करें. SQL 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" } ] } }
रिलेशनल क्वेरी लिखना
SQL Connect क्वेरी, टेबल के बीच के संबंधों के आधार पर डेटा को ऐक्सेस कर सकती हैं. अपने स्कीमा में तय किए गए ऑब्जेक्ट (वन-टू-वन) या कलेक्शन (वन-टू-मेनी) रिलेशनशिप का इस्तेमाल करके, नेस्ट की गई क्वेरी बनाई जा सकती हैं. इसका मतलब है कि किसी एक टाइप के डेटा के साथ-साथ, नेस्ट किए गए या मिलते-जुलते टाइप का डेटा फ़ेच किया जा सकता है.
इस तरह की क्वेरी, जनरेट किए गए रीड फ़ील्ड में मैजिक SQL 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 है: यह दिखाता है कि आपकी क्वेरी से कितनी लाइनें मैच करती हैं. आपके टाइप के हर फ़ील्ड के लिए, SQL Connect फ़ील्ड टाइप के आधार पर उससे जुड़े एग्रीगेट फ़ील्ड जनरेट करता है.
क्वेरी
query CountProducts {
products {
_count
}
}
जवाब one
one
उदाहरण के लिए, अगर आपके डेटाबेस में पांच प्रॉडक्ट हैं, तो नतीजा यह होगा:
{
"products": [
{
"_count": 5
}
]
}
सभी फ़ील्ड में एक <field>_count फ़ील्ड होता है. इससे यह पता चलता है कि उस फ़ील्ड में कितनी पंक्तियों में वैल्यू मौजूद है.
क्वेरी
query CountProductsWithExpirationDate {
products {
expirationDate_count
}
}
जवाबfield_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
_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
_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
distinct आर्ग्युमेंट की मदद से, किसी फ़ील्ड या फ़ील्ड के कॉम्बिनेशन के लिए सभी यूनीक वैल्यू पाई जा सकती हैं. उदाहरण के लिए:
क्वेरी
query ListDistinctManufacturers {
products(distinct: true) {
manufacturer
}
}
जवाबdistinct
distinct
उदाहरण के लिए, अगर आपके पास ये मैन्युफ़ैक्चरर हैं:
- प्रॉडक्ट A:
manufacturer: "Acme" - प्रॉडक्ट B:
manufacturer: "Beta" - प्रॉडक्ट C:
manufacturer: "Acme"
इससे यह नतीजा मिलेगा:
{
"products": [
{ "manufacturer": "Acme" },
{ "manufacturer": "Beta" }
]
}
एग्रीगेट फ़ील्ड पर distinct आर्ग्युमेंट का इस्तेमाल करके, अलग-अलग वैल्यू को एग्रीगेट किया जा सकता है. उदाहरण के लिए:
क्वेरी
query CountDistinctManufacturers {
products {
manufacturer_count(distinct: true)
}
}
जवाबdistinctonaggregate
distinctonaggregate
उदाहरण के लिए, अगर आपके पास ये मैन्युफ़ैक्चरर हैं:
- प्रॉडक्ट A:
manufacturer: "Acme" - प्रॉडक्ट B:
manufacturer: "Beta" - प्रॉडक्ट C:
manufacturer: "Acme"
इससे यह नतीजा मिलेगा:
{
"products": [
{
"manufacturer_count": 2
}
]
}
ग्रुप किए गए एग्रीगेट
किसी टाइप पर एग्रीगेट और नॉन-एग्रीगेट फ़ील्ड का कॉम्बिनेशन चुनकर, ग्रुप किया गया एग्रीगेट बनाया जा सकता है. यह उन सभी मिलती-जुलती पंक्तियों को एक साथ ग्रुप करता है जिनमें नॉन-एग्रीगेट फ़ील्ड के लिए एक जैसी वैल्यू होती है. साथ ही, उस ग्रुप के लिए एग्रीगेट फ़ील्ड का हिसाब लगाता है. उदाहरण के लिए:
क्वेरी
query MostExpensiveProductByManufacturer {
products {
manufacturer
price_max
}
}
जवाबgroupedaggregates
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
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
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 } }
]
}
क्वेरी एन्यूमरेशन फ़ील्ड
अपने स्कीमा में मौजूद एन्यूमरेशन फ़ील्ड के लिए क्वेरी की जा सकती है.
मान लें कि हमारा एन्यूमरेशन इस तरह लागू किया गया है:
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
}
}
एन्यूमरेशन फ़ील्ड फ़िल्टर करना
Enum के लिए, स्टैंडर्ड फ़िल्टर करने की कार्रवाइयां उपलब्ध हैं: eq, ne, ge, gt,
lt, le, in nin. साथ ही, सूचियों के लिए includes, excludes, includesAll, और
excludesAll.
order में, 'इससे ज़्यादा' और 'इससे कम' ऑपरेटर, enum वैल्यू के क्रम का इस्तेमाल करते हैं, ताकि सही तरीके से एक्ज़ीक्यूशन किया जा सके. enum की शुरुआत में मौजूद वैल्यू, enum की परिभाषा के आखिर में मौजूद वैल्यू से छोटी होती हैं.
उदाहरण के लिए, यहां दिया गया where क्लॉज़, उन सभी फ़िल्मों को दिखाएगा जिनका ratio, इनपुट किए गए आसपेक्ट रेशियो से कम है.
- पहले उदाहरण में, अगर
$aspectRatio, IMAX होता, तोratioसे मैच करने वाली ACADEMY, WIDESCREEN, और ANAMORPHIC फ़िल्में चुनी जातीं. - दूसरे उदाहरण में, सिर्फ़ वे फ़िल्में दिखेंगी जो 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 फ़ील्ड का इस्तेमाल करें
ऐसी कई स्थितियां होती हैं जिनमें आपको म्यूटेशन के दौरान अपने डेटाबेस को पढ़ने की ज़रूरत पड़ सकती है. ऐसा इसलिए, ताकि डेटा को इन्सर्ट या अपडेट करने से पहले, मौजूदा डेटा को खोजा जा सके और उसकी पुष्टि की जा सके. इन विकल्पों से, दोतरफ़ा यात्रा के ऑपरेशन और लागत की बचत होती है.
SQL Connect में यह सुविधा काम करती है. कई चरणों वाली कार्रवाइयां देखें.
अगले चरण
आपको यह भी पसंद आ सकता है:
- एआई असिस्टेंट टूल का इस्तेमाल करके, अपने ऐप्लिकेशन के लिए क्वेरी जनरेट करना
- अनुमति देने से जुड़ी गाइड के मुताबिक, आपकी क्वेरी को अनुमति देना
- वेब, iOS, Android, और Flutter के लिए, क्लाइंट कोड से क्वेरी कॉल करना.