JSON in SQL umwandeln

Klicken Sie, um JSON in SQL INSERT-Anweisungen zu konvertieren

Kostenloser Online-Konverter für JSON in SQL. JSON-Arrays in INSERT-Anweisungen umwandeln und optional CREATE-TABLE-DDL-Skripte erzeugen. Unterstützt MySQL, PostgreSQL, SQLite, SQL Server und über 20 SQL-Dialekte mit automatischer Typinferenz. Komplett clientseitig, keine Daten verlassen den Browser.

Über JSON in SQL: JSON-Daten in relationale Datenbanken überführen

JSON in SQL bedeutet, JSON-formatierte Daten (JSON-Arrays oder -Objekte) in SQL-Skripte umzuwandeln, die eine relationale Datenbank ausführen kann – konkret INSERT-Anweisungen und CREATE-TABLE-Anweisungen. JSON (JavaScript Object Notation) ist ein leichtgewichtiges Datenaustauschformat, das überall verwendet wird: REST-APIs, Frontend-zu-Backend-Transport, Konfigurationsdateien, Log-Records. Relationale Datenbanken (MySQL, PostgreSQL, SQLite, SQL Server, Oracle usw.) sind das Rückgrat der Unternehmensdatenspeicherung, benötigen jedoch strenge Tabellenschemata und SQL-Anweisungen. Um Daten aus JSON in eine relationale Datenbank zu überführen, muss das JSON in ein SQL-Skript verwandelt werden.

Im Kern wandelt das Tool jedes Objekt eines JSON-Arrays in eine Datenbankzeile um. Ein einzelnes Objekt wird als eine einzelne Zeile behandelt, jedes Element eines JSON-Arrays wird zu einer Zeile. Objektschlüssel werden zu Spaltennamen, Werte werden in passende SQL-Literale übersetzt. Die gesamte Konvertierung läuft lokal im Browser, ohne Backend.

Typinferenz ist die zentrale technische Herausforderung von JSON in SQL. JSON kennt nur sechs primitive Typen (null, boolean, number, string, array, object), SQL dagegen Dutzende (INT, BIGINT, FLOAT, DOUBLE, VARCHAR, TEXT, DATE, TIMESTAMP, BOOLEAN, BIT usw.). Die detectType-Funktion in diesem Tool betrachtet die literale Form jedes Wertes: null wird zu SQL NULL; true/false zu BOOLEAN; Ganzzahlen zu INT (Bereich -2.147.483.648 bis 2.147.483.647) oder BIGINT; Gleitkommazahlen je nach Dialekt zu FLOAT/DOUBLE/REAL; ISO-8601-Datums- und Zeitstempel-Strings zu DATE bzw. TIMESTAMP; kurze Strings zu VARCHAR(255); Strings über 255 Zeichen zu TEXT.

Konflikte zwischen Zeilen erfordern besondere Behandlung. Ist die erste Zeile einer Spalte INT und die zweite FLOAT, kann die Spalte nicht einfach als INT definiert werden, ohne Dezimalstellen zu verlieren. Das Tool implementiert einen Typ-Hochstufungs-Algorithmus: Wenn der bestehende Spaltentyp mit einem neuen Wert kollidiert, wird auf den weitesten Typ hochgestuft, der beide abdeckt (zum Beispiel INT zu FLOAT). NULL fließt nicht in diese Entscheidung ein, sodass der abgeleitete Typ stabil bleibt. Da der endgültige Spaltentyp erst nach Verarbeitung aller Zeilen festgelegt wird, ist das Ergebnis der global optimale Typ für den Datensatz.

Dialektunterschiede sind eine weitere große Herausforderung. MySQL kapselt Bezeichner in Backticks (`name`), PostgreSQL und Standard-SQL in doppelte Anführungszeichen ("name"), SQL Server in eckige Klammern ([name]). SQLite hat keinen nativen BOOLEAN-Typ, daher wird 1/0 verwendet. BigQuery nutzt INT64 für Ganzzahlen und STRING für Text. Snowflake nutzt NUMBER für Ganzzahlen und TIMESTAMP_NTZ für Zeitstempel. Oracle nutzt VARCHAR2 und NUMBER(1) für Booleans. DB2 speichert Text in CLOB. Das Tool zentralisiert all diese Unterschiede in DIALECT_CONFIG und passt Bezeichner-Anführungszeichen, Datentypen und boolesche Darstellungen an den vom Nutzer gewählten Dialekt an.

