SQL कनेक्ट स्कीमा डिज़ाइन करना

Firebase SQL Connect की मदद से, एक GraphQL स्कीमा डिज़ाइन किया जाता है. यह स्कीमा, आपके ऐप्लिकेशन के लिए ज़रूरी डेटा मॉडल को दिखाता है. SQL Connect इस स्कीमा को आपके ऐप्लिकेशन के लिए, Cloud SQL for PostgreSQL इंस्टेंस में बदल देता है. इसके बाद, बैकएंड के साथ इंटरफ़ेस करने के लिए क्वेरी और म्यूटेशन लिखे जाते हैं. साथ ही, क्लाइंट कोड से अपने डेटा का इस्तेमाल करने के लिए, इन कार्रवाइयों को कनेक्टर में बंडल किया जाता है.

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

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

इस गाइड में, उस स्कीमा को और बेहतर बनाया गया है. साथ ही, फ़िल्म की समीक्षा करने वाले ऐप्लिकेशन के फ़ाइनल स्कीमा के बराबर एसक्यूएल लिस्टिंग दी गई है.

फ़िल्म की समीक्षा करने वाले ऐप्लिकेशन के लिए स्कीमा

मान लें कि आपको एक ऐसी सेवा बनानी है जो उपयोगकर्ताओं को फ़िल्म की समीक्षाएं सबमिट करने और देखने की सुविधा देती है.

बुनियादी क्वेरी के लिए, आपको ऐसे ऐप्लिकेशन के लिए शुरुआती स्कीमा की ज़रूरत होगी. इस स्कीमा को बाद में बड़ा करके, मुश्किल रिलेशनल क्वेरी बनाई जा सकती हैं.

SQL Connect में, आपको GraphQL टाइप तय करने होंगे, ताकि उस डेटा का स्ट्रक्चर तय किया जा सके जिसे आपके क्लाइंट क्वेरी कर सकते हैं और उसमें बदलाव कर सकते हैं. स्कीमा लिखते समय, आपके टाइप को PostgreSQL टेबल के लिए Cloud SQL में ट्रांसलेट किया जाता है. आम तौर पर, GraphQL टाइप और डेटाबेस टेबल के बीच सीधा संबंध होता है. हालांकि, अन्य मैपिंग भी की जा सकती हैं. इस गाइड में, बुनियादी से लेकर ऐडवांस लेवल तक के कुछ उदाहरण दिए गए हैं.

Movie का बुनियादी टाइप तय करना

Movie टाइप से शुरुआत की जा सकती है.

Movie के स्कीमा में, मुख्य डायरेक्टिव शामिल होते हैं. जैसे:

  • @table(name) और @col(name), ताकि एसक्यूएल टेबल और कॉलम के नामों को पसंद के मुताबिक बनाया जा सके. अगर कोई नाम नहीं दिया जाता है, तो SQL Connect, snake_case नाम जनरेट करता है.
  • एसक्यूएल कॉलम के टाइप को अपनी ज़रूरत के मुताबिक बनाने के लिए @col(dataType).
  • @default, ताकि इंसर्ट के दौरान SQL कॉलम की डिफ़ॉल्ट वैल्यू कॉन्फ़िगर की जा सकें.

ज़्यादा जानकारी के लिए, @table, @col, @default के रेफ़रंस दस्तावेज़ देखें.

# Movies
type Movie @table(name: "movie", key: "id") {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int
  genre: String @col(dataType: "varchar(20)")
  rating: Int
  description: String
}

उपयोगकर्ता का ज़रूरी डेटा, User टाइप में अपने-आप सेव हो जाता है

आपका ऐप्लिकेशन, उपयोगकर्ताओं को ट्रैक करेगा. इसलिए, आपको User टाइप की ज़रूरत होगी.

इस मामले में, @default डायरेक्टिव खास तौर पर मददगार होता है. यहां मौजूद id फ़ील्ड, पुष्टि करने की प्रोसेस से उपयोगकर्ता का आईडी अपने-आप ले सकता है: नीचे दिए गए सैंपल में @default(expr: "auth.uid") का इस्तेमाल देखें.

