Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Erste Schritte mit Firebase SQL Connect

In dieser Kurzanleitung erfahren Sie, wie Sie mit Firebase SQL Connect Ihre Web- und mobilen Anwendungen mit einer PostgreSQL-Datenbank verbinden. Sie werden Folgendes tun:

Richten Sie Ihr lokales Firebase SQL Connect-Projektverzeichnis mit VS Code und der Firebase-Befehlszeile ein.
SQL Connect-Schemas, ‑Abfragen und ‑Mutationen basierend auf Ihren App-Ideen in natürlicher Sprache generieren.
Verwenden Sie die stark typisierten SDKs in Ihren Anwendungen, um SQL Connect-Abfragen und -Mutationen auszuführen.
Stellen Sie eine Cloud SQL for PostgreSQL-Instanz, ein SQL Connect-Schema, Abfragen und Mutationen bereit.

Lokales Projektverzeichnis einrichten

Sie haben zwei Möglichkeiten, lokale Entwicklungstools für SQL Connect zu installieren.

Führen Sie in einem Projektverzeichnis den folgenden Befehl aus.

Das Script installiert die Firebase CLI und die VS Code-Erweiterung für SQL Connect und führt Sie durch firebase init dataconnect, um Ihr Projekt einzurichten. Wenn Sie VS Code Desktop nicht installiert haben, wird es vom Script in einem Browser geöffnet.
```
curl -sL https://firebase.tools/init/dataconnect | editor=true bash
```
Öffnen Sie den Bildschirm der VS Code-Erweiterung „SQL Connect“, indem Sie im linken Bereich von Visual Studio Code auf das Firebase-Symbol klicken.
Klicken Sie auf Emulatoren starten, um den Emulator mit einer lokalen PGlite-Datenbank auszuführen.

Schema prüfen

Firebase SQL Connect verwendet GraphQL, um Ihr Datenmodell zu definieren. Die Anweisung @table ordnet einen GraphQL-Typ einer PostgreSQL-Tabelle zu. Felder im Typ werden PostgreSQL-Spalten zugeordnet. Sie können Beziehungen zwischen Tabellen mithilfe von Feldern definieren, die auf andere @table-Typen verweisen, einschließlich n:m-Beziehungen mithilfe von Join-Tabellen mit zusammengesetzten Primärschlüsseln.

In der Standardeinrichtung finden Sie die SQL Connect-Schemadateien im Verzeichnis dataconnect/schema/. Hier sind zwei Beispieltabellen aus dem Schema der Filmvorlage. Wenn Sie Gemini zum Erstellen des Schemas verwendet haben, kann es anders aussehen.

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

Weitere Informationen zu SQL Connect-Schemas

Abfragen und Mutationen entwickeln

Firebase SQL Connect verwendet GraphQL für Abfragen und Mutationen. Sie definieren diese in .gql-Dateien und rufen sie namentlich in Ihrer Anwendung auf. Die GraphQL-Syntax bietet stark typisierte SDKs und eine flexible API, um genau die Daten abzurufen, die Ihre Anwendung benötigt.

Daten in Ihre Datenbank einlesen

Wenn der Emulator ausgeführt wird, können Sie ihn mit ersten Daten füllen. Sie können die bereitgestellte dataconnect/seed_data.gql-Datei verwenden oder eigene Mutationen schreiben.

Verwenden Sie die Code Lens-Schaltfläche Ausführen (lokal) in VS Code, um die Mutationen auszuführen und Ihre lokale PGlite-Datenbank zu füllen.

CodeLens-Schaltfläche „Ausführen“ für Firebase SQL Connect

Abfragen und Mutationen prüfen

In der Standardeinrichtung finden Sie die SQL Connect-Abfragen und -Mutationen im Verzeichnis dataconnect/example/.

Mit verschachtelten Abfragen können Sie relationale Daten präzise abfragen.

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 hilft Ihnen, mit Firebase Auth sichere Abfragen und Mutationen zu erstellen.

Aus Sicherheitsgründen können Web- und mobile Apps nur auf SQL Connect-Abfragen und ‑Mutationen mit @auth-Anweisungen zugreifen. Abfragen und Mutationen können mit einem Ausdruck wie {field}_expr: "auth.uid" sicher auf die Firebase Auth-UID zugreifen.

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

Weitere Informationen zu SQL Connect-Abfragen Weitere Informationen zu SQL Connect-Mutationen Weitere Informationen zur SQL Connect-Authentifizierung

Abfragen und Mutationen generieren

Sie müssen kein GraphQL-Experte sein, um SQL Connect effektiv zu nutzen. Sie können SQL Connect-Abfragen und ‑Mutationen aus Beschreibungen in natürlicher Sprache generieren.

Geben Sie in einer beliebigen .gql-Datei # ein, um einen Kommentar zu beginnen, und beschreiben Sie eine Abfrage oder Mutation. Verwenden Sie dann die Code Lens-Schaltfläche Generate/Refine Operation, um den GraphQL-Vorgang zu generieren.

CodeLens-Button „Generieren“ für Firebase SQL Connect

Generiertes SDK in Ihrer App verwenden