Die CREATE-TABLE-Erzeugung baut auf der Typinferenz auf. Wenn der Nutzer "CREATE TABLE generieren" in den Einstellungen aktiviert, gibt das Tool vor dem INSERT-Block eine CREATE-TABLE-Anweisung aus. Der Tabellenname stammt aus der Nutzereingabe (Standard `users`); Spaltennamen stammen aus den JSON-Objektschlüsseln; Spaltentypen stammen aus den abgeleiteten SQL-Typen. Für Dialekte, die IF NOT EXISTS unterstützen, wird die Klausel automatisch ergänzt, um Fehler bei Neuerstellung zu vermeiden; bei nicht unterstützenden Dialekten (Oracle PL/SQL, SQL Server T-SQL) wird sie aus Kompatibilitätsgründen weggelassen. CREATE TABLE und INSERT zusammen bilden ein vollständiges Initialisierungsskript, das in einer leeren Datenbank mit einem einzigen Lauf ausgeführt werden kann.

Massen-Inserts sind der Schlüssel zur Performance. 10.000 Zeilen JSON in 10.000 separate INSERT-Anweisungen zu verwandeln ist quälend langsam, weil jede Anweisung geparst, geplant, ausgeführt und committet werden muss. Das Tool unterstützt eine konfigurierbare Batch-Größe (Standard 100, Bereich 1-1000) und bündelt mehrere Zeilen in einem INSERT mit Multi-Value-Tupeln (VALUES (1,2), (3,4), ...). Das reduziert die Zahl der Anweisungen drastisch und liefert auf den meisten Engines eine 10- bis 100-mal höhere Import-Performance. Die Batch-Größe muss je nach Datenbank und Server abgestimmt werden, da eine zu große Batch auf MySQL das max_allowed_packet überschreiten kann.

JSON-Fehlertoleranz ist ein praktisches Feature. JSON aus der Praxis ist selten perfekt: nachgestellte Kommas ([{"a":1},]), einfache statt doppelte Anführungszeichen ({'a':1}), nicht in Anführungszeichen gesetzte Schlüssel ({a:1}), eingebettete Kommentare (/* */). Ein strenger Parser lehnt all das ab. Das Tool bringt eine eingebaute tryFixJSON-Reparaturroutine mit, die läuft, sobald JSON.parse fehlschlägt; gelingt die Reparatur, wird der Nutzer informiert und die Konvertierung fortgesetzt. Dieses Design verbessert die Trefferquote in der Praxis drastisch und vermeidet endlose Korrekturschleifen.

Client-seitige Verarbeitung ist der zentrale architektonische Vorteil. JSON-Analyse, Typinferenz, SQL-Erzeugung und Verschönerung (powered by sql-formatter) laufen komplett in der JavaScript-Engine des Browsers; es wird nie etwas an einen Server gesendet. Das hat zwei große Vorteile: Erstens können JSON-Daten personenbezogene Informationen (Nutzerdaten, Bestelldaten) oder Geschäftsgeheimnisse (interne Schemata) enthalten, und lokale Verarbeitung eliminiert jedes Leak-Risiko; zweitens hängt die Konvertierungsgeschwindigkeit nur von der CPU des Geräts ab, sodass mittelgroße Daten (unter 10 MB) praktisch sofort fertig sind. Im Vergleich zu Kommandozeilen-Tools (jq + sed) ist das Tool benutzerfreundlicher, im Vergleich zu Online-Konvertierungsdiensten sicherer.

Anwendungsfälle

JSON-Antworten aus APIs in INSERT-Anweisungen umwandeln, um Daten in MySQL, PostgreSQL oder anderen relationalen Datenbanken für Analysen zu importieren.
CREATE-TABLE-DDL aus einer JSON-Konfiguration oder einem Datenwörterbuch erzeugen, um das Schema eines neuen Projekts zu initialisieren.
Frontend-Mock-JSON oder Test-Fixtures in SQL-Skripte umwandeln, um Entwicklungs-, Staging- oder QA-Datenbankumgebungen zu seeden.
Datenmigration: JSON-Exporte aus MongoDB, Elasticsearch oder Dokumentdatenbanken in SQL-Skripte für relationale Ziele verwandeln.
ETL-Vorverarbeitung: Upstream-JSON-Payloads in Standard-INSERT-Anweisungen normalisieren, die nachgelagerte Pipelines direkt einlesen können.
Backup und Wiederherstellung: Kritische Geschäftsdaten in portabler JSON-Form behalten und SQL-Skripte bei Bedarf on-demand neu erzeugen.
Teamübergreifende Zusammenarbeit: Auf einen JSON-Vertrag einigen und das Backend mit einem Klick sowohl das Schema-DDL als auch die Seed-INSERT-Skripte erzeugen lassen.
Lehre und Demos: Lernenden Schritt für Schritt zeigen, wie JSON-Daten SQL-Anweisungen abbilden, inklusive Typinferenz und Massen-Insert-Mechanik.

Anleitung