# Users
# Suppose a user can leave reviews for movies
type User @table {
  id: String! @default(expr: "auth.uid")
  username: String! @col(dataType: "varchar(50)")
}

मुख्य स्केलर और सर्वर वैल्यू

फ़िल्म की समीक्षा करने वाले ऐप्लिकेशन के बारे में ज़्यादा जानने से पहले, SQL Connect मुख्य स्केलर और सर्वर वैल्यू के बारे में जानना ज़रूरी है.

मुख्य स्केलर, ऑब्जेक्ट के छोटे आइडेंटिफ़ायर होते हैं जो आपके स्कीमा के मुख्य फ़ील्ड से अपने-आप SQL Connect इकट्ठा होते हैं. मुख्य स्केलर, बेहतर परफ़ॉर्मेंस के लिए होते हैं. इनकी मदद से, एक ही कॉल में अपने डेटा की पहचान और स्ट्रक्चर के बारे में जानकारी पाई जा सकती है. ये खास तौर पर तब काम आते हैं, जब आपको नए रिकॉर्ड पर क्रम से कार्रवाइयां करनी हों और आने वाले समय में होने वाली कार्रवाइयों के लिए, एक यूनीक आइडेंटिफ़ायर की ज़रूरत हो. साथ ही, ये तब भी काम आते हैं, जब आपको ज़्यादा जटिल कार्रवाइयां करने के लिए, रिलेशनल पासकोड ऐक्सेस करने हों.

सर्वर वैल्यू का इस्तेमाल करके, सर्वर को अपनी टेबल में फ़ील्ड को डाइनैमिक तौर पर भरने की अनुमति दी जा सकती है. इसके लिए, expr आर्ग्युमेंट में सर्वर-साइड के खास सीईएल एक्सप्रेशन के मुताबिक, सेव की गई या आसानी से कैलकुलेट की जा सकने वाली वैल्यू का इस्तेमाल किया जाता है. उदाहरण के लिए, किसी फ़ील्ड को टाइमस्टैंप के साथ तय किया जा सकता है. यह टाइमस्टैंप तब लागू होता है, जब फ़ील्ड को ऐक्सेस किया जाता है. इसके लिए, ऑपरेशन के अनुरोध updatedAt: Timestamp! @default(expr: "request.time") में सेव किए गए समय का इस्तेमाल किया जाता है.

Actor और MovieActor टाइप में मेनी-टू-मेनी रिलेशनशिप को मैनेज करना

उपयोगकर्ताओं को मैनेज करने के बाद, फ़िल्म के डेटा को मॉडल करने पर वापस आएं.

इसके बाद, आपको अपनी फ़िल्मों के लिए कलाकारों की ज़रूरत होगी.

Actor टेबल काफ़ी आसान है.

# Actors
# Suppose an actor can participate in multiple movies and movies can have multiple actors
# Movie - Actors (or vice versa) is a many to many relationship
type Actor @table {
  id: UUID! @default(expr: "uuidV4()")
  name: String! @col(dataType: "varchar(30)")
}

अगर आपको कई फ़िल्मों में कई कलाकारों को दिखाना है और फ़िल्मों में कई कलाकारों को दिखाना है, तो आपको "टेबल शामिल करें" की ज़रूरत होगी.

MovieActor टेबल, मेनी-टू-मेनी रिलेशनशिप को मैनेज करती है. इसकी प्राथमिक कुंजी, [movie, actor] (movie और actor के फ़ॉरेन की फ़ील्ड) का कॉम्बिनेशन है.

# Join table for many-to-many relationship for movies and actors
# The 'key' param signifies the primary keys of this table
# In this case, the keys are [movieId, actorId], the foreign key fields of the reference fields [movie, actor]
type MovieActor @table(key: ["movie", "actor"]) {
  movie: Movie!
  # movieId: UUID! <- implicitly added foreign key field
  actor: Actor!
  # actorId: UUID! <- implicitly added foreign key field
  role: String! # "main" or "supporting"
  # optional other fields
}