firebase init dataconnect richtet automatisch typsichere SDKs für Apps in Ihrem Projekt ein. Bei Bedarf können Sie das SDK manuell hinzufügen. Verwenden Sie dazu die Schaltfläche SDK zur App hinzufügen in der VS Code-Erweiterung für SQL Connect oder führen Sie firebase init dataconnect:sdk aus.

Web

Fügen Sie Firebase zu Ihrer Web-App hinzu.

In der Hauptdatei Ihrer React-Anwendung:

Importieren Sie das generierte SDK:

// Update as needed with the path to your generated SDK.
import { listMovies, ListMoviesData } from '@dataconnect/generated';

Instrumentieren Sie Ihre Anwendung, um eine Verbindung zum SQL Connect-Emulator herzustellen:

import { connectDataConnectEmulator } from 'firebase/data-connect';

const dataConnect = getDataConnect(connectorConfig);
connectDataConnectEmulator(dataConnect, 'localhost', 9399);

Rufen Sie SQL Connect-Methoden auf.

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 />);

Swift

Fügen Sie Firebase zu Ihrer iOS-App hinzu.
Wenn Sie das generierte SDK verwenden möchten, konfigurieren Sie es in Xcode als Abhängigkeit.

Wählen Sie in der oberen Navigationsleiste von Xcode File > Add Package Dependencies > Add Local (Datei > Paketabhängigkeiten hinzufügen > Lokal hinzufügen) aus und wählen Sie den Ordner mit der generierten Package.swift aus.

Im Haupt-Delegate Ihrer App:

Importieren Sie das SQL Connect SDK und Ihr generiertes SDK:

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

let connector = DataConnect.moviesConnector

Instrumentieren Sie Ihre Anwendung, um eine Verbindung zum SQL Connect-Emulator herzustellen:

// 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)

Rufen Sie die SQL Connect-Methoden auf:

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

Fügen Sie Firebase zu Ihrer Android-App hinzu.

Wenn Sie das generierte SDK verwenden möchten, konfigurieren Sie SQL Connect als Abhängigkeit in Gradle.

Aktualisieren Sie plugins und dependencies in Ihrem app/build.gradle.kts.

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

In der Hauptaktivität Ihrer App:

Rufen Sie eine Connector-Instanz aus dem generierten SDK ab:

private val connector = com.myapplication.MoviesConnector.instance

Instrumentieren Sie Ihre Anwendung, um eine Verbindung zum SQL Connect-Emulator herzustellen:

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

Rufen Sie SQL Connect-Methoden auf.

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

Fügen Sie Firebase zu Ihrer Flutter-App hinzu.
Installieren Sie die FlutterFire-Befehlszeile dart pub global activate flutterfire_cli.
Führen Sie flutterfire configure aus.

In der Hauptfunktion Ihrer App:

Importieren Sie das generierte SDK:

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

import 'movies_connector/movies.dart';

Instrumentieren Sie Ihre Anwendung, um eine Verbindung zum SQL Connect-Emulator herzustellen:

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-Methoden aufrufen

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();
            }),
      )
    ])));
  }
}

Für die Produktion bereitstellen

So stellen Sie Ihr Schema, Ihre Abfragen und Mutationen in der Produktion bereit:

Informationen zu den Preisen und zum kostenlosen Testzeitraum finden Sie auf der Seite Preise. Ihr Projekt ist möglicherweise für eine der Firebase SQL Connect-Testoptionen berechtigt.
Klicken Sie in der VS Code-Erweiterung „SQL Connect“ auf den Button In Produktion bereitstellen oder führen Sie den folgenden Befehl in einem Terminal aus:
```
firebase deploy --only dataconnect
```
Nach der Bereitstellung können Sie Ihr Schema aufrufen und Abfragen und Mutationen in der Firebase-Konsole ausführen. Gehen Sie dazu zu Datenbanken und Speicher > SQL Connect.

Tipp: Sie können die Cloud SQL-Region, den Instanznamen und den PostgreSQL-Datenbanknamen in dataconnect.yaml vor der Bereitstellung konfigurieren.

Weitere Informationen zu dataconnect.yaml Weitere Informationen zur Funktionsweise von SQL Connect mit Cloud SQL

Nächste Schritte

Nachdem Sie die Kurzanleitung abgeschlossen haben, können Sie Folgendes tun:

Sehen Sie sich ein Repository für eine Schnellstart-App an und erstellen Sie eine voll funktionsfähige SQL Connect-App, indem Sie unserem Codelab für das Web, Codelab für iOS oder Codelab für Android folgen.
In der Firebase Console können Sie Ihrer Datenbank Daten hinzufügen, Ihre Schemas prüfen und Ihren SQL Connect-Dienst überwachen.
Richten Sie den Firebase-MCP-Server mit KI-basierten Entwicklungstools wie Antigravity, Claude Code oder Cursor ein.
Weitere Informationen zur Entwicklung von Schemas, Abfragen und Mutationen.
SQL Connect verwaltet PostgreSQL-Schemas.
Weitere Informationen zu Client-SDKs für das Web, Android, iOS und Flutter sowie zu Admin-SDKs für Node.js.