In dieser Kurzanleitung erfahren Sie, wie Sie Firebase SQL Connect einrichten, um Ihre Web- und mobilen Apps mit einer PostgreSQL-Datenbank zu verbinden. Aktivitäten in diesem Lab:
- Lokales Firebase SQL Connect Projektverzeichnis mit VS Code und der Firebase CLI einrichten
- SQL Connect Schemas, ‑Abfragen und ‑Mutationen basierend auf Ihren App-Ideen in natürlicher Sprache generieren
- Stark typisierte SDKs in Ihren Apps verwenden, um SQL Connect Abfragen und ‑Mutationen auszuführen
- Cloud SQL for PostgreSQL-Instanz, ein SQL Connect Schema, Abfragen und Mutationen bereitstellen
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 Skript installiert die Firebase CLI und die SQL Connect VS Code-Erweiterung und führt Sie durch
firebase init dataconnect, um Ihr Projekt einzurichten. Wenn Sie VS Code Desktop nicht installiert haben, wird es im Browser geöffnet.curl -sL https://firebase.tools/init/dataconnect | editor=true bashÖffnen Sie den Bildschirm der SQL Connect VS Code-Erweiterung, 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
@table Direktive 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 m:n-Beziehungen mit Verknüpfungstabellen mit zusammengesetzten Primärschlüsseln.
In der Standardkonfiguration finden Sie die SQL Connect Schemadateien in
dem dataconnect/schema/ Verzeichnis. Hier sind zwei Beispieltabelle aus dem Filmschema. Ihr Schema kann sich unterscheiden, wenn Sie es mit Gemini generiert haben.
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 über den Namen aus Ihrer App auf. Die GraphQL-Syntax bietet stark typisierte SDKs und eine flexible API, um genau die Daten abzurufen, die Ihre App benötigt.
Daten in Ihrer Datenbank übertragen
Wenn der Emulator ausgeführt wird, können Sie ihn mit Anfangsdaten füllen. Sie können die bereitgestellte Datei dataconnect/seed_data.gql verwenden oder eigene Mutationen schreiben.
Verwenden Sie die Codelens-Schaltfläche Ausführen (lokal) in VS Code, um die Mutationen auszuführen und Ihre lokale PGlite-Datenbank zu füllen.
Abfragen und Mutationen prüfen
In der Standardkonfiguration finden Sie die SQL Connect Abfragen und ‑Mutationen im
dataconnect/example/ Verzeichnis.
Mit verschachtelten Abfragen können Sie relationale Daten genau 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, sichere Abfragen und Mutationen mit Firebase Auth zu erstellen.
Um Ihre App zu schützen, können Web- und mobile Apps nur auf
SQL Connect Abfragen und Mutationen mit
@auth
Direktiven zugreifen. Abfragen und Mutationen können sicher auf die Firebase Auth-UID zugreifen
indem sie einen Ausdruck wie {field}_expr: "auth.uid" verwenden.
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 zu SQL Connect Auth
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 Codelens-Schaltfläche Vorgang generieren/optimieren, um den GraphQL-Vorgang zu generieren.
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 mit der Schaltfläche SDK zur
App hinzufügen in der SQL Connect VS Code-Erweiterung oder durch Ausführen von firebase init
dataconnect:sdk hinzufügen.
Web
- Firebase zu Ihrer Web-App hinzufügen
In der Hauptdatei Ihrer React-App:
- Generiertes SDK importieren:
// Update as needed with the path to your generated SDK. import { listMovies, ListMoviesData } from '@dataconnect/generated';- App instrumentieren, um eine Verbindung zum SQL Connect Emulator herzustellen:
import { connectDataConnectEmulator } from 'firebase/data-connect'; const dataConnect = getDataConnect(connectorConfig); connectDataConnectEmulator(dataConnect, 'localhost', 9399);- SQL Connect-Methoden aufrufen:
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
- Firebase zu Ihrer iOS App hinzufügen
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-Datei aus.Im Hauptdelegate Ihrer App:
SQL Connect SDK und generiertes SDK importieren:
import FirebaseDataConnect // Generated queries. // Update as needed with the package name of your generated SDK. import <CONNECTOR-PACKAGE-NAME> let connector = DataConnect.moviesConnectorApp instrumentieren, 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)SQL Connect Methoden aufrufen:
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
- Firebase zu Ihrer Android App hinzufügen
Wenn Sie das generierte SDK verwenden möchten, konfigurieren Sie SQL Connect in Gradle als Abhängigkeit.
Aktualisieren Sie
pluginsunddependenciesinapp/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:
- Connector-Instanz aus dem generierten SDK abrufen:
private val connector = com.myapplication.MoviesConnector.instance- App instrumentieren, 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) }- SQL Connect-Methoden aufrufen:
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
- Firebase zu Ihrer Flutter-App hinzufügen
- Installieren Sie die FlutterFire CLI
dart pub global activate flutterfire_cli. - Führen Sie
flutterfire configureaus. In der Hauptfunktion Ihrer App:
- Generiertes SDK importieren:
// Generated queries. // Update as needed with the path to your generated SDK import 'movies_connector/movies.dart';- App instrumentieren, 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 für die Produktion bereit:
Informationen zu Preisen und kostenloser Testversion finden Sie auf der Seite Preise. Für Ihr Projekt ist möglicherweise eine der Firebase SQL Connect Testoptionen verfügbar.
Klicken Sie in der SQL Connect VS Code-Erweiterung auf die Schaltfläche Für die Produktion bereitstellen oder führen Sie im Terminal Folgendes aus:
firebase deploy --only dataconnectNach der Bereitstellung können Sie Ihr Schema ansehen und Abfragen und Mutationen in der Firebase Console ausführen. Rufen Sie dazu Datenbanken und Speicher > SQL Connect auf.
Weitere Informationen zu dataconnect.yaml Weitere Informationen zur Verwendung von SQL Connect mit Cloud SQL
Nächste Schritte
Nachdem Sie die Kurzanleitung durchgearbeitet haben, können Sie Folgendes tun:
- Sehen Sie sich ein Repository mit einer Kurzanleitungs-App an und erstellen Sie eine voll funktionsfähige SQL Connect App. Folgen Sie dazu unserem Codelab für das Web, Codelab für iOS, oder Codelab für Android.
- Fügen Sie Ihrer Datenbank Daten hinzu, prüfen Sie Ihre Schemas und beobachten Sie Ihren SQL Connect-Dienst in der Firebase Console.
- Richten Sie den Firebase MCP-Server mit KI-gestützten Entwicklungstools wie Gemini CLI, Claude Code oder Cursor ein.
- Weitere Informationen zur Entwicklung von Schemas, Abfragen und Mutationen
- Weitere Informationen zur Verwaltung von PostgreSQL-Schemas mit SQL Connect
- Weitere Informationen zu Client-SDKs für Web, Android, iOS und Flutter sowie zu Admin-SDKs für Node.js.