जब किसी टेबल पर फ़ॉरेन की कंस्ट्रेंट के साथ एसक्यूएल रिलेशनशिप तय किया जाता है, तो SQL Connect दूसरी तरफ़ उससे जुड़ा फ़ील्ड अपने-आप जनरेट कर देता है. आपको रिवर्स मैपिंग फ़ील्ड तय करने की ज़रूरत नहीं है. उदाहरण के लिए, Actor से वापस MovieActor पर.

MovieMetadata टाइप में वन-टू-वन रिलेशनशिप को मैनेज करना

अब फ़िल्म के डायरेक्टर पर नज़र रखें. साथ ही, Movie के साथ वन-टू-वन रिलेशनशिप सेट अप करें.

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

  • @ref(fields) से पता चलता है कि फ़ॉरेन की के किन फ़ील्ड का इस्तेमाल करना है.
  • @ref(references), टारगेट टेबल में रेफ़रंस के तौर पर दिए गए फ़ील्ड के बारे में बताता है. (डिफ़ॉल्ट रूप से, यह प्राइमरी कुंजी पर सेट होता है. हालांकि, @unique फ़ील्ड भी काम करते हैं). यह एक ऐडवांस विकल्प है. SQL Connect अक्सर आपके लिए इसका अनुमान लगा सकता है.

ज़्यादा जानकारी के लिए, @ref के रेफ़रंस दस्तावेज़ देखें.

# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata @table {
  # @unique ensures that each Movie only has one MovieMetadata.
  movie: Movie! @unique
  # Since it references to another table type, it adds a foreign key constraint.
  #  movie: Movie! @unique @ref(fields: "movieId", references: "id")
  #  movieId: UUID! <- implicitly added foreign key field
  director: String
}

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

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

मान लें कि आपके स्कीमा में Movie टाइप और उससे जुड़ा Actor टाइप शामिल है. SQL 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 }
    }
  }

इसे ध्यान में रखते हुए, क्वेरी लागू करने की गाइड और म्यूटेशन लागू करने की गाइड में, इन फ़ील्ड का इस्तेमाल करके ऑपरेशन लागू करने का तरीका पढ़ा जा सकता है.

स्कीमा के बारे में ज़्यादा बेहतर कॉन्सेप्ट

इन्यूमरेशन फ़ील्ड

SQL Connect, एन्यूमरेशन फ़ील्ड के साथ काम करता है. ये फ़ील्ड, PostgreSQL के एन्यूमरेटेड टाइप से मैप होते हैं. Enum की मदद से, किसी खास क्रम में स्टैटिक और पहले से तय की गई वैल्यू की सूची को तुरंत तय किया जा सकता है.

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

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

type Movie
  @table {
  title: String! 
  genre: String
  description: String
  originalAspectRatio: AspectRatio! @default(value: WIDESCREEN)
  otherAspectRatios: [AspectRatio!]
  tags: [String]
  rating: Float
  imageUrl: String!
  releaseYear: Int
}

Movie टाइप में, हमने एक enum फ़ील्ड originalAspectRatio जोड़ा है. इससे उस आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) की जानकारी मिलती है जिसमें फ़िल्म को शूट किया गया था. साथ ही, हमने एक और फ़ील्ड otherAspectRatios जोड़ा है. इससे अन्य उपलब्ध आसपेक्ट रेशियो की सूची मिलती है.

एन्यूमरेशन फ़ील्ड में किए गए बदलावों को मैनेज करना

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

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

enum वैल्यू में बदलाव सावधानी से किए जाने चाहिए, ताकि आपके ऑपरेशन या क्लाइंट कोड के पुराने वर्शन पर कोई असर न पड़े. किसी enum वैल्यू को हटाते या उसका नाम बदलते समय, पक्का करें कि आपके मौजूदा डेटाबेस में उसका कोई इंस्टेंस मौजूद न हो.

ऑपरेशन और क्लाइंट कोड में enum फ़ील्ड का इस्तेमाल करना

अब आपने स्कीमा में enum फ़ील्ड जोड़ लिया है. इसलिए, इस फ़ील्ड का इस्तेमाल क्वेरी और क्लाइंट कोड में किया जा सकता है.

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

