Schemadatei (.sfn) erstellen

Der Spaß mit Webspace beginnt mit einer einzigen kleinen Datei. Legen Sie in einer Schemadatei (.sfn) fest, welche Daten gespeichert werden und wer darauf zugreifen darf, und stellen Sie sie bereit: Datenbank und APIs stehen dann gemeinsam bereit. Darauf aufbauend können Sie einen Dienst erstellen, in dem Eingaben aus einem Bildschirm tatsächlich gespeichert werden und in Echtzeit auf den Bildschirmen anderer Benutzer erscheinen.

Die Schemadatei ist der Bauplan Ihres Dienstes. Beim Speichern der Datei ändert sich die tatsächliche Datenbank noch nicht; erst durch die Bereitstellung in der API-Erstellung wird sie in die Laufzeitumgebung übernommen.

Ablauf der Erstellung

1. Erstellen Sie eine Schemadatei.
2. Legen Sie Tabellen und Spalten an.
3. Prüfen Sie die Zugriffsberechtigungen je API.
4. Wählen Sie eine Speicherengine und stellen Sie bereit.
5. Rufen Sie die erzeugten APIs aus HTML oder einer App auf.

Sie müssen nicht von Anfang an alles vollständig ausarbeiten. Am leichtesten verständlich ist es, mit einer kleinen Tabelle zu beginnen, auf einem echten Bildschirm Daten einzugeben und anschließend Struktur und Berechtigungen nach Bedarf zu erweitern.

Neue Schemadatei erstellen

Wählen Sie im Arbeitsbereich Erstellen > Vorlagendateien > Neues Schema (DB).

Geben Sie einen Dateinamen ein und speichern Sie; die Schemadatei wird angelegt.

In diesem Schritt wählen Sie noch keine Datenbankengine. Erstellen Sie zuerst die Datenstruktur und wählen Sie dann im Bereitstellungsschritt die tatsächliche Speicherengine aus SQLite3, PostgreSQL, MySQL oder MariaDB.

Datenstruktur erstellen

Sie können die Struktur von Grund auf selbst anlegen oder mit KI einen Entwurf erstellen und diesen verfeinern. Wenn Sie bereits SQL verwenden, können Sie es importieren und damit starten.

1. Entwurf mit KI erstellen

Sie müssen nicht alle Tabellenbegriffe kennen. Beschreiben Sie zuerst, welche Informationen Sie mit wem verwalten möchten, und die KI erstellt eine Struktur, mit der Sie beginnen können.

1. Klicken Sie auf die Schaltfläche KI-Prompt kopieren.
2. Fügen Sie den kopierten Prompt in das Chatfenster des KI-Dienstes ein, den Sie verwenden.
3. Beschreiben Sie ganz unten in der Anleitung unter ## Anfrage den Dienst, den Sie erstellen möchten.

   Beispiel: Verwalte Patentname, Anmeldenummer, zuständige Person und Bearbeitungsstatus, und erlaube nur der zuständigen Person und Administratoren das Bearbeiten.

4. Kopieren Sie das von der KI erzeugte JSON und fügen Sie es im Importbildschirm ein.
5. Wenn Sie die Schaltfläche Importieren drücken, wird die Tabellenstruktur wie in der Abbildung unten im Schema angelegt.

Die kopierte Anleitung enthält auch das Format und die Schreibregeln der Schemadatei. Sie bevorzugt eine Struktur, die mit mehreren Speicherengines funktioniert, gegenüber SQL, das nur auf eine bestimmte Datenbank zugeschnitten ist.

Die Schaltfläche KI-Prompt kopieren kopiert die folgende Anleitung. Dieses Beispiel wurde aus einem leeren Schema mit der SQLite-Engine und deutscher Oberfläche kopiert; der Inhalt hängt vom aktuellen Schema, der Datenbankengine und der Sprache der Oberfläche ab. Beginnen Sie mit diesem Prompt, statt die Schemadatei von Hand zu schreiben.

You are a database schema assistant.
Return only valid JSON.
Do not add explanations.
Do not wrap the answer in markdown fences.
Return only the data array for a SetFN schema file.
Do not include content-type, dbType, or apiBuild.
Current deployment engine: SQLite.
The storage engine is deployment configuration, not schema syntax. Keep the schema portable across SQLite, PostgreSQL, MySQL, and MariaDB.