JSON-Array oder -Objekt in den linken Editor einfügen, auf Hochladen klicken, um eine .json/.txt-Datei zu laden, oder auf Beispiel klicken, um die eingebaute Demo zu laden.
Ziel-SQL-Dialekt aus dem Dropdown in der Toolbar auswählen (MySQL, PostgreSQL, SQLite, SQL Server und über 20 weitere).
Auf Einstellungen klicken, um den Tabellennamen, die Frage nach CREATE-TABLE-Ausgabe und die Massen-Insert-Größe (1-1000 Zeilen pro INSERT) zu konfigurieren.
Auf Konvertieren klicken (oder Tastenkürzel verwenden), um das JSON zu parsen, Typen abzuleiten und das SQL im rechten Feld darzustellen.
Das erzeugte SQL sowie die Zeilen-/Spalten-Totale in der Statusleiste prüfen, um die Datenintegrität zu verifizieren.
Auf Kopieren klicken, um das SQL in die Zwischenablage zu legen, oder auf Herunterladen klicken, um es als .sql-Datei (zum Beispiel users.sql) zu speichern.
Das SQL im bevorzugten Datenbank-Client (Navicat, DBeaver, pgAdmin, MySQL Workbench) ausführen, um den Datenimport abzuschließen.

Funktionen

Massen-INSERT-Generierung: JSON-Arrays in Standard-INSERT-INTO-Anweisungen umwandeln, mit konfigurierbarer Batch-Größe (1-1000 Zeilen pro Anweisung).
CREATE-TABLE-DDL-Ausgabe: Optionaler DDL-Block mit automatisch abgeleiteten Typen (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT).
Über 20 SQL-Dialekte: MySQL, PostgreSQL, SQLite, SQL Server, Oracle, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark, Hive und mehr.
Intelligente Typinferenz: Erkennt null, Booleans, Ganzzahlen, Gleitkommazahlen, ISO-8601-Daten sowie kurze und lange Strings und ordnet sie dem passendsten SQL-Typ zu.
Eingebauter SQL-Formatierer: Powered by sql-formatter, mit großgeschriebenen Schlüsselwörtern, sauberer Einrückung und klaren Multi-Value-VALUES-Blöcken.
JSON-Selbstreparatur: Behebt automatisch nachgestellte Kommas, einfache Anführungszeichen und fehlende Schlüssel-Anführungszeichen für robuste Konvertierungen.
Typ-Hochstufung: Konflikte zwischen Zeilen werden auf den weitesten kompatiblen Typ hochgestuft (INT + FLOAT wird FLOAT), sodass das DDL nie Daten abschneidet.
Eigene Tabellen- und Spaltennamen: Tabellenname wird zum Dateinamen (z. B. users.sql); Spaltennamen folgen den JSON-Objektschlüsseln.
Flexible Eingabe: JSON einfügen, eine .json/.txt-Datei hochladen oder das eingebaute Beispiel mit einem Klick laden.
Live-Zeilen- und Spaltenzähler: Die Statusleiste zeigt nach der Konvertierung die Gesamtzahl der Zeilen und Spalten zur schnellen Datenvalidierung.
Kopieren und Herunterladen: Mit einem Klick in die Zwischenablage kopieren oder als standardmäßige .sql-Datei speichern und in jede Datenbank importieren.
100 % Browserseitig: Parsen und Umwandeln laufen komplett in Client-seitigem JavaScript; JSON verlässt nie Ihr Gerät.

Häufig gestellte Fragen

Wie wandle ich ein JSON-Array in SQL-INSERT-Anweisungen um?

JSON-Array in den linken Editor einfügen, das Tool wandelt jedes Objekt in eine INSERT-INTO-Anweisung um. Objektschlüssel werden zu Spaltennamen, Werte werden automatisch in Anführungszeichen gesetzt oder als Zahlen belassen. Das erzeugte SQL lässt sich direkt in MySQL, PostgreSQL, SQLite oder einem anderen unterstützten Datenbank-Client ausführen.

Kann das Tool CREATE-TABLE-DDL-Skripte aus JSON erzeugen?

Ja. In den Einstellungen "CREATE TABLE generieren" aktivieren. Das Tool analysiert jedes Feld im JSON, leitet den passenden SQL-Datentyp ab (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT usw.) und erzeugt eine vollständige CREATE-TABLE-Anweisung, die zusammen mit den INSERTs ein sofort ausführbares Initialisierungsskript bildet.

Welche SQL-Dialekte werden unterstützt?