अन्य ऐडवांस कॉन्सेप्ट

बुनियादी, लेकिन काम के टाइप और रिलेशनशिप के बारे में ज़्यादा जानने के लिए, रेफ़रंस दस्तावेज़ में दिए गए उदाहरण देखें.

डेटा टाइप, जो इस्तेमाल किए जा सकते हैं

SQL Connect, इन स्केलर डेटा टाइप के साथ काम करता है. साथ ही, @col(dataType:) का इस्तेमाल करके, PostgreSQL टाइप को असाइन करता है.

SQL Connect टाइप GraphQL का पहले से मौजूद टाइप या
SQL Connect कस्टम टाइप 		PostgreSQL का डिफ़ॉल्ट टाइप PostgreSQL के साथ काम करने वाले टाइप
(ब्रैकेट में उपनाम)
स्ट्रिंग GraphQL टेक्स्ट text
bit(n), varbit(n)
char(n), varchar(n)
Int GraphQL int Int2 (smallint, smallserial),
int4 (integer, int, serial)
फ़्लोट GraphQL float8 float4 (real)
float8 (double precision)
numeric (decimal)
बूलियन GraphQL बूलियन बूलियन
यूयूआईडी कस्टम uuid uuid
Int64 कस्टम bigint int8 (bigint, bigserial)
numeric (decimal)
तारीख कस्टम date तारीख
टाइमस्टैम्प कस्टम timestamptz

timestamptz

ध्यान दें: स्थानीय टाइमज़ोन की जानकारी सेव नहीं की जाती.
PostgreSQL, ऐसे टाइमस्टैंप को यूटीसी में बदलता है और सेव करता है.
इन्यूमरेशन कस्टम enum

enum
वेक्टर कस्टम वेक्टर

वेक्टर

Vertex AI की मदद से, वेक्टर सिमिलैरिटी सर्च करना देखें.
  • GraphQL List, वन-डाइमेंशन वाले ऐरे पर मैप करता है.
    • उदाहरण के लिए, [Int] को int5[] और [Any] को jsonb[] से मैप किया जाता है.
    • SQL Connect में नेस्ट किए गए ऐरे का इस्तेमाल नहीं किया जा सकता.

इसके जैसा एसक्यूएल स्कीमा

-- Movies Table
CREATE TABLE Movies (
    movie_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    release_year INT,
    genre VARCHAR(30),
    rating INT,
    description TEXT,
    tags TEXT[]
);
-- Movie Metadata Table
CREATE TABLE MovieMetadata (
    movie_id UUID REFERENCES Movies(movie_id) UNIQUE,
    director VARCHAR(255) NOT NULL,
    PRIMARY KEY (movie_id)
);
-- Actors Table
CREATE TABLE Actors (
    actor_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    name VARCHAR(30) NOT NULL
);
-- MovieActor Join Table for Many-to-Many Relationship
CREATE TABLE MovieActor (
    movie_id UUID REFERENCES Movies(movie_id),
    actor_id UUID REFERENCES Actors(actor_id),
    role VARCHAR(50) NOT NULL, # "main" or "supporting"
    PRIMARY KEY (movie_id, actor_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id),
    FOREIGN KEY (actor_id) REFERENCES Actors(actor_id)
);
-- Users Table
CREATE TABLE Users (
    user_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_auth VARCHAR(255) NOT NULL
    username VARCHAR(30) NOT NULL
);
-- Reviews Table
CREATE TABLE Reviews (
    review_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_id UUID REFERENCES Users(user_id),
    movie_id UUID REFERENCES Movies(movie_id),
    rating INT,
    review_text TEXT,
    review_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE (movie_id, user_id)
    FOREIGN KEY (user_id) REFERENCES Users(user_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id)
);
-- Self Join Example for Movie Sequel Relationship
ALTER TABLE Movies
ADD COLUMN sequel_to UUID REFERENCES Movies(movie_id);

अगले चरण

आपको यह भी पसंद आ सकता है: