Firebase SQL Connect का इस्तेमाल शुरू करना

इस क्विकस्टार्ट की मदद से, Firebase SQL Connect को सेट अप किया जा सकता है. इससे, अपने वेब और मोबाइल ऐप्लिकेशन को PostgreSQL डेटाबेस से कनेक्ट किया जा सकता है. आपको ये काम करने होंगे:

VS Code और Firebase CLI की मदद से, अपने लोकल Firebase SQL Connect प्रोजेक्ट की डायरेक्ट्री सेट अप करना.
नैचुरल लैंग्वेज में, अपने ऐप्लिकेशन के आइडिया के आधार पर, SQL Connect स्कीमा, क्वेरी, और म्यूटेशन जनरेट करना.
SQL Connect क्वेरी और म्यूटेशन चलाने के लिए, अपने ऐप्लिकेशन में मज़बूत टाइप वाले SDK टूल का इस्तेमाल करना.SQL Connect
PostgreSQL के लिए Cloud SQL इंस्टेंस, एक SQL Connect स्कीमा, क्वेरी, और म्यूटेशन उपलब्ध कराना.

लोकल प्रोजेक्ट की डायरेक्ट्री सेट अप करना

SQL Connect के लिए, लोकल डेवलपमेंट टूल दो तरीकों से इंस्टॉल किए जा सकते हैं.

किसी प्रोजेक्ट डायरेक्ट्री में, यह कमांड चलाएं.

स्क्रिप्ट, Firebase CLI और SQL Connect VS Code एक्सटेंशन इंस्टॉल करती है. साथ ही, आपके प्रोजेक्ट को सेट अप करने के लिए, firebase init dataconnect के बारे में जानकारी देती है. अगर आपके पास VS Code डेस्कटॉप इंस्टॉल नहीं है, तो स्क्रिप्ट इसे ब्राउज़र में खोलती है.
```
curl -sL https://firebase.tools/init/dataconnect | editor=true bash
```
Visual Studio Code के बाएं पैनल में मौजूद Firebase आइकॉन पर क्लिक करके, SQL Connect VS Code एक्सटेंशन स्क्रीन खोलें.
लोकल PGlite डेटाबेस के साथ एम्युलेटर चलाने के लिए, एम्युलेटर शुरू करें पर क्लिक करें.

स्कीमा की समीक्षा करना

Firebase SQL Connect आपके डेटा मॉडल की परिभाषा तय करने के लिए GraphQL का इस्तेमाल करता है. @table डायरेक्टिव, GraphQL टाइप को PostgreSQL टेबल पर मैप करता है. टाइप में मौजूद फ़ील्ड, PostgreSQL कॉलम पर मैप होते हैं. टेबल के बीच रिलेशनशिप तय करने के लिए, उन फ़ील्ड का इस्तेमाल किया जा सकता है जो अन्य @table टाइप के रेफ़रंस देते हैं. इनमें, कंपोज़िट प्राइमरी की के साथ जॉइन टेबल का इस्तेमाल करके, मेनी-टू-मेनी रिलेशनशिप भी शामिल हैं.

डिफ़ॉल्ट सेटअप में, SQL Connect स्कीमा फ़ाइलें dataconnect/schema/ डायरेक्ट्री में देखी जा सकती हैं. यहां, मूवी टेंप्लेट स्कीमा से दो उदाहरण टेबल दिए गए हैं. अगर आपने इसे जनरेट करने के लिए Gemini का इस्तेमाल किया है, तो आपका स्कीमा अलग हो सकता है.

type Movie @table {
  # Every table has an implicit primary key field that looks something like:
  #  id: UUID! @default(expr: "uuidV4()")
  title: String!
  imageUrl: String!
  genre: String
}

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

SQL Connect स्कीमा के बारे में ज़्यादा जानें

क्वेरी और म्यूटेशन डेवलप करना

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

अपने डेटाबेस में डेटा सीड करना

एम्युलेटर के चालू होने पर, उसमें शुरुआती डेटा सीड किया जा सकता है. इसके लिए, दी गई dataconnect/seed_data.gql फ़ाइल का इस्तेमाल किया जा सकता है या अपने म्यूटेशन लिखे जा सकते हैं.

म्यूटेशन को एक्ज़ीक्यूट करने और अपने लोकल PGlite डेटाबेस में डेटा भरने के लिए, VS Code में चलाएं (लोकल) कोड लेंस बटन का इस्तेमाल करें.