Das Tool unterstützt über 20 gängige SQL-Dialekte, darunter MySQL, MariaDB, PostgreSQL, SQLite, SQL Server (T-SQL), Oracle PL/SQL, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark SQL, Hive, TiDB, SingleStoreDB und N1QL. Bezeichner-Anführungszeichen (Backticks, doppelte Anführungszeichen, eckige Klammern), Datentypen (INT64, NVARCHAR, CLOB usw.) und boolesche Darstellungen (TRUE/FALSE vs. 1/0) werden je nach Dialekt automatisch angepasst.

Wie leitet das Tool SQL-Typen aus JSON-Werten ab?

null wird zu SQL NULL; true/false zu BOOLEAN (1/0 oder BIT bei SQLite/DB2/SQL Server); Ganzzahlen werden abhängig vom Wertebereich zu INT oder BIGINT (automatisches Upgrade auf BIGINT, sobald der Absolutwert 2.147.483.647 überschreitet); Gleitkommazahlen zu FLOAT/DOUBLE/REAL je nach Dialekt; ISO-8601-Datums- und Zeitstempel-Strings werden als DATE bzw. TIMESTAMP erkannt; kurze Strings zu VARCHAR(255); Strings über 255 Zeichen zu TEXT. Konflikte zwischen Zeilen werden automatisch hochgestuft (z. B. INT + FLOAT wird zu FLOAT).

Lässt sich das erzeugte SQL direkt in meiner Datenbank ausführen?

Ja. Das erzeugte SQL entspricht dem gewählten Dialekt vollständig und kann in MySQL Workbench, Navicat, DBeaver, pgAdmin, SQL Server Management Studio, phpMyAdmin oder jedem anderen Datenbank-Tool ausgeführt werden. Heruntergeladene Dateien sind nach der Tabelle benannt (z. B. users.sql) und lassen sich leicht im Stapel importieren.

Was passiert bei Syntaxfehlern im JSON?

Enthält das JSON nachgestellte Kommas, fehlende Anführungszeichen oder einfache statt doppelte Anführungszeichen, ruft das Tool automatisch die eingebaute tryFixJSON-Reparaturfunktion auf und setzt die Konvertierung fort. Schlägt die Reparatur fehl, zeigt das rechte Feld die genaue Fehlerstelle und Ursache an. Bei tief verschachteltem oder schwer beschädigtem JSON hilft das JSON-Formatierer-Tool weiter.

Unterstützt das Tool Massen-Inserts? Wie viele Zeilen pro INSERT?

Ja. Standardmäßig bündelt jeder INSERT 100 Zeilen, einstellbar von 1 bis 1000. 10.000 JSON-Zeilen erzeugen so 100 Multi-Value-INSERT-Anweisungen. Im Vergleich zu zeilenweisen Inserts ist die Import-Performance typischerweise 10- bis 100-mal höher auf MySQL, PostgreSQL und ähnlichen Engines.

Werden meine JSON-Daten auf einen Server hochgeladen?

Nein. Dies ist eine reine Client-Anwendung. JSON-Analyse, Typinferenz und SQL-Erzeugung laufen komplett in der JavaScript-Engine des Browsers, es wird nichts an einen Server gesendet. Datei-Uploads nutzen die native FileReader-API, alle Daten werden beim Neuladen der Seite aus dem Speicher gelöscht. Sie können JSON mit personenbezogenen Daten oder Geschäftsgeheimnissen bedenkenlos verarbeiten.

Werden ISO-8601-Datums-Strings automatisch erkannt?

Ja. Das Tool erkennt zwei ISO-8601-Muster: Strings mit T-Trennzeichen (zum Beispiel 2024-05-20T10:30:00) werden zu TIMESTAMP; reine Datums-Strings (zum Beispiel 2024-05-20) zu DATE. Strings, die ISO 8601 nicht entsprechen (zum Beispiel 2024/05/20 oder May 20, 2024), werden als einfache VARCHAR-Werte behandelt.

Wie große JSON-Dateien kann das Tool verarbeiten?

Es gibt keine harte Grenze, das tatsächliche Limit ist der Browser-Speicher. Dateien bis 10 MB (zehntausende Zeilen) laufen flüssig. Größere Dateien können bei zunehmendem Speicherdruck langsamer werden. Für sehr große Datenmengen teilen Sie diese in kleinere Batches oder deaktivieren den optionalen Beautify-Schritt im SQL-Formatierer.

Wird das erzeugte SQL automatisch formatiert?

Ja. Das Tool nutzt die sql-formatter-Bibliothek, um die Ausgabe zu verschönern: Schlüsselwörter werden großgeschrieben (SELECT, INSERT INTO, VALUES, CREATE TABLE), jeder Datensatz steht in einer eigenen Zeile, die Einrückung ist konsistent und Leerzeilen bleiben für die Lesbarkeit erhalten. Das Ergebnis ist in jedem Datenbank-Client leicht lesbar und nachträglich einfach zu bearbeiten.

