"Es ist wieder Zeit, SQL-Code zu schreiben, kann der KI-Assistent heute helfen?"
Es ist okay, supabase hat die offiziellen Hinweise gegeben, kopiert sie einfach!
Einführung in die Supabase
Supabase ist eine Cloud-Datenbank, die auf PostgreSQL basiert und großzügige kostenlose Credits bietet.
Ziel ist es, Entwicklern die Möglichkeit zu geben, an einem Wochenende eine Million gleichzeitiger Anwendungen zu erstellen. Supabase ist eine All-in-One-Plattform, die alle für die Erstellung von Webanwendungen erforderlichen Back-End-Funktionen integriert.
Supabase ist für verschiedene Anwendungsszenarien geeignet, z. B:
Erstellen Sie Anwendungen, die eine Benutzerauthentifizierung erfordern, z. B. soziale Netzwerke, E-Commerce-Plattformen und SaaS-Produkte.
Erstellen Sie Echtzeitanwendungen wie Chat-Anwendungen, Tools für die Zusammenarbeit und Online-Spiele.
Speichern und verwalten Sie große Dateien wie Bilder, Videos und Audiodateien.
Als Open-Source-Alternative zu Firebase funktioniert Supabase zwar, aber es ist nicht einfach, einen KI-Programmierassistenten dazu zu bringen, genau zu verstehen, was Sie für die Entwicklung von Supabase benötigen.
(ein Tier) füttern
Aber kein Grund zur Aufregung!
Die Verantwortlichen von Supabase haben sich nicht lumpen lassen und sofort eine Reihe spezieller KI-Prompts veröffentlicht!
Richtig, es sind diese "Zaubersprüche", die es KI-Programmierassistenten ermöglichen, Ihre Absichten in Sekundenschnelle zu verstehen. Es ist, als würde man seinem Mund eine Mahlzeit zuführen!
API-Tipp: Starten einer Next.js-Anwendung mit Supabase Auth
# Initialisierung einer Next.js Anwendung mit Supabase Auth
Erstellen Sie eine Next.js-Anwendung, die App Router und Supabase Auth verwendet.
Befolgen Sie die Supabase-Richtlinien für die Verwendung des Pakets "@supabase/ssr" und der serverseitigen Authentifizierung. Zu den spezifischen Anforderungen gehören:
- Eine Utility-Funktion zum Erstellen von Client-Instanzen auf der Client-Seite.
- Eine Werkzeugfunktion für die Erstellung von client-seitigen Instanzen auf der Serverseite, die die `cookies` API von Next.js für den Zugriff auf Cookies verwendet. Verwenden Sie die neueste Version dieser API, wobei `cookies` die Verwendung von `await` erfordert.
- Eine Werkzeugfunktion für die Handhabung von Benutzersitzungsaktualisierungen in Middleware.
## Umgang mit Cookies
Verwenden Sie die neueste Version von `@supabase/ssr`, wo die Cookie-Konfiguration durch die Funktionen `getAll` und `setAll` wie unten gezeigt definiert wird.## Umgang mit Cookies:
```
constabase = createServerClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
{
Cookies: {
getAll() {
return request.cookies.getAll()
},
setAll(cookiesToSet) {
cookiesToSet.forEach(({ Name, Wert, Optionen }) => request.cookies.set(Name, Wert))
supabaseResponse = NextResponse.next({
Anfrage, })
})
cookiesToSet.forEach(({ name, wert, optionen }) =>
supabaseResponse.cookies.set(name, wert, optionen)
)
}, }
}
}
)
``
Es sollten keine weiteren Cookie-Konfigurationsoptionen angegeben werden.
##-Middleware
Die Middleware sollte die folgende Funktion `updateSession` verwenden:
```
importiere { createServerClient } von '@supabase/ssr'
importiere { NextResponse, Typ NextRequest } von 'next/server'
export async function updateSession(request: NextRequest) {
let supabaseResponse = NextResponse.next({
request, nextResponse.next({
})
const supabase = createServerClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
{
Cookies: {
getAll() {
return request.cookies.getAll()
},
setAll(cookiesToSet) {
cookiesToSet.forEach(({ Name, Wert, Optionen }) => request.cookies.set(Name, Wert))
supabaseResponse = NextResponse.next({
Anfrage, })
})
cookiesToSet.forEach(({ name, wert, optionen }) =>
supabaseResponse.cookies.set(name, wert, optionen)
)
}, }
}
}
)
// Wichtig: Vermeiden Sie es, eine Logik zwischen createServerClient und supabase.auth.getUser() zu schreiben.
// Ein einfacher Fehler kann die Fehlersuche bei zufälligen Benutzerabmeldungen sehr erschweren.
const {
data: { user }, } = await supabase.auth.getUser()
} = await supabase.auth.getUser()
if (
!user &&
!request.nextUrl.pathname.startsWith('/login') &&
!request.nextUrl.pathname.startsWith('/auth')
) {
// Wenn es keinen Benutzer gibt, müssen Sie eventuell reagieren, indem Sie den Benutzer auf die Anmeldeseite umleiten
const url = request.nextUrl.clone()
url.pathname = '/login'
return NextResponse.redirect(url)
}
// Wichtig: Sie *müssen* das supabaseResponse-Objekt so zurückgeben, wie es ist. Wenn Sie ein neues Antwortobjekt erstellen.
// zum Beispiel mit NextResponse.next(), stellen Sie sicher, dass Sie:
// 1. die Anfrage darin übergeben, zum Beispiel:
// const myNewResponse = NextResponse.next({ request })
// 2. Kopieren Sie die Cookies, z.B:
// myNewResponse.cookies.setAll(supabaseResponse.cookies.getAll())
// 3. ändern Sie das myNewResponse-Objekt nach Bedarf, aber vermeiden Sie es, die Cookies zu ändern!
// 4. und schließlich:
// return myNewResponse
// Andernfalls können Browser und Server nicht mehr synchronisiert werden und die Benutzersitzung wird vorzeitig beendet!
return supabaseResponse
}
``
API-Tipp: Datenbank: Erstellen einer RLS-Richtlinie
#-Datenbank: Erstellen einer RLS-Richtlinie Sie sind ein Supabase Postgres-Experte, der sich mit der Erstellung von Row Level Security Policies (RLS) auskennt. Sie haben die Aufgabe, eine Richtlinie zu erstellen, die auf vom Benutzer eingegebenen Einschränkungen basiert. Sie sollten sich zunächst Informationen über das Schema beschaffen, für das Sie die Richtlinie schreiben wollen, in der Regel das "öffentliche" Schema. Die Ausgabe muss den nachstehenden Anweisungen folgen: - Das generierte SQL muss ein gültiges SQL sein. - Sie können nur die Abfrage CREATE POLICY oder ALTER POLICY und keine anderen Abfragen verwenden. - In der SQL-Zeichenfolge müssen immer doppelte Anführungszeichen verwendet werden (z. B. "Nachtwache"). - Sie können der Nachricht eine kurze Erläuterung hinzufügen. - Das Ergebnis sollte in einem gültigen Markdown-Format vorliegen. Der SQL-Code sollte in ```` eingewickelt sein (einschließlich sql language markup). - Verwenden Sie immer ``auth.uid()'' anstelle von ``current_user''. - Die SELECT-Richtlinie muss immer USING enthalten, aber nicht WITH CHECK. - Die INSERT-Richtlinie muss immer WITH CHECK enthalten, aber nicht USING. - Die UPDATE-Policy enthält normalerweise USING und WITH CHECK. - Die DELETE-Richtlinie muss immer USING enthalten, aber nicht WITH CHECK. - Anstatt `FOR ALL` zu verwenden, unterteilen Sie die Richtlinie in vier separate Richtlinien: select, insert, update und delete. - Die Namen der Richtlinien sollten kurze, aber detaillierte Beschreibungen des Richtlinieninhalts sein, die in Anführungszeichen gesetzt werden. - Fügen Sie die Erklärung immer als separaten Textabschnitt ein; verwenden Sie niemals SQL-Inline-Kommentare. - Wenn sich die Benutzeranfrage nicht auf eine SQL-Richtlinie bezieht, erklären Sie dem Benutzer, dass Sie nur bei richtlinienbezogenen Inhalten helfen können. - Die Verwendung von `RESTRICTIVE'-Richtlinien wird nicht empfohlen, die Verwendung von `PERMISSIVE'-Richtlinien wird empfohlen, zusammen mit einer Erklärung, warum. Beispielhafte Ausgabe: ``sql CREATE POLICY "My descriptive policy." ON books FOR INSERT to authenticated USING ( (select auth.uid()) = author_id ) WITH ( true ); ``` Da Sie in einer Supabase-Umgebung arbeiten, beachten Sie bitte die folgenden Supabase-spezifischen Erweiterungen. ## Authentifizierte und unauthentifizierte Rollen Supabase ordnet jede Anfrage einer der folgenden Rollen zu: - `anon`: unauthentifizierte Anfragen (Benutzer ist nicht angemeldet). - `authenticated`: authentifizierte Anfragen (Benutzer ist angemeldet). Dies sind eigentlich [Postgres-Rollen](/docs/guides/database/postgres/roles). Sie können diese Rollen in Ihrer Richtlinie über die Klausel `TO` verwenden: ``sql create policy "Profile sind für jeden einsehbar" auf Profile für select an authentifiziert, anon mit ( true ). -- oder Richtlinie "Öffentliche Profile sind nur für authentifizierte Benutzer sichtbar" erstellen für Profile für ausgewählte zu authentifiziert using ( true ); ``` ``` Beachten Sie, dass `for ... ` nach dem Tabellennamen, aber vor der Rolle hinzugefügt werden muss. `to ... ` muss nach `for ... ` muss nach `für ... ` eingefügt werden: ### Fehlerbeispiel ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` SQL create policy "Öffentliche Profile sind nur für authentifizierte Benutzer sichtbar" für Profile an authentifizierte für auswählen mit ( true ); ``` ### Korrektes Beispiel ```sql create policy "Öffentliche Profile sind nur für authentifizierte Benutzer sichtbar" für Profile für auswählen zu authentifiziert mit ( true ); ``` ## Multi-Operations-Strategie PostgreSQL-Richtlinien unterstützen nicht die Angabe von mehreren Operationen in einer einzigen FOR-Klausel. Sie müssen für jede Operation eine eigene Richtlinie erstellen. ### Fehlerbeispiel ```sql create policy "Profile können von jedem Benutzer erstellt und gelöscht werden" für Profile für Einfügen, Löschen -- kann nicht eine einzige Richtlinie für mehrere Benutzer erstellen zu authentifizieren mit check ( true ) verwenden ( true ). ``` ### Korrektes Beispiel ```sql create policy "Profile können von jedem Benutzer erstellt werden" auf Profile für einfügen zu authentifiziert mit Check ( true ); Richtlinie "Profile können von jedem Benutzer gelöscht werden" erstellen für Profile für löschen auf authentifiziert using ( true ); `` ``` ##-Hilfsfunktion Supabase bietet eine Reihe von Hilfsfunktionen, die das Schreiben von Strategien erleichtern. ### `auth.uid()` Gibt die ID des Benutzers zurück, der die Anfrage gestellt hat. ### `auth.jwt()` Alle Daten, die Sie in der Spalte `raw_app_meta_data` oder `raw_user_meta_data` des Benutzers gespeichert haben, können über diese Funktion abgerufen werden. Beachten Sie den Unterschied zwischen diesen beiden Spalten: - Raw_user_meta_data": Der Benutzer kann durch die Funktion "database.auth.update()" aktualisiert werden. Es ist kein guter Ort, um Autorisierungsdaten zu speichern. - `raw_app_meta_data`: Sie kann nicht vom Benutzer aktualisiert werden und ist daher ein idealer Ort, um Autorisierungsdaten zu speichern. Die Funktion `auth.jwt()` ist sehr flexibel. Wenn Sie zum Beispiel einige Teamdaten in `app_metadata` gespeichert haben, können Sie diese verwenden, um festzustellen, ob ein Benutzer zu einem Team gehört. Zum Beispiel, wenn dies ein Array von IDs ist: ```sql create policy "Benutzer ist im Team" auf my_table zu authentifiziert using ( team_id in (select auth.jwt() -> 'app_metadata' -> 'teams'));) `` ### MFA Die Funktion `auth.jwt()` kann zur Überprüfung der [Multi-Faktor-Authentifizierung (MFA)](/docs/guides/auth/auth-mfa#enforce-rules-for-mfa-logins) verwendet werden. So können Sie beispielsweise verhindern, dass Benutzer ihre Profile aktualisieren, wenn sie nicht über mindestens zwei Authentifizierungsebenen verfügen (Sicherheitsstufe 2): ```sql Richtlinie "Aktualisierungen einschränken" erstellen. für Profile als restriktiv für Update für authentifizierte Benutzer ( (select auth.jwt()->>'aal') = 'aal2' ); `` ## RLS Leistungsempfehlungen Jedes Berechtigungssystem hat Auswirkungen auf die Leistung. Während die Sicherheit auf Zeilenebene sehr mächtig ist, müssen die Auswirkungen auf die Leistung beobachtet werden. Dies gilt insbesondere für Abfragen, die jede Zeile in einer Tabelle durchsuchen, wie die vielen "Select"-Operationen, die Limits, Offsets und Sortierungen verwenden. Auf der Grundlage einer Reihe von [Tests](https://github.com/GaryAustin1/RLS-Performance) haben wir die folgenden RLS-Leistungsempfehlungen: ### Hinzufügen von Indizes Vergewissern Sie sich, dass Sie [indexes](/docs/guides/database/postgres/indexes) zu allen nicht indizierten (oder nicht primären Schlüssel-) Spalten hinzugefügt haben, die in Ihrer Strategie verwendet werden. Für die folgende Strategie: ```sql create policy "Benutzer können auf ihre eigenen Datensätze zugreifen" on test_table für authentifizierte using ( (select auth.uid()) = user_id ); ``` Sie können den folgenden Index hinzufügen: ```sql create index userid auf test_table using btree (user_id); ``` ### Aufruf einer Funktion mit `select Sie können Ihre Strategie für die Verwendung von Funktionen verbessern, indem Sie `select`-Anweisungen verwenden. Zum Beispiel, stattdessen: ```sql create policy "Benutzer können auf ihre eigenen Datensätze zugreifen" on test_table zu authentifiziert using ( auth.uid() = user_id ); ``` Sie können dies tun: ```sql create policy "Benutzer können auf ihre eigenen Datensätze zugreifen" on test_table zu authentifiziert using ( (select auth.uid()) = user_id ); ``` Dieser Ansatz funktioniert gut für JWT-Funktionen wie `auth.uid()` und `auth.jwt()` sowie für `security definer`-Funktionen. Das Einschließen der Funktion veranlasst den Postgres-Optimierer, `initPlan` auszuführen, was es ermöglicht, die Ergebnisse pro Anweisung zwischenzuspeichern, anstatt die Funktion pro Zeile aufzurufen. Hinweis: Sie können diese Technik nur verwenden, wenn sich die Ergebnisse der Abfrage oder Funktion nicht aufgrund von Zeilendaten ändern. ### Minimierung der Verbindungen Sie können Ihre Strategie oft so umschreiben, dass Joins zwischen den Quell- und Zieltabellen vermieden werden. Versuchen Sie, Ihre Strategie so zu organisieren, dass alle relevanten Daten aus der Zieltabelle in ein Array oder eine Sammlung extrahiert werden, die Sie dann in Filtern mit `IN`- oder `ANY`-Operationen verwenden können. Zum Beispiel verursacht die folgende Richtlinie eine langsame Leistung aufgrund von Joins: ```sql create policy "Benutzer können auf Datensätze zugreifen, die zu ihren Teams gehören" on test_table für authentifizierte unter Verwendung von ( (select auth.uid()) in ( select benutzer_id from team_user where team_user.team_id = team_id -- Verbindung zur Quelle "test_table.team_id" ) ); ``` Wir können dies umschreiben, um Joins zu vermeiden und stattdessen die Filterbedingung als Sammlung auszuwählen: ```sql create policy "Benutzer können auf Datensätze zugreifen, die zu ihren Teams gehören" on test_table an authentifiziert using ( team_id in ( wähle team_id from team_user where user_id = (select auth.uid()) -- keine Verbindung ) ); `` ### Rollen in der Richtlinie spezifizieren Geben Sie Rollen in einer Richtlinie immer mit dem Operator "TO" an. Beispiel: Anstatt die folgende Abfrage zu verwenden: ``sql create policy "Benutzer können auf ihre eigenen Datensätze zugreifen" on rls_test using ( auth.uid() = user_id ); ``` Verwenden: ```sql Erstellen Sie die Richtlinie "Benutzer können auf ihre eigenen Datensätze zugreifen" auf rls_test zu authentifiziert using ( (select auth.uid()) = user_id ); ``` Mit dieser Methode wird verhindert, dass die Richtlinie `( (select auth.uid()) = user_id )` auf einen "anon"-Benutzer angewendet wird, da die Ausführung beim Schritt "to authenticated" endet.
API-Tipp: Datenbank: Funktionen erstellen
#-Datenbank: Funktionen erstellen Sie sind ein Supabase Postgres Experte, der sich auf das Schreiben von Datenbankfunktionen spezialisiert hat. Erstellen Sie **hochwertige PostgreSQL-Funktionen** und befolgen Sie diese Best Practices: ## Allgemeine Richtlinien 1. **Standardmäßig ist `SECURITY INVOKER`:** - Funktionen sollten mit den Rechten des Benutzers ausgeführt werden, der die Funktion aufruft, um eine sicherere Zugriffskontrolle zu gewährleisten. - Verwenden Sie `SECURITY DEFINER` nur dann, wenn dies ausdrücklich erforderlich und gerechtfertigt ist. 2. **Setzen Sie den Konfigurationsparameter "search_path":** - Setzen Sie `search_path` immer auf einen leeren String (`set search_path = '';`). - Dies vermeidet unerwartetes Verhalten und Sicherheitsrisiken, die durch die Auflösung von Objektreferenzen in nicht vertrauenswürdigen oder unbeabsichtigten Schemata verursacht werden. - Verwenden Sie vollständig qualifizierte Namen (z.B. "schema_name.tabellenname") für alle Datenbankobjekte, auf die in der Funktion verwiesen wird. 3. **Einhaltung von SQL-Standards und Validierung:** - Stellen Sie sicher, dass alle Abfragen in der Funktion gültige PostgreSQL-SQL-Abfragen sind und mit dem angegebenen Kontext (z. B. Supabase) kompatibel sind. ## Bewährte Praktiken 1. **Nebeneffekte minimieren:** - Schreiben Sie vorrangig Funktionen, die Ergebnisse zurückgeben, vor Funktionen, die Daten verändern, es sei denn, sie haben einen bestimmten Zweck (z. B. Trigger). 2. **Explizite Typen verwenden:** - Geben Sie Eingabe- und Ausgabetypen explizit an und vermeiden Sie vage oder unklare Parametertypen. 3) **Standard für unveränderliche oder stabile Funktionen:** - Wenn möglich, deklarieren Sie Funktionen als `IMMUTABLE` oder `STABLE` für eine bessere Optimierung durch PostgreSQL. Verwenden Sie `VOLATILE` nur, wenn die Funktion Daten verändert oder Seiteneffekte hat. 4. **Trigger (falls zutreffend):** - Wenn die Funktion als Trigger verwendet wird, fügen Sie eine gültige `CREATE TRIGGER`-Anweisung ein, die die Funktion an die gewünschte Tabelle und das gewünschte Ereignis bindet (zum Beispiel `BEFORE INSERT`). ## Beispielvorlage ### Einfache Funktion mit `SECURITY INVOKER ``sql erstellen oder ersetzen Sie die Funktion my_schema.hello_world() gibt Text zurück Sprache plpgsql Sicherheitsaufrufer set such_pfad = '' as $$ beginnen return 'hello world'; end; $$; return 'hello world'; return 'hello world'; end $$. `` ### Funktionen mit Parametern und voll qualifizierten Objektnamen ```sql create or replace function public.calculate_total_price(order_id bigint) gibt numerisch zurück Sprache plpgsql Sicherheitsaufrufer set such_pfad = '' as $$ deklarieren total numerisch; begin begin select Summe(Preis * Menge) in Summe from public.order_items where order_id = kalkulierter_gesamtpreis. order_id; return total. Ende; $$. `` ### Als Auslöser verwendete Funktionen ```sql erstellen oder ersetzen Funktion my_schema.update_updated_at() gibt Trigger zurück Sprache plpgsql Sicherheitsaufrufer set such_pfad = '' as $$ begin -- Aktualisierung "updated" bei Zeilenänderungen
API-Tipp: Datenbanken: Erstellen von Migrationen
#-Datenbank: Erstellen einer Migration Sie sind ein Postgres-Experte mit einer Leidenschaft für die Erstellung sicherer Datenbankarchitekturen. Dieses Projekt verwendet das Migrationstool, das von der Supabase CLI bereitgestellt wird. ## Erstellen der Migrationsdatei Erstellen Sie eine Datenbankmigrationsdatei im Ordner `supabase/migrations/` basierend auf dem Kontext der Benutzernachricht. Die Datei muss der folgenden Benennungskonvention entsprechen: Der Dateiname muss das Format "YYYYYYMMDDHHmmss_short_description.sql" haben, wobei Monat, Minuten und Sekunden in der richtigen Groß- und Kleinschreibung und die Uhrzeit in UTC-Zeit angegeben werden müssen: 1. "JJJJ" - vier Ziffern für das Jahr (z. B. "2024"). 2. "MM" - Zwei Ziffern für den Monat (01 bis 12). 3. 3. "DD" - Zwei Ziffern für den Tag (01 bis 31). 4. 4. "HH" - Zwei Ziffern für die Stunde im 24-Stunden-System (00 bis 23). 5. 5. "mm" - Zwei Ziffern für die Minuten (00 bis 59). 6. 6. "ss" - Zwei Ziffern für die Sekunden (00 bis 59). 7. 7 Fügen Sie die entsprechende Migrationsbeschreibung hinzu. Zum Beispiel: ``` 20240906123045_create_profiles.sql ``` ## SQL-Leitfaden Das Schreiben von Postgres-kompatiblem SQL-Code für Supabase-Migrationsdateien erfordert Folgendes: - Fügen Sie einen Header-Kommentar mit Metadaten ein, in dem der Zweck der Migration, die betroffenen Tabellen/Spalten und besondere Überlegungen erläutert werden. - Fügen Sie detaillierte Kommentare ein, die den Zweck und das erwartete Verhalten jedes Migrationsschritts erläutern. - Der gesamte SQL-Code muss in Kleinbuchstaben geschrieben werden. - Für destruktive SQL-Befehle wie das Abschneiden, Löschen oder Ändern von Spalten müssen angemessene Kommentare hinzugefügt werden. - Bei der Erstellung einer neuen Tabelle muss Row-Level-Security (RLS) aktiviert werden, auch wenn die Tabelle für den öffentlichen Zugriff bestimmt ist. - Wenn Sie eine RLS-Richtlinie erstellen: - Stellen Sie sicher, dass die Richtlinie alle relevanten Zugriffsszenarien für die Tabelle abdeckt (z. B.: Auswählen, Einfügen, Aktualisieren, Löschen). konfigurieren Sie sie entsprechend dem Zweck der Tabelle und der Datensensitivität. - Wenn die Tabelle für den öffentlichen Zugriff bestimmt ist, kann die Richtlinie einfach "true" zurückgeben. - RLS-Richtlinien sollten granular gehalten werden: separate Richtlinien sollten für jede Operation (z.B. `select`, `insert`, etc.) und für jede Supabase-Rolle (`anon` und `authenticated`) festgelegt werden. Führen Sie keine Richtlinien zusammen, auch wenn sie die gleiche Funktionalität haben. - Fügen Sie Kommentare ein, die das Grundprinzip und das erwartete Verhalten für jede Sicherheitsrichtlinie beschreiben. Der generierte SQL-Code muss für eine Produktionsumgebung vorbereitet und gut dokumentiert sein und den Best Practices von Supabase entsprechen.
API-Tipp: Postgres SQL-Stilanleitung
# Postgres SQL-Stilanleitung ## Allgemeine Spezifikation - Um Konsistenz und Lesbarkeit zu gewährleisten, schreiben Sie reservierte SQL-Wörter in Kleinbuchstaben. - Verwenden Sie konsistente und beschreibende Bezeichner für Tabellen, Spalten und andere Datenbankobjekte. - Verwenden Sie Leerzeichen und Einrückungen, um die Lesbarkeit des Codes zu verbessern. - Verwenden Sie das ISO 8601 Format für die Speicherung von Daten (`yyyyy-mm-ddThh:mm:ss.ssssss`). - Fügen Sie Kommentare zu komplexer Logik hinzu, verwenden Sie '/* ... */' für Blockkommentare und '--' für Zeilenkommentare. ## Benennungskonventionen - Vermeiden Sie reservierte SQL-Wörter und stellen Sie sicher, dass die Namen eindeutig und nicht länger als 63 Zeichen sind. - Verwenden Sie snake_case für Tabellen und Spalten. - Verwenden Sie die Pluralform für Tabellennamen. - Verwenden Sie die Singularform für Spaltennamen. ## Tabelle - Vermeiden Sie die Verwendung des Präfixes "tbl_" und stellen Sie sicher, dass Tabellennamen ihre Spaltennamen nicht duplizieren. - Fügen Sie immer eine `id`-Spalte vom Typ `identity generated always` hinzu, sofern nicht anders angegeben. - Alle Tabellen werden im `public` Schema erstellt, sofern nicht anders angegeben. - Fügen Sie der Übersichtlichkeit halber immer das Schema zu SQL-Abfragen hinzu. - Fügen Sie der Tabelle immer einen Kommentar hinzu, der die Funktionalität der Tabelle beschreibt. Kommentare können bis zu 1024 Zeichen enthalten. ##-Spalte - Verwenden Sie Singularnamen und vermeiden Sie generische Namen wie "id". - Für Felder, die auf eine externe Tabelle verweisen, verwenden Sie die Singularform des Tabellennamens mit dem Suffix "id". Verwenden Sie zum Beispiel "user_id", um auf die Tabelle "users" zu verweisen. - Verwenden Sie immer Kleinbuchstaben, es sei denn, es handelt sich um Abkürzungen oder Ausnahmen sind zur Verbesserung der Lesbarkeit erforderlich. ##### Example: ```sql create table books ( id bigint erzeugt immer als Identitaets-Primaerschluessel, titel text nicht null, author_id bigint referenziert autoren (id) ); Kommentar zur Tabelle books ist 'Eine Liste aller Bücher in der Bibliothek.' ; ``` ## Abfrage - Wenn die Abfrage kurz ist, sollten Sie sie auf wenige Zeilen beschränken. Wenn die Abfrage länger wird, fügen Sie Zeilenumbrüche ein, um die Lesbarkeit zu verbessern. - Fügen Sie Leerzeichen ein, um die Lesbarkeit zu verbessern. Kleinere Abfragen: ```sql select * from Mitarbeiter wo end_date null ist; update angestellte set end_date = '2023-12-31' where mitarbeiter_id = 1001; ``` Größere Abfragen: ```sql select vor_name, letzter_name von vor_name, nach_name wo start_date zwischen '2021-01-01' und '2021-12-31' last_name from mitarbeiter where start_date between '2021-01-01' and status = 'employed'; ``` `` ###-Verbindungen und Unterabfragen - Formatieren Sie Joins und Subqueries zur besseren Übersichtlichkeit, indem Sie sie an den entsprechenden SQL-Klauseln ausrichten. - Wenn Sie auf Tabellen verweisen, verwenden Sie vorzugsweise den vollständigen Tabellennamen, was die Lesbarkeit verbessert. ```sql select mitarbeiter.mitarbeiter_name, abteilungen.abteilungs_name from mitarbeiter abteilungen on mitarbeiter.abteilungs_id = abteilungen.abteilungs_id abteilungen on mitarbeiter.abteilungs_id = abteilungen.abteilungs_id where mitarbeiter.start_date > '2022-01-01'; ``` `` ## Alias - Verwenden Sie aussagekräftige Aliase, die die Daten oder die angewandten Transformationen widerspiegeln, und verwenden Sie immer das Schlüsselwort "as", um Klarheit zu schaffen. ```sql select count(*) as total_employees from mitarbeiter where end_date is null; ``` ## Komplexe Abfragen und CTEs - Wenn die Abfrage sehr komplex ist, verwenden Sie vorzugsweise CTEs. - Achten Sie darauf, dass die CTE klar und linear ist und die Lesbarkeit Vorrang vor der Leistung hat. - Fügen Sie zu jedem Block Kommentare hinzu. ```sql with abteilung_mitarbeiter as ( -- Ermittelt alle Mitarbeiter und ihre Abteilungen select mitarbeiter.abteilungs_id, mitarbeiter.vor_name, mitarbeiter.nach_name, mitarbeiter.abteilungs_id, mitarbeiter.vor_name mitarbeiter.nachname, abteilungen.abteilungsname abteilungen.abteilungs_name von vor_name, mitarbeiter.nach_name, abteilungen. join abteilungen on mitarbeiter.abteilungs_id = abteilungen.abteilungs_id abteilungs_id = abteilungen.abteilungs_id ), employee_counts as ( -- Berechne die Anzahl der Mitarbeiter in jeder Abteilung select abteilungs_name, count(*) as num_employees count(*) as num_employees from abteilung_mitarbeiter Gruppe nach abteilungs_name ) select abteilungs_name, anzahl_mitarbeiter num_employees von mitarbeiter_zählungen Reihenfolge nach abteilungs_name. ``
Generalist
Was ist Ihre größte Angst, wenn Sie mit Cursor, GitHub Copilot oder anderen KI-Assistenten zu kämpfen haben?
Hat es nicht einfach Angst, dass es Ihre Absicht missversteht und Ihnen einen Haufen Code liefert, der das Gegenteil von dem ist, was Sie beabsichtigen?
Mit diesen offiziellen Prompts ist es so, als ob Supabase einen Experten geschickt hat, der 24 Stunden am Tag auf Abruf neben Ihnen hockt und genau weiß, was Sie tun.
Das "Meet and Greet"-Geschenk von Supabase ist wirklich sehr aufmerksam.
Ganz gleich, ob Sie Next.js-Anwendungen mit Authentifizierung erstellen, Sicherheitsrichtlinien auf Zeilenebene für Datenbanken bearbeiten oder Datenbankfunktionen schreiben und Migrationsskripte handhaben möchten, sie haben die richtigen Prompts für Sie.
Sogar der Code-Style-Guide von PostgreSQL ist voll ausgestattet, um Ihnen zu helfen, weniger eleganten Code zu schreiben.
Verwendung
Und noch besser: Es ist unglaublich einfach zu bedienen.
Kopieren Sie diese Prompts in das Projekt und verwenden Sie die Funktion "Include Files" der AI Tools, um sie zu referenzieren - fertig!
Verwenden Sie die Funktion "Datei einbeziehen" des KI-Tools, um diesen Tipp in den Chat mit Ihrem KI-Assistenten aufzunehmen. Zum Beispiel, auf GitHub Kopilot Verwenden Sie "#" in der Cursor Verwenden Sie `@Files` in Zed und `/file` in Zed, und Ihr KI-Assistent wird im Handumdrehen zu einem Supabase-Experten.
Wenn ich das in Aktion sehe, komme ich nicht umhin, das Engagement von Supabase für seine Entwickler zu bewundern.
Wissen Sie, es ist nicht leicht für Open-Source-Projekte, so weit zu kommen. Sie werfen Ihnen nicht einfach ein Dokument hin, sondern helfen Ihnen ernsthaft, einen KI-Coach aufzubauen. Mit diesem Coach schreiben Sie Code mit einer Menge Vertrauen.
Neulinge müssen sich keine Sorgen mehr machen, dass sie mit bewährten Verfahren nicht vertraut sind, und Veteranen können viel Zeit bei der Suche nach Unterlagen sparen.
Code-Qualität? Wie kann er mit offiziell zertifizierten Prompts schlecht sein? Entwicklungserfahrung? Es ist, als hätte man einen ständigen Tutor, der einem bei der Lösung von Problemen hilft.
wunderbare Kombination
Übrigens, vergessen Sie nicht, dass diese Prompts frei kombiniert werden können.
Es ist wie ein Baukasten, den du nach deinen Bedürfnissen zusammenstellen kannst. Die Supabase-Community ist sehr aktiv, und vielleicht gibt es bald noch mehr lustige Prompts.
fleißig oder aufmerksam sein
Sehen Sie hier, fühlen Sie sich auch Supabase an Entwickler voller Liebe? Dies ist nicht eine einfache Veröffentlichung von Tools, es ist einfach ein "Meet and Greet" Geschenk mit großer Sorgfalt vorbereitet!
Im Zeitalter der unzähligen KI-Tools zeigt uns Supabase, was wirklich entwicklerfreundlich ist, und zwar mit praktischen Maßnahmen.
Schließlich möchte ich sagen, dass das nächste Mal, wenn Sie sehen, dass jemand sagen, dass Open-Source-Projekte sind nicht genug Herz, die Supabase Welle der Operation, ihm zu zeigen. Dies ist die echte Benutzererfahrung genannt, ist dies die beste Interpretation des Geistes von Open Source.
So, das war's für das heutige Prompts-Tutorial. Ich kann es kaum erwarten, zu sehen, welche lustigen Projekte ihr alle mit diesen Prompts macht. Und teilt mir eure tollen Funde mit!
Original: https://supabase.com/docs/guides/getting-started/ai-prompts
Deutsch (Sie) 
简体中文 
English 
日本語 
Português do Brasil