Firebase SQL Connect के लिए CodeLens Run बटन

क्वेरी और म्यूटेशन की समीक्षा करना

डिफ़ॉल्ट सेटअप में, SQL Connect क्वेरी और म्यूटेशन, dataconnect/example/ डायरेक्ट्री में देखे जा सकते हैं.

नेस्ट की गई क्वेरी की मदद से, रिलेशनल डेटा की सटीक क्वेरी की जा सकती है.

query ListMovies @auth(level: PUBLIC, insecureReason: "Anyone can list all movies and their reviews.") {
  movies {
    title imageUrl genre
    reviews_on_movie {
      rating reviewDate
      user { username }
    }
  }
}

SQL Connect Firebase Auth की मदद से सुरक्षित क्वेरी और म्यूटेशन बनाने में आपकी मदद करता है.

अपने ऐप्लिकेशन को सुरक्षित रखने के लिए, वेब और मोबाइल ऐप्लिकेशन, SQL Connect क्वेरी और म्यूटेशन को सिर्फ़ @auth डायरेक्टिव की मदद से ऐक्सेस कर सकते हैं. क्वेरी और म्यूटेशन, Firebase Auth UID को सुरक्षित तरीके से ऐक्सेस कर सकते हैं {field}_expr: "auth.uid" जैसे एक्सप्रेशन का इस्तेमाल करके.

mutation AddReview($movieId: UUID!, $rating: Int!, $reviewText: String!) @auth(level: USER) {
  review_upsert(
    data: {
      userId_expr: "auth.uid"
      movieId: $movieId
      rating: $rating
      reviewText: $reviewText
    }
  )
}

SQL Connect क्वेरी के बारे में ज़्यादा जानें SQL Connect म्यूटेशन के बारे में ज़्यादा जानें SQL Connect Auth के बारे में ज़्यादा जानें

क्वेरी और म्यूटेशन जनरेट करना

SQL Connect का असरदार तरीके से इस्तेमाल करने के लिए, GraphQL का एक्सपर्ट होना ज़रूरी नहीं है. नैचुरल लैंग्वेज में दिए गए ब्यौरों से, SQL Connect क्वेरी और म्यूटेशन जनरेट किए जा सकते हैं.

किसी भी .gql फ़ाइल में, टिप्पणी शुरू करने के लिए # टाइप करें और क्वेरी या म्यूटेशन के बारे में बताएं. इसके बाद, GraphQL ऑपरेशन जनरेट करने के लिए, ऑपरेशन जनरेट/बेहतर बनाएं कोड लेंस बटन का इस्तेमाल करें.

CodeLens Generate button for Firebase SQL
Connect

अपने ऐप्लिकेशन में जनरेट किए गए SDK टूल का इस्तेमाल करना

firebase init dataconnect आपके प्रोजेक्ट में मौजूद ऐप्लिकेशन के लिए, टाइप-सेफ़ SDK टूल अपने-आप सेट अप करता है. ज़रूरत पड़ने पर, SQL Connect VS Code एक्सटेंशन में मौजूद ऐप्लिकेशन में SDK टूल जोड़ें बटन का इस्तेमाल करके या firebase init dataconnect:sdk चलाकर, SDK टूल को मैन्युअल तरीके से जोड़ा जा सकता है.

वेब

अपने वेब ऐप्लिकेशन में Firebase जोड़ें.
अपने React ऐप्लिकेशन की मुख्य फ़ाइल में:
- जनरेट किए गए SDK टूल को इंपोर्ट करें:
```
// Update as needed with the path to your generated SDK.
import { listMovies, ListMoviesData } from '@dataconnect/generated';
```
- SQL Connect एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन को इंस्ट्रूमेंट करें:
```
import { connectDataConnectEmulator } from 'firebase/data-connect';

const dataConnect = getDataConnect(connectorConfig);
connectDataConnectEmulator(dataConnect, 'localhost', 9399);
```
- SQL Connect तरीके कॉल करें.
```
function App() {
  const [movies, setMovies] = useState<ListMoviesData['movies']>([]);
  useEffect(() => {
    listMovies.then(res => setMovies(res.data));
  }, []);
  return (
    movies.map(movie => <h1>{movie.title}</h1>);
  );
}

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);
```
ध्यान दें: इस सैंपल में, React ऐप्लिकेशन, Firebase JavaScript SDK टूल का इस्तेमाल करके आपकी क्वेरी को कॉल करता है. SQL Connect React में एसिंक्रोनस तरीके से SQL Connect के साथ काम करने के लिए, खास बाइंडिंग भी उपलब्ध कराता है.