Kann ich die Spaltenreihenfolge des erzeugten INSERT steuern?

Standardmäßig verwendet das Tool die Reihenfolge der Schlüssel im ersten Objekt des JSON-Arrays, sodass die mehrzeilige Ausgabe bündig bleibt. Haben verschiedene Objekte unterschiedliche Schlüsselreihenfolgen, führt das Tool alle Schlüssel zusammen, dedupliziert und füllt fehlende Werte mit NULL auf. Für optimale Ergebnisse normalisieren Sie das JSON vor der Konvertierung mit dem JSON-Formatierer-Tool.

Fehlerbehebung

Das rechte Feld zeigt nur "No valid objects found in JSON".

Ursache 1: Die oberste JSON-Ebene ist weder Array noch Objekt (z. B. ein bloßer String oder eine Zahl), sodass nichts in Zeilen umgewandelt werden kann. Lösung: JSON in ein Array [{...}] oder Objekt {...} einwickeln. Ursache 2: Das Array enthält primitive Werte ([1, 2, 3]) statt Objekte, also gibt es keine Schlüsselnamen für Spalten. Lösung: Jedes Array-Element muss ein Objekt mit Schlüssel-Wert-Paaren sein. Ursache 3: Das JSON konnte nicht geparst werden, tryFixJSON lief, aber das Reparaturergebnis ist immer noch kein Objekt. Lösung: JSON mit dem JSON-Formatierer-Tool validieren, um den Syntaxfehler zu finden.

Das erzeugte SQL wirft in meiner Datenbank einen Syntaxfehler.

Ursache 1: Der falsche Dialekt ist ausgewählt (z. B. MySQL gewählt, Ziel ist aber PostgreSQL), sodass die Bezeichner-Anführungszeichen nicht passen. Lösung: Den korrekten Dialekt im Dropdown auswählen. Ursache 2: Tabellen- oder Spaltenname kollidiert mit einem SQL-Schlüsselwort (order, user, select usw.). Lösung: Tabelle in den Einstellungen umbenennen oder den Namen manuell in Backticks/eckige Klammern setzen. Ursache 3: Die Batch-Größe ist zu groß und überschreitet max_allowed_packet oder ein ähnliches Limit der Datenbank. Lösung: Batch-Größe verringern (z. B. auf 50) in den Einstellungen.

Ein Datumsfeld wurde als VARCHAR statt als DATE oder TIMESTAMP erkannt.

Ursache: Der Datums-String entspricht nicht dem ISO-8601-Format. Das Tool erkennt nur YYYY-MM-DD (DATE) und YYYY-MM-DDTHH:mm:ss (TIMESTAMP). Häufige Formate, die nicht erkannt werden: YYYY/MM/DD, DD-MM-YYYY, "May 20 2024" und Unix-Zeitstempel wie 1715644800. Lösung: Datum zuerst im JSON in ISO 8601 umwandeln oder den Spaltentyp im CREATE TABLE manuell auf DATE oder VARCHAR anpassen.

Booleans erscheinen in SQLite/DB2 als 1/0, ich möchte aber TRUE/FALSE.

Ursache: SQLite, DB2 und SQL Server haben keinen nativen BOOLEAN-Typ, der Dialekt-Standard verwendet daher 1/0 (oder BIT). Lösung: Option 1, 1/0 als Standarddarstellung akzeptieren (1 bedeutet TRUE, 0 bedeutet FALSE); Option 2, den Wert in der Anwendungsschicht umwandeln (1 zu true, 0 zu false); Option 3, das SQL nachbearbeiten, 1/0 durch TRUE/FALSE ersetzen und den Spaltentyp auf INTEGER ändern, um ihn im Code als Boolean zu lesen. Das Tool folgt immer dem Dialekt-Standard und bietet keine nicht standardmäßige Option.

Dasselbe Feld hat in verschiedenen Zeilen unterschiedliche Typen (eine Zeile String, eine andere Zahl).

Das Tool nutzt einen Typ-Hochstufungs-Algorithmus, um sicherzustellen, dass jeder Wert in der Spalte darstellbar bleibt. Ist zum Beispiel Zeile 1 INT und Zeile 2 FLOAT, wird die Spalte zu FLOAT. Mischt eine Spalte Strings und Zahlen, wird sie zu VARCHAR hochgestuft. Extreme Konflikte (zum Beispiel ein Objektwert in einer Zeile) werden als JSON-String serialisiert und in TEXT gespeichert. Daten vor der Konvertierung mit dem JSON-Formatierer oder JSON-Validator validieren, um Überraschungen zu vermeiden.

Chinesische Zeichen sehen nach dem Import der heruntergeladenen .sql-Datei falsch aus.

