SQL-opmaker en -validator - Formatteer SQL-query's Online Gratis
Gratis SQL-opmaker en -validator. Formatteert SQL automatisch met juiste inspringing en hoofdlettergebruik. Controleer syntaxfouten direct. Werkt met MySQL, PostgreSQL, SQL Server, Oracle.
SQL-opmaker en -validator
Formateer en valideer SQL-query's met automatische inspringing, trefwoordhoofdlettergebruik en syntaxfoutdetectie.
Documentatie
Waarom SQL-opmaak ertoe doet
Ooit een databaseproject geërfd waar de SQL eruitziet alsof iemand het heeft getypt met een blinddoek om? Je staat niet alleen. Slecht geformatteerde SQL is een van de meest voorkomende bronnen van bugs en verspilde tijd in databaseontwikkeling.
Deze SQL-formatter en -validator helpt je rommelige query's automatisch op te schonen. Plak je SQL, en het past direct de juiste inspringing toe, maakt trefwoorden hoofdlettergevoelig en controleert op syntaxfouten—allemaal in je browser zonder gegevens naar een server te sturen. Wat normaal gesproken 10-15 minuten handmatige opmaak kost, gebeurt nu in seconden.
Uit mijn ervaring met databaseteams is de grootste tijdsbesparing niet alleen de opmaak—maar het onderscheppen van fouten voordat ze in productie komen. Een verkeerd geplaatste haakje of een niet afgesloten aanhalingsteken kan uren debuggen kosten. Deze tool vangt die problemen direct op, voordat je iets uitvoert tegen je database.
Hoe gebruik je de SQL-formatter
De interface is bewust minimaal—plak en ga:
- Plak je SQL in het invoervak (of typ het direct als je het vanaf het begin schrijft)
- Bekijk de automatische opmaak terwijl je typt—geen knoppen om te klikken, geen instellingen om te configureren
- Controleer validatiefouten als deze verschijnen onder de geformatteerde uitvoer
- Kopieer de geformatteerde SQL met Ă©Ă©n klik om te gebruiken in je IDE, documentatie of databasetool
Werkt op elk apparaat met een browser. De opmaak vindt volledig aan de clientzijde plaats, dus je query's verlaten nooit je machine—belangrijk bij het werken met productiedatabasestructuren of gevoelige schema's.
Wat de SQL-formatter Doet
Trefwoord Kapitalisatie
Alle SQL-trefwoorden worden automatisch gekapitaliseerd—SELECT, FROM, WHERE, JOIN, enzovoort. Dit volgt de conventie die door de meeste database-teams wordt gebruikt en maakt trefwoorden visueel onderscheidend van uw tabel- en kolomnamen. Wanneer u door een complexe query bladert, helpt deze visuele scheiding u om de querystructuur in één oogopslag te herkennen.
Slimme Inspringing
De formatter structureert uw SQL op basis van logische hiërarchie in plaats van willekeurige regelonderbrekingen toe te voegen. Hoofdclauses zoals SELECT en FROM beginnen aan de linkermarge. JOIN-clauses worden ingesprongen onder FROM om aan te geven dat ze deel uitmaken van de tabelselectie. Subquery's krijgen extra inspringingsniveaus, waardoor geneste logica duidelijk wordt.
Hier is wat er in de praktijk gebeurt: wanneer u een query heeft met meerdere joins en subquery's, laat de juiste inspringing u de querystructuur zien zonder elk woord te lezen. U kunt direct zien waar de ene join eindigt en de andere begint, of waar een subquery wordt gebruikt in uw SELECT-lijst.
Logische Regelonderbrekingen
Regelonderbrekingen verschijnen waar ze de leesbaarheid verbeteren, niet zomaar overal. Elke hoofdclause krijgt zijn eigen regel. Items in door komma's gescheiden lijsten (zoals kolomnamen in SELECT) krijgen elk hun eigen regel met de juiste inspringing. Subquery's worden visueel gescheiden. CASE-instructies worden onderbroken bij WHEN, THEN en ELSE voor duidelijkheid.
De spatiëring volgt de SQL Style Guide conventies die in de branche worden gebruikt, wat betekent dat uw geformatteerde SQL bekend zal aanvoelen voor andere ontwikkelaars.
SQL-validatie: Wat wordt gecontroleerd
De validator vangt de fouten op die normaal gesproken ongemerkt blijven wanneer je snel SQL schrijft. Het vervangt de query-analyzer van je database niet, maar vangt veelvoorkomende fouten op voordat je de query uitvoert.
Structurele fouten
Niet-gebalanceerde haakjes komen verrassend vaak voor in complexe query's met geneste subquery's. De validator telt openings- en sluithaakjes om onmiddellijk afwijkingen te signaleren. Ik heb productie-incidenten gezien die werden veroorzaakt door een enkel ontbrekend haakje in een query van 200 regels—dit vangt ze vroeg op.
Niet-afgesloten string-literals ontstaan wanneer je de afsluitende aanhalingstekens vergeet bij een string-waarde. Je database zal deze onmiddellijk afwijzen, maar ze hier opvangen bespaart een extra rondje.
Clausevolgorde-problemen worden gemarkeerd wanneer clausules in een verkeerde volgorde staan. Als je bijvoorbeeld HAVING voor GROUP BY zet, of WHERE na GROUP BY, waarschuwt de validator. Dit volgt de SQL-standaard syntaxregels gedefinieerd in de ISO/IEC 9075 SQL-standaard.
Logische fouten
JOIN-clausules zonder ON-voorwaarden creëren per ongeluk cross joins, waardoor veel meer rijen worden geretourneerd dan bedoeld. Een veelvoorkomend scenario: je voegt een derde of vierde tabel toe aan een query en vergeet de ON-clausule. Zonder deze controle merk je het pas als je duizenden dubbele rijen in je resultaten ziet.
HAVING zonder GROUP BY is technisch gezien ongeldige SQL in de meeste databases. De HAVING-clausule filtert gegroepeerde resultaten, dus vereist een GROUP BY om te werken. De validator vangt deze logische discrepantie op.
Onvolledige WHERE-voorwaarden ontstaan wanneer je begint met het typen van een voorwaarde maar deze niet afmaakt—zoals WHERE status = zonder waarde. Deze zijn gemakkelijk over het hoofd te zien bij het bewerken van query's.
Wat het niet zal opvangen
Deze validator richt zich op syntaxis en structuur, niet op databaseschema. Het zal niet weten of:
- Je tabel- of kolomnamen bestaan in je database
- Je joins compatibele gegevenstypen gebruiken
- Je query goed zal presteren of optimalisatieproblemen heeft
- Je toestemming hebt om de tabellen te bevragen die je opvraagt
Beschouw het als een eerste controle voordat je de query naar je daadwerkelijke database stuurt.
Opmaakregels Toegepast door Deze Tool
De formatter past consistente regels toe op basis van de SQL Style Guide-conventies die de meeste database-teams volgen.
Trefwoorden Worden Gekapitaliseerd
Elk SQL-trefwoord wordt hoofdletters: SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP. Dit omvat clausules (FROM, WHERE, GROUP BY, HAVING, ORDER BY), join-types (JOIN, INNER JOIN, LEFT JOIN), operators (AND, OR, NOT, IN, BETWEEN, LIKE), en veelgebruikte functies (COUNT, SUM, AVG, CASE, WHEN).
Waarom hoofdletters? Het creëert een visueel onderscheid tussen de taalelementen van SQL en uw database-specifieke namen (tabellen, kolommen, aliassen). Bij het scannen van een query worden de structuurelementen direct zichtbaar.
Twee Spaties Inspringing Per Niveau
Hoofdclausules zoals SELECT en FROM beginnen aan de linkermarge. JOIN-clausules worden twee spaties ingesprongen onder FROM om aan te geven dat ze deel uitmaken van tabelselectie. Subquery's worden nog eens twee spaties ingesprongen voor elk nestingsniveau. Dit creëert een visuele hiërarchie die overeenkomt met de logische structuur.
Komma-gescheiden lijsten (kolomnamen in SELECT, bijvoorbeeld) krijgen elk hun eigen regel met consistente inspringing. Wanneer u 15 kolommen in uw SELECT-lijst heeft, maakt dit het gemakkelijk om specifieke kolommen te scannen.
Voorwaarden in WHERE-clausules worden verticaal uitgelijnd. Wanneer u meerdere AND- of OR-voorwaarden heeft, maakt uitlijning de logische structuur direct duidelijk.
Voor en Na: Zie het Verschil
Voor Opmaak:
1select u.id, u.name, o.order_date from users u join orders o on u.id = o.user_id where o.status = "completed" group by u.id order by u.name;
2Na Opmaak:
1SELECT
2 u.id,
3 u.name,
4 o.order_date
5FROM users u
6 JOIN orders o ON u.id = o.user_id
7WHERE
8 o.status = "completed"
9GROUP BY
10 u.id
11ORDER BY
12 u.name;
13Validatieregels: Wat Wordt Gemarkeerd
De validator controleert structurele integriteit en basale logische consistentie. Hier is wat hij zoekt:
Structurele Controles
Gebalanceerde haakjes: Openende en sluitende haakjes moeten overeenkomen. Geneste subquery's hebben vaak meerdere niveaus van haakjes, en het verkeerd tellen ervan is een van de meest voorkomende SQL-fouten. De validator telt ze voor u.
Correct afgesloten strings: Elke openende quote (enkel of dubbel) heeft een sluitende quote nodig. Klinkt voor de hand liggend, maar wanneer je een complexe query schrijft met meerdere string-letterlijke waarden, is het gemakkelijk om er een te missen.
Correcte clausevolgorde: SQL heeft specifieke volgorde-eisen. SELECT komt voor FROM, wat voor WHERE komt, wat voor GROUP BY komt, wat voor HAVING komt, wat voor ORDER BY komt. Het plaatsen ervan in een andere volgorde veroorzaakt onmiddellijke syntaxfouten. De validator controleert deze volgorde op basis van de SQL-standaard.
Logische Consistentiecontroles
JOIN met ON-voorwaarde: Elke JOIN heeft een ON of USING-clausule nodig om aan te geven hoe tabellen gerelateerd zijn. Zonder krijg je een cross join—elke rij van de ene tabel gekoppeld aan elke rij van de andere tabel. Dat is zelden wat je wilt en wijst meestal op een ontbrekende ON-clausule.
Volledige WHERE-voorwaarden: Een WHERE-clausule heeft volledige predicaten nodig. WHERE status = zonder waarde is onvolledig en ongeldig. De validator markeert deze gedeeltelijke voorwaarden.
HAVING vereist GROUP BY: De HAVING-clausule filtert gegroepeerde resultaten, dus het heeft alleen zin wanneer je een GROUP BY hebt. HAVING gebruiken zonder GROUP BY is een logische fout die de meeste databases afwijzen.
GROUP BY aggregatieregels: Wanneer je aggregatiefuncties zoals COUNT() of SUM() gebruikt, moeten niet-geaggregeerde kolommen in je SELECT-lijst voorkomen in GROUP BY. Dit is een fundamentele SQL-eis die de validator controleert.
Voorbeeld van Veelvoorkomende Fouten die Worden Gevangen
Hier is SQL met meerdere problemen die de validator zou markeren:
1SELECT user_id, COUNT(*) FROM orders
2JOIN users
3WHERE status =
4GROUP BY
5HAVING count > 10;
6Gedetecteerde problemen:
JOIN usersmistON-voorwaarde (zal cross join maken)WHERE status =onvolledig (geen vergelijkingswaarde)- Lege
GROUP BY-clausule (geen kolommen gespecificeerd) HAVING count > 10verwijst naar ongedefinieerde kolom
Wanneer deze SQL-formatter te gebruiken
Tijdens Code Reviews
Heb je ooit geprobeerd een SQL-query van 50 regels die op Ă©Ă©n regel staat te beoordelen? Het is verschrikkelijk. Voordat je query's indient voor code review, laat ze door de formatter gaan. Je reviewers zullen je dankbaar zijn, en ze kunnen zich richten op logica in plaats van structuur te ontcijferen.
Vraag bij het beoordelen van pull requests met databasewijzigingen bijdragers om hun SQL eerst te formatteren. Het maakt het opsporen van logische fouten veel gemakkelijker wanneer de structuur consistent is.
Debuggen van Productie-problemen
Wanneer je een falende query in productie aan het oplossen bent, helpt het correct formatteren je de structuur duidelijk te zien. Ik heb talloze query's gedebugd waarbij het probleem duidelijk werd zodra de SQL correct was geformatteerd—een ontbrekende join-voorwaarde, een onjuiste WHERE-clausule groepering, of een subquery op de verkeerde plek.
Kopieer de query uit je logs, plak deze hier, en je zult meteen zien of er structurele problemen zijn.
Werken met Gegenereerde SQL
ORMs (Object-Relational Mappers) zoals Hibernate, Entity Framework of SQLAlchemy genereren SQL automatisch. Soms wil je zien welke query ze precies produceren. De gegenereerde SQL is meestal Ă©Ă©n lange regel zonder opmaak. Deze tool maakt ORM-gegenereerde query's leesbaar zodat je ze kunt begrijpen en optimaliseren.
Onderwijzen en Leren van SQL
Als je SQL leert of onderwijst, helpt deze formatter je de juiste querystructuur te begrijpen. Wanneer je een werkende query plakt en ziet hoe deze wordt geformatteerd, leer je de conventies. Wanneer je een gebroken query plakt en de validatiefouten ziet, begrijp je waarom deze niet werkt.
Migreren Tussen Database-systemen
Verschillende databases (PostgreSQL, MySQL, SQL Server) hebben licht verschillende SQL-dialecten. Bij het migreren van query's tussen systemen helpt correcte opmaak je dialect-specifieke syntaxis op te sporen die mogelijk aanpassing nodig heeft. De formatter volgt standaard SQL-conventies die werken voor de meeste grote databases.
Alternatieven voor deze SQL-formatter
Database-Specifieke IDE's
Gereedschappen zoals DataGrip, SQL Server Management Studio of MySQL Workbench hebben ingebouwde formatters. Ze zijn krachtig en integreren direct met uw databaseverbindingen.
De afweging: ze vereisen installatie en setup. DataGrip kost $199/jaar voor individuele gebruikers. SSMS is gratis maar alleen voor Windows. Als u snelle formattering zonder installatie nodig hebt, of als u werkt met meerdere database-systemen, is een browser-gebaseerd hulpmiddel praktischer.
Editor-extensies
Als u SQL schrijft in VS Code of Sublime Text, brengen extensies zoals SQL Beautify of SqlBeautifier formattering in uw editor. Dit werkt goed wanneer u actief query's schrijft en direct formattering wilt als onderdeel van uw workflow.
De beperking: extensies vereisen configuratie en zijn gekoppeld aan uw specifieke editor. Bij het delen van SQL met teamleden of het plaatsen van query's in documentatie zorgt een gestandaardiseerde webformatter ervoor dat iedereen dezelfde opmaak ziet.
Opdrachtregelformatters
Gereedschappen zoals sqlformat (Python) of sql-formatter-cli (Node.js) kunnen worden geĂŻntegreerd in CI/CD-pijplijnen om SQL automatisch te formatteren in versiebeheer. Dit waarborgt consistentie binnen een team.
Het beste gebruikt voor geautomatiseerde workflows in plaats van ad-hoc formattering. Als u slechts enkele query's wilt opschonen of SQL leert, voegen opdrachtregelgereedschappen onnodige complexiteit toe.
Hoe SQL-opmaak een standaardpraktijk werd
SQL werd in de jaren 70 ontwikkeld bij IBM, maar opmaakconventies kwamen veel later tot stand. Vroege SQL was functioneel maar inconsistent—elke ontwikkelaar formateerde query's anders.
Het keerpunt kwam in de jaren 90 toen databases verschoven van projecten met Ă©Ă©n ontwikkelaar naar teamgebaseerde ontwikkeling. Organisaties begonnen interne SQL-stijlgidsen te maken om consistentie te handhaven. Wanneer vijf ontwikkelaars aan dezelfde database werkten, werd leesbare SQL essentieel voor samenwerking.
De jaren 2000 brachten ORMs die SQL automatisch genereerden. Deze tools produceerden werkende maar lelijke SQL—alles op één regel, geen inspringen. Dit creëerde vraag naar geautomatiseerde formatters die gegenereerde SQL leesbaar voor mensen konden maken.
Online SQL-formatters verschenen in de jaren 2010 terwijl webontwikkeling volwassen werd. In plaats van tools te installeren of IDE-plugins te configureren, konden ontwikkelaars SQL in een browser opmaken. Dit democratiseerde de toegang tot correcte opmaak voor iedereen, van beginners die SQL leren tot ervaren ontwikkelaars die snelle query's opschonen.
Tegenwoordig wordt SQL-opmaak beschouwd als een basispraktijk, vergelijkbaar met codeformattering in andere programmeertalen. De SQL Style Guide van Simon Holywell biedt breed geadopteerde conventies, en tools zoals deze implementeren die standaarden automatisch.
Codevoorbeelden
Voorbeeld 1: Basis SELECT-query
Ongeformatteerd:
1select id, first_name, last_name, email from customers where status = 'active' order by last_name, first_name;
2Geformatteerd:
1SELECT
2 id,
3 first_name,
4 last_name,
5 email
6FROM
7 customers
8WHERE
9 status = 'active'
10ORDER BY
11 last_name,
12 first_name;
13Voorbeeld 2: JOIN-query
Ongeformatteerd:
1select c.id, c.name, o.order_date, o.total_amount from customers c left join orders o on c.id = o.customer_id where o.order_date >= '2023-01-01' and o.status != 'cancelled' order by o.order_date desc;
2Geformatteerd:
1SELECT
2 c.id,
3 c.name,
4 o.order_date,
5 o.total_amount
6FROM
7 customers c
8 LEFT JOIN orders o ON c.id = o.customer_id
9WHERE
10 o.order_date >= '2023-01-01'
11 AND o.status != 'cancelled'
12ORDER BY
13 o.order_date DESC;
14Voorbeeld 3: Complexe query met subquery
Ongeformatteerd:
1select d.department_name, (select count(*) from employees e where e.department_id = d.id) as employee_count, (select avg(salary) from employees e where e.department_id = d.id) as avg_salary from departments d where d.active = true having employee_count > 0 order by avg_salary desc;
2Geformatteerd:
1SELECT
2 d.department_name,
3 (
4 SELECT
5 COUNT(*)
6 FROM
7 employees e
8 WHERE
9 e.department_id = d.id
10 ) AS employee_count,
11 (
12 SELECT
13 AVG(salary)
14 FROM
15 employees e
16 WHERE
17 e.department_id = d.id
18 ) AS avg_salary
19FROM
20 departments d
21WHERE
22 d.active = TRUE
23HAVING
24 employee_count > 0
25ORDER BY
26 avg_salary DESC;
27Programmatische SQL-formattering
Hier zijn voorbeelden van hoe u SQL-formattering kunt implementeren in verschillende programmeertalen:
1// JavaScript SQL-formattering voorbeeld met sql-formatter bibliotheek
2const sqlFormatter = require('sql-formatter');
3
4function formatSQL(sql) {
5 return sqlFormatter.format(sql, {
6 language: 'sql',
7 uppercase: true,
8 linesBetweenQueries: 2,
9 indentStyle: 'standard'
10 });
11}
12
13const rawSQL = "select id, name from users where status='active'";
14const formattedSQL = formatSQL(rawSQL);
15console.log(formattedSQL);
161# Python SQL-formattering voorbeeld met sqlparse
2import sqlparse
3
4def format_sql(sql):
5 return sqlparse.format(
6 sql,
7 reindent=True,
8 keyword_case='upper',
9 identifier_case='lower',
10 indent_width=2
11 )
12
13raw_sql = "select id, name from users where status='active'"
14formatted_sql = format_sql(raw_sql)
15print(formatted_sql)
161// Java SQL-formattering voorbeeld met JSqlParser
2import net.sf.jsqlparser.parser.CCJSqlParserUtil;
3import net.sf.jsqlparser.statement.Statement;
4
5public class SQLFormatter {
6 public static String formatSQL(String sql) throws Exception {
7 Statement statement = CCJSqlParserUtil.parse(sql);
8 return statement.toString()
9 .replaceAll("(?i)SELECT", "\nSELECT")
10 .replaceAll("(?i)FROM", "\nFROM")
11 .replaceAll("(?i)WHERE", "\nWHERE")
12 .replaceAll("(?i)ORDER BY", "\nORDER BY");
13 }
14
15 public static void main(String[] args) throws Exception {
16 String rawSQL = "select id, name from users where status='active'";
17 String formattedSQL = formatSQL(rawSQL);
18 System.out.println(formattedSQL);
19 }
20}
211<?php
2// PHP SQL-formattering voorbeeld
3function formatSQL($sql) {
4 // Vervang trefwoorden door hoofdletterversies
5 $keywords = ['SELECT', 'FROM', 'WHERE', 'JOIN', 'LEFT JOIN', 'RIGHT JOIN',
6 'INNER JOIN', 'GROUP BY', 'ORDER BY', 'HAVING', 'LIMIT'];
7
8 $formattedSQL = $sql;
9 foreach ($keywords as $keyword) {
10 $formattedSQL = preg_replace('/\b' . preg_quote($keyword, '/') . '\b/i', "\n$keyword", $formattedSQL);
11 }
12
13 // Voeg inspringing toe
14 $lines = explode("\n", $formattedSQL);
15 $result = '';
16 $indentLevel = 0;
17
18 foreach ($lines as $line) {
19 $trimmedLine = trim($line);
20 if (!empty($trimmedLine)) {
21 $result .= str_repeat(" ", $indentLevel) . $trimmedLine . "\n";
22 }
23 }
24
25 return $result;
26}
27
28$rawSQL = "select id, name from users where status='active'";
29$formattedSQL = formatSQL($rawSQL);
30echo $formattedSQL;
31?>
32Veelgestelde vragen
Werkt deze SQL-formatter met PostgreSQL, MySQL en SQL Server?
Ja, hij behandelt standaard SQL-syntaxis die gemeenschappelijk is voor grote databases—PostgreSQL, MySQL, SQL Server (T-SQL), Oracle, SQLite en MariaDB. De formatter richt zich op basis-SQL die overal werkt: SELECT, JOIN, WHERE, GROUP BY, enzovoort.
Database-specifieke functies worden mogelijk niet perfect geformatteerd. Bijvoorbeeld, PostgreSQL's array-syntaxis of SQL Server's eigen functies krijgen mogelijk geen speciale formattering, maar ze zullen de formatter ook niet breken. De query zal nog steeds leesbaarder zijn dan voorheen.
Wordt mijn SQL-code naar een server gestuurd?
Nee. Alles gebeurt in je browser. Plak je SQL, en het wordt lokaal geformatteerd zonder netwerkaanvragen. Je query's verlaten nooit je machine.
Dit is belangrijk wanneer je werkt met productiedatabase-schema's of bedrijfseigen bedrijfslogica. Er is geen risico dat gevoelige informatie wordt gelogd of opgeslagen op iemand anders' server.
Kan de validator alle SQL-fouten vinden?
Zeker niet. Hij vangt structurele en syntaxproblemen—ontbrekende haakjes, niet-afgesloten aanhalingstekens, bepalingen in de verkeerde volgorde. Dat is het.
Hij zal niet weten of je tabelnamen verkeerd zijn, je gegevenstypen niet compatibel zijn, of je query 10 minuten zal duren. Daarvoor heb je je werkelijke database nodig. Beschouw deze validator als een spellingscontrole voor SQL, niet als een volledige query-analyzer.
Waarom SQL formatteren als mijn database het toch uitvoert?
Databases geven niet om opmaak—ze parseren de query hoe dan ook. Maar mensen wel. Wanneer je een falende query moet debuggen, een bestaande query moet wijzigen of iemand anders' SQL moet beoordelen, maakt correcte opmaak het verschil tussen begrijpen in 30 seconden of 30 minuten.
Geformatteerde SQL helpt je ook logische fouten te herkennen. Wanneer de structuur duidelijk is, kun je zien of je tabellen onjuist hebt gekoppeld of voorwaarden op de verkeerde plek hebt gezet.
Kan ik de inspringing of trefwoordstijl aanpassen?
Momenteel niet. De formatter gebruikt standaardconventies: hoofdlettertrefwoorden, twee spaties inspringen, bepalingen op aparte regels. Deze volgen de SQL Style Guide die de meeste teams gebruiken.
Als je aangepaste opmaak nodig hebt (andere inspringingsbreedte, kleine letters voor trefwoorden), heb je een configureerbaar opdrachtregelprogramma zoals sqlformat of een IDE met opmaak-instellingen nodig.
Werkt dit met 1000-regelige opgeslagen procedures?
Het formatteert grote query's, hoewel zeer complexe opgeslagen procedures (1000+ regels) enkele seconden kunnen duren om te verwerken. De formatter behandelt de SQL die je plakt, ongeacht de lengte.
Voor enorme opgeslagen procedures wil je ze mogelijk opsplitsen in kleinere stukken of een database-specifieke IDE gebruiken die is geoptimaliseerd voor grote bestanden.
Verandert formattering hoe mijn query wordt uitgevoerd?
Nee. Formattering voegt alleen witruimte toe en verandert hoofdlettergebruik. Je database negeert beide. De geformatteerde query levert exact dezelfde resultaten op en draait met dezelfde prestaties als de ongeformatteerde versie.
De enige uitzondering: als de validator daadwerkelijke syntaxfouten vindt (ontbrekende haakjes, enz.), zal het oplossen daarvan het gedrag veranderen—maar alleen van "draait niet" naar "draait correct".
Welke SQL-standaard volgt dit?
De formatter volgt SQL-92-conventies met uitbreidingen voor veelvoorkomende functies in SQL:1999 en latere standaarden. Dit dekt de SQL die de meeste ontwikkelaars dagelijks schrijven—SELECT-query's, joins, subquery's, CASE-instructies, windowfuncties.
Zeer nieuwe SQL-functies uit SQL:2016 of SQL:2019 worden mogelijk niet herkend, maar ze zullen de formatter niet breken. Je krijgt gewoon basale opmaak in plaats van gespecialiseerde behandeling.
Kan ik dit gebruiken voor Oracle PL/SQL of SQL Server T-SQL?
Voor basale query's, ja. Voor procedurele code (PL/SQL-blokken, T-SQL opgeslagen procedures met besturingsstructuren), zal de opmaak beperkt zijn. De tool richt zich op SELECT, INSERT, UPDATE, DELETE-instructies en hun bepalingen.
Als je veel werkt met database-specifieke procedurele code, zal de eigen IDE van je database (SQL Developer voor Oracle, SSMS voor SQL Server) betere opmaak bieden die de volledige syntaxis begrijpt.
Referenties en Verdere Bronnen
- SQL Stijlgids door Simon Holywell - De facto standaard voor SQL-formattering conventies gebruikt door ontwikkelingsteams
- ISO/IEC 9075 SQL Standaard - De officiële internationale SQL-standaard specificatie
- PostgreSQL SQL Syntaxis Documentatie - PostgreSQL's uitgebreide SQL syntaxis referentie
- Microsoft T-SQL Referentie - Officiële documentatie voor SQL Server's T-SQL dialect
- MySQL Referentiehandleiding - MySQL's volledige SQL-instructie referentie
Begin met het Formatteren van SQL
Leesbare SQL maakt debuggen sneller, code reviews gemakkelijker en samenwerking soepeler. Plak uw query hierboven om deze te formatteren volgens industriestandaard conventies—geen installatie, geen configuratie, geen gegevens die uw browser verlaten.