Swift

अपने iOS ऐप्लिकेशन में Firebase जोड़ें.
जनरेट किए गए SDK टूल का इस्तेमाल करने के लिए, इसे Xcode में डिपेंडेंसी के तौर पर कॉन्फ़िगर करें.

Xcode के सबसे ऊपर मौजूद नेविगेशन बार में, फ़ाइल > पैकेज डिपेंडेंसी जोड़ें > लोकल जोड़ें को चुनें. इसके बाद, जनरेट की गई Package.swift वाली फ़ोल्डर को चुनें.

अपने ऐप्लिकेशन के मुख्य डेलिगेट में:

SQL Connect SDK टूल और जनरेट किए गए SDK टूल को इंपोर्ट करें:

import FirebaseDataConnect
// Generated queries.
// Update as needed with the package name of your generated SDK.
import <CONNECTOR-PACKAGE-NAME>

let connector = DataConnect.moviesConnector

SQL Connect एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन को इंस्ट्रूमेंट करें:
```
// Connect to the emulator on "127.0.0.1:9399"
connector.useEmulator()

// (alternatively) if you're running your emulator on non-default port:
// connector.useEmulator(port: 9999)
```

SQL Connect तरीके कॉल करें:

struct ListMovieView: View {
    @StateObject private var queryRef = connector.listMovies.ref()

    var body: some View {
        VStack {
            Button {
                Task {
                    do {
                        try await refresh()
                    } catch {
                        print("Failed to refresh: \(error)")
                    }
                }
            } label: {
                Text("Refresh")
            }

            // use the query results in a view
            ForEach(queryRef.data?.movies ?? []) { movie in
                Text(movie.title)
            }
            
        }
    }
}

@MainActor
func refresh() async throws {
    _ = try await queryRef.execute()
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ListMovieView()
    }
}

Kotlin Android

अपने Android ऐप्लिकेशन में Firebase जोड़ें.

जनरेट किए गए SDK टूल का इस्तेमाल करने के लिए, SQL Connect को Gradle में डिपेंडेंसी के तौर पर कॉन्फ़िगर करें.

अपने app/build.gradle.kts में, plugins और dependencies को अपडेट करें.

plugins {
  // Use whichever versions of these dependencies suit your application.
  // The versions shown here were the latest as of March 14, 2025.
  // Note, however, that the version of kotlin("plugin.serialization") must,
  // in general, match the version of kotlin("android").
  id("com.android.application") version "8.9.0"
  id("com.google.gms.google-services") version "4.4.2"
  val kotlinVersion = "2.1.10"
  kotlin("android") version kotlinVersion
  kotlin("plugin.serialization") version kotlinVersion
}

dependencies {
  // Use whichever versions of these dependencies suit your application.
  // The versions shown here were the latest versions as of March 14, 2025.
  implementation("com.google.firebase:firebase-dataconnect:16.0.0-beta04")
  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")
  implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.7.3")

  // These dependencies are not strictly required, but will very likely be used
  // when writing modern Android applications.
  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
  implementation("androidx.appcompat:appcompat:1.7.0")
  implementation("androidx.activity:activity-ktx:1.10.1")
  implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7")
  implementation("com.google.android.material:material:1.12.0")
}

अपने ऐप्लिकेशन की मुख्य गतिविधि में:

जनरेट किए गए SDK टूल से, कनेक्टर इंस्टेंस पाएं:

private val connector = com.myapplication.MoviesConnector.instance

SQL Connect एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन को इंस्ट्रूमेंट करें:

private val connector = com.myapplication.MoviesConnector.instance
  .apply {
    // Connect to the emulator on "10.0.2.2:9399" (default port)
    dataConnect.useEmulator()

    // (alternatively) if you're running your emulator on non-default port:
    // dataConnect.useEmulator(port = 9999)
  }

SQL Connect तरीके कॉल करें.

class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val textView: TextView = findViewById(R.id.text_view)

    lifecycleScope.launch {
      lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
        
        val result = connector.listMovies.runCatching { execute { } }
        
        val newTextViewText = result.fold(
          onSuccess = {
            val titles = it.data.movies.map { it.title }
            "${titles.size} movies: " + titles.joinToString(", ")
          },
          onFailure = { "ERROR: ${it.message}" }
        )
        textView.text = newTextViewText
      }
    }
  }
}