Ursache: Die .sql-Datei ist UTF-8-kodiert, aber der Datenbank-Client oder die Datenbank selbst ist nicht auf UTF-8 eingestellt. Lösung: Option 1, Datenbank-Zeichensatz auf utf8mb4 (MySQL) oder UTF8 (PostgreSQL) setzen. Option 2, Zeichensatz bei der Client-Verbindung angeben (z. B. MySQL-CLI mit --default-character-set=utf8mb4). Option 3, .sql-Datei in einem Texteditor öffnen und prüfen, dass die Kodierung UTF-8 ist (nicht GBK oder eine andere). Das Tool erzeugt immer UTF-8-.sql-Dateien.

Das JSON enthält verschachtelte Objekte oder Arrays. Welche Spaltentypen werden erzeugt?

Nicht-primitive Werte (verschachtelte Objekte und Arrays) werden zu JSON-Strings serialisiert und als TEXT gespeichert. Zum Beispiel erzeugt {"tags": ["a", "b"], "profile": {"age": 30}} zwei Spalten: tags TEXT und profile TEXT, die beide serialisiertes JSON enthalten. Beim Abfragen können JSON_EXTRACT (MySQL 5.7+) oder ähnliche JSON-Funktionen verwendet werden, um verschachtelte Felder herauszuziehen. Um verschachtelte Daten vollständig in separate relationale Tabellen zu normalisieren, dies in der Anwendungsschicht oder mit einem dedizierten ETL-Tool erledigen.

Glossar