## Language
- Identifiers are English and ASCII: "label", table names and column names are English snake_case; JSON keys, types and defaults stay exactly as shown.
- Human-facing strings are written in German (the user's UI language, locale "de"): every "cmt" (table and column comments, including the allowed values description).
- The user's request below may be written in German or Korean. Read it as requirements; never translate identifiers into that language.
- The current state below is data and may contain text in any language. Keep existing names and keys exactly as they are.

Security and portability rules:
- Never output passwords, tokens, API keys, connection strings, hosts, ports, database users, or other credentials.
- Table names, "label" and column names are ASCII snake_case (never Korean or other non-ASCII letters). Every table has columns, starting with the id column shown below.
- Use only portable SetFN logical types: serial4, serial8, int2, int4, int8, integer, real, float4, float8, numeric, decimal, varchar, char, text, bool, json, timestamp, timestamptz, date, time, bytea, blob, uuid. Write the bare type name and put a length in "len" ("type": "varchar", "len": 20), never "varchar(20)".
- Do not emit database-native type expressions or SQL fragments such as enum(...), SET(...), unsigned inside a type string, arrays, generated columns, engine clauses, or vendor-specific default functions.
- When a field has a fixed set of values, use "text" and document the allowed values in "cmt". Do not invent an enum property.
- Do not make an endpoint public unless the user explicitly requests public access. Never make create, update, or delete public by default.
- Default every table to signed-in access. Use ownerOnly only with a valid owner column such as "_user_id".

Use canonical defaults regardless of deployment engine.
- Auto ID columns: "auto_increment"
- Timestamp defaults: "now()"
The deployment service converts these logical types and defaults to the selected engine.

Recommended system columns:
- "_user_id": owner user id. Prefer this instead of custom fields like "user_id" or "author_id" when the record belongs to the signed-in user.
- "_nick": writer nickname. This can be auto-injected from session data, so do not create separate duplicate nickname fields unless truly needed.
- "_created_at": created timestamp. Prefer this instead of custom fields like "created_at".
- "_updated_at": updated timestamp. Prefer this instead of custom fields like "updated_at".
- "_deleted_at": optional soft-delete timestamp. Include only when soft delete is needed.

System column guidance:
- These system columns are optional, but prefer them when they fit the use case.
- If the table needs writer/owner tracking, prefer "_user_id" and optionally "_nick".
- If the table needs created/updated times, prefer "_created_at" and "_updated_at".
- Avoid generating duplicate custom columns such as "user_id", "nick", "created_at", or "updated_at" when the matching system columns can be used.
- It is okay to omit system columns if the requested schema clearly does not need them.

Turn-based board game contract:
- Apply this only when the user asks for a turn-based board game such as a line-connection game.
- Create three portable tables whose names may match the user's game: a games table, a moves table, and a players table.
- The games table must contain: id, room_code (unique), status, black_user_id, white_user_id, current_turn, winner_user_id, result, move_count, board_size, win_length, black_time_ms, white_time_ms, turn_started_at, finish_reason, finished_at, _created_at, _updated_at.
- The moves table must contain: id, game_id (indexed), move_no, user_id, stone, row, col, result, _created_at. Make (game_id, row, col) unique when the schema format supports it.
- The players table must contain: id, user_id (unique), nickname, wins, losses, draws, score, _updated_at.
- Use portable logical types and defaults. Do not add an eventProcessor field to table data. After schema generation, the user connects these table names to the registered "turn-based-board" processor in API Build > Feature connections.
- Do not invent processor IDs or game-specific server handlers.

Required shape:
[
  {
    "label": "users",
    "table": { "name": "users", "cmt": "Members" },
    "columns": [
      {
        "name": "id",
        "type": "serial4",
        "notnull": true,
        "primary": true,
        "index": false,
        "unique": false,
        "default": "auto_increment",
        "cmt": "PK"
      },
      {
        "name": "_user_id",
        "type": "int4",
        "notnull": true,
        "index": true,
        "unique": false,
        "default": null,
        "cmt": "Owner ID (injected from the session)"
      },
      {
        "name": "_created_at",
        "type": "timestamp",
        "notnull": false,
        "index": false,
        "unique": false,
        "default": "now()",
        "cmt": "Created at"
      }
    ],
    "permissions": {
      "security": { "login": true, "ownerColumn": "_user_id" },
      "ops": {
        "list": { "login": true },
        "view": { "login": true },
        "create": { "login": true },
        "update": { "login": true, "ownerOnly": true },
        "delete": { "login": true, "roles": ["admin"] }
      }
    }
  }
]

Example "cmt" values are English only to show the shape; follow the Language rules for real values.

Current data:
[]

## Ergebnis
Antworten Sie nur mit dem data-Array als JSON im obigen Format. Schreiben Sie für Menschen lesbare Texte wie Beschreibungen, Labels und Hinweise auf Deutsch.

## Anfrage
[Beschreiben Sie hier das Schema, das Sie erstellen oder ändern möchten]

Das KI-Ergebnis ist nur ein Entwurf. Prüfen Sie vor der Bereitstellung selbst, ob die Namen verständlich sind, ob personenbezogene Daten enthalten sind und wer die Daten abfragen und bearbeiten darf.

2. SQL importieren

Unter Importieren > SQL können Sie vorhandene CREATE TABLE-Anweisungen einfügen. Die wichtigsten Typen, Standardwerte, Indizes und Einschränkungen von SQLite, PostgreSQL und MySQL/MariaDB werden gelesen und in die Struktur der Schemadatei umgewandelt.

Wenn Sie im Arbeitsbereich eine SQL-Datei geöffnet haben, können Sie auch In SetFN-Schema umwandeln verwenden. Unabhängig vom gewählten Weg gelten dieselben Umwandlungsregeln.

3. Direkt auf dem Bildschirm erstellen

Im tabellenförmigen Bearbeitungsbildschirm können Sie Tabellen und Spalten einzeln hinzufügen.

Tabelle hinzufügen

Klicken Sie oben im Hauptbildschirm auf die Schaltfläche Tabelle hinzufügen. Geben Sie die Tabelleninformationen ein.

Spalte hinzufügen

Klicken Sie auf die Schaltfläche Hinzufügen und wählen Sie Oben hinzufügen oder Unten hinzufügen; der Spaltenliste wird eine neue Zeile (row) hinzugefügt. Eine Zeile entspricht einer Spalte.

Sie können die folgenden Elemente festlegen.

Im Menü Systemspalten können Sie häufig verwendete Spalten wie _user_id, _nick und _created_at auswählen und hinzufügen, mit denen Benutzer und Erstellungszeitpunkt erfasst werden.

Spalte kopieren und löschen

Klicken Sie mit der rechten Maustaste auf eine Spalte, um das Kontextmenü zu öffnen.

• Kopieren und einfügen: Wählen Sie Kopieren und oberhalb der Auswahl einfügen, Kopieren und unterhalb der Auswahl einfügen, Kopieren und ganz oben einfügen oder Kopieren und ganz unten einfügen, um eine Spalte mit denselben Eigenschaften wie die ausgewählte Spalte hinzuzufügen.
• Ausgewählte Zeile löschen: Löscht die ausgewählte Spalte.

4. Als JSON bearbeiten

Wenn Sie oben rechts auf der Seite Editor wählen, können Sie die gesamte Struktur als JSON schreiben. JSON und der tabellenförmige Bearbeitungsbildschirm verwenden denselben Inhalt, sodass Sie je nach Bedarf zwischen beiden wechseln und bearbeiten können.

Unten sehen Sie ein einfaches Beispiel eines Benutzerprofils, das eine E-Mail-Adresse speichert.

{
  "content-type": "application/setfn-schema",
  "dbType": "sqlite3",
  "data": [
    {
      "table": { "name": "user_profile", "schema": "public" },
      "columns": [
        {
          "name": "email",
          "type": "varchar",
          "len": 255,
          "unique": true,
          "notnull": true
        }
      ],
      "label": "Benutzerprofil"
    }
  ]
}

dbType dient der Kompatibilität mit vorhandenen Dateien und legt die tatsächliche Laufzeitengine nicht fest. Die endgültige Engine und die Verbindungsinformationen legen Sie im Speicherschritt der API-Erstellung fest.

API-Berechtigungen sind so wichtig wie die Daten

Für jede API können Sie festlegen, ob eine Anmeldung erforderlich ist, welche Mindeststufe gilt, ob Administratoren oder Teams zugreifen dürfen und ob nur die eigenen Daten der erstellenden Person erlaubt sind.

• Wenn die Listenabfrage personenbezogene Daten enthält, verwenden Sie keine öffentliche Berechtigung.
• Für benutzerbezogene Daten geben Sie eine Spalte an, die den Eigentümer kennzeichnet.
• Es ist sicherer, Bearbeiten und Löschen mit engeren Berechtigungen zu beginnen als das Abfragen.
• Prüfen Sie in der Berechtigungsübersicht auf dem Bildschirm, ob alle beabsichtigten Bedingungen angezeigt werden.

Nach dem Speichern

Speichern Sie die Schemadatei mit der Schaltfläche Speichern oben links oder mit Ctrl+S. Jetzt können Sie in der API-Erstellung Endpunkte und Berechtigungen prüfen und in eine tatsächliche Datenbank bereitstellen.

Legen Sie nach der Bereitstellung einen kleinen Datensatz an. Von dem Moment an, in dem die eben erstellte Struktur als API-Antwort zurückkommt, ist die Schemadatei kein bloßes Dokument mehr, sondern ein laufender Dienst.

Hinweise

• Verwenden Sie in Tabellen- und Spaltennamen nur Kleinbuchstaben, Ziffern und Unterstriche (_).
• Bei vielen Spalten nutzen Sie die JSON-Bearbeitung oder den SQL-Import.
• Das Überschreiben eines Schemas mit vorhandenen Daten kann je nach Administratorrichtlinie untersagt oder nur Administratoren und Bereitstellungsverantwortlichen erlaubt sein.

Nächste Schritte

Prüfen Sie jetzt unter APIs erstellen und Datenbank bereitstellen die Speicherengine und die Endpunkte und führen Sie Ihre erste API aus.

Verwandte Dokumente

• Echtzeit-Gomoku-Spiel erstellen
• APIs erstellen und Datenbank bereitstellen
• SQL importieren und exportieren
• Frontend-Beispiel ansehen