Flutter

अपने Flutter ऐप्लिकेशन में Firebase जोड़ें.
flutterfire CLI dart pub global activate flutterfire_cli इंस्टॉल करें.
flutterfire configure चलाएं.

अपने ऐप्लिकेशन के मुख्य फ़ंक्शन में:

जनरेट किए गए SDK टूल को इंपोर्ट करें:

// Generated queries.
// Update as needed with the path to your generated SDK

import 'movies_connector/movies.dart';

SQL Connect एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन को इंस्ट्रूमेंट करें:

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  
  MoviesConnector.instance.dataConnect
      .useDataConnectEmulator(Uri.base.host, 443, isSecure: true);
  
  runApp(const MyApp());
}

SQL Connect तरीके कॉल करें.

class MyApp extends StatelessWidget {
  const MyApp({super.key});
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
        home: Scaffold(
            body: Column(children: [
      ConstrainedBox(
        constraints: const BoxConstraints(maxHeight: 200),
        child: FutureBuilder(
            future: MoviesConnector.instance.listMovies().execute(),
            builder: (context, snapshot) {
              if (snapshot.connectionState == ConnectionState.done) {
                return ListView.builder(
                  scrollDirection: Axis.vertical,
                  itemBuilder: (context, index) => Card(
                      child: Text(
                    snapshot.data!.data.movies[index].title,
                  )),
                  itemCount: snapshot.data!.data.movies.length,
                );
              }
              return const CircularProgressIndicator();
            }),
      )
    ])));
  }
}

प्रोडक्शन पर डिप्लॉय करना

अपने स्कीमा, क्वेरी, और म्यूटेशन को प्रोडक्शन पर डिप्लॉय करने के लिए:

कीमत वाले पेज पर, कीमत और बिना किसी शुल्क के आज़माने की सुविधा के बारे में जानकारी देखें. आपका प्रोजेक्ट, Firebase SQL Connect को आज़माने के किसी एक विकल्प के लिए ज़रूरी शर्तें पूरी कर सकता है.
SQL Connect VS Code एक्सटेंशन में मौजूद प्रोडक्शन पर डिप्लॉय करें बटन पर क्लिक करें या टर्मिनल में यह कमांड चलाएं:
```
firebase deploy --only dataconnect
```
डिप्लॉय करने के बाद, अपना स्कीमा देखने और क्वेरी और म्यूटेशन चलाने के लिए, Firebase कंसोल पर जाएं.

अहम जानकारी: डिप्लॉय करने से पहले, Cloud SQL का इलाका, इंस्टेंस का नाम, और PostgreSQL डेटाबेस का नाम dataconnect.yaml में कॉन्फ़िगर किया जा सकता है.

dataconnect.yaml के बारे में ज़्यादा जानें Cloud SQL के साथ SQL Connect के काम करने के तरीके के बारे में ज़्यादा जानें

अगले चरण

क्विकस्टार्ट पूरा करने के बाद, यहां कुछ अगले चरण दिए गए हैं:

क्विकस्टार्ट ऐप्लिकेशन का रिपॉज़िटरी एक्सप्लोर करें. साथ ही, पूरी सुविधाओं वाला SQL Connect ऐप्लिकेशन बनाने के लिए, वेब के लिए कोडलैब, iOS के लिए कोडलैब या Android के लिए कोडलैब के निर्देशों का पालन करें.
अपने डेटाबेस में डेटा जोड़ें, अपने स्कीमा की जांच करें, और Firebase कंसोल में अपनी SQL Connect सेवा की निगरानी करें.Firebase
एआई की मदद से काम करने वाले डेवलपमेंट टूल (जैसे, Gemini Code Assist) की मदद से, Firebase MCP सर्वर सेट अप करें.
स्कीमा, क्वेरी और म्यूटेशन डेवलपमेंट के बारे में ज़्यादा जानें.
SQL Connect SQL Connect, PostgreSQL स्कीमा को कैसे मैनेज करता है, इस बारे में ज़्यादा जानें.
वेब, Android, iOS, और Flutter के लिए क्लाइंट SDK टूल के साथ-साथ, Node.js के लिए एडमिन SDK टूल के बारे में ज़्यादा जानें.