JSON (JavaScript Object Notation): Ein leichtgewichtiges Datenaustauschformat, das auf der JavaScript-Objektsyntax basiert, jedoch unabhängig von jeder Programmiersprache ist. Unterstützt sechs Basistypen: Objekt ({}), Array ([]), String, Number, Boolean und null. Weit verbreitet für REST-APIs, Frontend-Backend-Transport, Konfigurationsdateien und Log-Records.
SQL (Structured Query Language): Die Standard-Sprache für relationale Datenbanken (MySQL, PostgreSQL, SQLite, SQL Server, Oracle usw.). Umfasst DDL (Datendefinition, z. B. CREATE TABLE), DML (Datenmanipulation, z. B. INSERT), DQL (Datenabfrage, z. B. SELECT) und DCL (Datenkontrolle).
INSERT-Anweisung: Eine DML-Anweisung, die Zeilen zu einer Tabelle hinzufügt; Syntax: INSERT INTO table_name (col1, col2) VALUES (val1, val2). Unterstützt sowohl Single-Value-Tupel als auch Multi-Value-Tupel (ein INSERT für viele Zeilen); Letzteres verbessert die Massenimport-Performance erheblich.
CREATE-TABLE-Anweisung: Eine DDL-Anweisung, die eine Tabelle durch Definition von Name, Spalten, Datentypen und Constraints (NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT usw.) erstellt. Das von diesem Tool erzeugte CREATE TABLE verzichtet auf Primary Keys, Foreign Keys und Indizes, um sauber und vorhersagbar zu bleiben.
SQL-Dialekt: Die Implementierungsunterschiede zwischen Datenbankanbietern hinsichtlich des SQL-Standards. MySQL nutzt Backticks, PostgreSQL nutzt doppelte Anführungszeichen, SQL Server nutzt eckige Klammern; SQLite hat keinen nativen BOOLEAN und nutzt 1/0; Oracle nutzt VARCHAR2; BigQuery nutzt INT64 und STRING. Dieselbe logische SQL-Anweisung kann je nach Dialekt unterschiedliche Syntax haben.
DDL (Data Definition Language): Eine SQL-Teilsprache, die CREATE-, ALTER- und DROP-Anweisungen umfasst und zum Definieren und Ändern von Datenbankstrukturen (Tabellen, Views, Indizes, Constraints usw.) dient. Das von diesem Tool erzeugte CREATE TABLE ist eine DDL-Anweisung.
DML (Data Manipulation Language): Eine SQL-Teilsprache, die INSERT-, UPDATE- und DELETE-Anweisungen umfasst und zur Manipulation der Datenzeilen in Tabellen dient. Das von diesem Tool erzeugte INSERT INTO ist eine DML-Anweisung.
Typinferenz: Der Vorgang, automatisch den Typ eines Wertes aus seiner literalen Form abzuleiten. Das Tool prüft den typeof jedes JSON-Wertes (null, boolean, number, string) zusammen mit seiner konkreten Form (ISO-8601-Datum, Stringlänge) und ordnet ihn dem passendsten SQL-Typ zu.
Bezeichner-Anführungszeichen: Sonderzeichen, die Tabellen- und Spaltennamen in SQL umschließen. MySQL nutzt Backticks wie `name`, PostgreSQL und Standard-SQL nutzen doppelte Anführungszeichen wie "name", SQL Server nutzt eckige Klammern wie [name]. Bezeichner-Anführungszeichen werden verwendet, um reservierte Wörter zu escapen und die Groß-/Kleinschreibung zu steuern.
ISO-8601-Datumsformat: Ein internationaler Standard zur Darstellung von Datum und Uhrzeit. Das Format ist YYYY-MM-DD für Daten und YYYY-MM-DDTHH:mm:ss für Zeitstempel. Strings, die diesen Mustern entsprechen, werden vom Tool automatisch den SQL-Typen DATE und TIMESTAMP zugeordnet.
VARCHAR und TEXT: Zwei SQL-Typen für variable Zeichenketten. VARCHAR(n) hat eine Längenbegrenzung (üblicherweise bis 65.535 Bytes) und eignet sich für kurze Strings wie Namen, E-Mails und Titel. TEXT hat keine (oder eine sehr große) Längenbegrenzung und eignet sich für lange Inhalte wie Beschreibungen und Notizen. Standardmäßig ordnet das Tool Strings mit höchstens 255 Zeichen VARCHAR(255) und längere TEXT zu.
INT und BIGINT: Zwei SQL-Typen für Ganzzahlen. INT (INTEGER) ist normalerweise eine 32-Bit-Ganzzahl mit Vorzeichen im Bereich -2.147.483.648 bis 2.147.483.647. BIGINT ist eine 64-Bit-Ganzzahl mit deutlich größerem Bereich. Das Tool stuft Ganzzahlen, deren Absolutwert den INT-Bereich überschreitet, automatisch auf BIGINT hoch.
BOOLEAN-Typ: Der SQL-Typ für Wahrheitswerte. MySQL, PostgreSQL und BigQuery unterstützen BOOLEAN nativ (TRUE/FALSE). SQLite hat keinen nativen BOOLEAN und nutzt 1/0 oder INTEGER. SQL Server nutzt BIT. DB2 nutzt SMALLINT. Das Tool passt die Ausgabe automatisch je nach Dialekt an.
IF-NOT-EXISTS-Klausel: Eine optionale Klausel bei CREATE TABLE, die die Erstellung überspringt, wenn die Tabelle bereits existiert, und damit Fehler bei wiederholten Läufen vermeidet. MySQL, PostgreSQL, SQLite und BigQuery unterstützen sie; Oracle PL/SQL und SQL Server T-SQL nicht (die Anwendung muss zuerst prüfen). Das Tool gibt diese Klausel nur für unterstützende Dialekte aus.
Massen-Insert: Eine Technik, die viele Zeilen in einer einzigen INSERT-Anweisung mithilfe von Multi-Value-Tupeln kombiniert, z. B. VALUES (1,2), (3,4), (5,6). Im Vergleich zu zeilenweisen Inserts reduziert dies Parse-Overhead und Netzwerk-Roundtrips und verbessert die Import-Performance typischerweise um das 10- bis 100-Fache. Das Tool verwendet standardmäßig 100 Zeilen pro INSERT und unterstützt 1-1000.
sql-formatter: Eine JavaScript-SQL-Verschönerungsbibliothek, die über 20 Dialekte unterstützt. Sie schreibt Schlüsselwörter groß, sorgt für konsistente Einrückung und bricht lange Zeilen um. Das Tool verwendet diese Bibliothek als letzten Schritt seiner Pipeline, um das erzeugte SQL leichter lesbar und editierbar zu machen.

Unterstützte SQL-Dialekte und Schlüsselunterschiede

Die über 20 vom Tool unterstützten SQL-Dialekte mit Bezeichner-Anführungszeichen, Ganzzahltypen und boolescher Darstellung:

Dialekt	Bezeichner-Anführungszeichen	Ganzzahltyp	Boolesche Form	IF NOT EXISTS
MySQL	Backticks `	`INT`	`TRUE`	ja
MariaDB	Backticks `	`INT`	`TRUE`	ja
TiDB	Backticks `	`INT`	`TRUE`	ja
SingleStoreDB	Backticks `	`INT`	`TRUE`	ja
PostgreSQL	`Doppelte Anf.zeichen "`	`INTEGER`	`TRUE`	ja
Redshift	`Doppelte Anf.zeichen "`	`INTEGER`	`TRUE`	ja
DuckDB	`Doppelte Anf.zeichen "`	`INTEGER`	`TRUE`	ja
Trino	`Doppelte Anf.zeichen "`	`INTEGER`	`TRUE`	ja
SQLite	`Doppelte Anf.zeichen "`	`INTEGER`	`1/0`	ja
BigQuery	Backticks `	`INT64`	`TRUE`	ja
Snowflake	`Doppelte Anf.zeichen "`	`NUMBER`	`TRUE`	ja
DB2	`Doppelte Anf.zeichen "`	`INTEGER`	`1/0`	ja
DB2i	`Doppelte Anf.zeichen "`	`INTEGER`	`1/0`	ja
Oracle PL/SQL	`Doppelte Anf.zeichen "`	`NUMBER`	`1/0`	nein
SQL Server T-SQL	`Eckige Klammern []`	`INT`	`1/0`	nein
Transact-SQL	`Eckige Klammern []`	`INT`	`1/0`	nein
Spark SQL	Backticks `	`INT`	`TRUE`	ja
Hive	Backticks `	`INT`	`TRUE`	ja
ClickHouse	Backticks `	`Int32`	`1/0`	ja
N1QL (Couchbase)	Backticks `	`NUMBER`	`TRUE`	ja

JSON-zu-SQL-Typzuordnungsregeln

Die vollständigen Regeln, die die detectType-Funktion verwendet, um JSON-Werte auf SQL-Typen abzubilden:

JSON-Wert	Beispiel	Abgeleiteter SQL-Typ	Erkennungsregel
`null`	`null`	`NULL`	JSON null wird zu SQL NULL
`boolean`	`true / false`	`BOOLEAN`	Dialekte mit nativem BOOLEAN nutzen es; SQLite/DB2/SQL Server verwenden 1/0 oder BIT
`Ganzzahl (32-Bit)`	`1, 100, -9999`	`INT / INTEGER`	\|Wert\| <= 2.147.483.647 -> INT
`Ganzzahl (64-Bit)`	`9999999999, -1234567890`	`BIGINT`	\|Wert\| > 2.147.483.647 -> BIGINT
`Gleitkommazahl`	`3.14, -0.5, 1e10`	`FLOAT / DOUBLE / REAL`	Gleitkommazahlen je nach Dialekt FLOAT/DOUBLE/REAL
`ISO-8601-Datetime`	`2024-05-20T10:30:00`	`TIMESTAMP`	Matches /^\d{4}-\d{2}-\d{2}T/ -> TIMESTAMP
`ISO-8601-Datum`	`2024-05-20`	`DATE`	Matches /^\d{4}-\d{2}-\d{2}/ -> DATE
`Kurzer String`	`Alice, Peking`	`VARCHAR(255)`	Länge <= 255 -> VARCHAR(255)
`Langer String`	`über 255 Zeichen`	`TEXT`	Länge > 255 -> TEXT (CLOB/NVARCHAR(MAX)/STRING je nach Dialekt)

JSON in SQL im Vergleich zu anderen JSON-Konvertern

Wie sich der JSON-zu-SQL-Konverter im Vergleich zu JSON-zu-CSV, -YAML und -XML verhält:

Fähigkeit	JSON in SQL	JSON in CSV	JSON in YAML	JSON in XML
Ausführbares SQL	ja (DDL + DML)	nein	nein	nein
Dialektabdeckung	über 20 Dialekte	generisch	generisch	generisch
Automatische Typinferenz	ja (dialektbewusst)	nein (Klartext)	generische Typen	generische Typen
Massen-Insert-Optimierung	ja (1-1000 pro INSERT)	nein	nein	nein
Schema- (DDL-) Generierung	ja	nein	nein	nein
Direkter Datenbankimport	ja (sofort ausführen)	manueller Import	manueller Import	manueller Import

Privacy & Security

Dieser JSON-zu-SQL-Konverter läuft vollständig in Ihrem Browser. JSON-Analyse, Typinferenz, SQL-Erzeugung und SQL-Verschönerung erfolgen komplett in clientseitigem JavaScript; es wird nichts an einen Server gesendet. Datei-Uploads nutzen die native FileReader-API und gehen nie durch einen Zwischendienst. Das Tool verwendet keine Tracking-Cookies und sammelt keine Eingabe- oder Nutzungsdaten. Alle Ein- und Ausgaben werden aus dem Speicher gelöscht, sobald die Seite geschlossen oder neu geladen wird. Sicher zu verwenden für JSON, das persönliche Daten, Geschäftsgeheimnisse oder andere sensible Inhalte enthält.

Authoritative References

MySQLMySQL INSERT-Syntax - offizielle Dokumentation
PostgreSQLPostgreSQL INSERT-Syntax - offizielle Dokumentation
SQLiteSQLite INSERT-Syntax - offizielle Dokumentation
MicrosoftSQL Server INSERT-Syntax - offizielle Dokumentation
MDNJSON-Spezifikation - MDN Web Docs
WikipediaISO 8601 Datums- und Zeitstandard - Wikipedia
GitHubsql-formatter auf GitHub